diff options
5 files changed, 2013 insertions, 0 deletions
@@ -65,6 +65,7 @@ usb.current/usb-oxu210hp-release-spinlock-on-error-path.patch usb.current/usb-fix-build-on-omaps-if-config_pm_runtime-is-not-set.patch usb.current/usb-gadget-s3c-hsotg-add-missing-unlock.patch usb.current/usb-ti_usb-fix-printk-format-warning.patch +usb.current/usb-rename-usb_buffer_alloc-and-usb_buffer_free.patch ################################# # Staging patches for 2.6.34 @@ -238,6 +239,10 @@ usb/usb-ueagle-fix-coding-styles.patch usb/devices-fix-coding-styles.patch usb/short-new-graph-for-usb-serial.txt.patch +usb/usb-rename-usb_buffer_alloc-and-usb_buffer_free-users.patch +usb/usb-staging-fix-up-usb_buffer_alloc-calls-in-the-staging-tree.patch +usb/usb-remove-unused-usb_buffer_alloc-and-usb_buffer_free-macros.patch + ####################################### # Staging stuff for after 2.6.34 is out ####################################### diff --git a/usb.current/usb-rename-usb_buffer_alloc-and-usb_buffer_free.patch b/usb.current/usb-rename-usb_buffer_alloc-and-usb_buffer_free.patch new file mode 100644 index 00000000000000..eca5ff1e24e410 --- /dev/null +++ b/usb.current/usb-rename-usb_buffer_alloc-and-usb_buffer_free.patch @@ -0,0 +1,121 @@ +From foo@baz Thu Apr 29 15:09:23 PDT 2010 +Date: Mon, 12 Apr 2010 13:17:25 +0200 +To: Greg KH <greg@kroah.com> +From: Daniel Mack <daniel@caiaq.de> +Subject: USB: rename usb_buffer_alloc() and usb_buffer_free() + +For more clearance what the functions actually do, + + usb_buffer_alloc() is renamed to usb_alloc_coherent() + usb_buffer_free() is renamed to usb_free_coherent() + +They should only be used in code which really needs DMA coherency. + +[added compatibility macros so we can convert things easier - gregkh] + +Signed-off-by: Daniel Mack <daniel@caiaq.de> +Cc: Alan Stern <stern@rowland.harvard.edu> +Cc: Pedro Ribeiro <pedrib@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + drivers/usb/core/usb.c | 20 ++++++++++---------- + include/linux/usb.h | 18 +++++++++++++++--- + 2 files changed, 25 insertions(+), 13 deletions(-) + +--- a/drivers/usb/core/usb.c ++++ b/drivers/usb/core/usb.c +@@ -718,7 +718,7 @@ int __usb_get_extra_descriptor(char *buf + EXPORT_SYMBOL_GPL(__usb_get_extra_descriptor); + + /** +- * usb_buffer_alloc - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP ++ * usb_alloc_coherent - allocate dma-consistent buffer for URB_NO_xxx_DMA_MAP + * @dev: device the buffer will be used with + * @size: requested buffer size + * @mem_flags: affect whether allocation may block +@@ -737,30 +737,30 @@ EXPORT_SYMBOL_GPL(__usb_get_extra_descri + * architectures where CPU caches are not DMA-coherent. On systems without + * bus-snooping caches, these buffers are uncached. + * +- * When the buffer is no longer used, free it with usb_buffer_free(). ++ * When the buffer is no longer used, free it with usb_free_coherent(). + */ +-void *usb_buffer_alloc(struct usb_device *dev, size_t size, gfp_t mem_flags, +- dma_addr_t *dma) ++void *usb_alloc_coherent(struct usb_device *dev, size_t size, gfp_t mem_flags, ++ dma_addr_t *dma) + { + if (!dev || !dev->bus) + return NULL; + return hcd_buffer_alloc(dev->bus, size, mem_flags, dma); + } +-EXPORT_SYMBOL_GPL(usb_buffer_alloc); ++EXPORT_SYMBOL_GPL(usb_alloc_coherent); + + /** +- * usb_buffer_free - free memory allocated with usb_buffer_alloc() ++ * usb_free_coherent - free memory allocated with usb_alloc_coherent() + * @dev: device the buffer was used with + * @size: requested buffer size + * @addr: CPU address of buffer + * @dma: DMA address of buffer + * + * This reclaims an I/O buffer, letting it be reused. The memory must have +- * been allocated using usb_buffer_alloc(), and the parameters must match ++ * been allocated using usb_alloc_coherent(), and the parameters must match + * those provided in that allocation request. + */ +-void usb_buffer_free(struct usb_device *dev, size_t size, void *addr, +- dma_addr_t dma) ++void usb_free_coherent(struct usb_device *dev, size_t size, void *addr, ++ dma_addr_t dma) + { + if (!dev || !dev->bus) + return; +@@ -768,7 +768,7 @@ void usb_buffer_free(struct usb_device * + return; + hcd_buffer_free(dev->bus, size, addr, dma); + } +-EXPORT_SYMBOL_GPL(usb_buffer_free); ++EXPORT_SYMBOL_GPL(usb_free_coherent); + + /** + * usb_buffer_map - create DMA mapping(s) for an urb +--- a/include/linux/usb.h ++++ b/include/linux/usb.h +@@ -1085,7 +1085,7 @@ typedef void (*usb_complete_t)(struct ur + * Alternatively, drivers may pass the URB_NO_xxx_DMA_MAP transfer flags, + * which tell the host controller driver that no such mapping is needed since + * the device driver is DMA-aware. For example, a device driver might +- * allocate a DMA buffer with usb_buffer_alloc() or call usb_buffer_map(). ++ * allocate a DMA buffer with usb_alloc_coherent() or call usb_buffer_map(). + * When these transfer flags are provided, host controller drivers will + * attempt to use the dma addresses found in the transfer_dma and/or + * setup_dma fields rather than determining a dma address themselves. +@@ -1366,11 +1366,23 @@ static inline int usb_urb_dir_out(struct + return (urb->transfer_flags & URB_DIR_MASK) == URB_DIR_OUT; + } + +-void *usb_buffer_alloc(struct usb_device *dev, size_t size, ++void *usb_alloc_coherent(struct usb_device *dev, size_t size, + gfp_t mem_flags, dma_addr_t *dma); +-void usb_buffer_free(struct usb_device *dev, size_t size, ++void usb_free_coherent(struct usb_device *dev, size_t size, + void *addr, dma_addr_t dma); + ++/* Compatible macros while we switch over */ ++static inline void *usb_buffer_alloc(struct usb_device *dev, size_t size, ++ gfp_t mem_flags, dma_addr_t *dma) ++{ ++ return usb_alloc_coherent(dev, size, mem_flags, dma); ++} ++static inline void usb_buffer_free(struct usb_device *dev, size_t size, ++ void *addr, dma_addr_t dma) ++{ ++ return usb_free_coherent(dev, size, addr, dma); ++} ++ + #if 0 + struct urb *usb_buffer_map(struct urb *urb); + void usb_buffer_dmasync(struct urb *urb); diff --git a/usb/usb-remove-unused-usb_buffer_alloc-and-usb_buffer_free-macros.patch b/usb/usb-remove-unused-usb_buffer_alloc-and-usb_buffer_free-macros.patch new file mode 100644 index 00000000000000..e2f6263c1b2e06 --- /dev/null +++ b/usb/usb-remove-unused-usb_buffer_alloc-and-usb_buffer_free-macros.patch @@ -0,0 +1,37 @@ +From foo@baz Thu Apr 29 15:46:07 PDT 2010 +Date: Thu, 29 Apr 2010 15:46:07 -0700 +To: Greg KH <greg@kroah.com> +From: Greg Kroah-Hartman <gregkh@suse.de> +Subject: USB: remove unused usb_buffer_alloc and usb_buffer_free macros + +Now that all callers are converted over, remove the compatibility +functions and all is good. + +Cc: Daniel Mack <daniel@caiaq.de> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + include/linux/usb.h | 12 ------------ + 1 file changed, 12 deletions(-) + +--- a/include/linux/usb.h ++++ b/include/linux/usb.h +@@ -1389,18 +1389,6 @@ void *usb_alloc_coherent(struct usb_devi + void usb_free_coherent(struct usb_device *dev, size_t size, + void *addr, dma_addr_t dma); + +-/* Compatible macros while we switch over */ +-static inline void *usb_buffer_alloc(struct usb_device *dev, size_t size, +- gfp_t mem_flags, dma_addr_t *dma) +-{ +- return usb_alloc_coherent(dev, size, mem_flags, dma); +-} +-static inline void usb_buffer_free(struct usb_device *dev, size_t size, +- void *addr, dma_addr_t dma) +-{ +- return usb_free_coherent(dev, size, addr, dma); +-} +- + #if 0 + struct urb *usb_buffer_map(struct urb *urb); + void usb_buffer_dmasync(struct urb *urb); diff --git a/usb/usb-rename-usb_buffer_alloc-and-usb_buffer_free-users.patch b/usb/usb-rename-usb_buffer_alloc-and-usb_buffer_free-users.patch new file mode 100644 index 00000000000000..e9880350237e6e --- /dev/null +++ b/usb/usb-rename-usb_buffer_alloc-and-usb_buffer_free-users.patch @@ -0,0 +1,1797 @@ +From daniel@caiaq.de Thu Apr 29 15:12:30 2010 +From: Daniel Mack <daniel@caiaq.de> +Date: Mon, 12 Apr 2010 13:17:25 +0200 +Subject: USB: rename usb_buffer_alloc() and usb_buffer_free() users +To: linux-kernel@vger.kernel.org +Cc: Daniel Mack <daniel@caiaq.de>, Alan Stern <stern@rowland.harvard.edu>, Greg KH <gregkh@suse.de>, Pedro Ribeiro <pedrib@gmail.com>, akpm@linux-foundation.org, linux-usb@vger.kernel.org, alsa-devel@alsa-project.org +Message-ID: <1271071045-3112-1-git-send-email-daniel@caiaq.de> + + +For more clearance what the functions actually do, + + usb_buffer_alloc() is renamed to usb_alloc_coherent() + usb_buffer_free() is renamed to usb_free_coherent() + +They should only be used in code which really needs DMA coherency. + +All call sites have been changed accordingly, except for staging +drivers. + +Signed-off-by: Daniel Mack <daniel@caiaq.de> +Cc: Alan Stern <stern@rowland.harvard.edu> +Cc: Pedro Ribeiro <pedrib@gmail.com> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> + +--- + Documentation/DocBook/writing_usb_driver.tmpl | 2 - + Documentation/usb/dma.txt | 4 +- + drivers/hid/usbhid/hid-core.c | 12 +++---- + drivers/hid/usbhid/usbkbd.c | 8 ++--- + drivers/hid/usbhid/usbmouse.c | 6 +-- + drivers/input/joystick/xpad.c | 16 +++++----- + drivers/input/misc/ati_remote.c | 12 +++---- + drivers/input/misc/ati_remote2.c | 4 +- + drivers/input/misc/cm109.c | 16 +++++----- + drivers/input/misc/keyspan_remote.c | 6 +-- + drivers/input/misc/powermate.c | 8 ++--- + drivers/input/misc/yealink.c | 14 +++------ + drivers/input/mouse/appletouch.c | 12 +++---- + drivers/input/mouse/bcm5974.c | 24 +++++++-------- + drivers/input/tablet/acecad.c | 6 +-- + drivers/input/tablet/aiptek.c | 14 ++++----- + drivers/input/tablet/gtco.c | 12 +++---- + drivers/input/tablet/kbtab.c | 6 +-- + drivers/input/tablet/wacom_sys.c | 10 +++--- + drivers/input/touchscreen/usbtouchscreen.c | 8 ++--- + drivers/media/dvb/dvb-usb/usb-urb.c | 7 ++-- + drivers/media/dvb/ttusb-dec/ttusb_dec.c | 6 +-- + drivers/media/video/au0828/au0828-video.c | 4 +- + drivers/media/video/cx231xx/cx231xx-core.c | 14 ++++----- + drivers/media/video/em28xx/em28xx-core.c | 4 +- + drivers/media/video/gspca/benq.c | 4 +- + drivers/media/video/gspca/gspca.c | 30 +++++++++---------- + drivers/media/video/hdpvr/hdpvr-video.c | 8 ++--- + drivers/media/video/tlg2300/pd-video.c | 14 ++++----- + drivers/media/video/usbvision/usbvision-core.c | 16 +++++----- + drivers/media/video/uvc/uvc_video.c | 4 +- + drivers/net/can/usb/ems_usb.c | 18 +++++------ + drivers/net/usb/kaweth.c | 12 +++---- + drivers/net/wireless/ath/ar9170/usb.c | 8 ++--- + drivers/net/wireless/zd1211rw/zd_usb.c | 10 +++--- + drivers/usb/class/cdc-acm.c | 22 +++++++------- + drivers/usb/class/cdc-wdm.c | 38 ++++++++++++------------- + drivers/usb/class/usblp.c | 2 - + drivers/usb/misc/appledisplay.c | 6 +-- + drivers/usb/misc/ftdi-elan.c | 18 +++++------ + drivers/usb/misc/iowarrior.c | 12 +++---- + drivers/usb/misc/usblcd.c | 8 ++--- + drivers/usb/misc/usbtest.c | 8 ++--- + drivers/usb/storage/onetouch.c | 12 +++---- + drivers/usb/storage/usb.c | 4 +- + drivers/usb/usb-skeleton.c | 10 +++--- + drivers/watchdog/pcwd_usb.c | 6 +-- + sound/usb/ua101.c | 16 +++++----- + sound/usb/usbaudio.c | 18 +++++------ + sound/usb/usbmidi.c | 14 ++++----- + 50 files changed, 276 insertions(+), 277 deletions(-) + +--- a/Documentation/DocBook/writing_usb_driver.tmpl ++++ b/Documentation/DocBook/writing_usb_driver.tmpl +@@ -342,7 +342,7 @@ static inline void skel_delete (struct u + { + kfree (dev->bulk_in_buffer); + if (dev->bulk_out_buffer != NULL) +- usb_buffer_free (dev->udev, dev->bulk_out_size, ++ usb_free_coherent (dev->udev, dev->bulk_out_size, + dev->bulk_out_buffer, + dev->write_urb->transfer_dma); + usb_free_urb (dev->write_urb); +--- a/Documentation/usb/dma.txt ++++ b/Documentation/usb/dma.txt +@@ -43,10 +43,10 @@ and effects like cache-trashing can impo + kind of addresses to store in urb->transfer_buffer and urb->transfer_dma. + You'd also set URB_NO_TRANSFER_DMA_MAP in urb->transfer_flags: + +- void *usb_buffer_alloc (struct usb_device *dev, size_t size, ++ void *usb_alloc_coherent (struct usb_device *dev, size_t size, + int mem_flags, dma_addr_t *dma); + +- void usb_buffer_free (struct usb_device *dev, size_t size, ++ void usb_free_coherent (struct usb_device *dev, size_t size, + void *addr, dma_addr_t dma); + + Most drivers should *NOT* be using these primitives; they don't need +--- a/drivers/hid/usbhid/hid-core.c ++++ b/drivers/hid/usbhid/hid-core.c +@@ -783,12 +783,12 @@ static int hid_alloc_buffers(struct usb_ + { + struct usbhid_device *usbhid = hid->driver_data; + +- usbhid->inbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, ++ usbhid->inbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, + &usbhid->inbuf_dma); +- usbhid->outbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, ++ usbhid->outbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, + &usbhid->outbuf_dma); + usbhid->cr = kmalloc(sizeof(*usbhid->cr), GFP_KERNEL); +- usbhid->ctrlbuf = usb_buffer_alloc(dev, usbhid->bufsize, GFP_KERNEL, ++ usbhid->ctrlbuf = usb_alloc_coherent(dev, usbhid->bufsize, GFP_KERNEL, + &usbhid->ctrlbuf_dma); + if (!usbhid->inbuf || !usbhid->outbuf || !usbhid->cr || + !usbhid->ctrlbuf) +@@ -843,10 +843,10 @@ static void hid_free_buffers(struct usb_ + { + struct usbhid_device *usbhid = hid->driver_data; + +- usb_buffer_free(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma); +- usb_buffer_free(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma); ++ usb_free_coherent(dev, usbhid->bufsize, usbhid->inbuf, usbhid->inbuf_dma); ++ usb_free_coherent(dev, usbhid->bufsize, usbhid->outbuf, usbhid->outbuf_dma); + kfree(usbhid->cr); +- usb_buffer_free(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma); ++ usb_free_coherent(dev, usbhid->bufsize, usbhid->ctrlbuf, usbhid->ctrlbuf_dma); + } + + static int usbhid_parse(struct hid_device *hid) +--- a/drivers/hid/usbhid/usbkbd.c ++++ b/drivers/hid/usbhid/usbkbd.c +@@ -196,11 +196,11 @@ static int usb_kbd_alloc_mem(struct usb_ + return -1; + if (!(kbd->led = usb_alloc_urb(0, GFP_KERNEL))) + return -1; +- if (!(kbd->new = usb_buffer_alloc(dev, 8, GFP_ATOMIC, &kbd->new_dma))) ++ if (!(kbd->new = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &kbd->new_dma))) + return -1; + if (!(kbd->cr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_KERNEL))) + return -1; +- if (!(kbd->leds = usb_buffer_alloc(dev, 1, GFP_ATOMIC, &kbd->leds_dma))) ++ if (!(kbd->leds = usb_alloc_coherent(dev, 1, GFP_ATOMIC, &kbd->leds_dma))) + return -1; + + return 0; +@@ -210,9 +210,9 @@ static void usb_kbd_free_mem(struct usb_ + { + usb_free_urb(kbd->irq); + usb_free_urb(kbd->led); +- usb_buffer_free(dev, 8, kbd->new, kbd->new_dma); ++ usb_free_coherent(dev, 8, kbd->new, kbd->new_dma); + kfree(kbd->cr); +- usb_buffer_free(dev, 1, kbd->leds, kbd->leds_dma); ++ usb_free_coherent(dev, 1, kbd->leds, kbd->leds_dma); + } + + static int usb_kbd_probe(struct usb_interface *iface, +--- a/drivers/hid/usbhid/usbmouse.c ++++ b/drivers/hid/usbhid/usbmouse.c +@@ -142,7 +142,7 @@ static int usb_mouse_probe(struct usb_in + if (!mouse || !input_dev) + goto fail1; + +- mouse->data = usb_buffer_alloc(dev, 8, GFP_ATOMIC, &mouse->data_dma); ++ mouse->data = usb_alloc_coherent(dev, 8, GFP_ATOMIC, &mouse->data_dma); + if (!mouse->data) + goto fail1; + +@@ -205,7 +205,7 @@ static int usb_mouse_probe(struct usb_in + fail3: + usb_free_urb(mouse->irq); + fail2: +- usb_buffer_free(dev, 8, mouse->data, mouse->data_dma); ++ usb_free_coherent(dev, 8, mouse->data, mouse->data_dma); + fail1: + input_free_device(input_dev); + kfree(mouse); +@@ -221,7 +221,7 @@ static void usb_mouse_disconnect(struct + usb_kill_urb(mouse->irq); + input_unregister_device(mouse->dev); + usb_free_urb(mouse->irq); +- usb_buffer_free(interface_to_usbdev(intf), 8, mouse->data, mouse->data_dma); ++ usb_free_coherent(interface_to_usbdev(intf), 8, mouse->data, mouse->data_dma); + kfree(mouse); + } + } +--- a/drivers/input/joystick/xpad.c ++++ b/drivers/input/joystick/xpad.c +@@ -533,8 +533,8 @@ static int xpad_init_output(struct usb_i + if (xpad->xtype != XTYPE_XBOX360 && xpad->xtype != XTYPE_XBOX) + return 0; + +- xpad->odata = usb_buffer_alloc(xpad->udev, XPAD_PKT_LEN, +- GFP_KERNEL, &xpad->odata_dma); ++ xpad->odata = usb_alloc_coherent(xpad->udev, XPAD_PKT_LEN, ++ GFP_KERNEL, &xpad->odata_dma); + if (!xpad->odata) + goto fail1; + +@@ -554,7 +554,7 @@ static int xpad_init_output(struct usb_i + + return 0; + +- fail2: usb_buffer_free(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma); ++ fail2: usb_free_coherent(xpad->udev, XPAD_PKT_LEN, xpad->odata, xpad->odata_dma); + fail1: return error; + } + +@@ -568,7 +568,7 @@ static void xpad_deinit_output(struct us + { + if (xpad->xtype == XTYPE_XBOX360 || xpad->xtype == XTYPE_XBOX) { + usb_free_urb(xpad->irq_out); +- usb_buffer_free(xpad->udev, XPAD_PKT_LEN, ++ usb_free_coherent(xpad->udev, XPAD_PKT_LEN, + xpad->odata, xpad->odata_dma); + } + } +@@ -788,8 +788,8 @@ static int xpad_probe(struct usb_interfa + if (!xpad || !input_dev) + goto fail1; + +- xpad->idata = usb_buffer_alloc(udev, XPAD_PKT_LEN, +- GFP_KERNEL, &xpad->idata_dma); ++ xpad->idata = usb_alloc_coherent(udev, XPAD_PKT_LEN, ++ GFP_KERNEL, &xpad->idata_dma); + if (!xpad->idata) + goto fail1; + +@@ -942,7 +942,7 @@ static int xpad_probe(struct usb_interfa + fail5: usb_kill_urb(xpad->irq_in); + fail4: usb_free_urb(xpad->irq_in); + fail3: xpad_deinit_output(xpad); +- fail2: usb_buffer_free(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); ++ fail2: usb_free_coherent(udev, XPAD_PKT_LEN, xpad->idata, xpad->idata_dma); + fail1: input_free_device(input_dev); + kfree(xpad); + return error; +@@ -964,7 +964,7 @@ static void xpad_disconnect(struct usb_i + usb_kill_urb(xpad->irq_in); + } + usb_free_urb(xpad->irq_in); +- usb_buffer_free(xpad->udev, XPAD_PKT_LEN, ++ usb_free_coherent(xpad->udev, XPAD_PKT_LEN, + xpad->idata, xpad->idata_dma); + kfree(xpad); + } +--- a/drivers/input/misc/ati_remote.c ++++ b/drivers/input/misc/ati_remote.c +@@ -620,13 +620,13 @@ static void ati_remote_irq_in(struct urb + static int ati_remote_alloc_buffers(struct usb_device *udev, + struct ati_remote *ati_remote) + { +- ati_remote->inbuf = usb_buffer_alloc(udev, DATA_BUFSIZE, GFP_ATOMIC, +- &ati_remote->inbuf_dma); ++ ati_remote->inbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC, ++ &ati_remote->inbuf_dma); + if (!ati_remote->inbuf) + return -1; + +- ati_remote->outbuf = usb_buffer_alloc(udev, DATA_BUFSIZE, GFP_ATOMIC, +- &ati_remote->outbuf_dma); ++ ati_remote->outbuf = usb_alloc_coherent(udev, DATA_BUFSIZE, GFP_ATOMIC, ++ &ati_remote->outbuf_dma); + if (!ati_remote->outbuf) + return -1; + +@@ -649,10 +649,10 @@ static void ati_remote_free_buffers(stru + usb_free_urb(ati_remote->irq_urb); + usb_free_urb(ati_remote->out_urb); + +- usb_buffer_free(ati_remote->udev, DATA_BUFSIZE, ++ usb_free_coherent(ati_remote->udev, DATA_BUFSIZE, + ati_remote->inbuf, ati_remote->inbuf_dma); + +- usb_buffer_free(ati_remote->udev, DATA_BUFSIZE, ++ usb_free_coherent(ati_remote->udev, DATA_BUFSIZE, + ati_remote->outbuf, ati_remote->outbuf_dma); + } + +--- a/drivers/input/misc/ati_remote2.c ++++ b/drivers/input/misc/ati_remote2.c +@@ -589,7 +589,7 @@ static int ati_remote2_urb_init(struct a + int i, pipe, maxp; + + for (i = 0; i < 2; i++) { +- ar2->buf[i] = usb_buffer_alloc(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]); ++ ar2->buf[i] = usb_alloc_coherent(udev, 4, GFP_KERNEL, &ar2->buf_dma[i]); + if (!ar2->buf[i]) + return -ENOMEM; + +@@ -617,7 +617,7 @@ static void ati_remote2_urb_cleanup(stru + + for (i = 0; i < 2; i++) { + usb_free_urb(ar2->urb[i]); +- usb_buffer_free(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]); ++ usb_free_coherent(ar2->udev, 4, ar2->buf[i], ar2->buf_dma[i]); + } + } + +--- a/drivers/input/misc/cm109.c ++++ b/drivers/input/misc/cm109.c +@@ -630,11 +630,11 @@ static void cm109_usb_cleanup(struct cm1 + { + kfree(dev->ctl_req); + if (dev->ctl_data) +- usb_buffer_free(dev->udev, USB_PKT_LEN, +- dev->ctl_data, dev->ctl_dma); ++ usb_free_coherent(dev->udev, USB_PKT_LEN, ++ dev->ctl_data, dev->ctl_dma); + if (dev->irq_data) +- usb_buffer_free(dev->udev, USB_PKT_LEN, +- dev->irq_data, dev->irq_dma); ++ usb_free_coherent(dev->udev, USB_PKT_LEN, ++ dev->irq_data, dev->irq_dma); + + usb_free_urb(dev->urb_irq); /* parameter validation in core/urb */ + usb_free_urb(dev->urb_ctl); /* parameter validation in core/urb */ +@@ -683,13 +683,13 @@ static int cm109_usb_probe(struct usb_in + goto err_out; + + /* allocate usb buffers */ +- dev->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN, +- GFP_KERNEL, &dev->irq_dma); ++ dev->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN, ++ GFP_KERNEL, &dev->irq_dma); + if (!dev->irq_data) + goto err_out; + +- dev->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN, +- GFP_KERNEL, &dev->ctl_dma); ++ dev->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN, ++ GFP_KERNEL, &dev->ctl_dma); + if (!dev->ctl_data) + goto err_out; + +--- a/drivers/input/misc/keyspan_remote.c ++++ b/drivers/input/misc/keyspan_remote.c +@@ -464,7 +464,7 @@ static int keyspan_probe(struct usb_inte + remote->in_endpoint = endpoint; + remote->toggle = -1; /* Set to -1 so we will always not match the toggle from the first remote message. */ + +- remote->in_buffer = usb_buffer_alloc(udev, RECV_SIZE, GFP_ATOMIC, &remote->in_dma); ++ remote->in_buffer = usb_alloc_coherent(udev, RECV_SIZE, GFP_ATOMIC, &remote->in_dma); + if (!remote->in_buffer) { + error = -ENOMEM; + goto fail1; +@@ -543,7 +543,7 @@ static int keyspan_probe(struct usb_inte + return 0; + + fail3: usb_free_urb(remote->irq_urb); +- fail2: usb_buffer_free(udev, RECV_SIZE, remote->in_buffer, remote->in_dma); ++ fail2: usb_free_coherent(udev, RECV_SIZE, remote->in_buffer, remote->in_dma); + fail1: kfree(remote); + input_free_device(input_dev); + +@@ -564,7 +564,7 @@ static void keyspan_disconnect(struct us + input_unregister_device(remote->input); + usb_kill_urb(remote->irq_urb); + usb_free_urb(remote->irq_urb); +- usb_buffer_free(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma); ++ usb_free_coherent(remote->udev, RECV_SIZE, remote->in_buffer, remote->in_dma); + kfree(remote); + } + } +--- a/drivers/input/misc/powermate.c ++++ b/drivers/input/misc/powermate.c +@@ -273,8 +273,8 @@ static int powermate_input_event(struct + + static int powermate_alloc_buffers(struct usb_device *udev, struct powermate_device *pm) + { +- pm->data = usb_buffer_alloc(udev, POWERMATE_PAYLOAD_SIZE_MAX, +- GFP_ATOMIC, &pm->data_dma); ++ pm->data = usb_alloc_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX, ++ GFP_ATOMIC, &pm->data_dma); + if (!pm->data) + return -1; + +@@ -287,8 +287,8 @@ static int powermate_alloc_buffers(struc + + static void powermate_free_buffers(struct usb_device *udev, struct powermate_device *pm) + { +- usb_buffer_free(udev, POWERMATE_PAYLOAD_SIZE_MAX, +- pm->data, pm->data_dma); ++ usb_free_coherent(udev, POWERMATE_PAYLOAD_SIZE_MAX, ++ pm->data, pm->data_dma); + kfree(pm->configcr); + } + +--- a/drivers/input/misc/yealink.c ++++ b/drivers/input/misc/yealink.c +@@ -836,10 +836,8 @@ static int usb_cleanup(struct yealink_de + usb_free_urb(yld->urb_ctl); + + kfree(yld->ctl_req); +- usb_buffer_free(yld->udev, USB_PKT_LEN, +- yld->ctl_data, yld->ctl_dma); +- usb_buffer_free(yld->udev, USB_PKT_LEN, +- yld->irq_data, yld->irq_dma); ++ usb_free_coherent(yld->udev, USB_PKT_LEN, yld->ctl_data, yld->ctl_dma); ++ usb_free_coherent(yld->udev, USB_PKT_LEN, yld->irq_data, yld->irq_dma); + + kfree(yld); + return err; +@@ -884,13 +882,13 @@ static int usb_probe(struct usb_interfac + return usb_cleanup(yld, -ENOMEM); + + /* allocate usb buffers */ +- yld->irq_data = usb_buffer_alloc(udev, USB_PKT_LEN, +- GFP_ATOMIC, &yld->irq_dma); ++ yld->irq_data = usb_alloc_coherent(udev, USB_PKT_LEN, ++ GFP_ATOMIC, &yld->irq_dma); + if (yld->irq_data == NULL) + return usb_cleanup(yld, -ENOMEM); + +- yld->ctl_data = usb_buffer_alloc(udev, USB_PKT_LEN, +- GFP_ATOMIC, &yld->ctl_dma); ++ yld->ctl_data = usb_alloc_coherent(udev, USB_PKT_LEN, ++ GFP_ATOMIC, &yld->ctl_dma); + if (!yld->ctl_data) + return usb_cleanup(yld, -ENOMEM); + +--- a/drivers/input/mouse/appletouch.c ++++ b/drivers/input/mouse/appletouch.c +@@ -806,8 +806,8 @@ static int atp_probe(struct usb_interfac + if (!dev->urb) + goto err_free_devs; + +- dev->data = usb_buffer_alloc(dev->udev, dev->info->datalen, GFP_KERNEL, +- &dev->urb->transfer_dma); ++ dev->data = usb_alloc_coherent(dev->udev, dev->info->datalen, GFP_KERNEL, ++ &dev->urb->transfer_dma); + if (!dev->data) + goto err_free_urb; + +@@ -862,8 +862,8 @@ static int atp_probe(struct usb_interfac + return 0; + + err_free_buffer: +- usb_buffer_free(dev->udev, dev->info->datalen, +- dev->data, dev->urb->transfer_dma); ++ usb_free_coherent(dev->udev, dev->info->datalen, ++ dev->data, dev->urb->transfer_dma); + err_free_urb: + usb_free_urb(dev->urb); + err_free_devs: +@@ -881,8 +881,8 @@ static void atp_disconnect(struct usb_in + if (dev) { + usb_kill_urb(dev->urb); + input_unregister_device(dev->input); +- usb_buffer_free(dev->udev, dev->info->datalen, +- dev->data, dev->urb->transfer_dma); ++ usb_free_coherent(dev->udev, dev->info->datalen, ++ dev->data, dev->urb->transfer_dma); + usb_free_urb(dev->urb); + kfree(dev); + } +--- a/drivers/input/mouse/bcm5974.c ++++ b/drivers/input/mouse/bcm5974.c +@@ -715,15 +715,15 @@ static int bcm5974_probe(struct usb_inte + if (!dev->tp_urb) + goto err_free_bt_urb; + +- dev->bt_data = usb_buffer_alloc(dev->udev, +- dev->cfg.bt_datalen, GFP_KERNEL, +- &dev->bt_urb->transfer_dma); ++ dev->bt_data = usb_alloc_coherent(dev->udev, ++ dev->cfg.bt_datalen, GFP_KERNEL, ++ &dev->bt_urb->transfer_dma); + if (!dev->bt_data) + goto err_free_urb; + +- dev->tp_data = usb_buffer_alloc(dev->udev, +- dev->cfg.tp_datalen, GFP_KERNEL, +- &dev->tp_urb->transfer_dma); ++ dev->tp_data = usb_alloc_coherent(dev->udev, ++ dev->cfg.tp_datalen, GFP_KERNEL, ++ &dev->tp_urb->transfer_dma); + if (!dev->tp_data) + goto err_free_bt_buffer; + +@@ -765,10 +765,10 @@ static int bcm5974_probe(struct usb_inte + return 0; + + err_free_buffer: +- usb_buffer_free(dev->udev, dev->cfg.tp_datalen, ++ usb_free_coherent(dev->udev, dev->cfg.tp_datalen, + dev->tp_data, dev->tp_urb->transfer_dma); + err_free_bt_buffer: +- usb_buffer_free(dev->udev, dev->cfg.bt_datalen, ++ usb_free_coherent(dev->udev, dev->cfg.bt_datalen, + dev->bt_data, dev->bt_urb->transfer_dma); + err_free_urb: + usb_free_urb(dev->tp_urb); +@@ -788,10 +788,10 @@ static void bcm5974_disconnect(struct us + usb_set_intfdata(iface, NULL); + + input_unregister_device(dev->input); +- usb_buffer_free(dev->udev, dev->cfg.tp_datalen, +- dev->tp_data, dev->tp_urb->transfer_dma); +- usb_buffer_free(dev->udev, dev->cfg.bt_datalen, +- dev->bt_data, dev->bt_urb->transfer_dma); ++ usb_free_coherent(dev->udev, dev->cfg.tp_datalen, ++ dev->tp_data, dev->tp_urb->transfer_dma); ++ usb_free_coherent(dev->udev, dev->cfg.bt_datalen, ++ dev->bt_data, dev->bt_urb->transfer_dma); + usb_free_urb(dev->tp_urb); + usb_free_urb(dev->bt_urb); + kfree(dev); +--- a/drivers/input/tablet/acecad.c ++++ b/drivers/input/tablet/acecad.c +@@ -155,7 +155,7 @@ static int usb_acecad_probe(struct usb_i + goto fail1; + } + +- acecad->data = usb_buffer_alloc(dev, 8, GFP_KERNEL, &acecad->data_dma); ++ acecad->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &acecad->data_dma); + if (!acecad->data) { + err= -ENOMEM; + goto fail1; +@@ -241,7 +241,7 @@ static int usb_acecad_probe(struct usb_i + + return 0; + +- fail2: usb_buffer_free(dev, 8, acecad->data, acecad->data_dma); ++ fail2: usb_free_coherent(dev, 8, acecad->data, acecad->data_dma); + fail1: input_free_device(input_dev); + kfree(acecad); + return err; +@@ -256,7 +256,7 @@ static void usb_acecad_disconnect(struct + usb_kill_urb(acecad->irq); + input_unregister_device(acecad->input); + usb_free_urb(acecad->irq); +- usb_buffer_free(interface_to_usbdev(intf), 10, acecad->data, acecad->data_dma); ++ usb_free_coherent(interface_to_usbdev(intf), 10, acecad->data, acecad->data_dma); + kfree(acecad); + } + } +--- a/drivers/input/tablet/aiptek.c ++++ b/drivers/input/tablet/aiptek.c +@@ -1711,8 +1711,8 @@ aiptek_probe(struct usb_interface *intf, + goto fail1; + } + +- aiptek->data = usb_buffer_alloc(usbdev, AIPTEK_PACKET_LENGTH, +- GFP_ATOMIC, &aiptek->data_dma); ++ aiptek->data = usb_alloc_coherent(usbdev, AIPTEK_PACKET_LENGTH, ++ GFP_ATOMIC, &aiptek->data_dma); + if (!aiptek->data) { + dev_warn(&intf->dev, "cannot allocate usb buffer\n"); + goto fail1; +@@ -1884,8 +1884,8 @@ aiptek_probe(struct usb_interface *intf, + + fail4: sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group); + fail3: usb_free_urb(aiptek->urb); +- fail2: usb_buffer_free(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data, +- aiptek->data_dma); ++ fail2: usb_free_coherent(usbdev, AIPTEK_PACKET_LENGTH, aiptek->data, ++ aiptek->data_dma); + fail1: usb_set_intfdata(intf, NULL); + input_free_device(inputdev); + kfree(aiptek); +@@ -1909,9 +1909,9 @@ static void aiptek_disconnect(struct usb + input_unregister_device(aiptek->inputdev); + sysfs_remove_group(&intf->dev.kobj, &aiptek_attribute_group); + usb_free_urb(aiptek->urb); +- usb_buffer_free(interface_to_usbdev(intf), +- AIPTEK_PACKET_LENGTH, +- aiptek->data, aiptek->data_dma); ++ usb_free_coherent(interface_to_usbdev(intf), ++ AIPTEK_PACKET_LENGTH, ++ aiptek->data, aiptek->data_dma); + kfree(aiptek); + } + } +--- a/drivers/input/tablet/gtco.c ++++ b/drivers/input/tablet/gtco.c +@@ -850,8 +850,8 @@ static int gtco_probe(struct usb_interfa + gtco->usbdev = usb_get_dev(interface_to_usbdev(usbinterface)); + + /* Allocate some data for incoming reports */ +- gtco->buffer = usb_buffer_alloc(gtco->usbdev, REPORT_MAX_SIZE, +- GFP_KERNEL, >co->buf_dma); ++ gtco->buffer = usb_alloc_coherent(gtco->usbdev, REPORT_MAX_SIZE, ++ GFP_KERNEL, >co->buf_dma); + if (!gtco->buffer) { + err("No more memory for us buffers"); + error = -ENOMEM; +@@ -982,8 +982,8 @@ static int gtco_probe(struct usb_interfa + err_free_urb: + usb_free_urb(gtco->urbinfo); + err_free_buf: +- usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE, +- gtco->buffer, gtco->buf_dma); ++ usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE, ++ gtco->buffer, gtco->buf_dma); + err_free_devs: + input_free_device(input_dev); + kfree(gtco); +@@ -1005,8 +1005,8 @@ static void gtco_disconnect(struct usb_i + input_unregister_device(gtco->inputdevice); + usb_kill_urb(gtco->urbinfo); + usb_free_urb(gtco->urbinfo); +- usb_buffer_free(gtco->usbdev, REPORT_MAX_SIZE, +- gtco->buffer, gtco->buf_dma); ++ usb_free_coherent(gtco->usbdev, REPORT_MAX_SIZE, ++ gtco->buffer, gtco->buf_dma); + kfree(gtco); + } + +--- a/drivers/input/tablet/kbtab.c ++++ b/drivers/input/tablet/kbtab.c +@@ -129,7 +129,7 @@ static int kbtab_probe(struct usb_interf + if (!kbtab || !input_dev) + goto fail1; + +- kbtab->data = usb_buffer_alloc(dev, 8, GFP_KERNEL, &kbtab->data_dma); ++ kbtab->data = usb_alloc_coherent(dev, 8, GFP_KERNEL, &kbtab->data_dma); + if (!kbtab->data) + goto fail1; + +@@ -182,7 +182,7 @@ static int kbtab_probe(struct usb_interf + return 0; + + fail3: usb_free_urb(kbtab->irq); +- fail2: usb_buffer_free(dev, 10, kbtab->data, kbtab->data_dma); ++ fail2: usb_free_coherent(dev, 10, kbtab->data, kbtab->data_dma); + fail1: input_free_device(input_dev); + kfree(kbtab); + return error; +@@ -197,7 +197,7 @@ static void kbtab_disconnect(struct usb_ + usb_kill_urb(kbtab->irq); + input_unregister_device(kbtab->dev); + usb_free_urb(kbtab->irq); +- usb_buffer_free(interface_to_usbdev(intf), 10, kbtab->data, kbtab->data_dma); ++ usb_free_coherent(interface_to_usbdev(intf), 10, kbtab->data, kbtab->data_dma); + kfree(kbtab); + } + } +--- a/drivers/input/tablet/wacom_sys.c ++++ b/drivers/input/tablet/wacom_sys.c +@@ -556,8 +556,8 @@ static int wacom_probe(struct usb_interf + goto fail1; + } + +- wacom_wac->data = usb_buffer_alloc(dev, WACOM_PKGLEN_MAX, +- GFP_KERNEL, &wacom->data_dma); ++ wacom_wac->data = usb_alloc_coherent(dev, WACOM_PKGLEN_MAX, ++ GFP_KERNEL, &wacom->data_dma); + if (!wacom_wac->data) { + error = -ENOMEM; + goto fail1; +@@ -633,7 +633,7 @@ static int wacom_probe(struct usb_interf + return 0; + + fail3: usb_free_urb(wacom->irq); +- fail2: usb_buffer_free(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma); ++ fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma); + fail1: input_free_device(input_dev); + kfree(wacom); + kfree(wacom_wac); +@@ -649,8 +649,8 @@ static void wacom_disconnect(struct usb_ + usb_kill_urb(wacom->irq); + input_unregister_device(wacom->dev); + usb_free_urb(wacom->irq); +- usb_buffer_free(interface_to_usbdev(intf), WACOM_PKGLEN_MAX, +- wacom->wacom_wac->data, wacom->data_dma); ++ usb_free_coherent(interface_to_usbdev(intf), WACOM_PKGLEN_MAX, ++ wacom->wacom_wac->data, wacom->data_dma); + kfree(wacom->wacom_wac); + kfree(wacom); + } +--- a/drivers/input/touchscreen/usbtouchscreen.c ++++ b/drivers/input/touchscreen/usbtouchscreen.c +@@ -1291,8 +1291,8 @@ static void usbtouch_close(struct input_ + static void usbtouch_free_buffers(struct usb_device *udev, + struct usbtouch_usb *usbtouch) + { +- usb_buffer_free(udev, usbtouch->type->rept_size, +- usbtouch->data, usbtouch->data_dma); ++ usb_free_coherent(udev, usbtouch->type->rept_size, ++ usbtouch->data, usbtouch->data_dma); + kfree(usbtouch->buffer); + } + +@@ -1336,8 +1336,8 @@ static int usbtouch_probe(struct usb_int + if (!type->process_pkt) + type->process_pkt = usbtouch_process_pkt; + +- usbtouch->data = usb_buffer_alloc(udev, type->rept_size, +- GFP_KERNEL, &usbtouch->data_dma); ++ usbtouch->data = usb_alloc_coherent(udev, type->rept_size, ++ GFP_KERNEL, &usbtouch->data_dma); + if (!usbtouch->data) + goto out_free; + +--- a/drivers/media/dvb/dvb-usb/usb-urb.c ++++ b/drivers/media/dvb/dvb-usb/usb-urb.c +@@ -96,8 +96,9 @@ static int usb_free_stream_buffers(struc + while (stream->buf_num) { + stream->buf_num--; + deb_mem("freeing buffer %d\n",stream->buf_num); +- usb_buffer_free(stream->udev, stream->buf_size, +- stream->buf_list[stream->buf_num], stream->dma_addr[stream->buf_num]); ++ usb_free_coherent(stream->udev, stream->buf_size, ++ stream->buf_list[stream->buf_num], ++ stream->dma_addr[stream->buf_num]); + } + } + +@@ -116,7 +117,7 @@ static int usb_allocate_stream_buffers(s + for (stream->buf_num = 0; stream->buf_num < num; stream->buf_num++) { + deb_mem("allocating buffer %d\n",stream->buf_num); + if (( stream->buf_list[stream->buf_num] = +- usb_buffer_alloc(stream->udev, size, GFP_ATOMIC, ++ usb_alloc_coherent(stream->udev, size, GFP_ATOMIC, + &stream->dma_addr[stream->buf_num]) ) == NULL) { + deb_mem("not enough memory for urb-buffer allocation.\n"); + usb_free_stream_buffers(stream); +--- a/drivers/media/dvb/ttusb-dec/ttusb_dec.c ++++ b/drivers/media/dvb/ttusb-dec/ttusb_dec.c +@@ -1257,7 +1257,7 @@ static int ttusb_dec_init_usb(struct ttu + if(!dec->irq_urb) { + return -ENOMEM; + } +- dec->irq_buffer = usb_buffer_alloc(dec->udev,IRQ_PACKET_SIZE, ++ dec->irq_buffer = usb_alloc_coherent(dec->udev,IRQ_PACKET_SIZE, + GFP_ATOMIC, &dec->irq_dma_handle); + if(!dec->irq_buffer) { + usb_free_urb(dec->irq_urb); +@@ -1550,8 +1550,8 @@ static void ttusb_dec_exit_rc(struct ttu + + usb_free_urb(dec->irq_urb); + +- usb_buffer_free(dec->udev,IRQ_PACKET_SIZE, +- dec->irq_buffer, dec->irq_dma_handle); ++ usb_free_coherent(dec->udev,IRQ_PACKET_SIZE, ++ dec->irq_buffer, dec->irq_dma_handle); + + if (dec->rc_input_dev) { + input_unregister_device(dec->rc_input_dev); +--- a/drivers/media/video/au0828/au0828-video.c ++++ b/drivers/media/video/au0828/au0828-video.c +@@ -177,7 +177,7 @@ void au0828_uninit_isoc(struct au0828_de + usb_unlink_urb(urb); + + if (dev->isoc_ctl.transfer_buffer[i]) { +- usb_buffer_free(dev->usbdev, ++ usb_free_coherent(dev->usbdev, + urb->transfer_buffer_length, + dev->isoc_ctl.transfer_buffer[i], + urb->transfer_dma); +@@ -247,7 +247,7 @@ int au0828_init_isoc(struct au0828_dev * + } + dev->isoc_ctl.urb[i] = urb; + +- dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->usbdev, ++ dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->usbdev, + sb_size, GFP_KERNEL, &urb->transfer_dma); + if (!dev->isoc_ctl.transfer_buffer[i]) { + printk("unable to allocate %i bytes for transfer" +--- a/drivers/media/video/cx231xx/cx231xx-core.c ++++ b/drivers/media/video/cx231xx/cx231xx-core.c +@@ -679,11 +679,11 @@ void cx231xx_uninit_isoc(struct cx231xx + usb_unlink_urb(urb); + + if (dev->video_mode.isoc_ctl.transfer_buffer[i]) { +- usb_buffer_free(dev->udev, +- urb->transfer_buffer_length, +- dev->video_mode.isoc_ctl. +- transfer_buffer[i], +- urb->transfer_dma); ++ usb_free_coherent(dev->udev, ++ urb->transfer_buffer_length, ++ dev->video_mode.isoc_ctl. ++ transfer_buffer[i], ++ urb->transfer_dma); + } + usb_free_urb(urb); + dev->video_mode.isoc_ctl.urb[i] = NULL; +@@ -770,8 +770,8 @@ int cx231xx_init_isoc(struct cx231xx *de + dev->video_mode.isoc_ctl.urb[i] = urb; + + dev->video_mode.isoc_ctl.transfer_buffer[i] = +- usb_buffer_alloc(dev->udev, sb_size, GFP_KERNEL, +- &urb->transfer_dma); ++ usb_alloc_coherent(dev->udev, sb_size, GFP_KERNEL, ++ &urb->transfer_dma); + if (!dev->video_mode.isoc_ctl.transfer_buffer[i]) { + cx231xx_err("unable to allocate %i bytes for transfer" + " buffer %i%s\n", +--- a/drivers/media/video/em28xx/em28xx-core.c ++++ b/drivers/media/video/em28xx/em28xx-core.c +@@ -966,7 +966,7 @@ void em28xx_uninit_isoc(struct em28xx *d + usb_unlink_urb(urb); + + if (dev->isoc_ctl.transfer_buffer[i]) { +- usb_buffer_free(dev->udev, ++ usb_free_coherent(dev->udev, + urb->transfer_buffer_length, + dev->isoc_ctl.transfer_buffer[i], + urb->transfer_dma); +@@ -1041,7 +1041,7 @@ int em28xx_init_isoc(struct em28xx *dev, + } + dev->isoc_ctl.urb[i] = urb; + +- dev->isoc_ctl.transfer_buffer[i] = usb_buffer_alloc(dev->udev, ++ dev->isoc_ctl.transfer_buffer[i] = usb_alloc_coherent(dev->udev, + sb_size, GFP_KERNEL, &urb->transfer_dma); + if (!dev->isoc_ctl.transfer_buffer[i]) { + em28xx_err("unable to allocate %i bytes for transfer" +--- a/drivers/media/video/gspca/benq.c ++++ b/drivers/media/video/gspca/benq.c +@@ -117,13 +117,13 @@ static int sd_start(struct gspca_dev *gs + return -ENOMEM; + } + gspca_dev->urb[n] = urb; +- urb->transfer_buffer = usb_buffer_alloc(gspca_dev->dev, ++ urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev, + SD_PKT_SZ * SD_NPKT, + GFP_KERNEL, + &urb->transfer_dma); + + if (urb->transfer_buffer == NULL) { +- err("usb_buffer_alloc failed"); ++ err("usb_alloc_coherent failed"); + return -ENOMEM; + } + urb->dev = gspca_dev->dev; +--- a/drivers/media/video/gspca/gspca.c ++++ b/drivers/media/video/gspca/gspca.c +@@ -213,7 +213,7 @@ static int alloc_and_submit_int_urb(stru + goto error; + } + +- buffer = usb_buffer_alloc(dev, ep->wMaxPacketSize, ++ buffer = usb_alloc_coherent(dev, ep->wMaxPacketSize, + GFP_KERNEL, &urb->transfer_dma); + if (!buffer) { + ret = -ENOMEM; +@@ -232,10 +232,10 @@ static int alloc_and_submit_int_urb(stru + return ret; + + error_submit: +- usb_buffer_free(dev, +- urb->transfer_buffer_length, +- urb->transfer_buffer, +- urb->transfer_dma); ++ usb_free_coherent(dev, ++ urb->transfer_buffer_length, ++ urb->transfer_buffer, ++ urb->transfer_dma); + error_buffer: + usb_free_urb(urb); + error: +@@ -272,10 +272,10 @@ static void gspca_input_destroy_urb(stru + if (urb) { + gspca_dev->int_urb = NULL; + usb_kill_urb(urb); +- usb_buffer_free(gspca_dev->dev, +- urb->transfer_buffer_length, +- urb->transfer_buffer, +- urb->transfer_dma); ++ usb_free_coherent(gspca_dev->dev, ++ urb->transfer_buffer_length, ++ urb->transfer_buffer, ++ urb->transfer_dma); + usb_free_urb(urb); + } + } +@@ -597,10 +597,10 @@ static void destroy_urbs(struct gspca_de + gspca_dev->urb[i] = NULL; + usb_kill_urb(urb); + if (urb->transfer_buffer != NULL) +- usb_buffer_free(gspca_dev->dev, +- urb->transfer_buffer_length, +- urb->transfer_buffer, +- urb->transfer_dma); ++ usb_free_coherent(gspca_dev->dev, ++ urb->transfer_buffer_length, ++ urb->transfer_buffer, ++ urb->transfer_dma); + usb_free_urb(urb); + } + } +@@ -721,13 +721,13 @@ static int create_urbs(struct gspca_dev + return -ENOMEM; + } + gspca_dev->urb[n] = urb; +- urb->transfer_buffer = usb_buffer_alloc(gspca_dev->dev, ++ urb->transfer_buffer = usb_alloc_coherent(gspca_dev->dev, + bsize, + GFP_KERNEL, + &urb->transfer_dma); + + if (urb->transfer_buffer == NULL) { +- err("usb_buffer_alloc failed"); ++ err("usb_alloc_coherent failed"); + return -ENOMEM; + } + urb->dev = gspca_dev->dev; +--- a/drivers/media/video/hdpvr/hdpvr-video.c ++++ b/drivers/media/video/hdpvr/hdpvr-video.c +@@ -92,8 +92,8 @@ static int hdpvr_free_queue(struct list_ + buf = list_entry(p, struct hdpvr_buffer, buff_list); + + urb = buf->urb; +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + usb_free_urb(urb); + tmp = p->next; + list_del(p); +@@ -143,8 +143,8 @@ int hdpvr_alloc_buffers(struct hdpvr_dev + } + buf->urb = urb; + +- mem = usb_buffer_alloc(dev->udev, dev->bulk_in_size, GFP_KERNEL, +- &urb->transfer_dma); ++ mem = usb_alloc_coherent(dev->udev, dev->bulk_in_size, GFP_KERNEL, ++ &urb->transfer_dma); + if (!mem) { + v4l2_err(&dev->v4l2_dev, + "cannot allocate usb transfer buffer\n"); +--- a/drivers/media/video/tlg2300/pd-video.c ++++ b/drivers/media/video/tlg2300/pd-video.c +@@ -476,10 +476,10 @@ static int prepare_iso_urb(struct video_ + goto out; + + video->urb_array[i] = urb; +- mem = usb_buffer_alloc(udev, +- ISO_PKT_SIZE * PK_PER_URB, +- GFP_KERNEL, +- &urb->transfer_dma); ++ mem = usb_alloc_coherent(udev, ++ ISO_PKT_SIZE * PK_PER_URB, ++ GFP_KERNEL, ++ &urb->transfer_dma); + + urb->complete = urb_complete_iso; /* handler */ + urb->dev = udev; +@@ -519,8 +519,8 @@ int alloc_bulk_urbs_generic(struct urb * + if (urb == NULL) + return i; + +- mem = usb_buffer_alloc(udev, buf_size, gfp_flags, +- &urb->transfer_dma); ++ mem = usb_alloc_coherent(udev, buf_size, gfp_flags, ++ &urb->transfer_dma); + if (mem == NULL) + return i; + +@@ -540,7 +540,7 @@ void free_all_urb_generic(struct urb **u + for (i = 0; i < num; i++) { + urb = urb_array[i]; + if (urb) { +- usb_buffer_free(urb->dev, ++ usb_free_coherent(urb->dev, + urb->transfer_buffer_length, + urb->transfer_buffer, + urb->transfer_dma); +--- a/drivers/media/video/usbvision/usbvision-core.c ++++ b/drivers/media/video/usbvision/usbvision-core.c +@@ -2493,10 +2493,10 @@ int usbvision_init_isoc(struct usb_usbvi + } + usbvision->sbuf[bufIdx].urb = urb; + usbvision->sbuf[bufIdx].data = +- usb_buffer_alloc(usbvision->dev, +- sb_size, +- GFP_KERNEL, +- &urb->transfer_dma); ++ usb_alloc_coherent(usbvision->dev, ++ sb_size, ++ GFP_KERNEL, ++ &urb->transfer_dma); + urb->dev = dev; + urb->context = usbvision; + urb->pipe = usb_rcvisocpipe(dev, usbvision->video_endp); +@@ -2552,10 +2552,10 @@ void usbvision_stop_isoc(struct usb_usbv + for (bufIdx = 0; bufIdx < USBVISION_NUMSBUF; bufIdx++) { + usb_kill_urb(usbvision->sbuf[bufIdx].urb); + if (usbvision->sbuf[bufIdx].data){ +- usb_buffer_free(usbvision->dev, +- sb_size, +- usbvision->sbuf[bufIdx].data, +- usbvision->sbuf[bufIdx].urb->transfer_dma); ++ usb_free_coherent(usbvision->dev, ++ sb_size, ++ usbvision->sbuf[bufIdx].data, ++ usbvision->sbuf[bufIdx].urb->transfer_dma); + } + usb_free_urb(usbvision->sbuf[bufIdx].urb); + usbvision->sbuf[bufIdx].urb = NULL; +--- a/drivers/media/video/uvc/uvc_video.c ++++ b/drivers/media/video/uvc/uvc_video.c +@@ -739,7 +739,7 @@ static void uvc_free_urb_buffers(struct + + for (i = 0; i < UVC_URBS; ++i) { + if (stream->urb_buffer[i]) { +- usb_buffer_free(stream->dev->udev, stream->urb_size, ++ usb_free_coherent(stream->dev->udev, stream->urb_size, + stream->urb_buffer[i], stream->urb_dma[i]); + stream->urb_buffer[i] = NULL; + } +@@ -780,7 +780,7 @@ static int uvc_alloc_urb_buffers(struct + for (; npackets > 1; npackets /= 2) { + for (i = 0; i < UVC_URBS; ++i) { + stream->urb_size = psize * npackets; +- stream->urb_buffer[i] = usb_buffer_alloc( ++ stream->urb_buffer[i] = usb_alloc_coherent( + stream->dev->udev, stream->urb_size, + gfp_flags | __GFP_NOWARN, &stream->urb_dma[i]); + if (!stream->urb_buffer[i]) { +--- a/drivers/net/can/usb/ems_usb.c ++++ b/drivers/net/can/usb/ems_usb.c +@@ -516,8 +516,8 @@ static void ems_usb_write_bulk_callback( + netdev = dev->netdev; + + /* free up our allocated buffer */ +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + + atomic_dec(&dev->active_tx_urbs); + +@@ -614,8 +614,8 @@ static int ems_usb_start(struct ems_usb + return -ENOMEM; + } + +- buf = usb_buffer_alloc(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL, +- &urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, RX_BUFFER_SIZE, GFP_KERNEL, ++ &urb->transfer_dma); + if (!buf) { + dev_err(netdev->dev.parent, + "No memory left for USB buffer\n"); +@@ -635,8 +635,8 @@ static int ems_usb_start(struct ems_usb + netif_device_detach(dev->netdev); + + usb_unanchor_urb(urb); +- usb_buffer_free(dev->udev, RX_BUFFER_SIZE, buf, +- urb->transfer_dma); ++ usb_free_coherent(dev->udev, RX_BUFFER_SIZE, buf, ++ urb->transfer_dma); + break; + } + +@@ -777,7 +777,7 @@ static netdev_tx_t ems_usb_start_xmit(st + goto nomem; + } + +- buf = usb_buffer_alloc(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, size, GFP_ATOMIC, &urb->transfer_dma); + if (!buf) { + dev_err(netdev->dev.parent, "No memory left for USB buffer\n"); + usb_free_urb(urb); +@@ -820,7 +820,7 @@ static netdev_tx_t ems_usb_start_xmit(st + */ + if (!context) { + usb_unanchor_urb(urb); +- usb_buffer_free(dev->udev, size, buf, urb->transfer_dma); ++ usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); + + dev_warn(netdev->dev.parent, "couldn't find free context\n"); + +@@ -845,7 +845,7 @@ static netdev_tx_t ems_usb_start_xmit(st + can_free_echo_skb(netdev, context->echo_index); + + usb_unanchor_urb(urb); +- usb_buffer_free(dev->udev, size, buf, urb->transfer_dma); ++ usb_free_coherent(dev->udev, size, buf, urb->transfer_dma); + dev_kfree_skb(skb); + + atomic_dec(&dev->active_tx_urbs); +--- a/drivers/net/usb/kaweth.c ++++ b/drivers/net/usb/kaweth.c +@@ -1155,13 +1155,13 @@ err_fw: + if (!kaweth->irq_urb) + goto err_tx_and_rx; + +- kaweth->intbuffer = usb_buffer_alloc( kaweth->dev, ++ kaweth->intbuffer = usb_alloc_coherent( kaweth->dev, + INTBUFFERSIZE, + GFP_KERNEL, + &kaweth->intbufferhandle); + if (!kaweth->intbuffer) + goto err_tx_and_rx_and_irq; +- kaweth->rx_buf = usb_buffer_alloc( kaweth->dev, ++ kaweth->rx_buf = usb_alloc_coherent( kaweth->dev, + KAWETH_BUF_SIZE, + GFP_KERNEL, + &kaweth->rxbufferhandle); +@@ -1202,9 +1202,9 @@ err_fw: + + err_intfdata: + usb_set_intfdata(intf, NULL); +- usb_buffer_free(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle); ++ usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle); + err_all_but_rxbuf: +- usb_buffer_free(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle); ++ usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle); + err_tx_and_rx_and_irq: + usb_free_urb(kaweth->irq_urb); + err_tx_and_rx: +@@ -1241,8 +1241,8 @@ static void kaweth_disconnect(struct usb + usb_free_urb(kaweth->tx_urb); + usb_free_urb(kaweth->irq_urb); + +- usb_buffer_free(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle); +- usb_buffer_free(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle); ++ usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle); ++ usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle); + + free_netdev(netdev); + } +--- a/drivers/net/wireless/ath/ar9170/usb.c ++++ b/drivers/net/wireless/ath/ar9170/usb.c +@@ -202,7 +202,7 @@ resubmit: + return; + + free: +- usb_buffer_free(aru->udev, 64, urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(aru->udev, 64, urb->transfer_buffer, urb->transfer_dma); + } + + static void ar9170_usb_rx_completed(struct urb *urb) +@@ -283,7 +283,7 @@ static int ar9170_usb_alloc_rx_irq_urb(s + if (!urb) + goto out; + +- ibuf = usb_buffer_alloc(aru->udev, 64, GFP_KERNEL, &urb->transfer_dma); ++ ibuf = usb_alloc_coherent(aru->udev, 64, GFP_KERNEL, &urb->transfer_dma); + if (!ibuf) + goto out; + +@@ -296,8 +296,8 @@ static int ar9170_usb_alloc_rx_irq_urb(s + err = usb_submit_urb(urb, GFP_KERNEL); + if (err) { + usb_unanchor_urb(urb); +- usb_buffer_free(aru->udev, 64, urb->transfer_buffer, +- urb->transfer_dma); ++ usb_free_coherent(aru->udev, 64, urb->transfer_buffer, ++ urb->transfer_dma); + } + + out: +--- a/drivers/net/wireless/zd1211rw/zd_usb.c ++++ b/drivers/net/wireless/zd1211rw/zd_usb.c +@@ -664,15 +664,15 @@ static struct urb *alloc_rx_urb(struct z + urb = usb_alloc_urb(0, GFP_KERNEL); + if (!urb) + return NULL; +- buffer = usb_buffer_alloc(udev, USB_MAX_RX_SIZE, GFP_KERNEL, +- &urb->transfer_dma); ++ buffer = usb_alloc_coherent(udev, USB_MAX_RX_SIZE, GFP_KERNEL, ++ &urb->transfer_dma); + if (!buffer) { + usb_free_urb(urb); + return NULL; + } + + usb_fill_bulk_urb(urb, udev, usb_rcvbulkpipe(udev, EP_DATA_IN), +- buffer, USB_MAX_RX_SIZE, ++ buffer, USB_MAX_RX_SIZE, + rx_urb_complete, usb); + urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; + +@@ -683,8 +683,8 @@ static void free_rx_urb(struct urb *urb) + { + if (!urb) + return; +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + usb_free_urb(urb); + } + +--- a/drivers/usb/class/cdc-acm.c ++++ b/drivers/usb/class/cdc-acm.c +@@ -892,7 +892,7 @@ static void acm_write_buffers_free(struc + struct usb_device *usb_dev = interface_to_usbdev(acm->control); + + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) +- usb_buffer_free(usb_dev, acm->writesize, wb->buf, wb->dmah); ++ usb_free_coherent(usb_dev, acm->writesize, wb->buf, wb->dmah); + } + + static void acm_read_buffers_free(struct acm *acm) +@@ -901,8 +901,8 @@ static void acm_read_buffers_free(struct + int i, n = acm->rx_buflimit; + + for (i = 0; i < n; i++) +- usb_buffer_free(usb_dev, acm->readsize, +- acm->rb[i].base, acm->rb[i].dma); ++ usb_free_coherent(usb_dev, acm->readsize, ++ acm->rb[i].base, acm->rb[i].dma); + } + + /* Little helper: write buffers allocate */ +@@ -912,13 +912,13 @@ static int acm_write_buffers_alloc(struc + struct acm_wb *wb; + + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { +- wb->buf = usb_buffer_alloc(acm->dev, acm->writesize, GFP_KERNEL, ++ wb->buf = usb_alloc_coherent(acm->dev, acm->writesize, GFP_KERNEL, + &wb->dmah); + if (!wb->buf) { + while (i != 0) { + --i; + --wb; +- usb_buffer_free(acm->dev, acm->writesize, ++ usb_free_coherent(acm->dev, acm->writesize, + wb->buf, wb->dmah); + } + return -ENOMEM; +@@ -1177,7 +1177,7 @@ made_compressed_probe: + tty_port_init(&acm->port); + acm->port.ops = &acm_port_ops; + +- buf = usb_buffer_alloc(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); ++ buf = usb_alloc_coherent(usb_dev, ctrlsize, GFP_KERNEL, &acm->ctrl_dma); + if (!buf) { + dev_dbg(&intf->dev, "out of memory (ctrl buffer alloc)\n"); + goto alloc_fail2; +@@ -1210,11 +1210,11 @@ made_compressed_probe: + for (i = 0; i < num_rx_buf; i++) { + struct acm_rb *rb = &(acm->rb[i]); + +- rb->base = usb_buffer_alloc(acm->dev, readsize, ++ rb->base = usb_alloc_coherent(acm->dev, readsize, + GFP_KERNEL, &rb->dma); + if (!rb->base) { + dev_dbg(&intf->dev, +- "out of memory (read bufs usb_buffer_alloc)\n"); ++ "out of memory (read bufs usb_alloc_coherent)\n"); + goto alloc_fail7; + } + } +@@ -1306,7 +1306,7 @@ alloc_fail7: + alloc_fail5: + acm_write_buffers_free(acm); + alloc_fail4: +- usb_buffer_free(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); ++ usb_free_coherent(usb_dev, ctrlsize, acm->ctrl_buffer, acm->ctrl_dma); + alloc_fail2: + kfree(acm); + alloc_fail: +@@ -1356,8 +1356,8 @@ static void acm_disconnect(struct usb_in + stop_data_traffic(acm); + + acm_write_buffers_free(acm); +- usb_buffer_free(usb_dev, acm->ctrlsize, acm->ctrl_buffer, +- acm->ctrl_dma); ++ usb_free_coherent(usb_dev, acm->ctrlsize, acm->ctrl_buffer, ++ acm->ctrl_dma); + acm_read_buffers_free(acm); + + if (!acm->combined_interfaces) +--- a/drivers/usb/class/cdc-wdm.c ++++ b/drivers/usb/class/cdc-wdm.c +@@ -276,14 +276,14 @@ static void free_urbs(struct wdm_device + + static void cleanup(struct wdm_device *desc) + { +- usb_buffer_free(interface_to_usbdev(desc->intf), +- desc->wMaxPacketSize, +- desc->sbuf, +- desc->validity->transfer_dma); +- usb_buffer_free(interface_to_usbdev(desc->intf), +- desc->wMaxCommand, +- desc->inbuf, +- desc->response->transfer_dma); ++ usb_free_coherent(interface_to_usbdev(desc->intf), ++ desc->wMaxPacketSize, ++ desc->sbuf, ++ desc->validity->transfer_dma); ++ usb_free_coherent(interface_to_usbdev(desc->intf), ++ desc->wMaxCommand, ++ desc->inbuf, ++ desc->response->transfer_dma); + kfree(desc->orq); + kfree(desc->irq); + kfree(desc->ubuf); +@@ -705,17 +705,17 @@ next_desc: + if (!desc->ubuf) + goto err; + +- desc->sbuf = usb_buffer_alloc(interface_to_usbdev(intf), ++ desc->sbuf = usb_alloc_coherent(interface_to_usbdev(intf), + desc->wMaxPacketSize, + GFP_KERNEL, + &desc->validity->transfer_dma); + if (!desc->sbuf) + goto err; + +- desc->inbuf = usb_buffer_alloc(interface_to_usbdev(intf), +- desc->bMaxPacketSize0, +- GFP_KERNEL, +- &desc->response->transfer_dma); ++ desc->inbuf = usb_alloc_coherent(interface_to_usbdev(intf), ++ desc->bMaxPacketSize0, ++ GFP_KERNEL, ++ &desc->response->transfer_dma); + if (!desc->inbuf) + goto err2; + +@@ -742,15 +742,15 @@ out: + return rv; + err3: + usb_set_intfdata(intf, NULL); +- usb_buffer_free(interface_to_usbdev(desc->intf), +- desc->bMaxPacketSize0, ++ usb_free_coherent(interface_to_usbdev(desc->intf), ++ desc->bMaxPacketSize0, + desc->inbuf, + desc->response->transfer_dma); + err2: +- usb_buffer_free(interface_to_usbdev(desc->intf), +- desc->wMaxPacketSize, +- desc->sbuf, +- desc->validity->transfer_dma); ++ usb_free_coherent(interface_to_usbdev(desc->intf), ++ desc->wMaxPacketSize, ++ desc->sbuf, ++ desc->validity->transfer_dma); + err: + free_urbs(desc); + kfree(desc->ubuf); +--- a/drivers/usb/class/usblp.c ++++ b/drivers/usb/class/usblp.c +@@ -27,7 +27,7 @@ + * v0.11 - add proto_bias option (Pete Zaitcev) + * v0.12 - add hpoj.sourceforge.net ioctls (David Paschal) + * v0.13 - alloc space for statusbuf (<status> not on stack); +- * use usb_buffer_alloc() for read buf & write buf; ++ * use usb_alloc_coherent() for read buf & write buf; + * none - Maintained in Linux kernel after v0.13 + */ + +--- a/drivers/usb/misc/appledisplay.c ++++ b/drivers/usb/misc/appledisplay.c +@@ -259,7 +259,7 @@ static int appledisplay_probe(struct usb + } + + /* Allocate buffer for interrupt data */ +- pdata->urbdata = usb_buffer_alloc(pdata->udev, ACD_URB_BUFFER_LEN, ++ pdata->urbdata = usb_alloc_coherent(pdata->udev, ACD_URB_BUFFER_LEN, + GFP_KERNEL, &pdata->urb->transfer_dma); + if (!pdata->urbdata) { + retval = -ENOMEM; +@@ -316,7 +316,7 @@ error: + if (pdata->urb) { + usb_kill_urb(pdata->urb); + if (pdata->urbdata) +- usb_buffer_free(pdata->udev, ACD_URB_BUFFER_LEN, ++ usb_free_coherent(pdata->udev, ACD_URB_BUFFER_LEN, + pdata->urbdata, pdata->urb->transfer_dma); + usb_free_urb(pdata->urb); + } +@@ -337,7 +337,7 @@ static void appledisplay_disconnect(stru + usb_kill_urb(pdata->urb); + cancel_delayed_work(&pdata->work); + backlight_device_unregister(pdata->bd); +- usb_buffer_free(pdata->udev, ACD_URB_BUFFER_LEN, ++ usb_free_coherent(pdata->udev, ACD_URB_BUFFER_LEN, + pdata->urbdata, pdata->urb->transfer_dma); + usb_free_urb(pdata->urb); + kfree(pdata->msgdata); +--- a/drivers/usb/misc/ftdi-elan.c ++++ b/drivers/usb/misc/ftdi-elan.c +@@ -734,7 +734,7 @@ static void ftdi_elan_write_bulk_callbac + dev_err(&ftdi->udev->dev, "urb=%p write bulk status received: %" + "d\n", urb, status); + } +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, + urb->transfer_buffer, urb->transfer_dma); + } + +@@ -795,7 +795,7 @@ static int ftdi_elan_command_engine(stru + total_size); + return -ENOMEM; + } +- buf = usb_buffer_alloc(ftdi->udev, total_size, GFP_KERNEL, ++ buf = usb_alloc_coherent(ftdi->udev, total_size, GFP_KERNEL, + &urb->transfer_dma); + if (!buf) { + dev_err(&ftdi->udev->dev, "could not get a buffer to write %d c" +@@ -829,7 +829,7 @@ static int ftdi_elan_command_engine(stru + dev_err(&ftdi->udev->dev, "failed %d to submit urb %p to write " + "%d commands totaling %d bytes to the Uxxx\n", retval, + urb, command_size, total_size); +- usb_buffer_free(ftdi->udev, total_size, buf, urb->transfer_dma); ++ usb_free_coherent(ftdi->udev, total_size, buf, urb->transfer_dma); + usb_free_urb(urb); + return retval; + } +@@ -1167,7 +1167,7 @@ static ssize_t ftdi_elan_write(struct fi + retval = -ENOMEM; + goto error_1; + } +- buf = usb_buffer_alloc(ftdi->udev, count, GFP_KERNEL, ++ buf = usb_alloc_coherent(ftdi->udev, count, GFP_KERNEL, + &urb->transfer_dma); + if (!buf) { + retval = -ENOMEM; +@@ -1192,7 +1192,7 @@ static ssize_t ftdi_elan_write(struct fi + exit: + return count; + error_3: +- usb_buffer_free(ftdi->udev, count, buf, urb->transfer_dma); ++ usb_free_coherent(ftdi->udev, count, buf, urb->transfer_dma); + error_2: + usb_free_urb(urb); + error_1: +@@ -1968,7 +1968,7 @@ static int ftdi_elan_synchronize_flush(s + "ence\n"); + return -ENOMEM; + } +- buf = usb_buffer_alloc(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); ++ buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); + if (!buf) { + dev_err(&ftdi->udev->dev, "could not get a buffer for flush seq" + "uence\n"); +@@ -1985,7 +1985,7 @@ static int ftdi_elan_synchronize_flush(s + if (retval) { + dev_err(&ftdi->udev->dev, "failed to submit urb containing the " + "flush sequence\n"); +- usb_buffer_free(ftdi->udev, i, buf, urb->transfer_dma); ++ usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma); + usb_free_urb(urb); + return -ENOMEM; + } +@@ -2011,7 +2011,7 @@ static int ftdi_elan_synchronize_reset(s + "quence\n"); + return -ENOMEM; + } +- buf = usb_buffer_alloc(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); ++ buf = usb_alloc_coherent(ftdi->udev, I, GFP_KERNEL, &urb->transfer_dma); + if (!buf) { + dev_err(&ftdi->udev->dev, "could not get a buffer for the reset" + " sequence\n"); +@@ -2030,7 +2030,7 @@ static int ftdi_elan_synchronize_reset(s + if (retval) { + dev_err(&ftdi->udev->dev, "failed to submit urb containing the " + "reset sequence\n"); +- usb_buffer_free(ftdi->udev, i, buf, urb->transfer_dma); ++ usb_free_coherent(ftdi->udev, i, buf, urb->transfer_dma); + usb_free_urb(urb); + return -ENOMEM; + } +--- a/drivers/usb/misc/iowarrior.c ++++ b/drivers/usb/misc/iowarrior.c +@@ -239,8 +239,8 @@ static void iowarrior_write_callback(str + __func__, status); + } + /* free up our allocated buffer */ +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + /* tell a waiting writer the interrupt-out-pipe is available again */ + atomic_dec(&dev->write_busy); + wake_up_interruptible(&dev->write_wait); +@@ -421,8 +421,8 @@ static ssize_t iowarrior_write(struct fi + dbg("%s Unable to allocate urb ", __func__); + goto error_no_urb; + } +- buf = usb_buffer_alloc(dev->udev, dev->report_size, +- GFP_KERNEL, &int_out_urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, dev->report_size, ++ GFP_KERNEL, &int_out_urb->transfer_dma); + if (!buf) { + retval = -ENOMEM; + dbg("%s Unable to allocate buffer ", __func__); +@@ -459,8 +459,8 @@ static ssize_t iowarrior_write(struct fi + break; + } + error: +- usb_buffer_free(dev->udev, dev->report_size, buf, +- int_out_urb->transfer_dma); ++ usb_free_coherent(dev->udev, dev->report_size, buf, ++ int_out_urb->transfer_dma); + error_no_buffer: + usb_free_urb(int_out_urb); + error_no_urb: +--- a/drivers/usb/misc/usblcd.c ++++ b/drivers/usb/misc/usblcd.c +@@ -205,8 +205,8 @@ static void lcd_write_bulk_callback(stru + } + + /* free up our allocated buffer */ +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + up(&dev->limit_sem); + } + +@@ -234,7 +234,7 @@ static ssize_t lcd_write(struct file *fi + goto err_no_buf; + } + +- buf = usb_buffer_alloc(dev->udev, count, GFP_KERNEL, &urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, count, GFP_KERNEL, &urb->transfer_dma); + if (!buf) { + retval = -ENOMEM; + goto error; +@@ -268,7 +268,7 @@ exit: + error_unanchor: + usb_unanchor_urb(urb); + error: +- usb_buffer_free(dev->udev, count, buf, urb->transfer_dma); ++ usb_free_coherent(dev->udev, count, buf, urb->transfer_dma); + usb_free_urb(urb); + err_no_buf: + up(&dev->limit_sem); +--- a/drivers/usb/misc/usbtest.c ++++ b/drivers/usb/misc/usbtest.c +@@ -202,7 +202,7 @@ static struct urb *simple_alloc_urb ( + urb->transfer_flags = URB_NO_TRANSFER_DMA_MAP; + if (usb_pipein (pipe)) + urb->transfer_flags |= URB_SHORT_NOT_OK; +- urb->transfer_buffer = usb_buffer_alloc (udev, bytes, GFP_KERNEL, ++ urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL, + &urb->transfer_dma); + if (!urb->transfer_buffer) { + usb_free_urb (urb); +@@ -272,8 +272,8 @@ static inline int simple_check_buf(struc + + static void simple_free_urb (struct urb *urb) + { +- usb_buffer_free (urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + usb_free_urb (urb); + } + +@@ -1416,7 +1416,7 @@ static struct urb *iso_alloc_urb ( + + urb->number_of_packets = packets; + urb->transfer_buffer_length = bytes; +- urb->transfer_buffer = usb_buffer_alloc (udev, bytes, GFP_KERNEL, ++ urb->transfer_buffer = usb_alloc_coherent (udev, bytes, GFP_KERNEL, + &urb->transfer_dma); + if (!urb->transfer_buffer) { + usb_free_urb (urb); +--- a/drivers/usb/storage/onetouch.c ++++ b/drivers/usb/storage/onetouch.c +@@ -201,8 +201,8 @@ static int onetouch_connect_input(struct + if (!onetouch || !input_dev) + goto fail1; + +- onetouch->data = usb_buffer_alloc(udev, ONETOUCH_PKT_LEN, +- GFP_KERNEL, &onetouch->data_dma); ++ onetouch->data = usb_alloc_coherent(udev, ONETOUCH_PKT_LEN, ++ GFP_KERNEL, &onetouch->data_dma); + if (!onetouch->data) + goto fail1; + +@@ -264,8 +264,8 @@ static int onetouch_connect_input(struct + return 0; + + fail3: usb_free_urb(onetouch->irq); +- fail2: usb_buffer_free(udev, ONETOUCH_PKT_LEN, +- onetouch->data, onetouch->data_dma); ++ fail2: usb_free_coherent(udev, ONETOUCH_PKT_LEN, ++ onetouch->data, onetouch->data_dma); + fail1: kfree(onetouch); + input_free_device(input_dev); + return error; +@@ -279,8 +279,8 @@ static void onetouch_release_input(void + usb_kill_urb(onetouch->irq); + input_unregister_device(onetouch->dev); + usb_free_urb(onetouch->irq); +- usb_buffer_free(onetouch->udev, ONETOUCH_PKT_LEN, +- onetouch->data, onetouch->data_dma); ++ usb_free_coherent(onetouch->udev, ONETOUCH_PKT_LEN, ++ onetouch->data, onetouch->data_dma); + } + } + +--- a/drivers/usb/storage/usb.c ++++ b/drivers/usb/storage/usb.c +@@ -414,7 +414,7 @@ static int associate_dev(struct us_data + return -ENOMEM; + } + +- us->iobuf = usb_buffer_alloc(us->pusb_dev, US_IOBUF_SIZE, ++ us->iobuf = usb_alloc_coherent(us->pusb_dev, US_IOBUF_SIZE, + GFP_KERNEL, &us->iobuf_dma); + if (!us->iobuf) { + US_DEBUGP("I/O buffer allocation failed\n"); +@@ -758,7 +758,7 @@ static void dissociate_dev(struct us_dat + + /* Free the buffers */ + kfree(us->cr); +- usb_buffer_free(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma); ++ usb_free_coherent(us->pusb_dev, US_IOBUF_SIZE, us->iobuf, us->iobuf_dma); + + /* Remove our private data from the interface */ + usb_set_intfdata(us->pusb_intf, NULL); +--- a/drivers/usb/usb-skeleton.c ++++ b/drivers/usb/usb-skeleton.c +@@ -387,8 +387,8 @@ static void skel_write_bulk_callback(str + } + + /* free up our allocated buffer */ +- usb_buffer_free(urb->dev, urb->transfer_buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, urb->transfer_buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + up(&dev->limit_sem); + } + +@@ -442,8 +442,8 @@ static ssize_t skel_write(struct file *f + goto error; + } + +- buf = usb_buffer_alloc(dev->udev, writesize, GFP_KERNEL, +- &urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL, ++ &urb->transfer_dma); + if (!buf) { + retval = -ENOMEM; + goto error; +@@ -491,7 +491,7 @@ error_unanchor: + usb_unanchor_urb(urb); + error: + if (urb) { +- usb_buffer_free(dev->udev, writesize, buf, urb->transfer_dma); ++ usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma); + usb_free_urb(urb); + } + up(&dev->limit_sem); +--- a/drivers/watchdog/pcwd_usb.c ++++ b/drivers/watchdog/pcwd_usb.c +@@ -600,8 +600,8 @@ static inline void usb_pcwd_delete(struc + { + usb_free_urb(usb_pcwd->intr_urb); + if (usb_pcwd->intr_buffer != NULL) +- usb_buffer_free(usb_pcwd->udev, usb_pcwd->intr_size, +- usb_pcwd->intr_buffer, usb_pcwd->intr_dma); ++ usb_free_coherent(usb_pcwd->udev, usb_pcwd->intr_size, ++ usb_pcwd->intr_buffer, usb_pcwd->intr_dma); + kfree(usb_pcwd); + } + +@@ -671,7 +671,7 @@ static int usb_pcwd_probe(struct usb_int + le16_to_cpu(endpoint->wMaxPacketSize) : 8); + + /* set up the memory buffer's */ +- usb_pcwd->intr_buffer = usb_buffer_alloc(udev, usb_pcwd->intr_size, ++ usb_pcwd->intr_buffer = usb_alloc_coherent(udev, usb_pcwd->intr_size, + GFP_ATOMIC, &usb_pcwd->intr_dma); + if (!usb_pcwd->intr_buffer) { + printk(KERN_ERR PFX "Out of memory\n"); +--- a/sound/usb/ua101.c ++++ b/sound/usb/ua101.c +@@ -41,7 +41,7 @@ MODULE_SUPPORTED_DEVICE("{{Edirol,UA-101 + /* + * This magic value optimizes memory usage efficiency for the UA-101's packet + * sizes at all sample rates, taking into account the stupid cache pool sizes +- * that usb_buffer_alloc() uses. ++ * that usb_alloc_coherent() uses. + */ + #define DEFAULT_QUEUE_LENGTH 21 + +@@ -1056,7 +1056,7 @@ static int alloc_stream_buffers(struct u + (unsigned int)MAX_QUEUE_LENGTH); + + /* +- * The cache pool sizes used by usb_buffer_alloc() (128, 512, 2048) are ++ * The cache pool sizes used by usb_alloc_coherent() (128, 512, 2048) are + * quite bad when used with the packet sizes of this device (e.g. 280, + * 520, 624). Therefore, we allocate and subdivide entire pages, using + * a smaller buffer only for the last chunk. +@@ -1067,8 +1067,8 @@ static int alloc_stream_buffers(struct u + packets = min(remaining_packets, packets_per_page); + size = packets * stream->max_packet_bytes; + stream->buffers[i].addr = +- usb_buffer_alloc(ua->dev, size, GFP_KERNEL, +- &stream->buffers[i].dma); ++ usb_alloc_coherent(ua->dev, size, GFP_KERNEL, ++ &stream->buffers[i].dma); + if (!stream->buffers[i].addr) + return -ENOMEM; + stream->buffers[i].size = size; +@@ -1088,10 +1088,10 @@ static void free_stream_buffers(struct u + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(stream->buffers); ++i) +- usb_buffer_free(ua->dev, +- stream->buffers[i].size, +- stream->buffers[i].addr, +- stream->buffers[i].dma); ++ usb_free_coherent(ua->dev, ++ stream->buffers[i].size, ++ stream->buffers[i].addr, ++ stream->buffers[i].dma); + } + + static int alloc_stream_urbs(struct ua101 *ua, struct ua101_stream *stream, +--- a/sound/usb/usbaudio.c ++++ b/sound/usb/usbaudio.c +@@ -985,9 +985,9 @@ static void release_urb_ctx(struct snd_u + { + if (u->urb) { + if (u->buffer_size) +- usb_buffer_free(u->subs->dev, u->buffer_size, +- u->urb->transfer_buffer, +- u->urb->transfer_dma); ++ usb_free_coherent(u->subs->dev, u->buffer_size, ++ u->urb->transfer_buffer, ++ u->urb->transfer_dma); + usb_free_urb(u->urb); + u->urb = NULL; + } +@@ -1008,8 +1008,8 @@ static void release_substream_urbs(struc + release_urb_ctx(&subs->dataurb[i]); + for (i = 0; i < SYNC_URBS; i++) + release_urb_ctx(&subs->syncurb[i]); +- usb_buffer_free(subs->dev, SYNC_URBS * 4, +- subs->syncbuf, subs->sync_dma); ++ usb_free_coherent(subs->dev, SYNC_URBS * 4, ++ subs->syncbuf, subs->sync_dma); + subs->syncbuf = NULL; + subs->nurbs = 0; + } +@@ -1113,8 +1113,8 @@ static int init_substream_urbs(struct sn + if (!u->urb) + goto out_of_memory; + u->urb->transfer_buffer = +- usb_buffer_alloc(subs->dev, u->buffer_size, GFP_KERNEL, +- &u->urb->transfer_dma); ++ usb_alloc_coherent(subs->dev, u->buffer_size, GFP_KERNEL, ++ &u->urb->transfer_dma); + if (!u->urb->transfer_buffer) + goto out_of_memory; + u->urb->pipe = subs->datapipe; +@@ -1126,8 +1126,8 @@ static int init_substream_urbs(struct sn + + if (subs->syncpipe) { + /* allocate and initialize sync urbs */ +- subs->syncbuf = usb_buffer_alloc(subs->dev, SYNC_URBS * 4, +- GFP_KERNEL, &subs->sync_dma); ++ subs->syncbuf = usb_alloc_coherent(subs->dev, SYNC_URBS * 4, ++ GFP_KERNEL, &subs->sync_dma); + if (!subs->syncbuf) + goto out_of_memory; + for (i = 0; i < SYNC_URBS; i++) { +--- a/sound/usb/usbmidi.c ++++ b/sound/usb/usbmidi.c +@@ -1047,8 +1047,8 @@ static struct snd_rawmidi_ops snd_usbmid + static void free_urb_and_buffer(struct snd_usb_midi *umidi, struct urb *urb, + unsigned int buffer_length) + { +- usb_buffer_free(umidi->dev, buffer_length, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(umidi->dev, buffer_length, ++ urb->transfer_buffer, urb->transfer_dma); + usb_free_urb(urb); + } + +@@ -1099,8 +1099,8 @@ static int snd_usbmidi_in_endpoint_creat + pipe = usb_rcvbulkpipe(umidi->dev, ep_info->in_ep); + length = usb_maxpacket(umidi->dev, pipe, 0); + for (i = 0; i < INPUT_URBS; ++i) { +- buffer = usb_buffer_alloc(umidi->dev, length, GFP_KERNEL, +- &ep->urbs[i]->transfer_dma); ++ buffer = usb_alloc_coherent(umidi->dev, length, GFP_KERNEL, ++ &ep->urbs[i]->transfer_dma); + if (!buffer) { + snd_usbmidi_in_endpoint_delete(ep); + return -ENOMEM; +@@ -1190,9 +1190,9 @@ static int snd_usbmidi_out_endpoint_crea + break; + } + for (i = 0; i < OUTPUT_URBS; ++i) { +- buffer = usb_buffer_alloc(umidi->dev, +- ep->max_transfer, GFP_KERNEL, +- &ep->urbs[i].urb->transfer_dma); ++ buffer = usb_alloc_coherent(umidi->dev, ++ ep->max_transfer, GFP_KERNEL, ++ &ep->urbs[i].urb->transfer_dma); + if (!buffer) { + snd_usbmidi_out_endpoint_delete(ep); + return -ENOMEM; diff --git a/usb/usb-staging-fix-up-usb_buffer_alloc-calls-in-the-staging-tree.patch b/usb/usb-staging-fix-up-usb_buffer_alloc-calls-in-the-staging-tree.patch new file mode 100644 index 00000000000000..3282f9764fbbde --- /dev/null +++ b/usb/usb-staging-fix-up-usb_buffer_alloc-calls-in-the-staging-tree.patch @@ -0,0 +1,53 @@ +From foo@baz Thu Apr 29 15:36:29 PDT 2010 +Date: Thu, 29 Apr 2010 15:36:29 -0700 +To: Greg KH <greg@kroah.com> +From: Greg Kroah-Hartman <gregkh@suse.de> +Subject: USB: staging: fix up usb_buffer_alloc calls in the staging tree + +This renames the functions usb_buffer_alloc and usb_buffer_free to the correct +ones for the drivers in the staging tree. + +Cc: Daniel Mack <daniel@caiaq.de> +Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de> +--- + drivers/staging/rt2860/iface/rtmp_usb.h | 4 ++-- + drivers/staging/udlfb/udlfb.c | 8 ++++---- + 2 files changed, 6 insertions(+), 6 deletions(-) + +--- a/drivers/staging/rt2860/iface/rtmp_usb.h ++++ b/drivers/staging/rt2860/iface/rtmp_usb.h +@@ -81,8 +81,8 @@ extern u8 EpToQueue[6]; + #define RT28XX_PUT_DEVICE usb_put_dev + #define RTUSB_ALLOC_URB(iso) usb_alloc_urb(iso, GFP_ATOMIC) + #define RTUSB_SUBMIT_URB(pUrb) usb_submit_urb(pUrb, GFP_ATOMIC) +-#define RTUSB_URB_ALLOC_BUFFER(pUsb_Dev, BufSize, pDma_addr) usb_buffer_alloc(pUsb_Dev, BufSize, GFP_ATOMIC, pDma_addr) +-#define RTUSB_URB_FREE_BUFFER(pUsb_Dev, BufSize, pTransferBuf, Dma_addr) usb_buffer_free(pUsb_Dev, BufSize, pTransferBuf, Dma_addr) ++#define RTUSB_URB_ALLOC_BUFFER(pUsb_Dev, BufSize, pDma_addr) usb_alloc_coherent(pUsb_Dev, BufSize, GFP_ATOMIC, pDma_addr) ++#define RTUSB_URB_FREE_BUFFER(pUsb_Dev, BufSize, pTransferBuf, Dma_addr) usb_free_coherent(pUsb_Dev, BufSize, pTransferBuf, Dma_addr) + + #define RTUSB_FREE_URB(pUrb) usb_free_urb(pUrb) + +--- a/drivers/staging/udlfb/udlfb.c ++++ b/drivers/staging/udlfb/udlfb.c +@@ -1508,8 +1508,8 @@ static void dlfb_free_urb_list(struct dl + urb = unode->urb; + + /* Free each separately allocated piece */ +- usb_buffer_free(urb->dev, dev->urbs.size, +- urb->transfer_buffer, urb->transfer_dma); ++ usb_free_coherent(urb->dev, dev->urbs.size, ++ urb->transfer_buffer, urb->transfer_dma); + usb_free_urb(urb); + kfree(node); + } +@@ -1543,8 +1543,8 @@ static int dlfb_alloc_urb_list(struct dl + } + unode->urb = urb; + +- buf = usb_buffer_alloc(dev->udev, MAX_TRANSFER, GFP_KERNEL, +- &urb->transfer_dma); ++ buf = usb_alloc_coherent(dev->udev, MAX_TRANSFER, GFP_KERNEL, ++ &urb->transfer_dma); + if (!buf) { + kfree(unode); + usb_free_urb(urb); |