retval = register_chrdev_region(USB_DEVICE_DEV, USB_DEVICE_MAX,
                                        "usb_device");
        if (retval) {
-               err("unable to register minors for usb_device");
+               printk(KERN_ERR "Unable to register minors for usb_device\n");
                goto out;
        }
        cdev_init(&usb_device_cdev, &usbdev_file_operations);
        retval = cdev_add(&usb_device_cdev, USB_DEVICE_DEV, USB_DEVICE_MAX);
        if (retval) {
-               err("unable to get usb_device major %d", USB_DEVICE_MAJOR);
+               printk(KERN_ERR "Unable to get usb_device major %d\n",
+                      USB_DEVICE_MAJOR);
                goto error_cdev;
        }
 #ifdef CONFIG_USB_DEVICE_CLASS
        usb_classdev_class = class_create(THIS_MODULE, "usb_device");
        if (IS_ERR(usb_classdev_class)) {
-               err("unable to register usb_device class");
+               printk(KERN_ERR "Unable to register usb_device class\n");
                retval = PTR_ERR(usb_classdev_class);
                cdev_del(&usb_device_cdev);
                usb_classdev_class = NULL;
 
        error = alloc_chrdev_region(&dev, 0, MAX_ENDPOINT_MINORS,
                                    "usb_endpoint");
        if (error) {
-               err("unable to get a dynamic major for usb endpoints");
+               printk(KERN_ERR "Unable to get a dynamic major for "
+                      "usb endpoints.\n");
                return error;
        }
        usb_endpoint_major = MAJOR(dev);
 
        usb_class->class = class_create(THIS_MODULE, "usb");
        if (IS_ERR(usb_class->class)) {
                result = IS_ERR(usb_class->class);
-               err("class_create failed for usb devices");
+               printk(KERN_ERR "class_create failed for usb devices\n");
                kfree(usb_class);
                usb_class = NULL;
        }
 
        error = register_chrdev(USB_MAJOR, "usb", &usb_fops);
        if (error)
-               err("unable to get major %d for usb devices", USB_MAJOR);
+               printk(KERN_ERR "Unable to get major %d for usb devices\n",
+                      USB_MAJOR);
 
        return error;
 }
 
                        listmode = option & S_IRWXUGO;
                        break;
                default:
-                       err("usbfs: unrecognised mount option \"%s\" "
-                           "or missing value\n", p);
+                       printk(KERN_ERR "usbfs: unrecognised mount option "
+                              "\"%s\" or missing value\n", p);
                        return -EINVAL;
                }
        }
        /* create the devices special file */
        retval = simple_pin_fs(&usb_fs_type, &usbfs_mount, &usbfs_mount_count);
        if (retval) {
-               err ("Unable to get usbfs mount");
+               printk(KERN_ERR "Unable to get usbfs mount\n");
                goto exit;
        }
 
                                               NULL, &usbfs_devices_fops,
                                               listuid, listgid);
        if (devices_usbfs_dentry == NULL) {
-               err ("Unable to create devices usbfs file");
+               printk(KERN_ERR "Unable to create devices usbfs file\n");
                retval = -ENODEV;
                goto error_clean_mounts;
        }
        bus->usbfs_dentry = fs_create_file (name, busmode | S_IFDIR, parent,
                                            bus, NULL, busuid, busgid);
        if (bus->usbfs_dentry == NULL) {
-               err ("error creating usbfs bus entry");
+               printk(KERN_ERR "Error creating usbfs bus entry\n");
                return;
        }
 }
                                            &usbdev_file_operations,
                                            devuid, devgid);
        if (dev->usbfs_dentry == NULL) {
-               err ("error creating usbfs device entry");
+               printk(KERN_ERR "Error creating usbfs device entry\n");
                return;
        }
 
 
                iso_packets * sizeof(struct usb_iso_packet_descriptor),
                mem_flags);
        if (!urb) {
-               err("alloc_urb: kmalloc failed");
+               printk(KERN_ERR "alloc_urb: kmalloc failed\n");
                return NULL;
        }
        usb_init_urb(urb);
 
        /* fail if submitter gave bogus flags */
        if (urb->transfer_flags != orig_flags) {
-               err("BOGUS urb flags, %x --> %x",
+               dev_err(&dev->dev, "BOGUS urb flags, %x --> %x\n",
                        orig_flags, urb->transfer_flags);
                return -EINVAL;
        }