Merge 3.4-rc4 into usb-next.

This resolves the conflict in:
	drivers/usb/host/ehci-fsl.c
And picks up loads of xhci bugfixes to make it easier for others to test
with.

Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

10 files changed, 139 insertions, 155 deletions

diff --git a/drivers/usb/misc/emi26.c b/drivers/usb/misc/emi26.c
index da97dcec1f32..d65984dee751 100644
--- a/drivers/usb/misc/emi26.c
+++ b/drivers/usb/misc/emi26.c
@@ -78,18 +78,14 @@ static int emi26_load_firmware (struct usb_device *dev)
         const struct firmware *bitstream_fw = NULL;
         const struct firmware *firmware_fw = NULL;
         const struct ihex_binrec *rec;
-        int err;
+        int err = -ENOMEM;
         int i;
         __u32 addr;     /* Address to write */
         __u8 *buf;
 
         buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
-        if (!buf) {
-                dev_err(&dev->dev, "%s - error loading firmware: error = %d\n",
-                        __func__, -ENOMEM);
-                err = -ENOMEM;
+        if (!buf)
                 goto wraperr;
-        }
 
         err = request_ihex_firmware(&loader_fw, "emi26/loader.fw", &dev->dev);
         if (err)
@@ -111,11 +107,8 @@ static int emi26_load_firmware (struct usb_device *dev)
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi26_set_reset(dev,1);
-        if (err < 0) {
-                dev_err(&dev->dev,"%s - error loading firmware: error = %d\n",
-                        __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         rec = (const struct ihex_binrec *)loader_fw->data;
         /* 1. We need to put the loader for the FPGA into the EZ-USB */
@@ -123,19 +116,15 @@ static int emi26_load_firmware (struct usb_device *dev)
                 err = emi26_writememory(dev, be32_to_cpu(rec->addr),
                                         rec->data, be16_to_cpu(rec->len),
                                         ANCHOR_LOAD_INTERNAL);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
                 rec = ihex_next_binrec(rec);
         }
 
         /* De-assert reset (let the CPU run) */
         err = emi26_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
         msleep(250);    /* let device settle */
 
         /* 2. We upload the FPGA firmware into the EMI
@@ -153,18 +142,14 @@ static int emi26_load_firmware (struct usb_device *dev)
                         rec = ihex_next_binrec(rec);
                 }
                 err = emi26_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
         } while (rec);
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi26_set_reset(dev,1);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         /* 3. We need to put the loader for the firmware into the EZ-USB (again...) */
         for (rec = (const struct ihex_binrec *)loader_fw->data;
@@ -172,19 +157,15 @@ static int emi26_load_firmware (struct usb_device *dev)
                 err = emi26_writememory(dev, be32_to_cpu(rec->addr),
                                         rec->data, be16_to_cpu(rec->len),
                                         ANCHOR_LOAD_INTERNAL);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
         }
         msleep(250);    /* let device settle */
 
         /* De-assert reset (let the CPU run) */
         err = emi26_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         /* 4. We put the part of the firmware that lies in the external RAM into the EZ-USB */
 
@@ -194,19 +175,15 @@ static int emi26_load_firmware (struct usb_device *dev)
                         err = emi26_writememory(dev, be32_to_cpu(rec->addr),
                                                 rec->data, be16_to_cpu(rec->len),
                                                 ANCHOR_LOAD_EXTERNAL);
-                        if (err < 0) {
-                                err("%s - error loading firmware: error = %d", __func__, err);
+                        if (err < 0)
                                 goto wraperr;
-                        }
                 }
         }
-        
+
         /* Assert reset (stop the CPU in the EMI) */
         err = emi26_set_reset(dev,1);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         for (rec = (const struct ihex_binrec *)firmware_fw->data;
              rec; rec = ihex_next_binrec(rec)) {
@@ -214,19 +191,15 @@ static int emi26_load_firmware (struct usb_device *dev)
                         err = emi26_writememory(dev, be32_to_cpu(rec->addr),
                                                 rec->data, be16_to_cpu(rec->len),
                                                 ANCHOR_LOAD_INTERNAL);
-                        if (err < 0) {
-                                err("%s - error loading firmware: error = %d", __func__, err);
+                        if (err < 0)
                                 goto wraperr;
-                        }
                 }
         }
 
         /* De-assert reset (let the CPU run) */
         err = emi26_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
         msleep(250);    /* let device settle */
 
         /* return 1 to fail the driver inialization
@@ -234,6 +207,10 @@ static int emi26_load_firmware (struct usb_device *dev)
         err = 1;
 
 wraperr:
+        if (err < 0)
+                dev_err(&dev->dev,"%s - error loading firmware: error = %d\n",
+                        __func__, err);
+
         release_firmware(loader_fw);
         release_firmware(bitstream_fw);
         release_firmware(firmware_fw);
diff --git a/drivers/usb/misc/emi62.c b/drivers/usb/misc/emi62.c
index 4e0f167a6c4e..ff08015b230c 100644
--- a/drivers/usb/misc/emi62.c
+++ b/drivers/usb/misc/emi62.c
@@ -56,7 +56,7 @@ static int emi62_writememory(struct usb_device *dev, int address,
         unsigned char *buffer =  kmemdup(data, length, GFP_KERNEL);
 
         if (!buffer) {
-                err("emi62: kmalloc(%d) failed.", length);
+                dev_err(&dev->dev, "kmalloc(%d) failed.\n", length);
                 return -ENOMEM;
         }
         /* Note: usb_control_msg returns negative value on error or length of the
@@ -73,9 +73,8 @@ static int emi62_set_reset (struct usb_device *dev, unsigned char reset_bit)
         dev_info(&dev->dev, "%s - %d\n", __func__, reset_bit);
         
         response = emi62_writememory (dev, CPUCS_REG, &reset_bit, 1, 0xa0);
-        if (response < 0) {
-                err("emi62: set_reset (%d) failed", reset_bit);
-        }
+        if (response < 0)
+                dev_err(&dev->dev, "set_reset (%d) failed\n", reset_bit);
         return response;
 }
 
@@ -87,18 +86,15 @@ static int emi62_load_firmware (struct usb_device *dev)
         const struct firmware *bitstream_fw = NULL;
         const struct firmware *firmware_fw = NULL;
         const struct ihex_binrec *rec;
-        int err;
+        int err = -ENOMEM;
         int i;
         __u32 addr;     /* Address to write */
         __u8 *buf;
 
         dev_dbg(&dev->dev, "load_firmware\n");
         buf = kmalloc(FW_LOAD_SIZE, GFP_KERNEL);
-        if (!buf) {
-                err( "%s - error loading firmware: error = %d", __func__, -ENOMEM);
-                err = -ENOMEM;
+        if (!buf)
                 goto wraperr;
-        }
 
         err = request_ihex_firmware(&loader_fw, "emi62/loader.fw", &dev->dev);
         if (err)
@@ -112,16 +108,13 @@ static int emi62_load_firmware (struct usb_device *dev)
         err = request_ihex_firmware(&firmware_fw, FIRMWARE_FW, &dev->dev);
         if (err) {
         nofw:
-                err( "%s - request_firmware() failed", __func__);
                 goto wraperr;
         }
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi62_set_reset(dev,1);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         rec = (const struct ihex_binrec *)loader_fw->data;
 
@@ -130,19 +123,15 @@ static int emi62_load_firmware (struct usb_device *dev)
                 err = emi62_writememory(dev, be32_to_cpu(rec->addr),
                                         rec->data, be16_to_cpu(rec->len),
                                         ANCHOR_LOAD_INTERNAL);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
                 rec = ihex_next_binrec(rec);
         }
 
         /* De-assert reset (let the CPU run) */
         err = emi62_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
         msleep(250);    /* let device settle */
 
         /* 2. We upload the FPGA firmware into the EMI
@@ -160,18 +149,14 @@ static int emi62_load_firmware (struct usb_device *dev)
                         rec = ihex_next_binrec(rec);
                 }
                 err = emi62_writememory(dev, addr, buf, i, ANCHOR_LOAD_FPGA);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
         } while (rec);
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi62_set_reset(dev,1);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         /* 3. We need to put the loader for the firmware into the EZ-USB (again...) */
         for (rec = (const struct ihex_binrec *)loader_fw->data;
@@ -179,18 +164,14 @@ static int emi62_load_firmware (struct usb_device *dev)
                 err = emi62_writememory(dev, be32_to_cpu(rec->addr),
                                         rec->data, be16_to_cpu(rec->len),
                                         ANCHOR_LOAD_INTERNAL);
-                if (err < 0) {
-                        err("%s - error loading firmware: error = %d", __func__, err);
+                if (err < 0)
                         goto wraperr;
-                }
         }
 
         /* De-assert reset (let the CPU run) */
         err = emi62_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
         msleep(250);    /* let device settle */
 
         /* 4. We put the part of the firmware that lies in the external RAM into the EZ-USB */
@@ -201,19 +182,15 @@ static int emi62_load_firmware (struct usb_device *dev)
                         err = emi62_writememory(dev, be32_to_cpu(rec->addr),
                                                 rec->data, be16_to_cpu(rec->len),
                                                 ANCHOR_LOAD_EXTERNAL);
-                        if (err < 0) {
-                                err("%s - error loading firmware: error = %d", __func__, err);
+                        if (err < 0)
                                 goto wraperr;
-                        }
                 }
         }
 
         /* Assert reset (stop the CPU in the EMI) */
         err = emi62_set_reset(dev,1);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
 
         for (rec = (const struct ihex_binrec *)firmware_fw->data;
              rec; rec = ihex_next_binrec(rec)) {
@@ -221,19 +198,15 @@ static int emi62_load_firmware (struct usb_device *dev)
                         err = emi62_writememory(dev, be32_to_cpu(rec->addr),
                                                 rec->data, be16_to_cpu(rec->len),
                                                 ANCHOR_LOAD_EXTERNAL);
-                        if (err < 0) {
-                                err("%s - error loading firmware: error = %d", __func__, err);
+                        if (err < 0)
                                 goto wraperr;
-                        }
                 }
         }
 
         /* De-assert reset (let the CPU run) */
         err = emi62_set_reset(dev,0);
-        if (err < 0) {
-                err("%s - error loading firmware: error = %d", __func__, err);
+        if (err < 0)
                 goto wraperr;
-        }
         msleep(250);    /* let device settle */
 
         release_firmware(loader_fw);
@@ -247,6 +220,9 @@ static int emi62_load_firmware (struct usb_device *dev)
         return 1;
 
 wraperr:
+        if (err < 0)
+                dev_err(&dev->dev,"%s - error loading firmware: error = %d\n",
+                        __func__, err);
         release_firmware(loader_fw);
         release_firmware(bitstream_fw);
         release_firmware(firmware_fw);
diff --git a/drivers/usb/misc/idmouse.c b/drivers/usb/misc/idmouse.c
index 0dee24698504..c00fcd74d39d 100644
--- a/drivers/usb/misc/idmouse.c
+++ b/drivers/usb/misc/idmouse.c
@@ -366,14 +366,14 @@ static int idmouse_probe(struct usb_interface *interface,
                         kmalloc(IMGSIZE + dev->bulk_in_size, GFP_KERNEL);
 
                 if (!dev->bulk_in_buffer) {
-                        err("Unable to allocate input buffer.");
+                        dev_err(&interface->dev, "Unable to allocate input buffer.\n");
                         idmouse_delete(dev);
                         return -ENOMEM;
                 }
         }
 
         if (!(dev->bulk_in_endpointAddr)) {
-                err("Unable to find bulk-in endpoint.");
+                dev_err(&interface->dev, "Unable to find bulk-in endpoint.\n");
                 idmouse_delete(dev);
                 return -ENODEV;
         }
@@ -385,7 +385,7 @@ static int idmouse_probe(struct usb_interface *interface,
         result = usb_register_dev(interface, &idmouse_class);
         if (result) {
                 /* something prevented us from registering this device */
-                err("Unble to allocate minor number.");
+                dev_err(&interface->dev, "Unble to allocate minor number.\n");
                 usb_set_intfdata(interface, NULL);
                 idmouse_delete(dev);
                 return result;
diff --git a/drivers/usb/misc/iowarrior.c b/drivers/usb/misc/iowarrior.c
index 4fd0dc835ae5..db46143c67a6 100644
--- a/drivers/usb/misc/iowarrior.c
+++ b/drivers/usb/misc/iowarrior.c
@@ -610,8 +610,8 @@ static int iowarrior_open(struct inode *inode, struct file *file)
         interface = usb_find_interface(&iowarrior_driver, subminor);
         if (!interface) {
                 mutex_unlock(&iowarrior_mutex);
-                err("%s - error, can't find device for minor %d", __func__,
-                    subminor);
+                printk(KERN_ERR "%s - error, can't find device for minor %d\n",
+                       __func__, subminor);
                 return -ENODEV;
         }
 
diff --git a/drivers/usb/misc/ldusb.c b/drivers/usb/misc/ldusb.c
index 5db4ab52061e..ac762299eaa8 100644
--- a/drivers/usb/misc/ldusb.c
+++ b/drivers/usb/misc/ldusb.c
@@ -334,8 +334,8 @@ static int ld_usb_open(struct inode *inode, struct file *file)
         interface = usb_find_interface(&ld_usb_driver, subminor);
 
         if (!interface) {
-                err("%s - error, can't find device for minor %d\n",
-                     __func__, subminor);
+                printk(KERN_ERR "%s - error, can't find device for minor %d\n",
+                       __func__, subminor);
                 return -ENODEV;
         }
 
@@ -485,7 +485,7 @@ static ssize_t ld_usb_read(struct file *file, char __user *buffer, size_t count,
         /* verify that the device wasn't unplugged */
         if (dev->intf == NULL) {
                 retval = -ENODEV;
-                err("No device or device unplugged %d\n", retval);
+                printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
                 goto unlock_exit;
         }
 
@@ -565,7 +565,7 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
         /* verify that the device wasn't unplugged */
         if (dev->intf == NULL) {
                 retval = -ENODEV;
-                err("No device or device unplugged %d\n", retval);
+                printk(KERN_ERR "ldusb: No device or device unplugged %d\n", retval);
                 goto unlock_exit;
         }
 
@@ -603,7 +603,9 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
                                          bytes_to_write,
                                          USB_CTRL_SET_TIMEOUT * HZ);
                 if (retval < 0)
-                        err("Couldn't submit HID_REQ_SET_REPORT %d\n", retval);
+                        dev_err(&dev->intf->dev,
+                                "Couldn't submit HID_REQ_SET_REPORT %d\n",
+                                retval);
                 goto unlock_exit;
         }
 
@@ -624,7 +626,8 @@ static ssize_t ld_usb_write(struct file *file, const char __user *buffer,
         retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL);
         if (retval) {
                 dev->interrupt_out_busy = 0;
-                err("Couldn't submit interrupt_out_urb %d\n", retval);
+                dev_err(&dev->intf->dev,
+                        "Couldn't submit interrupt_out_urb %d\n", retval);
                 goto unlock_exit;
         }
         retval = bytes_to_write;
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index 575222042767..a2702cbfe804 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -354,8 +354,8 @@ static int tower_open (struct inode *inode, struct file *file)
         interface = usb_find_interface (&tower_driver, subminor);
 
         if (!interface) {
-                err ("%s - error, can't find device for minor %d",
-                     __func__, subminor);
+                printk(KERN_ERR "%s - error, can't find device for minor %d\n",
+                       __func__, subminor);
                 retval = -ENODEV;
                 goto exit;
         }
@@ -397,7 +397,8 @@ static int tower_open (struct inode *inode, struct file *file)
                                   sizeof(reset_reply),
                                   1000);
         if (result < 0) {
-                err("LEGO USB Tower reset control request failed");
+                dev_err(&dev->udev->dev,
+                        "LEGO USB Tower reset control request failed\n");
                 retval = result;
                 goto unlock_exit;
         }
@@ -420,7 +421,8 @@ static int tower_open (struct inode *inode, struct file *file)
 
         retval = usb_submit_urb (dev->interrupt_in_urb, GFP_KERNEL);
         if (retval) {
-                err("Couldn't submit interrupt_in_urb %d", retval);
+                dev_err(&dev->udev->dev,
+                        "Couldn't submit interrupt_in_urb %d\n", retval);
                 dev->interrupt_in_running = 0;
                 dev->open_count = 0;
                 goto unlock_exit;
@@ -608,7 +610,7 @@ static ssize_t tower_read (struct file *file, char __user *buffer, size_t count,
         /* verify that the device wasn't unplugged */
         if (dev->udev == NULL) {
                 retval = -ENODEV;
-                err("No device or device unplugged %d", retval);
+                printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval);
                 goto unlock_exit;
         }
 
@@ -697,7 +699,7 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
         /* verify that the device wasn't unplugged */
         if (dev->udev == NULL) {
                 retval = -ENODEV;
-                err("No device or device unplugged %d", retval);
+                printk(KERN_ERR "legousbtower: No device or device unplugged %d\n", retval);
                 goto unlock_exit;
         }
 
@@ -744,7 +746,8 @@ static ssize_t tower_write (struct file *file, const char __user *buffer, size_t
         retval = usb_submit_urb (dev->interrupt_out_urb, GFP_KERNEL);
         if (retval) {
                 dev->interrupt_out_busy = 0;
-                err("Couldn't submit interrupt_out_urb %d", retval);
+                dev_err(&dev->udev->dev,
+                        "Couldn't submit interrupt_out_urb %d\n", retval);
                 goto unlock_exit;
         }
         retval = bytes_to_write;
@@ -803,9 +806,10 @@ resubmit:
         /* resubmit if we're still running */
         if (dev->interrupt_in_running && dev->udev) {
                 retval = usb_submit_urb (dev->interrupt_in_urb, GFP_ATOMIC);
-                if (retval) {
-                        err("%s: usb_submit_urb failed (%d)", __func__, retval);
-                }
+                if (retval)
+                        dev_err(&dev->udev->dev,
+                                "%s: usb_submit_urb failed (%d)\n",
+                                __func__, retval);
         }
 
 exit:
@@ -852,6 +856,7 @@ static void tower_interrupt_out_callback (struct urb *urb)
  */
 static int tower_probe (struct usb_interface *interface, const struct usb_device_id *id)
 {
+        struct device *idev = &interface->dev;
         struct usb_device *udev = interface_to_usbdev(interface);
         struct lego_usb_tower *dev = NULL;
         struct usb_host_interface *iface_desc;
@@ -871,7 +876,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
         dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
 
         if (dev == NULL) {
-                err ("Out of memory");
+                dev_err(idev, "Out of memory\n");
                 goto exit;
         }
 
@@ -915,37 +920,37 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
                 }
         }
         if(dev->interrupt_in_endpoint == NULL) {
-                err("interrupt in endpoint not found");
+                dev_err(idev, "interrupt in endpoint not found\n");
                 goto error;
         }
         if (dev->interrupt_out_endpoint == NULL) {
-                err("interrupt out endpoint not found");
+                dev_err(idev, "interrupt out endpoint not found\n");
                 goto error;
         }
 
         dev->read_buffer = kmalloc (read_buffer_size, GFP_KERNEL);
         if (!dev->read_buffer) {
-                err("Couldn't allocate read_buffer");
+                dev_err(idev, "Couldn't allocate read_buffer\n");
                 goto error;
         }
         dev->interrupt_in_buffer = kmalloc (usb_endpoint_maxp(dev->interrupt_in_endpoint), GFP_KERNEL);
         if (!dev->interrupt_in_buffer) {
-                err("Couldn't allocate interrupt_in_buffer");
+                dev_err(idev, "Couldn't allocate interrupt_in_buffer\n");
                 goto error;
         }
         dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->interrupt_in_urb) {
-                err("Couldn't allocate interrupt_in_urb");
+                dev_err(idev, "Couldn't allocate interrupt_in_urb\n");
                 goto error;
         }
         dev->interrupt_out_buffer = kmalloc (write_buffer_size, GFP_KERNEL);
         if (!dev->interrupt_out_buffer) {
-                err("Couldn't allocate interrupt_out_buffer");
+                dev_err(idev, "Couldn't allocate interrupt_out_buffer\n");
                 goto error;
         }
         dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->interrupt_out_urb) {
-                err("Couldn't allocate interrupt_out_urb");
+                dev_err(idev, "Couldn't allocate interrupt_out_urb\n");
                 goto error;
         }
         dev->interrupt_in_interval = interrupt_in_interval ? interrupt_in_interval : dev->interrupt_in_endpoint->bInterval;
@@ -958,7 +963,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
 
         if (retval) {
                 /* something prevented us from registering this driver */
-                err ("Not able to get a minor for this device.");
+                dev_err(idev, "Not able to get a minor for this device.\n");
                 usb_set_intfdata (interface, NULL);
                 goto error;
         }
@@ -980,7 +985,7 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
                                   sizeof(get_version_reply),
                                   1000);
         if (result < 0) {
-                err("LEGO USB Tower get version control request failed");
+                dev_err(idev, "LEGO USB Tower get version control request failed\n");
                 retval = result;
                 goto error;
         }
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index 487a8ce0775e..cb55dc5330df 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -171,7 +171,9 @@ static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
                         if (result == -ETIMEDOUT)
                                 retries--;
                         else if (result < 0) {
-                                err("Error executing ioctrl. code = %d", result);
+                                dev_err(&rio->rio_dev->dev,
+                                        "Error executing ioctrl. code = %d\n",
+                                        result);
                                 retries = 0;
                         } else {
                                 dbg("Executed ioctl. Result = %d (data=%02x)",
@@ -238,7 +240,9 @@ static long ioctl_rio(struct file *file, unsigned int cmd, unsigned long arg)
                         if (result == -ETIMEDOUT)
                                 retries--;
                         else if (result < 0) {
-                                err("Error executing ioctrl. code = %d", result);
+                                dev_err(&rio->rio_dev->dev,
+                                        "Error executing ioctrl. code = %d\n",
+                                        result);
                                 retries = 0;
                         } else {
                                 dbg("Executed ioctl. Result = %d", result);
@@ -332,7 +336,8 @@ write_rio(struct file *file, const char __user *buffer,
                                 break;
                 };
                 if (result) {
-                        err("Write Whoops - %x", result);
+                        dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
+                                result);
                         errn = -EIO;
                         goto error;
                 }
@@ -401,7 +406,8 @@ read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
                 } else if (result == -ETIMEDOUT || result == 15) {      /* FIXME: 15 ??? */
                         if (!maxretry--) {
                                 mutex_unlock(&(rio->lock));
-                                err("read_rio: maxretry timeout");
+                                dev_err(&rio->rio_dev->dev,
+                                        "read_rio: maxretry timeout\n");
                                 return -ETIME;
                         }
                         prepare_to_wait(&rio->wait_q, &wait, TASK_INTERRUPTIBLE);
@@ -410,8 +416,9 @@ read_rio(struct file *file, char __user *buffer, size_t count, loff_t * ppos)
                         continue;
                 } else if (result != -EREMOTEIO) {
                         mutex_unlock(&(rio->lock));
-                        err("Read Whoops - result:%u partial:%u this_read:%u",
-                             result, partial, this_read);
+                        dev_err(&rio->rio_dev->dev,
+                                "Read Whoops - result:%u partial:%u this_read:%u\n",
+                                result, partial, this_read);
                         return -EIO;
                 } else {
                         mutex_unlock(&(rio->lock));
@@ -459,21 +466,24 @@ static int probe_rio(struct usb_interface *intf,
 
         retval = usb_register_dev(intf, &usb_rio_class);
         if (retval) {
-                err("Not able to get a minor for this device.");
+                dev_err(&dev->dev,
+                        "Not able to get a minor for this device.\n");
                 return -ENOMEM;
         }
 
         rio->rio_dev = dev;
 
         if (!(rio->obuf = kmalloc(OBUF_SIZE, GFP_KERNEL))) {
-                err("probe_rio: Not enough memory for the output buffer");
+                dev_err(&dev->dev,
+                        "probe_rio: Not enough memory for the output buffer\n");
                 usb_deregister_dev(intf, &usb_rio_class);
                 return -ENOMEM;
         }
         dbg("probe_rio: obuf address:%p", rio->obuf);
 
         if (!(rio->ibuf = kmalloc(IBUF_SIZE, GFP_KERNEL))) {
-                err("probe_rio: Not enough memory for the input buffer");
+                dev_err(&dev->dev,
+                        "probe_rio: Not enough memory for the input buffer\n");
                 usb_deregister_dev(intf, &usb_rio_class);
                 kfree(rio->obuf);
                 return -ENOMEM;
diff --git a/drivers/usb/misc/usblcd.c b/drivers/usb/misc/usblcd.c
index e2b4bd31c2b6..c4ef9a1d5efd 100644
--- a/drivers/usb/misc/usblcd.c
+++ b/drivers/usb/misc/usblcd.c
@@ -87,8 +87,8 @@ static int lcd_open(struct inode *inode, struct file *file)
         interface = usb_find_interface(&lcd_driver, subminor);
         if (!interface) {
                 mutex_unlock(&lcd_mutex);
-                err("USBLCD: %s - error, can't find device for minor %d",
-                     __func__, subminor);
+                printk(KERN_ERR "USBLCD: %s - error, can't find device for minor %d\n",
+                       __func__, subminor);
                 return -ENODEV;
         }
 
@@ -268,8 +268,9 @@ static ssize_t lcd_write(struct file *file, const char __user * user_buffer,
         /* send the data out the bulk port */
         retval = usb_submit_urb(urb, GFP_KERNEL);
         if (retval) {
-                err("USBLCD: %s - failed submitting write urb, error %d",
-                    __func__, retval);
+                dev_err(&dev->udev->dev,
+                        "%s - failed submitting write urb, error %d\n",
+                        __func__, retval);
                 goto error_unanchor;
         }
 
@@ -322,7 +323,7 @@ static int lcd_probe(struct usb_interface *interface,
         /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (dev == NULL) {
-                err("Out of memory");
+                dev_err(&interface->dev, "Out of memory\n");
                 goto error;
         }
         kref_init(&dev->kref);
@@ -352,7 +353,8 @@ static int lcd_probe(struct usb_interface *interface,
                         dev->bulk_in_endpointAddr = endpoint->bEndpointAddress;
                         dev->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
                         if (!dev->bulk_in_buffer) {
-                                err("Could not allocate bulk_in_buffer");
+                                dev_err(&interface->dev,
+                                        "Could not allocate bulk_in_buffer\n");
                                 goto error;
                         }
                 }
@@ -364,7 +366,8 @@ static int lcd_probe(struct usb_interface *interface,
                 }
         }
         if (!(dev->bulk_in_endpointAddr && dev->bulk_out_endpointAddr)) {
-                err("Could not find both bulk-in and bulk-out endpoints");
+                dev_err(&interface->dev,
+                        "Could not find both bulk-in and bulk-out endpoints\n");
                 goto error;
         }
 
@@ -375,7 +378,8 @@ static int lcd_probe(struct usb_interface *interface,
         retval = usb_register_dev(interface, &lcd_class);
         if (retval) {
                 /* something prevented us from registering this driver */
-                err("Not able to get a minor for this device.");
+                dev_err(&interface->dev,
+                        "Not able to get a minor for this device.\n");
                 usb_set_intfdata(interface, NULL);
                 goto error;
         }
diff --git a/drivers/usb/misc/uss720.c b/drivers/usb/misc/uss720.c
index 8b1d94a76914..7f64147ea229 100644
--- a/drivers/usb/misc/uss720.c
+++ b/drivers/usb/misc/uss720.c
@@ -118,7 +118,8 @@ static void async_complete(struct urb *urb)
         priv = rq->priv;
         pp = priv->pp;
         if (status) {
-                err("async_complete: urb error %d", status);
+                dev_err(&urb->dev->dev, "async_complete: urb error %d\n",
+                        status);
         } else if (rq->dr.bRequest == 3) {
                 memcpy(priv->reg, rq->reg, sizeof(priv->reg));
 #if 0
@@ -151,7 +152,7 @@ static struct uss720_async_request *submit_async_request(struct parport_uss720_p
                 return NULL;
         rq = kmalloc(sizeof(struct uss720_async_request), mem_flags);
         if (!rq) {
-                err("submit_async_request out of memory");
+                dev_err(&usbdev->dev, "submit_async_request out of memory\n");
                 return NULL;
         }
         kref_init(&rq->ref_count);
@@ -162,7 +163,7 @@ static struct uss720_async_request *submit_async_request(struct parport_uss720_p
         rq->urb = usb_alloc_urb(0, mem_flags);
         if (!rq->urb) {
                 kref_put(&rq->ref_count, destroy_async);
-                err("submit_async_request out of memory");
+                dev_err(&usbdev->dev, "submit_async_request out of memory\n");
                 return NULL;
         }
         rq->dr.bRequestType = requesttype;
@@ -182,7 +183,7 @@ static struct uss720_async_request *submit_async_request(struct parport_uss720_p
         if (!ret)
                 return rq;
         destroy_async(&rq->ref_count);
-        err("submit_async_request submit_urb failed with %d", ret);
+        dev_err(&usbdev->dev, "submit_async_request submit_urb failed with %d\n", ret);
         return NULL;
 }
 
@@ -217,7 +218,8 @@ static int get_1284_register(struct parport *pp, unsigned char reg, unsigned cha
         priv = pp->private_data;
         rq = submit_async_request(priv, 3, 0xc0, ((unsigned int)reg) << 8, 0, mem_flags);
         if (!rq) {
-                err("get_1284_register(%u) failed", (unsigned int)reg);
+                dev_err(&priv->usbdev->dev, "get_1284_register(%u) failed",
+                        (unsigned int)reg);
                 return -EIO;
         }
         if (!val) {
@@ -248,7 +250,8 @@ static int set_1284_register(struct parport *pp, unsigned char reg, unsigned cha
         priv = pp->private_data;
         rq = submit_async_request(priv, 4, 0x40, (((unsigned int)reg) << 8) | val, 0, mem_flags);
         if (!rq) {
-                err("set_1284_register(%u,%u) failed", (unsigned int)reg, (unsigned int)val);
+                dev_err(&priv->usbdev->dev, "set_1284_register(%u,%u) failed",
+                        (unsigned int)reg, (unsigned int)val);
                 return -EIO;
         }
         kref_put(&rq->ref_count, destroy_async);
diff --git a/drivers/usb/misc/yurex.c b/drivers/usb/misc/yurex.c
index 70201462e19c..1d8ad4c5b99e 100644
--- a/drivers/usb/misc/yurex.c
+++ b/drivers/usb/misc/yurex.c
@@ -83,7 +83,8 @@ static void yurex_control_callback(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                err("%s - control failed: %d\n", __func__, status);
+                dev_err(&urb->dev->dev, "%s - control failed: %d\n",
+                        __func__, status);
                 wake_up_interruptible(&dev->waitq);
                 return;
         }
@@ -137,8 +138,9 @@ static void yurex_interrupt(struct urb *urb)
         case 0: /*success*/
                 break;
         case -EOVERFLOW:
-                err("%s - overflow with length %d, actual length is %d",
-                    __func__, YUREX_BUF_SIZE, dev->urb->actual_length);
+                dev_err(&dev->interface->dev,
+                        "%s - overflow with length %d, actual length is %d\n",
+                        __func__, YUREX_BUF_SIZE, dev->urb->actual_length);
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
@@ -146,7 +148,8 @@ static void yurex_interrupt(struct urb *urb)
                 /* The device is terminated, clean up */
                 return;
         default:
-                err("%s - unknown status received: %d", __func__, status);
+                dev_err(&dev->interface->dev,
+                        "%s - unknown status received: %d\n", __func__, status);
                 goto exit;
         }
 
@@ -179,7 +182,7 @@ static void yurex_interrupt(struct urb *urb)
 exit:
         retval = usb_submit_urb(dev->urb, GFP_ATOMIC);
         if (retval) {
-                err("%s - usb_submit_urb failed: %d",
+                dev_err(&dev->interface->dev, "%s - usb_submit_urb failed: %d\n",
                         __func__, retval);
         }
 }
@@ -196,7 +199,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         /* allocate memory for our device state and initialize it */
         dev = kzalloc(sizeof(*dev), GFP_KERNEL);
         if (!dev) {
-                err("Out of memory");
+                dev_err(&interface->dev, "Out of memory\n");
                 goto error;
         }
         kref_init(&dev->kref);
@@ -219,7 +222,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         }
         if (!dev->int_in_endpointAddr) {
                 retval = -ENODEV;
-                err("Could not find endpoints");
+                dev_err(&interface->dev, "Could not find endpoints\n");
                 goto error;
         }
 
@@ -227,14 +230,14 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         /* allocate control URB */
         dev->cntl_urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->cntl_urb) {
-                err("Could not allocate control URB");
+                dev_err(&interface->dev, "Could not allocate control URB\n");
                 goto error;
         }
 
         /* allocate buffer for control req */
         dev->cntl_req = kmalloc(YUREX_BUF_SIZE, GFP_KERNEL);
         if (!dev->cntl_req) {
-                err("Could not allocate cntl_req");
+                dev_err(&interface->dev, "Could not allocate cntl_req\n");
                 goto error;
         }
 
@@ -243,7 +246,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
                                               GFP_KERNEL,
                                               &dev->cntl_urb->transfer_dma);
         if (!dev->cntl_buffer) {
-                err("Could not allocate cntl_buffer");
+                dev_err(&interface->dev, "Could not allocate cntl_buffer\n");
                 goto error;
         }
 
@@ -265,7 +268,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         /* allocate interrupt URB */
         dev->urb = usb_alloc_urb(0, GFP_KERNEL);
         if (!dev->urb) {
-                err("Could not allocate URB");
+                dev_err(&interface->dev, "Could not allocate URB\n");
                 goto error;
         }
 
@@ -273,7 +276,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         dev->int_buffer = usb_alloc_coherent(dev->udev, YUREX_BUF_SIZE,
                                         GFP_KERNEL, &dev->urb->transfer_dma);
         if (!dev->int_buffer) {
-                err("Could not allocate int_buffer");
+                dev_err(&interface->dev, "Could not allocate int_buffer\n");
                 goto error;
         }
 
@@ -285,7 +288,7 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         dev->urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
         if (usb_submit_urb(dev->urb, GFP_KERNEL)) {
                 retval = -EIO;
-                err("Could not submitting URB");
+                dev_err(&interface->dev, "Could not submitting URB\n");
                 goto error;
         }
 
@@ -295,7 +298,8 @@ static int yurex_probe(struct usb_interface *interface, const struct usb_device_
         /* we can register the device now, as it is ready */
         retval = usb_register_dev(interface, &yurex_class);
         if (retval) {
-                err("Not able to get a minor for this device.");
+                dev_err(&interface->dev,
+                        "Not able to get a minor for this device.\n");
                 usb_set_intfdata(interface, NULL);
                 goto error;
         }
@@ -368,8 +372,8 @@ static int yurex_open(struct inode *inode, struct file *file)
 
         interface = usb_find_interface(&yurex_driver, subminor);
         if (!interface) {
-                err("%s - error, can't find device for minor %d",
-                    __func__, subminor);
+                printk(KERN_ERR "%s - error, can't find device for minor %d",
+                       __func__, subminor);
                 retval = -ENODEV;
                 goto exit;
         }
@@ -514,7 +518,9 @@ static ssize_t yurex_write(struct file *file, const char *user_buffer, size_t co
         mutex_unlock(&dev->io_mutex);
 
         if (retval < 0) {
-                err("%s - failed to send bulk msg, error %d", __func__, retval);
+                dev_err(&dev->interface->dev,
+                        "%s - failed to send bulk msg, error %d\n",
+                        __func__, retval);
                 goto error;
         }
         if (set && timeout)