254 files changed, 10363 insertions, 5847 deletions

diff --git a/drivers/usb/Kconfig b/drivers/usb/Kconfig
index 7065df6036ca..2564b546ba8a 100644
--- a/drivers/usb/Kconfig
+++ b/drivers/usb/Kconfig
@@ -48,6 +48,7 @@ config USB_ARCH_HAS_EHCI
         default y if SPARC_LEON
         default y if ARCH_MMP
         default y if MACH_LOONGSON1
+        default y if PLAT_ORION
         default PCI
 
 # some non-PCI HCDs implement xHCI
diff --git a/drivers/usb/atm/ueagle-atm.c b/drivers/usb/atm/ueagle-atm.c
index d7e422dc0ef7..e1f8b2c973fe 100644
--- a/drivers/usb/atm/ueagle-atm.c
+++ b/drivers/usb/atm/ueagle-atm.c
@@ -307,6 +307,34 @@ enum {
 #define FW_GET_BYTE(p) (*((__u8 *) (p)))
 
 #define FW_DIR "ueagle-atm/"
+#define EAGLE_FIRMWARE FW_DIR "eagle.fw"
+#define ADI930_FIRMWARE FW_DIR "adi930.fw"
+#define EAGLE_I_FIRMWARE FW_DIR "eagleI.fw"
+#define EAGLE_II_FIRMWARE FW_DIR "eagleII.fw"
+#define EAGLE_III_FIRMWARE FW_DIR "eagleIII.fw"
+#define EAGLE_IV_FIRMWARE FW_DIR "eagleIV.fw"
+
+#define DSP4I_FIRMWARE FW_DIR "DSP4i.bin"
+#define DSP4P_FIRMWARE FW_DIR "DSP4p.bin"
+#define DSP9I_FIRMWARE FW_DIR "DSP9i.bin"
+#define DSP9P_FIRMWARE FW_DIR "DSP9p.bin"
+#define DSPEI_FIRMWARE FW_DIR "DSPei.bin"
+#define DSPEP_FIRMWARE FW_DIR "DSPep.bin"
+#define FPGA930_FIRMWARE FW_DIR "930-fpga.bin"
+
+#define CMV4P_FIRMWARE FW_DIR "CMV4p.bin"
+#define CMV4PV2_FIRMWARE FW_DIR "CMV4p.bin.v2"
+#define CMV4I_FIRMWARE FW_DIR "CMV4i.bin"
+#define CMV4IV2_FIRMWARE FW_DIR "CMV4i.bin.v2"
+#define CMV9P_FIRMWARE FW_DIR "CMV9p.bin"
+#define CMV9PV2_FIRMWARE FW_DIR "CMV9p.bin.v2"
+#define CMV9I_FIRMWARE FW_DIR "CMV9i.bin"
+#define CMV9IV2_FIRMWARE FW_DIR "CMV9i.bin.v2"
+#define CMVEP_FIRMWARE FW_DIR "CMVep.bin"
+#define CMVEPV2_FIRMWARE FW_DIR "CMVep.bin.v2"
+#define CMVEI_FIRMWARE FW_DIR "CMVei.bin"
+#define CMVEIV2_FIRMWARE FW_DIR "CMVei.bin.v2"
+
 #define UEA_FW_NAME_MAX 30
 #define NB_MODEM 4
 
@@ -694,26 +722,26 @@ err:
 static int uea_load_firmware(struct usb_device *usb, unsigned int ver)
 {
         int ret;
-        char *fw_name = FW_DIR "eagle.fw";
+        char *fw_name = EAGLE_FIRMWARE;
 
         uea_enters(usb);
         uea_info(usb, "pre-firmware device, uploading firmware\n");
 
         switch (ver) {
         case ADI930:
-                fw_name = FW_DIR "adi930.fw";
+                fw_name = ADI930_FIRMWARE;
                 break;
         case EAGLE_I:
-                fw_name = FW_DIR "eagleI.fw";
+                fw_name = EAGLE_I_FIRMWARE;
                 break;
         case EAGLE_II:
-                fw_name = FW_DIR "eagleII.fw";
+                fw_name = EAGLE_II_FIRMWARE;
                 break;
         case EAGLE_III:
-                fw_name = FW_DIR "eagleIII.fw";
+                fw_name = EAGLE_III_FIRMWARE;
                 break;
         case EAGLE_IV:
-                fw_name = FW_DIR "eagleIV.fw";
+                fw_name = EAGLE_IV_FIRMWARE;
                 break;
         }
 
@@ -869,19 +897,19 @@ static int request_dsp(struct uea_softc *sc)
 
         if (UEA_CHIP_VERSION(sc) == EAGLE_IV) {
                 if (IS_ISDN(sc))
-                        dsp_name = FW_DIR "DSP4i.bin";
+                        dsp_name = DSP4I_FIRMWARE;
                 else
-                        dsp_name = FW_DIR "DSP4p.bin";
+                        dsp_name = DSP4P_FIRMWARE;
         } else if (UEA_CHIP_VERSION(sc) == ADI930) {
                 if (IS_ISDN(sc))
-                        dsp_name = FW_DIR "DSP9i.bin";
+                        dsp_name = DSP9I_FIRMWARE;
                 else
-                        dsp_name = FW_DIR "DSP9p.bin";
+                        dsp_name = DSP9P_FIRMWARE;
         } else {
                 if (IS_ISDN(sc))
-                        dsp_name = FW_DIR "DSPei.bin";
+                        dsp_name = DSPEI_FIRMWARE;
                 else
-                        dsp_name = FW_DIR "DSPep.bin";
+                        dsp_name = DSPEP_FIRMWARE;
         }
 
         ret = request_firmware(&sc->dsp_firm, dsp_name, &sc->usb_dev->dev);
@@ -1925,7 +1953,7 @@ static int load_XILINX_firmware(struct uea_softc *sc)
         int ret, size, u, ln;
         const u8 *pfw;
         u8 value;
-        char *fw_name = FW_DIR "930-fpga.bin";
+        char *fw_name = FPGA930_FIRMWARE;
 
         uea_enters(INS_TO_USBDEV(sc));
 
@@ -2753,3 +2781,28 @@ module_usb_driver(uea_driver);
 MODULE_AUTHOR("Damien Bergamini/Matthieu Castet/Stanislaw W. Gruszka");
 MODULE_DESCRIPTION("ADI 930/Eagle USB ADSL Modem driver");
 MODULE_LICENSE("Dual BSD/GPL");
+MODULE_FIRMWARE(EAGLE_FIRMWARE);
+MODULE_FIRMWARE(ADI930_FIRMWARE);
+MODULE_FIRMWARE(EAGLE_I_FIRMWARE);
+MODULE_FIRMWARE(EAGLE_II_FIRMWARE);
+MODULE_FIRMWARE(EAGLE_III_FIRMWARE);
+MODULE_FIRMWARE(EAGLE_IV_FIRMWARE);
+MODULE_FIRMWARE(DSP4I_FIRMWARE);
+MODULE_FIRMWARE(DSP4P_FIRMWARE);
+MODULE_FIRMWARE(DSP9I_FIRMWARE);
+MODULE_FIRMWARE(DSP9P_FIRMWARE);
+MODULE_FIRMWARE(DSPEI_FIRMWARE);
+MODULE_FIRMWARE(DSPEP_FIRMWARE);
+MODULE_FIRMWARE(FPGA930_FIRMWARE);
+MODULE_FIRMWARE(CMV4P_FIRMWARE);
+MODULE_FIRMWARE(CMV4PV2_FIRMWARE);
+MODULE_FIRMWARE(CMV4I_FIRMWARE);
+MODULE_FIRMWARE(CMV4IV2_FIRMWARE);
+MODULE_FIRMWARE(CMV9P_FIRMWARE);
+MODULE_FIRMWARE(CMV9PV2_FIRMWARE);
+MODULE_FIRMWARE(CMV9I_FIRMWARE);
+MODULE_FIRMWARE(CMV9IV2_FIRMWARE);
+MODULE_FIRMWARE(CMVEP_FIRMWARE);
+MODULE_FIRMWARE(CMVEPV2_FIRMWARE);
+MODULE_FIRMWARE(CMVEI_FIRMWARE);
+MODULE_FIRMWARE(CMVEIV2_FIRMWARE);
diff --git a/drivers/usb/atm/usbatm.c b/drivers/usb/atm/usbatm.c
index ee62b3576f94..35f10bfe15db 100644
--- a/drivers/usb/atm/usbatm.c
+++ b/drivers/usb/atm/usbatm.c
@@ -84,7 +84,7 @@
 #include <linux/ratelimit.h>
 
 #ifdef VERBOSE_DEBUG
-static int usbatm_print_packet(const unsigned char *data, int len);
+static int usbatm_print_packet(struct usbatm_data *instance, const unsigned char *data, int len);
 #define PACKETDEBUG(arg...)     usbatm_print_packet(arg)
 #define vdbg(arg...)            dev_dbg(arg)
 #else
@@ -230,8 +230,8 @@ static int usbatm_submit_urb(struct urb *urb)
         struct usbatm_channel *channel = urb->context;
         int ret;
 
-        vdbg("%s: submitting urb 0x%p, size %u",
-             __func__, urb, urb->transfer_buffer_length);
+        /* vdbg("%s: submitting urb 0x%p, size %u",
+             __func__, urb, urb->transfer_buffer_length); */
 
         ret = usb_submit_urb(urb, GFP_ATOMIC);
         if (ret) {
@@ -261,8 +261,8 @@ static void usbatm_complete(struct urb *urb)
         unsigned long flags;
         int status = urb->status;
 
-        vdbg("%s: urb 0x%p, status %d, actual_length %d",
-             __func__, urb, status, urb->actual_length);
+        /* vdbg("%s: urb 0x%p, status %d, actual_length %d",
+             __func__, urb, status, urb->actual_length); */
 
         /* usually in_interrupt(), but not always */
         spin_lock_irqsave(&channel->lock, flags);
@@ -311,7 +311,7 @@ static void usbatm_extract_one_cell(struct usbatm_data *instance, unsigned char
         int vci = ((source[1] & 0x0f) << 12) | (source[2] << 4) | (source[3] >> 4);
         u8 pti = ((source[3] & 0xe) >> 1);
 
-        vdbg("%s: vpi %hd, vci %d, pti %d", __func__, vpi, vci, pti);
+        vdbg(&instance->usb_intf->dev, "%s: vpi %hd, vci %d, pti %d", __func__, vpi, vci, pti);
 
         if ((vci != instance->cached_vci) || (vpi != instance->cached_vpi)) {
                 instance->cached_vpi = vpi;
@@ -381,7 +381,9 @@ static void usbatm_extract_one_cell(struct usbatm_data *instance, unsigned char
                         goto out;
                 }
 
-                vdbg("%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)", __func__, length, pdu_length, vcc);
+                vdbg(&instance->usb_intf->dev,
+                     "%s: got packet (length: %u, pdu_length: %u, vcc: 0x%p)",
+                     __func__, length, pdu_length, vcc);
 
                 if (!(skb = dev_alloc_skb(length))) {
                         if (printk_ratelimit())
@@ -391,7 +393,9 @@ static void usbatm_extract_one_cell(struct usbatm_data *instance, unsigned char
                         goto out;
                 }
 
-                vdbg("%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)", __func__, skb, skb->truesize);
+                vdbg(&instance->usb_intf->dev,
+                     "%s: allocated new sk_buff (skb: 0x%p, skb->truesize: %u)",
+                     __func__, skb, skb->truesize);
 
                 if (!atm_charge(vcc, skb->truesize)) {
                         atm_rldbg(instance, "%s: failed atm_charge (skb->truesize: %u)!\n",
@@ -405,10 +409,11 @@ static void usbatm_extract_one_cell(struct usbatm_data *instance, unsigned char
                                         length);
                 __skb_put(skb, length);
 
-                vdbg("%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
+                vdbg(&instance->usb_intf->dev,
+                     "%s: sending skb 0x%p, skb->len %u, skb->truesize %u",
                      __func__, skb, skb->len, skb->truesize);
 
-                PACKETDEBUG(skb->data, skb->len);
+                PACKETDEBUG(instance, skb->data, skb->len);
 
                 vcc->push(vcc, skb);
 
@@ -474,7 +479,8 @@ static unsigned int usbatm_write_cells(struct usbatm_data *instance,
         unsigned int bytes_written;
         unsigned int stride = instance->tx_channel.stride;
 
-        vdbg("%s: skb->len=%d, avail_space=%u", __func__, skb->len, avail_space);
+        vdbg(&instance->usb_intf->dev, "%s: skb->len=%d, avail_space=%u",
+             __func__, skb->len, avail_space);
         UDSL_ASSERT(instance, !(avail_space % stride));
 
         for (bytes_written = 0; bytes_written < avail_space && ctrl->len;
@@ -534,7 +540,8 @@ static void usbatm_rx_process(unsigned long data)
         struct urb *urb;
 
         while ((urb = usbatm_pop_urb(&instance->rx_channel))) {
-                vdbg("%s: processing urb 0x%p", __func__, urb);
+                vdbg(&instance->usb_intf->dev,
+                     "%s: processing urb 0x%p", __func__, urb);
 
                 if (usb_pipeisoc(urb->pipe)) {
                         unsigned char *merge_start = NULL;
@@ -608,7 +615,8 @@ static void usbatm_tx_process(unsigned long data)
                                                   buffer + bytes_written,
                                                   buf_size - bytes_written);
 
-                vdbg("%s: wrote %u bytes from skb 0x%p to urb 0x%p",
+                vdbg(&instance->usb_intf->dev,
+                     "%s: wrote %u bytes from skb 0x%p to urb 0x%p",
                      __func__, bytes_written, skb, urb);
 
                 if (!UDSL_SKB(skb)->len) {
@@ -664,7 +672,8 @@ static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
         struct usbatm_control *ctrl = UDSL_SKB(skb);
         int err;
 
-        vdbg("%s called (skb 0x%p, len %u)", __func__, skb, skb->len);
+        vdbg(&instance->usb_intf->dev, "%s called (skb 0x%p, len %u)", __func__,
+             skb, skb->len);
 
         /* racy disconnection check - fine */
         if (!instance || instance->disconnected) {
@@ -688,7 +697,7 @@ static int usbatm_atm_send(struct atm_vcc *vcc, struct sk_buff *skb)
                 goto fail;
         }
 
-        PACKETDEBUG(skb->data, skb->len);
+        PACKETDEBUG(instance, skb->data, skb->len);
 
         /* initialize the control block */
         ctrl->atm.vcc = vcc;
@@ -1202,7 +1211,7 @@ int usbatm_usb_probe(struct usb_interface *intf, const struct usb_device_id *id,
                 if (i >= num_rcv_urbs)
                         list_add_tail(&urb->urb_list, &channel->list);
 
-                vdbg("%s: alloced buffer 0x%p buf size %u urb 0x%p",
+                vdbg(&intf->dev, "%s: alloced buffer 0x%p buf size %u urb 0x%p",
                      __func__, urb->transfer_buffer, urb->transfer_buffer_length, urb);
         }
 
@@ -1359,7 +1368,8 @@ MODULE_VERSION(DRIVER_VERSION);
 ************/
 
 #ifdef VERBOSE_DEBUG
-static int usbatm_print_packet(const unsigned char *data, int len)
+static int usbatm_print_packet(struct usbatm_data *instance,
+                               const unsigned char *data, int len)
 {
         unsigned char buffer[256];
         int i = 0, j = 0;
@@ -1369,7 +1379,7 @@ static int usbatm_print_packet(const unsigned char *data, int len)
                 sprintf(buffer, "%.3d :", i);
                 for (j = 0; (j < 16) && (i < len); j++, i++)
                         sprintf(buffer, "%s %2.2x", buffer, data[i]);
-                dbg("%s", buffer);
+                dev_dbg(&instance->usb_intf->dev, "%s", buffer);
         }
         return i;
 }
diff --git a/drivers/usb/chipidea/Kconfig b/drivers/usb/chipidea/Kconfig
index 47e499c9c0b6..1ea932a13685 100644
--- a/drivers/usb/chipidea/Kconfig
+++ b/drivers/usb/chipidea/Kconfig
@@ -13,7 +13,6 @@ if USB_CHIPIDEA
 config USB_CHIPIDEA_UDC
         bool "ChipIdea device controller"
         depends on USB_GADGET=y || USB_GADGET=USB_CHIPIDEA
-        select USB_GADGET_DUALSPEED
         help
           Say Y here to enable device controller functionality of the
           ChipIdea driver.
diff --git a/drivers/usb/chipidea/Makefile b/drivers/usb/chipidea/Makefile
index 5c66d9c330ca..d92ca325b104 100644
--- a/drivers/usb/chipidea/Makefile
+++ b/drivers/usb/chipidea/Makefile
@@ -1,3 +1,5 @@
+ccflags-$(CONFIG_USB_CHIPIDEA_DEBUG) := -DDEBUG
+
 obj-$(CONFIG_USB_CHIPIDEA)              += ci_hdrc.o
 
 ci_hdrc-y                               := core.o
@@ -15,5 +17,5 @@ ifneq ($(CONFIG_PCI),)
 endif
 
 ifneq ($(CONFIG_OF_DEVICE),)
-        obj-$(CONFIG_USB_CHIPIDEA)      += ci13xxx_imx.o
+        obj-$(CONFIG_USB_CHIPIDEA)      += ci13xxx_imx.o usbmisc_imx6q.o
 endif
diff --git a/drivers/usb/chipidea/ci.h b/drivers/usb/chipidea/ci.h
index d738603a2757..e25d1263da13 100644
--- a/drivers/usb/chipidea/ci.h
+++ b/drivers/usb/chipidea/ci.h
@@ -139,6 +139,7 @@ struct ci13xxx {
         enum ci_role                    role;
         bool                            is_otg;
         struct work_struct              work;
+        struct work_struct              vbus_work;
         struct workqueue_struct         *wq;
 
         struct dma_pool                 *qh_pool;
diff --git a/drivers/usb/chipidea/ci13xxx_imx.c b/drivers/usb/chipidea/ci13xxx_imx.c
index ef60d06835d0..0f5ca4bea17f 100644
--- a/drivers/usb/chipidea/ci13xxx_imx.c
+++ b/drivers/usb/chipidea/ci13xxx_imx.c
@@ -20,8 +20,10 @@
 #include <linux/usb/chipidea.h>
 #include <linux/clk.h>
 #include <linux/regulator/consumer.h>
+#include <linux/pinctrl/consumer.h>
 
 #include "ci.h"
+#include "ci13xxx_imx.h"
 
 #define pdev_to_phy(pdev) \
         ((struct usb_phy *)platform_get_drvdata(pdev))
@@ -34,6 +36,55 @@ struct ci13xxx_imx_data {
         struct regulator *reg_vbus;
 };
 
+static const struct usbmisc_ops *usbmisc_ops;
+
+/* Common functions shared by usbmisc drivers */
+
+int usbmisc_set_ops(const struct usbmisc_ops *ops)
+{
+        if (usbmisc_ops)
+                return -EBUSY;
+
+        usbmisc_ops = ops;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usbmisc_set_ops);
+
+void usbmisc_unset_ops(const struct usbmisc_ops *ops)
+{
+        usbmisc_ops = NULL;
+}
+EXPORT_SYMBOL_GPL(usbmisc_unset_ops);
+
+int usbmisc_get_init_data(struct device *dev, struct usbmisc_usb_device *usbdev)
+{
+        struct device_node *np = dev->of_node;
+        struct of_phandle_args args;
+        int ret;
+
+        usbdev->dev = dev;
+
+        ret = of_parse_phandle_with_args(np, "fsl,usbmisc", "#index-cells",
+                                        0, &args);
+        if (ret) {
+                dev_err(dev, "Failed to parse property fsl,usbmisc, errno %d\n",
+                        ret);
+                memset(usbdev, 0, sizeof(*usbdev));
+                return ret;
+        }
+        usbdev->index = args.args[0];
+        of_node_put(args.np);
+
+        if (of_find_property(np, "disable-over-current", NULL))
+                usbdev->disable_oc = 1;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(usbmisc_get_init_data);
+
+/* End of common functions shared by usbmisc drivers*/
+
 static struct ci13xxx_platform_data ci13xxx_imx_platdata __devinitdata  = {
         .name                   = "ci13xxx_imx",
         .flags                  = CI13XXX_REQUIRE_TRANSCEIVER |
@@ -49,8 +100,13 @@ static int __devinit ci13xxx_imx_probe(struct platform_device *pdev)
         struct device_node *phy_np;
         struct resource *res;
         struct regulator *reg_vbus;
+        struct pinctrl *pinctrl;
         int ret;
 
+        if (of_find_property(pdev->dev.of_node, "fsl,usbmisc", NULL)
+                && !usbmisc_ops)
+                return -EPROBE_DEFER;
+
         data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
         if (!data) {
                 dev_err(&pdev->dev, "Failed to allocate CI13xxx-IMX data!\n");
@@ -63,6 +119,11 @@ static int __devinit ci13xxx_imx_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
+        pinctrl = devm_pinctrl_get_select_default(&pdev->dev);
+        if (IS_ERR(pinctrl))
+                dev_warn(&pdev->dev, "pinctrl get/select failed, err=%ld\n",
+                        PTR_ERR(pinctrl));
+
         data->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(data->clk)) {
                 dev_err(&pdev->dev,
@@ -120,6 +181,16 @@ static int __devinit ci13xxx_imx_probe(struct platform_device *pdev)
                 *pdev->dev.dma_mask = DMA_BIT_MASK(32);
                 dma_set_coherent_mask(&pdev->dev, *pdev->dev.dma_mask);
         }
+
+        if (usbmisc_ops && usbmisc_ops->init) {
+                ret = usbmisc_ops->init(&pdev->dev);
+                if (ret) {
+                        dev_err(&pdev->dev,
+                                "usbmisc init failed, ret=%d\n", ret);
+                        goto err;
+                }
+        }
+
         plat_ci = ci13xxx_add_device(&pdev->dev,
                                 pdev->resource, pdev->num_resources,
                                 &ci13xxx_imx_platdata);
diff --git a/drivers/usb/chipidea/ci13xxx_imx.h b/drivers/usb/chipidea/ci13xxx_imx.h
new file mode 100644
index 000000000000..2e88accb3d67
--- /dev/null
+++ b/drivers/usb/chipidea/ci13xxx_imx.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2012 Freescale Semiconductor, Inc.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+/* Used to set SoC specific callbacks */
+struct usbmisc_ops {
+        /* It's called once when probe a usb device */
+        int (*init)(struct device *dev);
+};
+
+struct usbmisc_usb_device {
+        struct device *dev; /* usb controller device */
+        int index;
+
+        int disable_oc:1; /* over current detect disabled */
+};
+
+int usbmisc_set_ops(const struct usbmisc_ops *ops);
+void usbmisc_unset_ops(const struct usbmisc_ops *ops);
+int
+usbmisc_get_init_data(struct device *dev, struct usbmisc_usb_device *usbdev);
diff --git a/drivers/usb/chipidea/core.c b/drivers/usb/chipidea/core.c
index 1083585fad00..f69d029b4607 100644
--- a/drivers/usb/chipidea/core.c
+++ b/drivers/usb/chipidea/core.c
@@ -273,14 +273,13 @@ static void ci_role_work(struct work_struct *work)
         struct ci13xxx *ci = container_of(work, struct ci13xxx, work);
         enum ci_role role = ci_otg_role(ci);
 
-        hw_write(ci, OP_OTGSC, OTGSC_IDIS, OTGSC_IDIS);
-
         if (role != ci->role) {
                 dev_dbg(ci->dev, "switching from %s to %s\n",
                         ci_role(ci)->name, ci->roles[role]->name);
 
                 ci_role_stop(ci);
                 ci_role_start(ci, role);
+                enable_irq(ci->irq);
         }
 }
 
@@ -320,17 +319,22 @@ static irqreturn_t ci_irq(int irq, void *data)
 {
         struct ci13xxx *ci = data;
         irqreturn_t ret = IRQ_NONE;
+        u32 otgsc = 0;
+
+        if (ci->is_otg)
+                otgsc = hw_read(ci, OP_OTGSC, ~0);
 
-        if (ci->is_otg) {
-                u32 sts = hw_read(ci, OP_OTGSC, ~0);
+        if (ci->role != CI_ROLE_END)
+                ret = ci_role(ci)->irq(ci);
 
-                if (sts & OTGSC_IDIS) {
-                        queue_work(ci->wq, &ci->work);
-                        ret = IRQ_HANDLED;
-                }
+        if (ci->is_otg && (otgsc & OTGSC_IDIS)) {
+                hw_write(ci, OP_OTGSC, OTGSC_IDIS, OTGSC_IDIS);
+                disable_irq_nosync(ci->irq);
+                queue_work(ci->wq, &ci->work);
+                ret = IRQ_HANDLED;
         }
 
-        return ci->role == CI_ROLE_END ? ret : ci_role(ci)->irq(ci);
+        return ret;
 }
 
 static DEFINE_IDA(ci_ida);
@@ -462,6 +466,8 @@ static int __devinit ci_hdrc_probe(struct platform_device *pdev)
 
         if (ci->roles[CI_ROLE_HOST] && ci->roles[CI_ROLE_GADGET]) {
                 ci->is_otg = true;
+                /* ID pin needs 1ms debouce time, we delay 2ms for safe */
+                mdelay(2);
                 ci->role = ci_otg_role(ci);
         } else {
                 ci->role = ci->roles[CI_ROLE_HOST]
diff --git a/drivers/usb/chipidea/udc.c b/drivers/usb/chipidea/udc.c
index d214448b677e..2f45bba8561d 100644
--- a/drivers/usb/chipidea/udc.c
+++ b/drivers/usb/chipidea/udc.c
@@ -305,6 +305,18 @@ static u32 hw_test_and_clear_intr_active(struct ci13xxx *ci)
         return reg;
 }
 
+static void hw_enable_vbus_intr(struct ci13xxx *ci)
+{
+        hw_write(ci, OP_OTGSC, OTGSC_AVVIS, OTGSC_AVVIS);
+        hw_write(ci, OP_OTGSC, OTGSC_AVVIE, OTGSC_AVVIE);
+        queue_work(ci->wq, &ci->vbus_work);
+}
+
+static void hw_disable_vbus_intr(struct ci13xxx *ci)
+{
+        hw_write(ci, OP_OTGSC, OTGSC_AVVIE, 0);
+}
+
 /**
  * hw_test_and_clear_setup_guard: test & clear setup guard (execute without
  *                                interruption)
@@ -371,6 +383,16 @@ static int hw_usb_reset(struct ci13xxx *ci)
         return 0;
 }
 
+static void vbus_work(struct work_struct *work)
+{
+        struct ci13xxx *ci = container_of(work, struct ci13xxx, vbus_work);
+
+        if (hw_read(ci, OP_OTGSC, OTGSC_AVV))
+                usb_gadget_vbus_connect(&ci->gadget);
+        else
+                usb_gadget_vbus_disconnect(&ci->gadget);
+}
+
 /******************************************************************************
  * UTIL block
  *****************************************************************************/
@@ -1370,6 +1392,7 @@ static int ci13xxx_vbus_session(struct usb_gadget *_gadget, int is_active)
                 if (is_active) {
                         pm_runtime_get_sync(&_gadget->dev);
                         hw_device_reset(ci, USBMODE_CM_DC);
+                        hw_enable_vbus_intr(ci);
                         hw_device_state(ci, ci->ep0out->qh.dma);
                 } else {
                         hw_device_state(ci, 0);
@@ -1544,8 +1567,10 @@ static int ci13xxx_start(struct usb_gadget *gadget,
         pm_runtime_get_sync(&ci->gadget.dev);
         if (ci->platdata->flags & CI13XXX_PULLUP_ON_VBUS) {
                 if (ci->vbus_active) {
-                        if (ci->platdata->flags & CI13XXX_REGS_SHARED)
+                        if (ci->platdata->flags & CI13XXX_REGS_SHARED) {
                                 hw_device_reset(ci, USBMODE_CM_DC);
+                                hw_enable_vbus_intr(ci);
+                        }
                 } else {
                         pm_runtime_put_sync(&ci->gadget.dev);
                         goto done;
@@ -1651,6 +1676,13 @@ static irqreturn_t udc_irq(struct ci13xxx *ci)
         } else {
                 retval = IRQ_NONE;
         }
+
+        intr = hw_read(ci, OP_OTGSC, ~0);
+        hw_write(ci, OP_OTGSC, ~0, intr);
+
+        if (intr & (OTGSC_AVVIE & OTGSC_AVVIS))
+                queue_work(ci->wq, &ci->vbus_work);
+
         spin_unlock(&ci->lock);
 
         return retval;
@@ -1726,6 +1758,7 @@ static int udc_start(struct ci13xxx *ci)
                 retval = hw_device_reset(ci, USBMODE_CM_DC);
                 if (retval)
                         goto put_transceiver;
+                hw_enable_vbus_intr(ci);
         }
 
         retval = device_register(&ci->gadget.dev);
@@ -1788,6 +1821,9 @@ static void udc_stop(struct ci13xxx *ci)
         if (ci == NULL)
                 return;
 
+        hw_disable_vbus_intr(ci);
+        cancel_work_sync(&ci->vbus_work);
+
         usb_del_gadget_udc(&ci->gadget);
 
         destroy_eps(ci);
@@ -1828,6 +1864,7 @@ int ci_hdrc_gadget_init(struct ci13xxx *ci)
         rdrv->irq       = udc_irq;
         rdrv->name      = "gadget";
         ci->roles[CI_ROLE_GADGET] = rdrv;
+        INIT_WORK(&ci->vbus_work, vbus_work);
 
         return 0;
 }
diff --git a/drivers/usb/chipidea/usbmisc_imx6q.c b/drivers/usb/chipidea/usbmisc_imx6q.c
new file mode 100644
index 000000000000..416e3fc58fd0
--- /dev/null
+++ b/drivers/usb/chipidea/usbmisc_imx6q.c
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2012 Freescale Semiconductor, Inc.
+ *
+ * The code contained herein is licensed under the GNU General Public
+ * License. You may obtain a copy of the GNU General Public License
+ * Version 2 or later at the following locations:
+ *
+ * http://www.opensource.org/licenses/gpl-license.html
+ * http://www.gnu.org/copyleft/gpl.html
+ */
+
+#include <linux/module.h>
+#include <linux/of_platform.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/io.h>
+
+#include "ci13xxx_imx.h"
+
+#define USB_DEV_MAX 4
+
+#define BM_OVER_CUR_DIS         BIT(7)
+
+struct imx6q_usbmisc {
+        void __iomem *base;
+        spinlock_t lock;
+        struct clk *clk;
+        struct usbmisc_usb_device usbdev[USB_DEV_MAX];
+};
+
+static struct imx6q_usbmisc *usbmisc;
+
+static struct usbmisc_usb_device *get_usbdev(struct device *dev)
+{
+        int i, ret;
+
+        for (i = 0; i < USB_DEV_MAX; i++) {
+                if (usbmisc->usbdev[i].dev == dev)
+                        return &usbmisc->usbdev[i];
+                else if (!usbmisc->usbdev[i].dev)
+                        break;
+        }
+
+        if (i >= USB_DEV_MAX)
+                return ERR_PTR(-EBUSY);
+
+        ret = usbmisc_get_init_data(dev, &usbmisc->usbdev[i]);
+        if (ret)
+                return ERR_PTR(ret);
+
+        return &usbmisc->usbdev[i];
+}
+
+static int usbmisc_imx6q_init(struct device *dev)
+{
+
+        struct usbmisc_usb_device *usbdev;
+        unsigned long flags;
+        u32 reg;
+
+        usbdev = get_usbdev(dev);
+        if (IS_ERR(usbdev))
+                return PTR_ERR(usbdev);
+
+        if (usbdev->disable_oc) {
+                spin_lock_irqsave(&usbmisc->lock, flags);
+                reg = readl(usbmisc->base + usbdev->index * 4);
+                writel(reg | BM_OVER_CUR_DIS,
+                        usbmisc->base + usbdev->index * 4);
+                spin_unlock_irqrestore(&usbmisc->lock, flags);
+        }
+
+        return 0;
+}
+
+static const struct usbmisc_ops imx6q_usbmisc_ops = {
+        .init = usbmisc_imx6q_init,
+};
+
+static const struct of_device_id usbmisc_imx6q_dt_ids[] = {
+        { .compatible = "fsl,imx6q-usbmisc"},
+        { /* sentinel */ }
+};
+
+static int __devinit usbmisc_imx6q_probe(struct platform_device *pdev)
+{
+        struct resource *res;
+        struct imx6q_usbmisc *data;
+        int ret;
+
+        if (usbmisc)
+                return -EBUSY;
+
+        data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        spin_lock_init(&data->lock);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        data->base = devm_request_and_ioremap(&pdev->dev, res);
+        if (!data->base)
+                return -EADDRNOTAVAIL;
+
+        data->clk = devm_clk_get(&pdev->dev, NULL);
+        if (IS_ERR(data->clk)) {
+                dev_err(&pdev->dev,
+                        "failed to get clock, err=%ld\n", PTR_ERR(data->clk));
+                return PTR_ERR(data->clk);
+        }
+
+        ret = clk_prepare_enable(data->clk);
+        if (ret) {
+                dev_err(&pdev->dev,
+                        "clk_prepare_enable failed, err=%d\n", ret);
+                return ret;
+        }
+
+        ret = usbmisc_set_ops(&imx6q_usbmisc_ops);
+        if (ret) {
+                clk_disable_unprepare(data->clk);
+                return ret;
+        }
+
+        usbmisc = data;
+
+        return 0;
+}
+
+static int __devexit usbmisc_imx6q_remove(struct platform_device *pdev)
+{
+        usbmisc_unset_ops(&imx6q_usbmisc_ops);
+        clk_disable_unprepare(usbmisc->clk);
+        return 0;
+}
+
+static struct platform_driver usbmisc_imx6q_driver = {
+        .probe = usbmisc_imx6q_probe,
+        .remove = __devexit_p(usbmisc_imx6q_remove),
+        .driver = {
+                .name = "usbmisc_imx6q",
+                .owner = THIS_MODULE,
+                .of_match_table = usbmisc_imx6q_dt_ids,
+         },
+};
+
+int __init usbmisc_imx6q_drv_init(void)
+{
+        return platform_driver_register(&usbmisc_imx6q_driver);
+}
+subsys_initcall(usbmisc_imx6q_drv_init);
+
+void __exit usbmisc_imx6q_drv_exit(void)
+{
+        platform_driver_unregister(&usbmisc_imx6q_driver);
+}
+module_exit(usbmisc_imx6q_drv_exit);
+
+MODULE_ALIAS("platform:usbmisc-imx6q");
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("driver for imx6q usb non-core registers");
+MODULE_AUTHOR("Richard Zhao <richard.zhao@freescale.com>");
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index ff7b5a8d501c..36f2be4def2f 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -39,7 +39,6 @@
 #include <linux/serial.h>
 #include <linux/tty_driver.h>
 #include <linux/tty_flip.h>
-#include <linux/serial.h>
 #include <linux/module.h>
 #include <linux/mutex.h>
 #include <linux/uaccess.h>
diff --git a/drivers/usb/core/Kconfig b/drivers/usb/core/Kconfig
index 9981984b365b..f70c1a1694ad 100644
--- a/drivers/usb/core/Kconfig
+++ b/drivers/usb/core/Kconfig
@@ -56,7 +56,7 @@ config USB_SUSPEND
 
 config USB_OTG
         bool "OTG support"
-        depends on USB && EXPERIMENTAL
+        depends on USB
         depends on USB_SUSPEND
         default n
         help
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index f4bdd0ce8d56..7199adccf444 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -702,6 +702,8 @@ int usb_get_configuration(struct usb_device *dev)
                 if (result < 0) {
                         dev_err(ddev, "unable to read config index %d "
                             "descriptor/%s: %d\n", cfgno, "start", result);
+                        if (result != -EPIPE)
+                                goto err;
                         dev_err(ddev, "chopping to %d config(s)\n", cfgno);
                         dev->descriptor.bNumConfigurations = cfgno;
                         break;
diff --git a/drivers/usb/core/devices.c b/drivers/usb/core/devices.c
index 3440812b4a84..f460de31acee 100644
--- a/drivers/usb/core/devices.c
+++ b/drivers/usb/core/devices.c
@@ -496,6 +496,7 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
         char *pages_start, *data_end, *speed;
         unsigned int length;
         ssize_t total_written = 0;
+        struct usb_device *childdev = NULL;
 
         /* don't bother with anything else if we're not writing any data */
         if (*nbytes <= 0)
@@ -589,14 +590,12 @@ static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
         free_pages((unsigned long)pages_start, 1);
 
         /* Now look at all of this device's children. */
-        for (chix = 0; chix < usbdev->maxchild; chix++) {
-                struct usb_device *childdev = usbdev->children[chix];
-
+        usb_hub_for_each_child(usbdev, chix, childdev) {
                 if (childdev) {
                         usb_lock_device(childdev);
                         ret = usb_device_dump(buffer, nbytes, skip_bytes,
                                               file_offset, childdev, bus,
-                                              level + 1, chix, ++cnt);
+                                              level + 1, chix - 1, ++cnt);
                         usb_unlock_device(childdev);
                         if (ret == -EFAULT)
                                 return total_written;
diff --git a/drivers/usb/core/devio.c b/drivers/usb/core/devio.c
index ebb8a9de8b5f..e0356cb859b5 100644
--- a/drivers/usb/core/devio.c
+++ b/drivers/usb/core/devio.c
@@ -1928,6 +1928,38 @@ static int proc_get_capabilities(struct dev_state *ps, void __user *arg)
         return 0;
 }
 
+static int proc_disconnect_claim(struct dev_state *ps, void __user *arg)
+{
+        struct usbdevfs_disconnect_claim dc;
+        struct usb_interface *intf;
+
+        if (copy_from_user(&dc, arg, sizeof(dc)))
+                return -EFAULT;
+
+        intf = usb_ifnum_to_if(ps->dev, dc.interface);
+        if (!intf)
+                return -EINVAL;
+
+        if (intf->dev.driver) {
+                struct usb_driver *driver = to_usb_driver(intf->dev.driver);
+
+                if ((dc.flags & USBDEVFS_DISCONNECT_CLAIM_IF_DRIVER) &&
+                                strncmp(dc.driver, intf->dev.driver->name,
+                                        sizeof(dc.driver)) != 0)
+                        return -EBUSY;
+
+                if ((dc.flags & USBDEVFS_DISCONNECT_CLAIM_EXCEPT_DRIVER) &&
+                                strncmp(dc.driver, intf->dev.driver->name,
+                                        sizeof(dc.driver)) == 0)
+                        return -EBUSY;
+
+                dev_dbg(&intf->dev, "disconnect by usbfs\n");
+                usb_driver_release_interface(driver, intf);
+        }
+
+        return claimintf(ps, dc.interface);
+}
+
 /*
  * NOTE:  All requests here that have interface numbers as parameters
  * are assuming that somehow the configuration has been prevented from
@@ -2101,6 +2133,9 @@ static long usbdev_do_ioctl(struct file *file, unsigned int cmd,
         case USBDEVFS_GET_CAPABILITIES:
                 ret = proc_get_capabilities(ps, p);
                 break;
+        case USBDEVFS_DISCONNECT_CLAIM:
+                ret = proc_disconnect_claim(ps, p);
+                break;
         }
         usb_unlock_device(dev);
         if (ret >= 0)
diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
index 445455a4429b..ddd820d25288 100644
--- a/drivers/usb/core/driver.c
+++ b/drivers/usb/core/driver.c
@@ -125,10 +125,9 @@ store_remove_id(struct device_driver *driver, const char *buf, size_t count)
 {
         struct usb_dynid *dynid, *n;
         struct usb_driver *usb_driver = to_usb_driver(driver);
-        u32 idVendor = 0;
-        u32 idProduct = 0;
-        int fields = 0;
-        int retval = 0;
+        u32 idVendor;
+        u32 idProduct;
+        int fields;
 
         fields = sscanf(buf, "%x %x", &idVendor, &idProduct);
         if (fields < 2)
@@ -141,14 +140,10 @@ store_remove_id(struct device_driver *driver, const char *buf, size_t count)
                     (id->idProduct == idProduct)) {
                         list_del(&dynid->node);
                         kfree(dynid);
-                        retval = 0;
                         break;
                 }
         }
         spin_unlock(&usb_driver->dynids.lock);
-
-        if (retval)
-                return retval;
         return count;
 }
 static DRIVER_ATTR(remove_id, S_IRUGO | S_IWUSR, show_dynids, store_remove_id);
diff --git a/drivers/usb/core/endpoint.c b/drivers/usb/core/endpoint.c
index db7fe50c23d4..68cc6532e749 100644
--- a/drivers/usb/core/endpoint.c
+++ b/drivers/usb/core/endpoint.c
@@ -24,10 +24,6 @@ struct ep_device {
 #define to_ep_device(_dev) \
         container_of(_dev, struct ep_device, dev)
 
-struct device_type usb_ep_device_type = {
-        .name =         "usb_endpoint",
-};
-
 struct ep_attribute {
         struct attribute attr;
         ssize_t (*show)(struct usb_device *,
@@ -172,6 +168,11 @@ static void ep_device_release(struct device *dev)
         kfree(ep_dev);
 }
 
+struct device_type usb_ep_device_type = {
+        .name =         "usb_endpoint",
+        .release = ep_device_release,
+};
+
 int usb_create_ep_devs(struct device *parent,
                         struct usb_host_endpoint *endpoint,
                         struct usb_device *udev)
@@ -190,7 +191,6 @@ int usb_create_ep_devs(struct device *parent,
         ep_dev->dev.groups = ep_dev_groups;
         ep_dev->dev.type = &usb_ep_device_type;
         ep_dev->dev.parent = parent;
-        ep_dev->dev.release = ep_device_release;
         dev_set_name(&ep_dev->dev, "ep_%02x", endpoint->desc.bEndpointAddress);
 
         retval = device_register(&ep_dev->dev);
diff --git a/drivers/usb/core/hcd.c b/drivers/usb/core/hcd.c
index 75ba2091f9b4..1e741bca0265 100644
--- a/drivers/usb/core/hcd.c
+++ b/drivers/usb/core/hcd.c
@@ -22,6 +22,7 @@
  * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <linux/bcd.h>
 #include <linux/module.h>
 #include <linux/version.h>
 #include <linux/kernel.h>
@@ -123,9 +124,8 @@ static inline int is_root_hub(struct usb_device *udev)
  */
 
 /*-------------------------------------------------------------------------*/
-
-#define KERNEL_REL      ((LINUX_VERSION_CODE >> 16) & 0x0ff)
-#define KERNEL_VER      ((LINUX_VERSION_CODE >> 8) & 0x0ff)
+#define KERNEL_REL      bin2bcd(((LINUX_VERSION_CODE >> 16) & 0x0ff))
+#define KERNEL_VER      bin2bcd(((LINUX_VERSION_CODE >> 8) & 0x0ff))
 
 /* usb 3.0 root hub device descriptor */
 static const u8 usb3_rh_dev_descriptor[18] = {
@@ -2151,15 +2151,8 @@ EXPORT_SYMBOL_GPL(usb_bus_start_enum);
 irqreturn_t usb_hcd_irq (int irq, void *__hcd)
 {
         struct usb_hcd          *hcd = __hcd;
-        unsigned long           flags;
         irqreturn_t             rc;
 
-        /* IRQF_DISABLED doesn't work correctly with shared IRQs
-         * when the first handler doesn't use it.  So let's just
-         * assume it's never used.
-         */
-        local_irq_save(flags);
-
         if (unlikely(HCD_DEAD(hcd) || !HCD_HW_ACCESSIBLE(hcd)))
                 rc = IRQ_NONE;
         else if (hcd->driver->irq(hcd) == IRQ_NONE)
@@ -2167,7 +2160,6 @@ irqreturn_t usb_hcd_irq (int irq, void *__hcd)
         else
                 rc = IRQ_HANDLED;
 
-        local_irq_restore(flags);
         return rc;
 }
 EXPORT_SYMBOL_GPL(usb_hcd_irq);
@@ -2355,14 +2347,6 @@ static int usb_hcd_request_irqs(struct usb_hcd *hcd,
         int retval;
 
         if (hcd->driver->irq) {
-
-                /* IRQF_DISABLED doesn't work as advertised when used together
-                 * with IRQF_SHARED. As usb_hcd_irq() will always disable
-                 * interrupts we can remove it here.
-                 */
-                if (irqflags & IRQF_SHARED)
-                        irqflags &= ~IRQF_DISABLED;
-
                 snprintf(hcd->irq_descr, sizeof(hcd->irq_descr), "%s:usb%d",
                                 hcd->driver->description, hcd->self.busnum);
                 retval = request_irq(irqnum, &usb_hcd_irq, irqflags,
diff --git a/drivers/usb/core/hub.c b/drivers/usb/core/hub.c
index 128a804c42f4..673ee4696262 100644
--- a/drivers/usb/core/hub.c
+++ b/drivers/usb/core/hub.c
@@ -39,6 +39,13 @@
 #endif
 #endif
 
+struct usb_port {
+        struct usb_device *child;
+        struct device dev;
+        struct dev_state *port_owner;
+        enum usb_port_connect_type connect_type;
+};
+
 struct usb_hub {
         struct device           *intfdev;       /* the "interface" device */
         struct usb_device       *hdev;
@@ -83,7 +90,7 @@ struct usb_hub {
         u8                      indicator[USB_MAXCHILDREN];
         struct delayed_work     leds;
         struct delayed_work     init_work;
-        struct dev_state        **port_owners;
+        struct usb_port         **ports;
 };
 
 static inline int hub_is_superspeed(struct usb_device *hdev)
@@ -156,6 +163,8 @@ EXPORT_SYMBOL_GPL(ehci_cf_port_reset_rwsem);
 #define HUB_DEBOUNCE_STEP         25
 #define HUB_DEBOUNCE_STABLE      100
 
+#define to_usb_port(_dev) \
+        container_of(_dev, struct usb_port, dev)
 
 static int usb_reset_and_verify_device(struct usb_device *udev);
 
@@ -174,7 +183,7 @@ static inline char *portspeed(struct usb_hub *hub, int portstatus)
 /* Note that hdev or one of its children must be locked! */
 static struct usb_hub *hdev_to_hub(struct usb_device *hdev)
 {
-        if (!hdev || !hdev->actconfig)
+        if (!hdev || !hdev->actconfig || !hdev->maxchild)
                 return NULL;
         return usb_get_intfdata(hdev->actconfig->interface[0]);
 }
@@ -869,8 +878,8 @@ static int hub_port_disable(struct usb_hub *hub, int port1, int set_state)
         struct usb_device *hdev = hub->hdev;
         int ret = 0;
 
-        if (hdev->children[port1-1] && set_state)
-                usb_set_device_state(hdev->children[port1-1],
+        if (hub->ports[port1 - 1]->child && set_state)
+                usb_set_device_state(hub->ports[port1 - 1]->child,
                                 USB_STATE_NOTATTACHED);
         if (!hub->error && !hub_is_superspeed(hub->hdev))
                 ret = clear_port_feature(hdev, port1, USB_PORT_FEAT_ENABLE);
@@ -1026,7 +1035,7 @@ static void hub_activate(struct usb_hub *hub, enum hub_activation_type type)
          * which ports need attention.
          */
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device *udev = hdev->children[port1-1];
+                struct usb_device *udev = hub->ports[port1 - 1]->child;
                 u16 portstatus, portchange;
 
                 portstatus = portchange = 0;
@@ -1191,8 +1200,8 @@ static void hub_quiesce(struct usb_hub *hub, enum hub_quiescing_type type)
         if (type != HUB_SUSPEND) {
                 /* Disconnect all the children */
                 for (i = 0; i < hdev->maxchild; ++i) {
-                        if (hdev->children[i])
-                                usb_disconnect(&hdev->children[i]);
+                        if (hub->ports[i]->child)
+                                usb_disconnect(&hub->ports[i]->child);
                 }
         }
 
@@ -1222,6 +1231,52 @@ static int hub_post_reset(struct usb_interface *intf)
         return 0;
 }
 
+static void usb_port_device_release(struct device *dev)
+{
+        struct usb_port *port_dev = to_usb_port(dev);
+
+        kfree(port_dev);
+}
+
+static void usb_hub_remove_port_device(struct usb_hub *hub,
+                                       int port1)
+{
+        device_unregister(&hub->ports[port1 - 1]->dev);
+}
+
+struct device_type usb_port_device_type = {
+        .name =         "usb_port",
+        .release =      usb_port_device_release,
+};
+
+static int usb_hub_create_port_device(struct usb_hub *hub,
+                                      int port1)
+{
+        struct usb_port *port_dev = NULL;
+        int retval;
+
+        port_dev = kzalloc(sizeof(*port_dev), GFP_KERNEL);
+        if (!port_dev) {
+                retval = -ENOMEM;
+                goto exit;
+        }
+
+        hub->ports[port1 - 1] = port_dev;
+        port_dev->dev.parent = hub->intfdev;
+        port_dev->dev.type = &usb_port_device_type;
+        dev_set_name(&port_dev->dev, "port%d", port1);
+
+        retval = device_register(&port_dev->dev);
+        if (retval)
+                goto error_register;
+        return 0;
+
+error_register:
+        put_device(&port_dev->dev);
+exit:
+        return retval;
+}
+
 static int hub_configure(struct usb_hub *hub,
         struct usb_endpoint_descriptor *endpoint)
 {
@@ -1231,7 +1286,7 @@ static int hub_configure(struct usb_hub *hub,
         u16 hubstatus, hubchange;
         u16 wHubCharacteristics;
         unsigned int pipe;
-        int maxp, ret;
+        int maxp, ret, i;
         char *message = "out of memory";
 
         hub->buffer = kmalloc(sizeof(*hub->buffer), GFP_KERNEL);
@@ -1271,11 +1326,9 @@ static int hub_configure(struct usb_hub *hub,
         dev_info (hub_dev, "%d port%s detected\n", hdev->maxchild,
                 (hdev->maxchild == 1) ? "" : "s");
 
-        hdev->children = kzalloc(hdev->maxchild *
-                                sizeof(struct usb_device *), GFP_KERNEL);
-        hub->port_owners = kzalloc(hdev->maxchild * sizeof(struct dev_state *),
-                                GFP_KERNEL);
-        if (!hdev->children || !hub->port_owners) {
+        hub->ports = kzalloc(hdev->maxchild * sizeof(struct usb_port *),
+                             GFP_KERNEL);
+        if (!hub->ports) {
                 ret = -ENOMEM;
                 goto fail;
         }
@@ -1484,6 +1537,11 @@ static int hub_configure(struct usb_hub *hub,
         if (hub->has_indicators && blinkenlights)
                 hub->indicator [0] = INDICATOR_CYCLE;
 
+        for (i = 0; i < hdev->maxchild; i++)
+                if (usb_hub_create_port_device(hub, i + 1) < 0)
+                        dev_err(hub->intfdev,
+                                "couldn't create port%d device.\n", i + 1);
+
         hub_activate(hub, HUB_INIT);
         return 0;
 
@@ -1508,6 +1566,7 @@ static void hub_disconnect(struct usb_interface *intf)
 {
         struct usb_hub *hub = usb_get_intfdata(intf);
         struct usb_device *hdev = interface_to_usbdev(intf);
+        int i;
 
         /* Take the hub off the event list and don't let it be added again */
         spin_lock_irq(&hub_event_lock);
@@ -1523,14 +1582,16 @@ static void hub_disconnect(struct usb_interface *intf)
         hub_quiesce(hub, HUB_DISCONNECT);
 
         usb_set_intfdata (intf, NULL);
+
+        for (i = 0; i < hdev->maxchild; i++)
+                usb_hub_remove_port_device(hub, i + 1);
         hub->hdev->maxchild = 0;
 
         if (hub->hdev->speed == USB_SPEED_HIGH)
                 highspeed_hubs--;
 
         usb_free_urb(hub->urb);
-        kfree(hdev->children);
-        kfree(hub->port_owners);
+        kfree(hub->ports);
         kfree(hub->descriptor);
         kfree(hub->status);
         kfree(hub->buffer);
@@ -1617,6 +1678,7 @@ static int
 hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
 {
         struct usb_device *hdev = interface_to_usbdev (intf);
+        struct usb_hub *hub = hdev_to_hub(hdev);
 
         /* assert ifno == 0 (part of hub spec) */
         switch (code) {
@@ -1630,11 +1692,11 @@ hub_ioctl(struct usb_interface *intf, unsigned int code, void *user_data)
                 else {
                         info->nports = hdev->maxchild;
                         for (i = 0; i < info->nports; i++) {
-                                if (hdev->children[i] == NULL)
+                                if (hub->ports[i]->child == NULL)
                                         info->port[i] = 0;
                                 else
                                         info->port[i] =
-                                                hdev->children[i]->devnum;
+                                                hub->ports[i]->child->devnum;
                         }
                 }
                 spin_unlock_irq(&device_state_lock);
@@ -1662,7 +1724,7 @@ static int find_port_owner(struct usb_device *hdev, unsigned port1,
         /* This assumes that devices not managed by the hub driver
          * will always have maxchild equal to 0.
          */
-        *ppowner = &(hdev_to_hub(hdev)->port_owners[port1 - 1]);
+        *ppowner = &(hdev_to_hub(hdev)->ports[port1 - 1]->port_owner);
         return 0;
 }
 
@@ -1699,16 +1761,14 @@ int usb_hub_release_port(struct usb_device *hdev, unsigned port1,
 
 void usb_hub_release_all_ports(struct usb_device *hdev, struct dev_state *owner)
 {
+        struct usb_hub *hub = hdev_to_hub(hdev);
         int n;
-        struct dev_state **powner;
 
-        n = find_port_owner(hdev, 1, &powner);
-        if (n == 0) {
-                for (; n < hdev->maxchild; (++n, ++powner)) {
-                        if (*powner == owner)
-                                *powner = NULL;
-                }
+        for (n = 0; n < hdev->maxchild; n++) {
+                if (hub->ports[n]->port_owner == owner)
+                        hub->ports[n]->port_owner = NULL;
         }
+
 }
 
 /* The caller must hold udev's lock */
@@ -1719,17 +1779,17 @@ bool usb_device_is_owned(struct usb_device *udev)
         if (udev->state == USB_STATE_NOTATTACHED || !udev->parent)
                 return false;
         hub = hdev_to_hub(udev->parent);
-        return !!hub->port_owners[udev->portnum - 1];
+        return !!hub->ports[udev->portnum - 1]->port_owner;
 }
 
-
 static void recursively_mark_NOTATTACHED(struct usb_device *udev)
 {
+        struct usb_hub *hub = hdev_to_hub(udev);
         int i;
 
         for (i = 0; i < udev->maxchild; ++i) {
-                if (udev->children[i])
-                        recursively_mark_NOTATTACHED(udev->children[i]);
+                if (hub->ports[i]->child)
+                        recursively_mark_NOTATTACHED(hub->ports[i]->child);
         }
         if (udev->state == USB_STATE_SUSPENDED)
                 udev->active_duration -= jiffies;
@@ -1893,6 +1953,7 @@ static void hub_free_dev(struct usb_device *udev)
 void usb_disconnect(struct usb_device **pdev)
 {
         struct usb_device       *udev = *pdev;
+        struct usb_hub          *hub = hdev_to_hub(udev);
         int                     i;
 
         /* mark the device as inactive, so any further urb submissions for
@@ -1907,8 +1968,8 @@ void usb_disconnect(struct usb_device **pdev)
 
         /* Free up all the children before we remove this device */
         for (i = 0; i < udev->maxchild; i++) {
-                if (udev->children[i])
-                        usb_disconnect(&udev->children[i]);
+                if (hub->ports[i]->child)
+                        usb_disconnect(&hub->ports[i]->child);
         }
 
         /* deallocate hcd/hardware state ... nuking all pending urbs and
@@ -2113,7 +2174,8 @@ static void set_usb_port_removable(struct usb_device *udev)
                 return;
 
         if (hub_is_superspeed(hdev)) {
-                if (hub->descriptor->u.ss.DeviceRemovable & (1 << port))
+                if (le16_to_cpu(hub->descriptor->u.ss.DeviceRemovable)
+                                & (1 << port))
                         removable = false;
         } else {
                 if (hub->descriptor->u.hs.DeviceRemovable[port / 8] & (1 << (port % 8)))
@@ -3072,7 +3134,7 @@ static int hub_suspend(struct usb_interface *intf, pm_message_t msg)
         for (port1 = 1; port1 <= hdev->maxchild; port1++) {
                 struct usb_device       *udev;
 
-                udev = hdev->children [port1-1];
+                udev = hub->ports[port1 - 1]->child;
                 if (udev && udev->can_submit) {
                         dev_warn(&intf->dev, "port %d nyet suspended\n", port1);
                         if (PMSG_IS_AUTO(msg))
@@ -3999,7 +4061,7 @@ hub_power_remaining (struct usb_hub *hub)
 
         remaining = hdev->bus_mA - hub->descriptor->bHubContrCurrent;
         for (port1 = 1; port1 <= hdev->maxchild; ++port1) {
-                struct usb_device       *udev = hdev->children[port1 - 1];
+                struct usb_device       *udev = hub->ports[port1 - 1]->child;
                 int                     delta;
 
                 if (!udev)
@@ -4063,7 +4125,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 #endif
 
         /* Try to resuscitate an existing device */
-        udev = hdev->children[port1-1];
+        udev = hub->ports[port1 - 1]->child;
         if ((portstatus & USB_PORT_STAT_CONNECTION) && udev &&
                         udev->state != USB_STATE_NOTATTACHED) {
                 usb_lock_device(udev);
@@ -4092,7 +4154,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
 
         /* Disconnect any existing devices under this port */
         if (udev)
-                usb_disconnect(&hdev->children[port1-1]);
+                usb_disconnect(&hub->ports[port1 - 1]->child);
         clear_bit(port1, hub->change_bits);
 
         /* We can forget about a "removed" device when there's a physical
@@ -4228,7 +4290,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                 if (hdev->state == USB_STATE_NOTATTACHED)
                         status = -ENOTCONN;
                 else
-                        hdev->children[port1-1] = udev;
+                        hub->ports[port1 - 1]->child = udev;
                 spin_unlock_irq(&device_state_lock);
 
                 /* Run it through the hoops (find a driver, etc) */
@@ -4236,7 +4298,7 @@ static void hub_port_connect_change(struct usb_hub *hub, int port1,
                         status = usb_new_device(udev);
                         if (status) {
                                 spin_lock_irq(&device_state_lock);
-                                hdev->children[port1-1] = NULL;
+                                hub->ports[port1 - 1]->child = NULL;
                                 spin_unlock_irq(&device_state_lock);
                         }
                 }
@@ -4282,7 +4344,7 @@ static int hub_handle_remote_wakeup(struct usb_hub *hub, unsigned int port,
         int ret;
 
         hdev = hub->hdev;
-        udev = hdev->children[port-1];
+        udev = hub->ports[port - 1]->child;
         if (!hub_is_superspeed(hdev)) {
                 if (!(portchange & USB_PORT_STAT_C_SUSPEND))
                         return 0;
@@ -4436,7 +4498,7 @@ static void hub_events(void)
                                  */
                                 if (!(portstatus & USB_PORT_STAT_ENABLE)
                                     && !connect_change
-                                    && hdev->children[i-1]) {
+                                    && hub->ports[i - 1]->child) {
                                         dev_err (hub_dev,
                                             "port %i "
                                             "disabled by hub (EMI?), "
@@ -4993,3 +5055,75 @@ void usb_queue_reset_device(struct usb_interface *iface)
         schedule_work(&iface->reset_ws);
 }
 EXPORT_SYMBOL_GPL(usb_queue_reset_device);
+
+/**
+ * usb_hub_find_child - Get the pointer of child device
+ * attached to the port which is specified by @port1.
+ * @hdev: USB device belonging to the usb hub
+ * @port1: port num to indicate which port the child device
+ *      is attached to.
+ *
+ * USB drivers call this function to get hub's child device
+ * pointer.
+ *
+ * Return NULL if input param is invalid and
+ * child's usb_device pointer if non-NULL.
+ */
+struct usb_device *usb_hub_find_child(struct usb_device *hdev,
+                int port1)
+{
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        if (port1 < 1 || port1 > hdev->maxchild)
+                return NULL;
+        return hub->ports[port1 - 1]->child;
+}
+EXPORT_SYMBOL_GPL(usb_hub_find_child);
+
+/**
+ * usb_set_hub_port_connect_type - set hub port connect type.
+ * @hdev: USB device belonging to the usb hub
+ * @port1: port num of the port
+ * @type: connect type of the port
+ */
+void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
+        enum usb_port_connect_type type)
+{
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        hub->ports[port1 - 1]->connect_type = type;
+}
+
+/**
+ * usb_get_hub_port_connect_type - Get the port's connect type
+ * @hdev: USB device belonging to the usb hub
+ * @port1: port num of the port
+ *
+ * Return connect type of the port and if input params are
+ * invalid, return USB_PORT_CONNECT_TYPE_UNKNOWN.
+ */
+enum usb_port_connect_type
+usb_get_hub_port_connect_type(struct usb_device *hdev, int port1)
+{
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        return hub->ports[port1 - 1]->connect_type;
+}
+
+#ifdef CONFIG_ACPI
+/**
+ * usb_get_hub_port_acpi_handle - Get the usb port's acpi handle
+ * @hdev: USB device belonging to the usb hub
+ * @port1: port num of the port
+ *
+ * Return port's acpi handle if successful, NULL if params are
+ * invaild.
+ */
+acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
+        int port1)
+{
+        struct usb_hub *hub = hdev_to_hub(hdev);
+
+        return DEVICE_ACPI_HANDLE(&hub->ports[port1 - 1]->dev);
+}
+#endif
diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
index 0ab7da2283e3..1ed5afd91e6d 100644
--- a/drivers/usb/core/message.c
+++ b/drivers/usb/core/message.c
@@ -146,8 +146,6 @@ int usb_control_msg(struct usb_device *dev, unsigned int pipe, __u8 request,
         dr->wIndex = cpu_to_le16(index);
         dr->wLength = cpu_to_le16(size);
 
-        /* dbg("usb_control_msg"); */
-
         ret = usb_internal_control_msg(dev, pipe, dr, data, size, timeout);
 
         kfree(dr);
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index e77a8e8eaa23..fdefd9c7f7af 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -209,7 +209,7 @@ void usb_detect_quirks(struct usb_device *udev)
          * for all devices.  It will affect things like hub resets
          * and EMF-related port disables.
          */
-        if (!(udev->quirks & USB_QUIRK_RESET_MORPHS))
+        if (!(udev->quirks & USB_QUIRK_RESET))
                 udev->persist_enabled = 1;
 #endif  /* CONFIG_PM */
 }
diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
index 682e8256b95d..818e4a024d0d 100644
--- a/drivers/usb/core/sysfs.c
+++ b/drivers/usb/core/sysfs.c
@@ -196,7 +196,7 @@ show_avoid_reset_quirk(struct device *dev, struct device_attribute *attr, char *
         struct usb_device *udev;
 
         udev = to_usb_device(dev);
-        return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET_MORPHS));
+        return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
 }
 
 static ssize_t
@@ -204,15 +204,15 @@ set_avoid_reset_quirk(struct device *dev, struct device_attribute *attr,
                 const char *buf, size_t count)
 {
         struct usb_device       *udev = to_usb_device(dev);
-        int                     config;
+        int                     val;
 
-        if (sscanf(buf, "%d", &config) != 1 || config < 0 || config > 1)
+        if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
                 return -EINVAL;
         usb_lock_device(udev);
-        if (config)
-                udev->quirks |= USB_QUIRK_RESET_MORPHS;
+        if (val)
+                udev->quirks |= USB_QUIRK_RESET;
         else
-                udev->quirks &= ~USB_QUIRK_RESET_MORPHS;
+                udev->quirks &= ~USB_QUIRK_RESET;
         usb_unlock_device(udev);
         return count;
 }
diff --git a/drivers/usb/core/usb-acpi.c b/drivers/usb/core/usb-acpi.c
index 8947b203d5a4..0ef7d42d8abe 100644
--- a/drivers/usb/core/usb-acpi.c
+++ b/drivers/usb/core/usb-acpi.c
@@ -19,20 +19,91 @@
 
 #include "usb.h"
 
-static int usb_acpi_check_upc(struct usb_device *udev, acpi_handle handle)
+/**
+ * usb_acpi_power_manageable - check whether usb port has
+ * acpi power resource.
+ * @hdev: USB device belonging to the usb hub
+ * @index: port index based zero
+ *
+ * Return true if the port has acpi power resource and false if no.
+ */
+bool usb_acpi_power_manageable(struct usb_device *hdev, int index)
+{
+        acpi_handle port_handle;
+        int port1 = index + 1;
+
+        port_handle = usb_get_hub_port_acpi_handle(hdev,
+                port1);
+        if (port_handle)
+                return acpi_bus_power_manageable(port_handle);
+        else
+                return false;
+}
+EXPORT_SYMBOL_GPL(usb_acpi_power_manageable);
+
+/**
+ * usb_acpi_set_power_state - control usb port's power via acpi power
+ * resource
+ * @hdev: USB device belonging to the usb hub
+ * @index: port index based zero
+ * @enable: power state expected to be set
+ *
+ * Notice to use usb_acpi_power_manageable() to check whether the usb port
+ * has acpi power resource before invoking this function.
+ *
+ * Returns 0 on success, else negative errno.
+ */
+int usb_acpi_set_power_state(struct usb_device *hdev, int index, bool enable)
+{
+        acpi_handle port_handle;
+        unsigned char state;
+        int port1 = index + 1;
+        int error = -EINVAL;
+
+        port_handle = (acpi_handle)usb_get_hub_port_acpi_handle(hdev,
+                port1);
+        if (!port_handle)
+                return error;
+
+        if (enable)
+                state = ACPI_STATE_D0;
+        else
+                state = ACPI_STATE_D3_COLD;
+
+        error = acpi_bus_set_power(port_handle, state);
+        if (!error)
+                dev_dbg(&hdev->dev, "The power of hub port %d was set to %d\n",
+                        port1, enable);
+        else
+                dev_dbg(&hdev->dev, "The power of hub port failed to be set\n");
+
+        return error;
+}
+EXPORT_SYMBOL_GPL(usb_acpi_set_power_state);
+
+static int usb_acpi_check_port_connect_type(struct usb_device *hdev,
+        acpi_handle handle, int port1)
 {
         acpi_status status;
         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
         union acpi_object *upc;
+        struct acpi_pld pld;
         int ret = 0;
 
-        status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
-
+        /*
+         * Accoding to ACPI Spec 9.13. PLD indicates whether usb port is
+         * user visible and _UPC indicates whether it is connectable. If
+         * the port was visible and connectable, it could be freely connected
+         * and disconnected with USB devices. If no visible and connectable,
+         * a usb device is directly hard-wired to the port. If no visible and
+         * no connectable, the port would be not used.
+         */
+        status = acpi_get_physical_device_location(handle, &pld);
         if (ACPI_FAILURE(status))
                 return -ENODEV;
 
+        status = acpi_evaluate_object(handle, "_UPC", NULL, &buffer);
         upc = buffer.pointer;
-
         if (!upc || (upc->type != ACPI_TYPE_PACKAGE)
                 || upc->package.count != 4) {
                 ret = -EINVAL;
@@ -40,69 +111,107 @@ static int usb_acpi_check_upc(struct usb_device *udev, acpi_handle handle)
         }
 
         if (upc->package.elements[0].integer.value)
-                udev->removable = USB_DEVICE_REMOVABLE;
-        else
-                udev->removable = USB_DEVICE_FIXED;
+                if (pld.user_visible)
+                        usb_set_hub_port_connect_type(hdev, port1,
+                                USB_PORT_CONNECT_TYPE_HOT_PLUG);
+                else
+                        usb_set_hub_port_connect_type(hdev, port1,
+                                USB_PORT_CONNECT_TYPE_HARD_WIRED);
+        else if (!pld.user_visible)
+                usb_set_hub_port_connect_type(hdev, port1, USB_PORT_NOT_USED);
 
 out:
         kfree(upc);
         return ret;
 }
 
-static int usb_acpi_check_pld(struct usb_device *udev, acpi_handle handle)
-{
-        acpi_status status;
-        struct acpi_pld pld;
-
-        status = acpi_get_physical_device_location(handle, &pld);
-
-        if (ACPI_FAILURE(status))
-                return -ENODEV;
-
-        if (pld.user_visible)
-                udev->removable = USB_DEVICE_REMOVABLE;
-        else
-                udev->removable = USB_DEVICE_FIXED;
-
-        return 0;
-}
-
 static int usb_acpi_find_device(struct device *dev, acpi_handle *handle)
 {
         struct usb_device *udev;
-        struct device *parent;
         acpi_handle *parent_handle;
-
-        if (!is_usb_device(dev))
-                return -ENODEV;
-
-        udev = to_usb_device(dev);
-        parent = dev->parent;
-        parent_handle = DEVICE_ACPI_HANDLE(parent);
-
-        if (!parent_handle)
-                return -ENODEV;
-
-        *handle = acpi_get_child(parent_handle, udev->portnum);
-
-        if (!*handle)
-                return -ENODEV;
+        int port_num;
 
         /*
-         * PLD will tell us whether a port is removable to the user or
-         * not. If we don't get an answer from PLD (it's not present
-         * or it's malformed) then try to infer it from UPC. If a
-         * device isn't connectable then it's probably not removable.
+         * In the ACPI DSDT table, only usb root hub and usb ports are
+         * acpi device nodes. The hierarchy like following.
+         * Device (EHC1)
+         *      Device (HUBN)
+         *              Device (PR01)
+         *                      Device (PR11)
+         *                      Device (PR12)
+         *                      Device (PR13)
+         *                      ...
+         * So all binding process is divided into two parts. binding
+         * root hub and usb ports.
          */
-        if (usb_acpi_check_pld(udev, *handle) != 0)
-                usb_acpi_check_upc(udev, *handle);
+        if (is_usb_device(dev)) {
+                udev = to_usb_device(dev);
+                if (udev->parent) {
+                        enum usb_port_connect_type type;
+
+                        /*
+                         * According usb port's connect type to set usb device's
+                         * removability.
+                         */
+                        type = usb_get_hub_port_connect_type(udev->parent,
+                                udev->portnum);
+                        switch (type) {
+                        case USB_PORT_CONNECT_TYPE_HOT_PLUG:
+                                udev->removable = USB_DEVICE_REMOVABLE;
+                                break;
+                        case USB_PORT_CONNECT_TYPE_HARD_WIRED:
+                                udev->removable = USB_DEVICE_FIXED;
+                                break;
+                        default:
+                                udev->removable = USB_DEVICE_REMOVABLE_UNKNOWN;
+                                break;
+                        }
+
+                        return -ENODEV;
+                }
+
+                /* root hub's parent is the usb hcd. */
+                parent_handle = DEVICE_ACPI_HANDLE(dev->parent);
+                *handle = acpi_get_child(parent_handle, udev->portnum);
+                if (!*handle)
+                        return -ENODEV;
+                return 0;
+        } else if (is_usb_port(dev)) {
+                sscanf(dev_name(dev), "port%d", &port_num);
+                /* Get the struct usb_device point of port's hub */
+                udev = to_usb_device(dev->parent->parent);
+
+                /*
+                 * The root hub ports' parent is the root hub. The non-root-hub
+                 * ports' parent is the parent hub port which the hub is
+                 * connected to.
+                 */
+                if (!udev->parent) {
+                        *handle = acpi_get_child(DEVICE_ACPI_HANDLE(&udev->dev),
+                                port_num);
+                        if (!*handle)
+                                return -ENODEV;
+                } else {
+                        parent_handle =
+                                usb_get_hub_port_acpi_handle(udev->parent,
+                                udev->portnum);
+                        if (!parent_handle)
+                                return -ENODEV;
+
+                        *handle = acpi_get_child(parent_handle, port_num);
+                        if (!*handle)
+                                return -ENODEV;
+                }
+                usb_acpi_check_port_connect_type(udev, *handle, port_num);
+        } else
+                return -ENODEV;
 
         return 0;
 }
 
 static struct acpi_bus_type usb_acpi_bus = {
         .bus = &usb_bus_type,
-        .find_bridge = NULL,
+        .find_bridge = usb_acpi_find_device,
         .find_device = usb_acpi_find_device,
 };
 
diff --git a/drivers/usb/core/usb.h b/drivers/usb/core/usb.h
index acb103c5c391..1c528c1bf0be 100644
--- a/drivers/usb/core/usb.h
+++ b/drivers/usb/core/usb.h
@@ -1,4 +1,5 @@
 #include <linux/pm.h>
+#include <linux/acpi.h>
 
 struct dev_state;
 
@@ -115,6 +116,7 @@ extern struct bus_type usb_bus_type;
 extern struct device_type usb_device_type;
 extern struct device_type usb_if_device_type;
 extern struct device_type usb_ep_device_type;
+extern struct device_type usb_port_device_type;
 extern struct usb_device_driver usb_generic_driver;
 
 static inline int is_usb_device(const struct device *dev)
@@ -132,6 +134,11 @@ static inline int is_usb_endpoint(const struct device *dev)
         return dev->type == &usb_ep_device_type;
 }
 
+static inline int is_usb_port(const struct device *dev)
+{
+        return dev->type == &usb_port_device_type;
+}
+
 /* Do the same for device drivers and interface drivers. */
 
 static inline int is_usb_device_driver(struct device_driver *drv)
@@ -162,10 +169,16 @@ extern void usb_notify_add_device(struct usb_device *udev);
 extern void usb_notify_remove_device(struct usb_device *udev);
 extern void usb_notify_add_bus(struct usb_bus *ubus);
 extern void usb_notify_remove_bus(struct usb_bus *ubus);
+extern enum usb_port_connect_type
+        usb_get_hub_port_connect_type(struct usb_device *hdev, int port1);
+extern void usb_set_hub_port_connect_type(struct usb_device *hdev, int port1,
+        enum usb_port_connect_type type);
 
 #ifdef CONFIG_ACPI
 extern int usb_acpi_register(void);
 extern void usb_acpi_unregister(void);
+extern acpi_handle usb_get_hub_port_acpi_handle(struct usb_device *hdev,
+        int port1);
 #else
 static inline int usb_acpi_register(void) { return 0; };
 static inline void usb_acpi_unregister(void) { };
diff --git a/drivers/usb/dwc3/Kconfig b/drivers/usb/dwc3/Kconfig
index d13c60f42139..f6a6e070c2ac 100644
--- a/drivers/usb/dwc3/Kconfig
+++ b/drivers/usb/dwc3/Kconfig
@@ -2,8 +2,6 @@ config USB_DWC3
         tristate "DesignWare USB3 DRD Core Support"
         depends on (USB && USB_GADGET)
         select USB_OTG_UTILS
-        select USB_GADGET_DUALSPEED
-        select USB_GADGET_SUPERSPEED
         select USB_XHCI_PLATFORM if USB_SUPPORT && USB_XHCI_HCD
         help
           Say Y or M here if your system has a Dual Role SuperSpeed
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index a68ff53124dc..b415c0c859d3 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -50,6 +50,7 @@
 #include <linux/dma-mapping.h>
 #include <linux/of.h>
 
+#include <linux/usb/otg.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
@@ -99,6 +100,7 @@ void dwc3_put_device_id(int id)
 
         ret = test_bit(id, dwc3_devs);
         WARN(!ret, "dwc3: ID %d not in use\n", id);
+        smp_mb__before_clear_bit();
         clear_bit(id, dwc3_devs);
 }
 EXPORT_SYMBOL_GPL(dwc3_put_device_id);
@@ -136,6 +138,8 @@ static void dwc3_core_soft_reset(struct dwc3 *dwc)
         reg |= DWC3_GUSB2PHYCFG_PHYSOFTRST;
         dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), reg);
 
+        usb_phy_init(dwc->usb2_phy);
+        usb_phy_init(dwc->usb3_phy);
         mdelay(100);
 
         /* Clear USB3 PHY reset */
@@ -464,12 +468,24 @@ static int __devinit dwc3_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
-        regs = devm_ioremap(dev, res->start, resource_size(res));
+        regs = devm_ioremap_nocache(dev, res->start, resource_size(res));
         if (!regs) {
                 dev_err(dev, "ioremap failed\n");
                 return -ENOMEM;
         }
 
+        dwc->usb2_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
+        if (IS_ERR_OR_NULL(dwc->usb2_phy)) {
+                dev_err(dev, "no usb2 phy configured\n");
+                return -EPROBE_DEFER;
+        }
+
+        dwc->usb3_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB3);
+        if (IS_ERR_OR_NULL(dwc->usb3_phy)) {
+                dev_err(dev, "no usb3 phy configured\n");
+                return -EPROBE_DEFER;
+        }
+
         spin_lock_init(&dwc->lock);
         platform_set_drvdata(pdev, dwc);
 
diff --git a/drivers/usb/dwc3/core.h b/drivers/usb/dwc3/core.h
index 151eca876dfd..243affc93431 100644
--- a/drivers/usb/dwc3/core.h
+++ b/drivers/usb/dwc3/core.h
@@ -457,7 +457,6 @@ enum dwc3_phy {
 enum dwc3_ep0_next {
         DWC3_EP0_UNKNOWN = 0,
         DWC3_EP0_COMPLETE,
-        DWC3_EP0_NRDY_SETUP,
         DWC3_EP0_NRDY_DATA,
         DWC3_EP0_NRDY_STATUS,
 };
@@ -624,6 +623,8 @@ struct dwc3_scratchpad_array {
  * @maximum_speed: maximum speed requested (mainly for testing purposes)
  * @revision: revision register contents
  * @mode: mode of operation
+ * @usb2_phy: pointer to USB2 PHY
+ * @usb3_phy: pointer to USB3 PHY
  * @is_selfpowered: true when we are selfpowered
  * @three_stage_setup: set if we perform a three phase setup
  * @ep0_bounced: true when we used bounce buffer
@@ -667,6 +668,9 @@ struct dwc3 {
         struct usb_gadget       gadget;
         struct usb_gadget_driver *gadget_driver;
 
+        struct usb_phy          *usb2_phy;
+        struct usb_phy          *usb3_phy;
+
         void __iomem            *regs;
         size_t                  regs_size;
 
@@ -779,7 +783,6 @@ struct dwc3_event_depevt {
 #define DEPEVT_STREAMEVT_NOTFOUND       2
 
 /* Control-only Status */
-#define DEPEVT_STATUS_CONTROL_SETUP     0
 #define DEPEVT_STATUS_CONTROL_DATA      1
 #define DEPEVT_STATUS_CONTROL_STATUS    2
 
diff --git a/drivers/usb/dwc3/dwc3-exynos.c b/drivers/usb/dwc3/dwc3-exynos.c
index b8f00389fa34..ca6597853f90 100644
--- a/drivers/usb/dwc3/dwc3-exynos.c
+++ b/drivers/usb/dwc3/dwc3-exynos.c
@@ -19,16 +19,74 @@
 #include <linux/platform_data/dwc3-exynos.h>
 #include <linux/dma-mapping.h>
 #include <linux/clk.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include "core.h"
 
 struct dwc3_exynos {
         struct platform_device  *dwc3;
+        struct platform_device  *usb2_phy;
+        struct platform_device  *usb3_phy;
         struct device           *dev;
 
         struct clk              *clk;
 };
 
+static int __devinit dwc3_exynos_register_phys(struct dwc3_exynos *exynos)
+{
+        struct nop_usb_xceiv_platform_data pdata;
+        struct platform_device  *pdev;
+        int                     ret;
+
+        memset(&pdata, 0x00, sizeof(pdata));
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 0);
+        if (!pdev)
+                return -ENOMEM;
+
+        exynos->usb2_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB2;
+
+        ret = platform_device_add_data(exynos->usb2_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err1;
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 1);
+        if (!pdev) {
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        exynos->usb3_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB3;
+
+        ret = platform_device_add_data(exynos->usb3_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(exynos->usb2_phy);
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(exynos->usb3_phy);
+        if (ret)
+                goto err3;
+
+        return 0;
+
+err3:
+        platform_device_del(exynos->usb2_phy);
+
+err2:
+        platform_device_put(exynos->usb3_phy);
+
+err1:
+        platform_device_put(exynos->usb2_phy);
+
+        return ret;
+}
+
 static int __devinit dwc3_exynos_probe(struct platform_device *pdev)
 {
         struct dwc3_exynos_data *pdata = pdev->dev.platform_data;
@@ -51,6 +109,12 @@ static int __devinit dwc3_exynos_probe(struct platform_device *pdev)
         if (devid < 0)
                 goto err1;
 
+        ret = dwc3_exynos_register_phys(exynos);
+        if (ret) {
+                dev_err(&pdev->dev, "couldn't register PHYs\n");
+                goto err1;
+        }
+
         dwc3 = platform_device_alloc("dwc3", devid);
         if (!dwc3) {
                 dev_err(&pdev->dev, "couldn't allocate dwc3 device\n");
@@ -120,6 +184,8 @@ static int __devexit dwc3_exynos_remove(struct platform_device *pdev)
         struct dwc3_exynos_data *pdata = pdev->dev.platform_data;
 
         platform_device_unregister(exynos->dwc3);
+        platform_device_unregister(exynos->usb2_phy);
+        platform_device_unregister(exynos->usb3_phy);
 
         dwc3_put_device_id(exynos->dwc3->id);
 
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 479dc047da3a..ee57a10d90d0 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -48,6 +48,9 @@
 #include <linux/io.h>
 #include <linux/of.h>
 
+#include <linux/usb/otg.h>
+#include <linux/usb/nop-usb-xceiv.h>
+
 #include "core.h"
 
 /*
@@ -131,6 +134,8 @@ struct dwc3_omap {
         spinlock_t              lock;
 
         struct platform_device  *dwc3;
+        struct platform_device  *usb2_phy;
+        struct platform_device  *usb3_phy;
         struct device           *dev;
 
         int                     irq;
@@ -152,6 +157,59 @@ static inline void dwc3_omap_writel(void __iomem *base, u32 offset, u32 value)
         writel(value, base + offset);
 }
 
+static int __devinit dwc3_omap_register_phys(struct dwc3_omap *omap)
+{
+        struct nop_usb_xceiv_platform_data pdata;
+        struct platform_device  *pdev;
+        int                     ret;
+
+        memset(&pdata, 0x00, sizeof(pdata));
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 0);
+        if (!pdev)
+                return -ENOMEM;
+
+        omap->usb2_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB2;
+
+        ret = platform_device_add_data(omap->usb2_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err1;
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 1);
+        if (!pdev) {
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        omap->usb3_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB3;
+
+        ret = platform_device_add_data(omap->usb3_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(omap->usb2_phy);
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(omap->usb3_phy);
+        if (ret)
+                goto err3;
+
+        return 0;
+
+err3:
+        platform_device_del(omap->usb2_phy);
+
+err2:
+        platform_device_put(omap->usb3_phy);
+
+err1:
+        platform_device_put(omap->usb2_phy);
+
+        return ret;
+}
 
 static irqreturn_t dwc3_omap_interrupt(int irq, void *_omap)
 {
@@ -251,6 +309,12 @@ static int __devinit dwc3_omap_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        ret = dwc3_omap_register_phys(omap);
+        if (ret) {
+                dev_err(dev, "couldn't register PHYs\n");
+                return ret;
+        }
+
         devid = dwc3_get_device_id();
         if (devid < 0)
                 return -ENODEV;
@@ -371,6 +435,8 @@ static int __devexit dwc3_omap_remove(struct platform_device *pdev)
         struct dwc3_omap        *omap = platform_get_drvdata(pdev);
 
         platform_device_unregister(omap->dwc3);
+        platform_device_unregister(omap->usb2_phy);
+        platform_device_unregister(omap->usb3_phy);
 
         dwc3_put_device_id(omap->dwc3->id);
 
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index a9ca9adba391..94f550e37f98 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -42,6 +42,9 @@
 #include <linux/pci.h>
 #include <linux/platform_device.h>
 
+#include <linux/usb/otg.h>
+#include <linux/usb/nop-usb-xceiv.h>
+
 #include "core.h"
 
 /* FIXME define these in <linux/pci_ids.h> */
@@ -51,8 +54,64 @@
 struct dwc3_pci {
         struct device           *dev;
         struct platform_device  *dwc3;
+        struct platform_device  *usb2_phy;
+        struct platform_device  *usb3_phy;
 };
 
+static int __devinit dwc3_pci_register_phys(struct dwc3_pci *glue)
+{
+        struct nop_usb_xceiv_platform_data pdata;
+        struct platform_device  *pdev;
+        int                     ret;
+
+        memset(&pdata, 0x00, sizeof(pdata));
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 0);
+        if (!pdev)
+                return -ENOMEM;
+
+        glue->usb2_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB2;
+
+        ret = platform_device_add_data(glue->usb2_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err1;
+
+        pdev = platform_device_alloc("nop_usb_xceiv", 1);
+        if (!pdev) {
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        glue->usb3_phy = pdev;
+        pdata.type = USB_PHY_TYPE_USB3;
+
+        ret = platform_device_add_data(glue->usb3_phy, &pdata, sizeof(pdata));
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(glue->usb2_phy);
+        if (ret)
+                goto err2;
+
+        ret = platform_device_add(glue->usb3_phy);
+        if (ret)
+                goto err3;
+
+        return 0;
+
+err3:
+        platform_device_del(glue->usb2_phy);
+
+err2:
+        platform_device_put(glue->usb3_phy);
+
+err1:
+        platform_device_put(glue->usb2_phy);
+
+        return ret;
+}
+
 static int __devinit dwc3_pci_probe(struct pci_dev *pci,
                 const struct pci_device_id *id)
 {
@@ -80,6 +139,12 @@ static int __devinit dwc3_pci_probe(struct pci_dev *pci,
         pci_set_power_state(pci, PCI_D0);
         pci_set_master(pci);
 
+        ret = dwc3_pci_register_phys(glue);
+        if (ret) {
+                dev_err(dev, "couldn't register PHYs\n");
+                return ret;
+        }
+
         devid = dwc3_get_device_id();
         if (devid < 0) {
                 ret = -ENOMEM;
@@ -144,6 +209,8 @@ static void __devexit dwc3_pci_remove(struct pci_dev *pci)
 {
         struct dwc3_pci *glue = pci_get_drvdata(pci);
 
+        platform_device_unregister(glue->usb2_phy);
+        platform_device_unregister(glue->usb3_phy);
         dwc3_put_device_id(glue->dwc3->id);
         platform_device_unregister(glue->dwc3);
         pci_set_drvdata(pci, NULL);
diff --git a/drivers/usb/dwc3/ep0.c b/drivers/usb/dwc3/ep0.c
index e4d5ca86b9da..d7da073a23fe 100644
--- a/drivers/usb/dwc3/ep0.c
+++ b/drivers/usb/dwc3/ep0.c
@@ -125,7 +125,6 @@ static int __dwc3_gadget_ep0_queue(struct dwc3_ep *dep,
                 struct dwc3_request *req)
 {
         struct dwc3             *dwc = dep->dwc;
-        int                     ret = 0;
 
         req->request.actual     = 0;
         req->request.status     = -EINPROGRESS;
@@ -156,16 +155,72 @@ static int __dwc3_gadget_ep0_queue(struct dwc3_ep *dep,
 
                 dep->flags &= ~(DWC3_EP_PENDING_REQUEST |
                                 DWC3_EP0_DIR_IN);
-        } else if (dwc->delayed_status) {
+
+                return 0;
+        }
+
+        /*
+         * In case gadget driver asked us to delay the STATUS phase,
+         * handle it here.
+         */
+        if (dwc->delayed_status) {
+                unsigned        direction;
+
+                direction = !dwc->ep0_expect_in;
                 dwc->delayed_status = false;
 
                 if (dwc->ep0state == EP0_STATUS_PHASE)
-                        __dwc3_ep0_do_control_status(dwc, dwc->eps[1]);
+                        __dwc3_ep0_do_control_status(dwc, dwc->eps[direction]);
                 else
                         dev_dbg(dwc->dev, "too early for delayed status\n");
+
+                return 0;
         }
 
-        return ret;
+        /*
+         * Unfortunately we have uncovered a limitation wrt the Data Phase.
+         *
+         * Section 9.4 says we can wait for the XferNotReady(DATA) event to
+         * come before issueing Start Transfer command, but if we do, we will
+         * miss situations where the host starts another SETUP phase instead of
+         * the DATA phase.  Such cases happen at least on TD.7.6 of the Link
+         * Layer Compliance Suite.
+         *
+         * The problem surfaces due to the fact that in case of back-to-back
+         * SETUP packets there will be no XferNotReady(DATA) generated and we
+         * will be stuck waiting for XferNotReady(DATA) forever.
+         *
+         * By looking at tables 9-13 and 9-14 of the Databook, we can see that
+         * it tells us to start Data Phase right away. It also mentions that if
+         * we receive a SETUP phase instead of the DATA phase, core will issue
+         * XferComplete for the DATA phase, before actually initiating it in
+         * the wire, with the TRB's status set to "SETUP_PENDING". Such status
+         * can only be used to print some debugging logs, as the core expects
+         * us to go through to the STATUS phase and start a CONTROL_STATUS TRB,
+         * just so it completes right away, without transferring anything and,
+         * only then, we can go back to the SETUP phase.
+         *
+         * Because of this scenario, SNPS decided to change the programming
+         * model of control transfers and support on-demand transfers only for
+         * the STATUS phase. To fix the issue we have now, we will always wait
+         * for gadget driver to queue the DATA phase's struct usb_request, then
+         * start it right away.
+         *
+         * If we're actually in a 2-stage transfer, we will wait for
+         * XferNotReady(STATUS).
+         */
+        if (dwc->three_stage_setup) {
+                unsigned        direction;
+
+                direction = dwc->ep0_expect_in;
+                dwc->ep0state = EP0_DATA_PHASE;
+
+                __dwc3_ep0_do_control_data(dwc, dwc->eps[direction], req);
+
+                dep->flags &= ~DWC3_EP0_DIR_IN;
+        }
+
+        return 0;
 }
 
 int dwc3_gadget_ep0_queue(struct usb_ep *ep, struct usb_request *request,
@@ -207,9 +262,14 @@ out:
 
 static void dwc3_ep0_stall_and_restart(struct dwc3 *dwc)
 {
-        struct dwc3_ep          *dep = dwc->eps[0];
+        struct dwc3_ep          *dep;
+
+        /* reinitialize physical ep1 */
+        dep = dwc->eps[1];
+        dep->flags = DWC3_EP_ENABLED;
 
         /* stall is always issued on EP0 */
+        dep = dwc->eps[0];
         __dwc3_gadget_ep_set_halt(dep, 1);
         dep->flags = DWC3_EP_ENABLED;
         dwc->delayed_status = false;
@@ -698,6 +758,7 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc,
         struct dwc3_trb         *trb;
         struct dwc3_ep          *ep0;
         u32                     transferred;
+        u32                     status;
         u32                     length;
         u8                      epnum;
 
@@ -710,6 +771,17 @@ static void dwc3_ep0_complete_data(struct dwc3 *dwc,
         ur = &r->request;
 
         trb = dwc->ep0_trb;
+
+        status = DWC3_TRB_SIZE_TRBSTS(trb->size);
+        if (status == DWC3_TRBSTS_SETUP_PENDING) {
+                dev_dbg(dwc->dev, "Setup Pending received\n");
+
+                if (r)
+                        dwc3_gadget_giveback(ep0, r, -ECONNRESET);
+
+                return;
+        }
+
         length = trb->size & DWC3_TRB_SIZE_MASK;
 
         if (dwc->ep0_bounced) {
@@ -745,8 +817,11 @@ static void dwc3_ep0_complete_status(struct dwc3 *dwc,
 {
         struct dwc3_request     *r;
         struct dwc3_ep          *dep;
+        struct dwc3_trb         *trb;
+        u32                     status;
 
         dep = dwc->eps[0];
+        trb = dwc->ep0_trb;
 
         if (!list_empty(&dep->request_list)) {
                 r = next_request(&dep->request_list);
@@ -766,6 +841,10 @@ static void dwc3_ep0_complete_status(struct dwc3 *dwc,
                 }
         }
 
+        status = DWC3_TRB_SIZE_TRBSTS(trb->size);
+        if (status == DWC3_TRBSTS_SETUP_PENDING)
+                dev_dbg(dwc->dev, "Setup Pending received\n");
+
         dwc->ep0state = EP0_SETUP_PHASE;
         dwc3_ep0_out_start(dwc);
 }
@@ -799,12 +878,6 @@ static void dwc3_ep0_xfer_complete(struct dwc3 *dwc,
         }
 }
 
-static void dwc3_ep0_do_control_setup(struct dwc3 *dwc,
-                const struct dwc3_event_depevt *event)
-{
-        dwc3_ep0_out_start(dwc);
-}
-
 static void __dwc3_ep0_do_control_data(struct dwc3 *dwc,
                 struct dwc3_ep *dep, struct dwc3_request *req)
 {
@@ -857,29 +930,6 @@ static void __dwc3_ep0_do_control_data(struct dwc3 *dwc,
         WARN_ON(ret < 0);
 }
 
-static void dwc3_ep0_do_control_data(struct dwc3 *dwc,
-                const struct dwc3_event_depevt *event)
-{
-        struct dwc3_ep          *dep;
-        struct dwc3_request     *req;
-
-        dep = dwc->eps[0];
-
-        if (list_empty(&dep->request_list)) {
-                dev_vdbg(dwc->dev, "pending request for EP0 Data phase\n");
-                dep->flags |= DWC3_EP_PENDING_REQUEST;
-
-                if (event->endpoint_number)
-                        dep->flags |= DWC3_EP0_DIR_IN;
-                return;
-        }
-
-        req = next_request(&dep->request_list);
-        dep = dwc->eps[event->endpoint_number];
-
-        __dwc3_ep0_do_control_data(dwc, dep, req);
-}
-
 static int dwc3_ep0_start_control_status(struct dwc3_ep *dep)
 {
         struct dwc3             *dwc = dep->dwc;
@@ -911,100 +961,61 @@ static void dwc3_ep0_do_control_status(struct dwc3 *dwc,
         __dwc3_ep0_do_control_status(dwc, dep);
 }
 
-static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
-                const struct dwc3_event_depevt *event)
+static void dwc3_ep0_end_control_data(struct dwc3 *dwc, struct dwc3_ep *dep)
 {
-        dwc->setup_packet_pending = true;
-
-        /*
-         * This part is very tricky: If we have just handled
-         * XferNotReady(Setup) and we're now expecting a
-         * XferComplete but, instead, we receive another
-         * XferNotReady(Setup), we should STALL and restart
-         * the state machine.
-         *
-         * In all other cases, we just continue waiting
-         * for the XferComplete event.
-         *
-         * We are a little bit unsafe here because we're
-         * not trying to ensure that last event was, indeed,
-         * XferNotReady(Setup).
-         *
-         * Still, we don't expect any condition where that
-         * should happen and, even if it does, it would be
-         * another error condition.
-         */
-        if (dwc->ep0_next_event == DWC3_EP0_COMPLETE) {
-                switch (event->status) {
-                case DEPEVT_STATUS_CONTROL_SETUP:
-                        dev_vdbg(dwc->dev, "Unexpected XferNotReady(Setup)\n");
-                        dwc3_ep0_stall_and_restart(dwc);
-                        break;
-                case DEPEVT_STATUS_CONTROL_DATA:
-                        /* FALLTHROUGH */
-                case DEPEVT_STATUS_CONTROL_STATUS:
-                        /* FALLTHROUGH */
-                default:
-                        dev_vdbg(dwc->dev, "waiting for XferComplete\n");
-                }
+        struct dwc3_gadget_ep_cmd_params params;
+        u32                     cmd;
+        int                     ret;
 
+        if (!dep->resource_index)
                 return;
-        }
-
-        switch (event->status) {
-        case DEPEVT_STATUS_CONTROL_SETUP:
-                dev_vdbg(dwc->dev, "Control Setup\n");
 
-                dwc->ep0state = EP0_SETUP_PHASE;
+        cmd = DWC3_DEPCMD_ENDTRANSFER;
+        cmd |= DWC3_DEPCMD_CMDIOC;
+        cmd |= DWC3_DEPCMD_PARAM(dep->resource_index);
+        memset(&params, 0, sizeof(params));
+        ret = dwc3_send_gadget_ep_cmd(dwc, dep->number, cmd, &params);
+        WARN_ON_ONCE(ret);
+        dep->resource_index = 0;
+}
 
-                dwc3_ep0_do_control_setup(dwc, event);
-                break;
+static void dwc3_ep0_xfernotready(struct dwc3 *dwc,
+                const struct dwc3_event_depevt *event)
+{
+        dwc->setup_packet_pending = true;
 
+        switch (event->status) {
         case DEPEVT_STATUS_CONTROL_DATA:
                 dev_vdbg(dwc->dev, "Control Data\n");
 
-                dwc->ep0state = EP0_DATA_PHASE;
-
-                if (dwc->ep0_next_event != DWC3_EP0_NRDY_DATA) {
-                        dev_vdbg(dwc->dev, "Expected %d got %d\n",
-                                        dwc->ep0_next_event,
-                                        DWC3_EP0_NRDY_DATA);
-
-                        dwc3_ep0_stall_and_restart(dwc);
-                        return;
-                }
-
                 /*
-                 * One of the possible error cases is when Host _does_
-                 * request for Data Phase, but it does so on the wrong
-                 * direction.
+                 * We already have a DATA transfer in the controller's cache,
+                 * if we receive a XferNotReady(DATA) we will ignore it, unless
+                 * it's for the wrong direction.
                  *
-                 * Here, we already know ep0_next_event is DATA (see above),
-                 * so we only need to check for direction.
+                 * In that case, we must issue END_TRANSFER command to the Data
+                 * Phase we already have started and issue SetStall on the
+                 * control endpoint.
                  */
                 if (dwc->ep0_expect_in != event->endpoint_number) {
+                        struct dwc3_ep  *dep = dwc->eps[dwc->ep0_expect_in];
+
                         dev_vdbg(dwc->dev, "Wrong direction for Data phase\n");
+                        dwc3_ep0_end_control_data(dwc, dep);
                         dwc3_ep0_stall_and_restart(dwc);
                         return;
                 }
 
-                dwc3_ep0_do_control_data(dwc, event);
                 break;
 
         case DEPEVT_STATUS_CONTROL_STATUS:
+                if (dwc->ep0_next_event != DWC3_EP0_NRDY_STATUS)
+                        return;
+
                 dev_vdbg(dwc->dev, "Control Status\n");
 
                 dwc->ep0state = EP0_STATUS_PHASE;
 
-                if (dwc->ep0_next_event != DWC3_EP0_NRDY_STATUS) {
-                        dev_vdbg(dwc->dev, "Expected %d got %d\n",
-                                        dwc->ep0_next_event,
-                                        DWC3_EP0_NRDY_STATUS);
-
-                        dwc3_ep0_stall_and_restart(dwc);
-                        return;
-                }
-
                 if (dwc->delayed_status) {
                         WARN_ON_ONCE(event->endpoint_number != 1);
                         dev_vdbg(dwc->dev, "Mass Storage delayed status\n");
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index c2813c2b005a..c9e729a4bf65 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -434,15 +434,25 @@ static int dwc3_gadget_start_config(struct dwc3 *dwc, struct dwc3_ep *dep)
 
 static int dwc3_gadget_set_ep_config(struct dwc3 *dwc, struct dwc3_ep *dep,
                 const struct usb_endpoint_descriptor *desc,
-                const struct usb_ss_ep_comp_descriptor *comp_desc)
+                const struct usb_ss_ep_comp_descriptor *comp_desc,
+                bool ignore)
 {
         struct dwc3_gadget_ep_cmd_params params;
 
         memset(&params, 0x00, sizeof(params));
 
         params.param0 = DWC3_DEPCFG_EP_TYPE(usb_endpoint_type(desc))
-                | DWC3_DEPCFG_MAX_PACKET_SIZE(usb_endpoint_maxp(desc))
-                | DWC3_DEPCFG_BURST_SIZE(dep->endpoint.maxburst - 1);
+                | DWC3_DEPCFG_MAX_PACKET_SIZE(usb_endpoint_maxp(desc));
+
+        /* Burst size is only needed in SuperSpeed mode */
+        if (dwc->gadget.speed == USB_SPEED_SUPER) {
+                u32 burst = dep->endpoint.maxburst - 1;
+
+                params.param0 |= DWC3_DEPCFG_BURST_SIZE(burst);
+        }
+
+        if (ignore)
+                params.param0 |= DWC3_DEPCFG_IGN_SEQ_NUM;
 
         params.param1 = DWC3_DEPCFG_XFER_COMPLETE_EN
                 | DWC3_DEPCFG_XFER_NOT_READY_EN;
@@ -501,7 +511,8 @@ static int dwc3_gadget_set_xfer_resource(struct dwc3 *dwc, struct dwc3_ep *dep)
  */
 static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
                 const struct usb_endpoint_descriptor *desc,
-                const struct usb_ss_ep_comp_descriptor *comp_desc)
+                const struct usb_ss_ep_comp_descriptor *comp_desc,
+                bool ignore)
 {
         struct dwc3             *dwc = dep->dwc;
         u32                     reg;
@@ -513,7 +524,7 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
                         return ret;
         }
 
-        ret = dwc3_gadget_set_ep_config(dwc, dep, desc, comp_desc);
+        ret = dwc3_gadget_set_ep_config(dwc, dep, desc, comp_desc, ignore);
         if (ret)
                 return ret;
 
@@ -561,27 +572,7 @@ static void dwc3_remove_requests(struct dwc3 *dwc, struct dwc3_ep *dep)
         if (!list_empty(&dep->req_queued)) {
                 dwc3_stop_active_transfer(dwc, dep->number);
 
-                /*
-                 * NOTICE: We are violating what the Databook says about the
-                 * EndTransfer command. Ideally we would _always_ wait for the
-                 * EndTransfer Command Completion IRQ, but that's causing too
-                 * much trouble synchronizing between us and gadget driver.
-                 *
-                 * We have discussed this with the IP Provider and it was
-                 * suggested to giveback all requests here, but give HW some
-                 * extra time to synchronize with the interconnect. We're using
-                 * an arbitraty 100us delay for that.
-                 *
-                 * Note also that a similar handling was tested by Synopsys
-                 * (thanks a lot Paul) and nothing bad has come out of it.
-                 * In short, what we're doing is:
-                 *
-                 * - Issue EndTransfer WITH CMDIOC bit set
-                 * - Wait 100us
-                 * - giveback all requests to gadget driver
-                 */
-                udelay(100);
-
+                /* - giveback all requests to gadget driver */
                 while (!list_empty(&dep->req_queued)) {
                         req = next_request(&dep->req_queued);
 
@@ -660,6 +651,12 @@ static int dwc3_gadget_ep_enable(struct usb_ep *ep,
         dep = to_dwc3_ep(ep);
         dwc = dep->dwc;
 
+        if (dep->flags & DWC3_EP_ENABLED) {
+                dev_WARN_ONCE(dwc->dev, true, "%s is already enabled\n",
+                                dep->name);
+                return 0;
+        }
+
         switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_CONTROL:
                 strlcat(dep->name, "-control", sizeof(dep->name));
@@ -677,16 +674,10 @@ static int dwc3_gadget_ep_enable(struct usb_ep *ep,
                 dev_err(dwc->dev, "invalid endpoint transfer type\n");
         }
 
-        if (dep->flags & DWC3_EP_ENABLED) {
-                dev_WARN_ONCE(dwc->dev, true, "%s is already enabled\n",
-                                dep->name);
-                return 0;
-        }
-
         dev_vdbg(dwc->dev, "Enabling %s\n", dep->name);
 
         spin_lock_irqsave(&dwc->lock, flags);
-        ret = __dwc3_gadget_ep_enable(dep, desc, ep->comp_desc);
+        ret = __dwc3_gadget_ep_enable(dep, desc, ep->comp_desc, false);
         spin_unlock_irqrestore(&dwc->lock, flags);
 
         return ret;
@@ -1105,12 +1096,9 @@ static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
                 }
 
                 ret = __dwc3_gadget_kick_transfer(dep, 0, true);
-                if (ret && ret != -EBUSY) {
-                        struct dwc3     *dwc = dep->dwc;
-
+                if (ret && ret != -EBUSY)
                         dev_dbg(dwc->dev, "%s: failed to kick transfers\n",
                                         dep->name);
-                }
         }
 
         /*
@@ -1119,16 +1107,14 @@ static int __dwc3_gadget_ep_queue(struct dwc3_ep *dep, struct dwc3_request *req)
          *    core may not see the modified TRB(s).
          */
         if (usb_endpoint_xfer_isoc(dep->endpoint.desc) &&
-                        (dep->flags & DWC3_EP_BUSY)) {
+                        (dep->flags & DWC3_EP_BUSY) &&
+                        !(dep->flags & DWC3_EP_MISSED_ISOC)) {
                 WARN_ON_ONCE(!dep->resource_index);
                 ret = __dwc3_gadget_kick_transfer(dep, dep->resource_index,
                                 false);
-                if (ret && ret != -EBUSY) {
-                        struct dwc3     *dwc = dep->dwc;
-
+                if (ret && ret != -EBUSY)
                         dev_dbg(dwc->dev, "%s: failed to kick transfers\n",
                                         dep->name);
-                }
         }
 
         /*
@@ -1533,14 +1519,14 @@ static int dwc3_gadget_start(struct usb_gadget *g,
         dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(512);
 
         dep = dwc->eps[0];
-        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL);
+        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false);
         if (ret) {
                 dev_err(dwc->dev, "failed to enable %s\n", dep->name);
                 goto err0;
         }
 
         dep = dwc->eps[1];
-        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL);
+        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, false);
         if (ret) {
                 dev_err(dwc->dev, "failed to enable %s\n", dep->name);
                 goto err1;
@@ -1765,7 +1751,7 @@ static void dwc3_endpoint_transfer_complete(struct dwc3 *dwc,
                 int             i;
 
                 for (i = 0; i < DWC3_ENDPOINTS_NUM; i++) {
-                        struct dwc3_ep  *dep = dwc->eps[i];
+                        dep = dwc->eps[i];
 
                         if (!(dep->flags & DWC3_EP_ENABLED))
                                 continue;
@@ -1892,6 +1878,25 @@ static void dwc3_stop_active_transfer(struct dwc3 *dwc, u32 epnum)
         if (!dep->resource_index)
                 return;
 
+        /*
+         * NOTICE: We are violating what the Databook says about the
+         * EndTransfer command. Ideally we would _always_ wait for the
+         * EndTransfer Command Completion IRQ, but that's causing too
+         * much trouble synchronizing between us and gadget driver.
+         *
+         * We have discussed this with the IP Provider and it was
+         * suggested to giveback all requests here, but give HW some
+         * extra time to synchronize with the interconnect. We're using
+         * an arbitraty 100us delay for that.
+         *
+         * Note also that a similar handling was tested by Synopsys
+         * (thanks a lot Paul) and nothing bad has come out of it.
+         * In short, what we're doing is:
+         *
+         * - Issue EndTransfer WITH CMDIOC bit set
+         * - Wait 100us
+         */
+
         cmd = DWC3_DEPCMD_ENDTRANSFER;
         cmd |= DWC3_DEPCMD_HIPRI_FORCERM | DWC3_DEPCMD_CMDIOC;
         cmd |= DWC3_DEPCMD_PARAM(dep->resource_index);
@@ -1899,6 +1904,8 @@ static void dwc3_stop_active_transfer(struct dwc3 *dwc, u32 epnum)
         ret = dwc3_send_gadget_ep_cmd(dwc, dep->number, cmd, &params);
         WARN_ON_ONCE(ret);
         dep->resource_index = 0;
+
+        udelay(100);
 }
 
 static void dwc3_stop_active_transfers(struct dwc3 *dwc)
@@ -2156,14 +2163,14 @@ static void dwc3_gadget_conndone_interrupt(struct dwc3 *dwc)
         }
 
         dep = dwc->eps[0];
-        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL);
+        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, true);
         if (ret) {
                 dev_err(dwc->dev, "failed to enable %s\n", dep->name);
                 return;
         }
 
         dep = dwc->eps[1];
-        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL);
+        ret = __dwc3_gadget_ep_enable(dep, &dwc3_gadget_ep0_desc, NULL, true);
         if (ret) {
                 dev_err(dwc->dev, "failed to enable %s\n", dep->name);
                 return;
diff --git a/drivers/usb/early/ehci-dbgp.c b/drivers/usb/early/ehci-dbgp.c
index 89dcf155d57e..e426ad626d74 100644
--- a/drivers/usb/early/ehci-dbgp.c
+++ b/drivers/usb/early/ehci-dbgp.c
@@ -491,7 +491,7 @@ static int ehci_wait_for_port(int port);
  * Return -ENODEV for any general failure
  * Return -EIO if wait for port fails
  */
-int dbgp_external_startup(void)
+static int _dbgp_external_startup(void)
 {
         int devnum;
         struct usb_debug_descriptor dbgp_desc;
@@ -613,6 +613,11 @@ err:
                 goto try_again;
         return -ENODEV;
 }
+
+int dbgp_external_startup(struct usb_hcd *hcd)
+{
+        return xen_dbgp_external_startup(hcd) ?: _dbgp_external_startup();
+}
 EXPORT_SYMBOL_GPL(dbgp_external_startup);
 
 static int ehci_reset_port(int port)
@@ -804,7 +809,7 @@ try_next_port:
                 dbgp_ehci_status("ehci skip - already configured");
         }
 
-        ret = dbgp_external_startup();
+        ret = _dbgp_external_startup();
         if (ret == -EIO)
                 goto next_debug_port;
 
@@ -934,7 +939,7 @@ static void early_dbgp_write(struct console *con, const char *str, u32 n)
                 ctrl = readl(&ehci_debug->control);
                 if (!(ctrl & DBGP_ENABLED)) {
                         dbgp_not_safe = 1;
-                        dbgp_external_startup();
+                        _dbgp_external_startup();
                 } else {
                         cmd |= CMD_RUN;
                         writel(cmd, &ehci_regs->command);
@@ -974,10 +979,14 @@ struct console early_dbgp_console = {
         .index =        -1,
 };
 
-int dbgp_reset_prep(void)
+int dbgp_reset_prep(struct usb_hcd *hcd)
 {
+        int ret = xen_dbgp_reset_prep(hcd);
         u32 ctrl;
 
+        if (ret)
+                return ret;
+
         dbgp_not_safe = 1;
         if (!ehci_debug)
                 return 0;
diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig
index 51ab5fd5d468..dfb51a45496c 100644
--- a/drivers/usb/gadget/Kconfig
+++ b/drivers/usb/gadget/Kconfig
@@ -154,16 +154,25 @@ config USB_LPC32XX
 
 config USB_ATMEL_USBA
         tristate "Atmel USBA"
-        select USB_GADGET_DUALSPEED
         depends on AVR32 || ARCH_AT91SAM9RL || ARCH_AT91SAM9G45
         help
           USBA is the integrated high-speed USB Device controller on
           the AT32AP700x, some AT91SAM9 and AT91CAP9 processors from Atmel.
 
+config USB_BCM63XX_UDC
+        tristate "Broadcom BCM63xx Peripheral Controller"
+        depends on BCM63XX
+        help
+           Many Broadcom BCM63xx chipsets (such as the BCM6328) have a
+           high speed USB Device Port with support for four fixed endpoints
+           (plus endpoint zero).
+
+           Say "y" to link the driver statically, or "m" to build a
+           dynamically linked module called "bcm63xx_udc".
+
 config USB_FSL_USB2
         tristate "Freescale Highspeed USB DR Peripheral Controller"
         depends on FSL_SOC || ARCH_MXC
-        select USB_GADGET_DUALSPEED
         select USB_FSL_MPH_DR_OF if OF
         help
            Some of Freescale PowerPC and i.MX processors have a High Speed
@@ -179,7 +188,6 @@ config USB_FSL_USB2
 config USB_FUSB300
         tristate "Faraday FUSB300 USB Peripheral Controller"
         depends on !PHYS_ADDR_T_64BIT
-        select USB_GADGET_DUALSPEED
         help
            Faraday usb device controller FUSB300 driver
 
@@ -227,7 +235,6 @@ config USB_PXA25X_SMALL
 
 config USB_R8A66597
         tristate "Renesas R8A66597 USB Peripheral Controller"
-        select USB_GADGET_DUALSPEED
         help
            R8A66597 is a discrete USB host and peripheral controller chip that
            supports both full and high speed USB 2.0 data transfers.
@@ -240,7 +247,6 @@ config USB_R8A66597
 config USB_RENESAS_USBHS_UDC
         tristate 'Renesas USBHS controller'
         depends on USB_RENESAS_USBHS
-        select USB_GADGET_DUALSPEED
         help
            Renesas USBHS is a discrete USB host and peripheral controller chip
            that supports both full and high speed USB 2.0 data transfers.
@@ -268,7 +274,6 @@ config USB_PXA27X
 config USB_S3C_HSOTG
         tristate "S3C HS/OtG USB Device controller"
         depends on S3C_DEV_USB_HSOTG
-        select USB_GADGET_DUALSPEED
         help
           The Samsung S3C64XX USB2.0 high-speed gadget controller
           integrated into the S3C64XX series SoC.
@@ -305,7 +310,6 @@ config USB_S3C2410_DEBUG
 config USB_S3C_HSUDC
         tristate "S3C2416, S3C2443 and S3C2450 USB Device Controller"
         depends on ARCH_S3C24XX
-        select USB_GADGET_DUALSPEED
         help
           Samsung's S3C2416, S3C2443 and S3C2450 is an ARM9 based SoC
           integrated with dual speed USB 2.0 device controller. It has
@@ -315,7 +319,6 @@ config USB_S3C_HSUDC
 
 config USB_MV_UDC
         tristate "Marvell USB2.0 Device Controller"
-        select USB_GADGET_DUALSPEED
         help
           Marvell Socs (including PXA and MMP series) include a high speed
           USB2.0 OTG controller, which can be configured as high speed or
@@ -338,14 +341,12 @@ config USB_MV_U3D
 config USB_GADGET_MUSB_HDRC
         tristate "Inventra HDRC USB Peripheral (TI, ADI, ...)"
         depends on USB_MUSB_HDRC
-        select USB_GADGET_DUALSPEED
         help
           This OTG-capable silicon IP is used in dual designs including
           the TI DaVinci, OMAP 243x, OMAP 343x, TUSB 6010, and ADI Blackfin
 
 config USB_M66592
         tristate "Renesas M66592 USB Peripheral Controller"
-        select USB_GADGET_DUALSPEED
         help
            M66592 is a discrete USB peripheral controller chip that
            supports both full and high speed USB 2.0 data transfers.
@@ -362,7 +363,6 @@ config USB_M66592
 config USB_AMD5536UDC
         tristate "AMD5536 UDC"
         depends on PCI
-        select USB_GADGET_DUALSPEED
         help
            The AMD5536 UDC is part of the AMD Geode CS5536, an x86 southbridge.
            It is a USB Highspeed DMA capable USB device controller. Beside ep0
@@ -389,7 +389,6 @@ config USB_FSL_QE
 
 config USB_NET2272
         tristate "PLX NET2272"
-        select USB_GADGET_DUALSPEED
         help
           PLX NET2272 is a USB peripheral controller which supports
           both full and high speed USB 2.0 data transfers.
@@ -413,7 +412,6 @@ config USB_NET2272_DMA
 config USB_NET2280
         tristate "NetChip 228x"
         depends on PCI
-        select USB_GADGET_DUALSPEED
         help
            NetChip 2280 / 2282 is a PCI based USB peripheral controller which
            supports both full and high speed USB 2.0 data transfers.
@@ -443,7 +441,6 @@ config USB_GOKU
 config USB_EG20T
         tristate "Intel EG20T PCH/LAPIS Semiconductor IOH(ML7213/ML7831) UDC"
         depends on PCI
-        select USB_GADGET_DUALSPEED
         help
           This is a USB device driver for EG20T PCH.
           EG20T PCH is the platform controller hub that is used in Intel's
@@ -470,8 +467,6 @@ config USB_EG20T
 config USB_DUMMY_HCD
         tristate "Dummy HCD (DEVELOPMENT)"
         depends on USB=y || (USB=m && USB_GADGET=m)
-        select USB_GADGET_DUALSPEED
-        select USB_GADGET_SUPERSPEED
         help
           This host controller driver emulates USB, looping all data transfer
           requests back to a USB "gadget driver" in the same host.  The host
@@ -496,18 +491,15 @@ config USB_DUMMY_HCD
 
 endmenu
 
-# Selected by UDC drivers that support high-speed operation.
-config USB_GADGET_DUALSPEED
-        bool
-
-# Selected by UDC drivers that support super-speed opperation
-config USB_GADGET_SUPERSPEED
-        bool
-        depends on USB_GADGET_DUALSPEED
-
 #
 # USB Gadget Drivers
 #
+
+# composite based drivers
+config USB_LIBCOMPOSITE
+        tristate
+        depends on USB_GADGET
+
 choice
         tristate "USB Gadget Drivers"
         default USB_ETH
@@ -531,6 +523,7 @@ choice
 
 config USB_ZERO
         tristate "Gadget Zero (DEVELOPMENT)"
+        select USB_LIBCOMPOSITE
         help
           Gadget Zero is a two-configuration device.  It either sinks and
           sources bulk data; or it loops back a configurable number of
@@ -564,8 +557,9 @@ config USB_ZERO_HNPTEST
           one serve as the USB host instead (in the "B-Host" role).
 
 config USB_AUDIO
-        tristate "Audio Gadget (EXPERIMENTAL)"
+        tristate "Audio Gadget"
         depends on SND
+        select USB_LIBCOMPOSITE
         select SND_PCM
         help
           This Gadget Audio driver is compatible with USB Audio Class
@@ -594,6 +588,7 @@ config GADGET_UAC1
 config USB_ETH
         tristate "Ethernet Gadget (with CDC Ethernet support)"
         depends on NET
+        select USB_LIBCOMPOSITE
         select CRC32
         help
           This driver implements Ethernet style communication, in one of
@@ -629,6 +624,7 @@ config USB_ETH
 config USB_ETH_RNDIS
         bool "RNDIS support"
         depends on USB_ETH
+        select USB_LIBCOMPOSITE
         default y
         help
            Microsoft Windows XP bundles the "Remote NDIS" (RNDIS) protocol,
@@ -647,6 +643,7 @@ config USB_ETH_RNDIS
 config USB_ETH_EEM
        bool "Ethernet Emulation Model (EEM) support"
        depends on USB_ETH
+        select USB_LIBCOMPOSITE
        default n
        help
          CDC EEM is a newer USB standard that is somewhat simpler than CDC ECM
@@ -663,6 +660,7 @@ config USB_ETH_EEM
 config USB_G_NCM
         tristate "Network Control Model (NCM) support"
         depends on NET
+        select USB_LIBCOMPOSITE
         select CRC32
         help
           This driver implements USB CDC NCM subclass standard. NCM is
@@ -674,8 +672,7 @@ config USB_G_NCM
           dynamically linked module called "g_ncm".
 
 config USB_GADGETFS
-        tristate "Gadget Filesystem (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Gadget Filesystem"
         help
           This driver provides a filesystem based API that lets user mode
           programs implement a single-configuration USB device, including
@@ -683,15 +680,12 @@ config USB_GADGETFS
           All endpoints, transfer speeds, and transfer types supported by
           the hardware are available, through read() and write() calls.
 
-          Currently, this option is still labelled as EXPERIMENTAL because
-          of existing race conditions in the underlying in-kernel AIO core.
-
           Say "y" to link the driver statically, or "m" to build a
           dynamically linked module called "gadgetfs".
 
 config USB_FUNCTIONFS
-        tristate "Function Filesystem (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Function Filesystem"
+        select USB_LIBCOMPOSITE
         select USB_FUNCTIONFS_GENERIC if !(USB_FUNCTIONFS_ETH || USB_FUNCTIONFS_RNDIS)
         help
           The Function Filesystem (FunctionFS) lets one create USB
@@ -755,6 +749,7 @@ config USB_FILE_STORAGE_TEST
 config USB_MASS_STORAGE
         tristate "Mass Storage Gadget"
         depends on BLOCK
+        select USB_LIBCOMPOSITE
         help
           The Mass Storage Gadget acts as a USB Mass Storage disk drive.
           As its storage repository it can use a regular file or a block
@@ -770,6 +765,7 @@ config USB_MASS_STORAGE
 config USB_GADGET_TARGET
         tristate "USB Gadget Target Fabric Module"
         depends on TARGET_CORE
+        select USB_LIBCOMPOSITE
         help
           This fabric is an USB gadget. Two USB protocols are supported that is
           BBB or BOT (Bulk Only Transport) and UAS (USB Attached SCSI). BOT is
@@ -779,6 +775,7 @@ config USB_GADGET_TARGET
 
 config USB_G_SERIAL
         tristate "Serial Gadget (with CDC ACM and CDC OBEX support)"
+        select USB_LIBCOMPOSITE
         help
           The Serial Gadget talks to the Linux-USB generic serial driver.
           This driver supports a CDC-ACM module option, which can be used
@@ -797,8 +794,9 @@ config USB_G_SERIAL
           make MS-Windows work with CDC ACM.
 
 config USB_MIDI_GADGET
-        tristate "MIDI Gadget (EXPERIMENTAL)"
-        depends on SND && EXPERIMENTAL
+        tristate "MIDI Gadget"
+        depends on SND
+        select USB_LIBCOMPOSITE
         select SND_RAWMIDI
         help
           The MIDI Gadget acts as a USB Audio device, with one MIDI
@@ -812,6 +810,7 @@ config USB_MIDI_GADGET
 
 config USB_G_PRINTER
         tristate "Printer Gadget"
+        select USB_LIBCOMPOSITE
         help
           The Printer Gadget channels data between the USB host and a
           userspace program driving the print engine. The user space
@@ -828,6 +827,7 @@ config USB_G_PRINTER
 config USB_CDC_COMPOSITE
         tristate "CDC Composite Device (Ethernet and ACM)"
         depends on NET
+        select USB_LIBCOMPOSITE
         help
           This driver provides two functions in one configuration:
           a CDC Ethernet (ECM) link, and a CDC ACM (serial port) link.
@@ -842,6 +842,7 @@ config USB_CDC_COMPOSITE
 config USB_G_NOKIA
         tristate "Nokia composite gadget"
         depends on PHONET
+        select USB_LIBCOMPOSITE
         help
           The Nokia composite gadget provides support for acm, obex
           and phonet in only one composite gadget driver.
@@ -852,6 +853,7 @@ config USB_G_NOKIA
 config USB_G_ACM_MS
         tristate "CDC Composite Device (ACM and mass storage)"
         depends on BLOCK
+        select USB_LIBCOMPOSITE
         help
           This driver provides two functions in one configuration:
           a mass storage, and a CDC ACM (serial port) link.
@@ -860,9 +862,10 @@ config USB_G_ACM_MS
           dynamically linked module called "g_acm_ms".
 
 config USB_G_MULTI
-        tristate "Multifunction Composite Gadget (EXPERIMENTAL)"
+        tristate "Multifunction Composite Gadget"
         depends on BLOCK && NET
         select USB_G_MULTI_CDC if !USB_G_MULTI_RNDIS
+        select USB_LIBCOMPOSITE
         help
           The Multifunction Composite Gadget provides Ethernet (RNDIS
           and/or CDC Ethernet), mass storage and ACM serial link
@@ -903,6 +906,7 @@ config USB_G_MULTI_CDC
 
 config USB_G_HID
         tristate "HID Gadget"
+        select USB_LIBCOMPOSITE
         help
           The HID gadget driver provides generic emulation of USB
           Human Interface Devices (HID).
@@ -913,8 +917,10 @@ config USB_G_HID
           Say "y" to link the driver statically, or "m" to build a
           dynamically linked module called "g_hid".
 
+# Standalone / single function gadgets
 config USB_G_DBGP
         tristate "EHCI Debug Device Gadget"
+        select USB_LIBCOMPOSITE
         help
           This gadget emulates an EHCI Debug device. This is useful when you want
           to interact with an EHCI Debug Port.
diff --git a/drivers/usb/gadget/Makefile b/drivers/usb/gadget/Makefile
index 3fd8cd09d2c1..307be5fa824c 100644
--- a/drivers/usb/gadget/Makefile
+++ b/drivers/usb/gadget/Makefile
@@ -4,6 +4,9 @@
 ccflags-$(CONFIG_USB_GADGET_DEBUG) := -DDEBUG
 
 obj-$(CONFIG_USB_GADGET)        += udc-core.o
+obj-$(CONFIG_USB_LIBCOMPOSITE)  += libcomposite.o
+libcomposite-y                  := usbstring.o config.o epautoconf.o
+libcomposite-y                  += composite.o
 obj-$(CONFIG_USB_DUMMY_HCD)     += dummy_hcd.o
 obj-$(CONFIG_USB_NET2272)       += net2272.o
 obj-$(CONFIG_USB_NET2280)       += net2280.o
@@ -16,6 +19,7 @@ obj-$(CONFIG_USB_OMAP)		+= omap_udc.o
 obj-$(CONFIG_USB_S3C2410)       += s3c2410_udc.o
 obj-$(CONFIG_USB_AT91)          += at91_udc.o
 obj-$(CONFIG_USB_ATMEL_USBA)    += atmel_usba_udc.o
+obj-$(CONFIG_USB_BCM63XX_UDC)   += bcm63xx_udc.o
 obj-$(CONFIG_USB_FSL_USB2)      += fsl_usb2_udc.o
 fsl_usb2_udc-y                  := fsl_udc_core.o
 fsl_usb2_udc-$(CONFIG_ARCH_MXC) += fsl_mxc_udc.o
diff --git a/drivers/usb/gadget/acm_ms.c b/drivers/usb/gadget/acm_ms.c
index 75b8a691fd00..5a7f289805ff 100644
--- a/drivers/usb/gadget/acm_ms.c
+++ b/drivers/usb/gadget/acm_ms.c
@@ -15,7 +15,7 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
+#include <linux/module.h>
 
 #include "u_serial.h"
 
@@ -41,15 +41,12 @@
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
 
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
 #include "u_serial.c"
 #include "f_acm.c"
 #include "f_mass_storage.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
@@ -89,17 +86,11 @@ static const struct usb_descriptor_header *otg_desc[] = {
         NULL,
 };
 
-
 /* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -157,7 +148,6 @@ static struct usb_configuration acm_ms_config_driver = {
 
 static int __init acm_ms_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
         void                    *retp;
@@ -174,44 +164,22 @@ static int __init acm_ms_bind(struct usb_composite_dev *cdev)
                 goto fail0;
         }
 
-        /* set bcdDevice */
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0) {
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        } else {
-                WARNING(cdev, "controller '%s' not recognized; trying %s\n",
-                                gadget->name,
-                                acm_ms_config_driver.label);
-                device_desc.bcdDevice =
-                        cpu_to_le16(0x0300 | 0x0099);
-        }
-
         /*
          * Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
-
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail1;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail1;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register our configuration */
         status = usb_add_config(cdev, &acm_ms_config_driver, acm_ms_do_config);
         if (status < 0)
                 goto fail1;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
                         DRIVER_DESC);
         fsg_common_put(&fsg_common);
@@ -232,11 +200,12 @@ static int __exit acm_ms_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver acm_ms_driver = {
+static __refdata struct usb_composite_driver acm_ms_driver = {
         .name           = "g_acm_ms",
         .dev            = &device_desc,
         .max_speed      = USB_SPEED_SUPER,
         .strings        = dev_strings,
+        .bind           = acm_ms_bind,
         .unbind         = __exit_p(acm_ms_unbind),
 };
 
@@ -246,7 +215,7 @@ MODULE_LICENSE("GPL v2");
 
 static int __init init(void)
 {
-        return usb_composite_probe(&acm_ms_driver, acm_ms_bind);
+        return usb_composite_probe(&acm_ms_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/amd5536udc.c b/drivers/usb/gadget/amd5536udc.c
index 187d21181cd5..fc0ec5e0d58e 100644
--- a/drivers/usb/gadget/amd5536udc.c
+++ b/drivers/usb/gadget/amd5536udc.c
@@ -1401,7 +1401,7 @@ static int udc_wakeup(struct usb_gadget *gadget)
 }
 
 static int amd5536_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int amd5536_stop(struct usb_gadget_driver *driver);
 /* gadget operations */
 static const struct usb_gadget_ops udc_ops = {
@@ -1914,7 +1914,7 @@ static int setup_ep0(struct udc *dev)
 
 /* Called by gadget driver to register itself */
 static int amd5536_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct udc              *dev = udc;
         int                     retval;
@@ -1932,7 +1932,7 @@ static int amd5536_start(struct usb_gadget_driver *driver,
         dev->driver = driver;
         dev->gadget.dev.driver = &driver->driver;
 
-        retval = bind(&dev->gadget);
+        retval = bind(&dev->gadget, driver);
 
         /* Some gadget drivers use both ep0 directions.
          * NOTE: to gadget driver, ep0 is just one endpoint...
diff --git a/drivers/usb/gadget/at91_udc.c b/drivers/usb/gadget/at91_udc.c
index 1e35963bd4ed..89d90b5fb787 100644
--- a/drivers/usb/gadget/at91_udc.c
+++ b/drivers/usb/gadget/at91_udc.c
@@ -469,7 +469,7 @@ static int at91_ep_enable(struct usb_ep *_ep,
                                 const struct usb_endpoint_descriptor *desc)
 {
         struct at91_ep  *ep = container_of(_ep, struct at91_ep, ep);
-        struct at91_udc *udc = ep->udc;
+        struct at91_udc *udc;
         u16             maxpacket;
         u32             tmp;
         unsigned long   flags;
@@ -483,6 +483,7 @@ static int at91_ep_enable(struct usb_ep *_ep,
                 return -EINVAL;
         }
 
+        udc = ep->udc;
         if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN) {
                 DBG("bogus device state\n");
                 return -ESHUTDOWN;
@@ -1699,7 +1700,7 @@ static int __devinit at91udc_probe(struct platform_device *pdev)
         int             retval;
         struct resource *res;
 
-        if (!dev->platform_data) {
+        if (!dev->platform_data && !pdev->dev.of_node) {
                 /* small (so we copy it) but critical! */
                 DBG("missing platform_data\n");
                 return -ENODEV;
diff --git a/drivers/usb/gadget/audio.c b/drivers/usb/gadget/audio.c
index 98899244860e..231b0efe8fdc 100644
--- a/drivers/usb/gadget/audio.c
+++ b/drivers/usb/gadget/audio.c
@@ -12,35 +12,21 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
+#include <linux/module.h>
+#include <linux/usb/composite.h>
 
+#include "gadget_chips.h"
 #define DRIVER_DESC             "Linux USB Audio Gadget"
 #define DRIVER_VERSION          "Feb 2, 2012"
 
-/*-------------------------------------------------------------------------*/
-
-/*
- * Kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
- */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
+USB_GADGET_COMPOSITE_OPTIONS();
 
 /* string IDs are assigned dynamically */
 
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -149,39 +135,18 @@ static struct usb_configuration audio_config_driver = {
 
 static int __init audio_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         int                     status;
 
-        gcnum = usb_gadget_controller_number(cdev->gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        else {
-                ERROR(cdev, "controller '%s' not recognized; trying %s\n",
-                        cdev->gadget->name,
-                        audio_config_driver.label);
-                device_desc.bcdDevice =
-                        __constant_cpu_to_le16(0x0300 | 0x0099);
-        }
-
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                cdev->gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         status = usb_add_config(cdev, &audio_config_driver, audio_do_config);
         if (status < 0)
                 goto fail;
+        usb_composite_overwrite_options(cdev, &coverwrite);
 
         INFO(cdev, "%s, version: %s\n", DRIVER_DESC, DRIVER_VERSION);
         return 0;
@@ -198,17 +163,18 @@ static int __exit audio_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver audio_driver = {
+static __refdata struct usb_composite_driver audio_driver = {
         .name           = "g_audio",
         .dev            = &device_desc,
         .strings        = audio_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = audio_bind,
         .unbind         = __exit_p(audio_unbind),
 };
 
 static int __init init(void)
 {
-        return usb_composite_probe(&audio_driver, audio_bind);
+        return usb_composite_probe(&audio_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/bcm63xx_udc.c b/drivers/usb/gadget/bcm63xx_udc.c
new file mode 100644
index 000000000000..9ca792224cd4
--- /dev/null
+++ b/drivers/usb/gadget/bcm63xx_udc.c
@@ -0,0 +1,2464 @@
+/*
+ * bcm63xx_udc.c -- BCM63xx UDC high/full speed USB device controller
+ *
+ * Copyright (C) 2012 Kevin Cernekee <cernekee@gmail.com>
+ * Copyright (C) 2012 Broadcom Corporation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include <linux/bitops.h>
+#include <linux/bug.h>
+#include <linux/clk.h>
+#include <linux/compiler.h>
+#include <linux/debugfs.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/dma-mapping.h>
+#include <linux/errno.h>
+#include <linux/init.h>
+#include <linux/interrupt.h>
+#include <linux/ioport.h>
+#include <linux/kconfig.h>
+#include <linux/kernel.h>
+#include <linux/list.h>
+#include <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/platform_device.h>
+#include <linux/sched.h>
+#include <linux/seq_file.h>
+#include <linux/slab.h>
+#include <linux/timer.h>
+#include <linux/usb/ch9.h>
+#include <linux/usb/gadget.h>
+#include <linux/workqueue.h>
+
+#include <bcm63xx_cpu.h>
+#include <bcm63xx_iudma.h>
+#include <bcm63xx_dev_usb_usbd.h>
+#include <bcm63xx_io.h>
+#include <bcm63xx_regs.h>
+
+#define DRV_MODULE_NAME         "bcm63xx_udc"
+
+static const char bcm63xx_ep0name[] = "ep0";
+static const char *const bcm63xx_ep_name[] = {
+        bcm63xx_ep0name,
+        "ep1in-bulk", "ep2out-bulk", "ep3in-int", "ep4out-int",
+};
+
+static bool use_fullspeed;
+module_param(use_fullspeed, bool, S_IRUGO);
+MODULE_PARM_DESC(use_fullspeed, "true for fullspeed only");
+
+/*
+ * RX IRQ coalescing options:
+ *
+ * false (default) - one IRQ per DATAx packet.  Slow but reliable.  The
+ * driver is able to pass the "testusb" suite and recover from conditions like:
+ *
+ *   1) Device queues up a 2048-byte RX IUDMA transaction on an OUT bulk ep
+ *   2) Host sends 512 bytes of data
+ *   3) Host decides to reconfigure the device and sends SET_INTERFACE
+ *   4) Device shuts down the endpoint and cancels the RX transaction
+ *
+ * true - one IRQ per transfer, for transfers <= 2048B.  Generates
+ * considerably fewer IRQs, but error recovery is less robust.  Does not
+ * reliably pass "testusb".
+ *
+ * TX always uses coalescing, because we can cancel partially complete TX
+ * transfers by repeatedly flushing the FIFO.  The hardware doesn't allow
+ * this on RX.
+ */
+static bool irq_coalesce;
+module_param(irq_coalesce, bool, S_IRUGO);
+MODULE_PARM_DESC(irq_coalesce, "take one IRQ per RX transfer");
+
+#define BCM63XX_NUM_EP                  5
+#define BCM63XX_NUM_IUDMA               6
+#define BCM63XX_NUM_FIFO_PAIRS          3
+
+#define IUDMA_RESET_TIMEOUT_US          10000
+
+#define IUDMA_EP0_RXCHAN                0
+#define IUDMA_EP0_TXCHAN                1
+
+#define IUDMA_MAX_FRAGMENT              2048
+#define BCM63XX_MAX_CTRL_PKT            64
+
+#define BCMEP_CTRL                      0x00
+#define BCMEP_ISOC                      0x01
+#define BCMEP_BULK                      0x02
+#define BCMEP_INTR                      0x03
+
+#define BCMEP_OUT                       0x00
+#define BCMEP_IN                        0x01
+
+#define BCM63XX_SPD_FULL                1
+#define BCM63XX_SPD_HIGH                0
+
+#define IUDMA_DMAC_OFFSET               0x200
+#define IUDMA_DMAS_OFFSET               0x400
+
+enum bcm63xx_ep0_state {
+        EP0_REQUEUE,
+        EP0_IDLE,
+        EP0_IN_DATA_PHASE_SETUP,
+        EP0_IN_DATA_PHASE_COMPLETE,
+        EP0_OUT_DATA_PHASE_SETUP,
+        EP0_OUT_DATA_PHASE_COMPLETE,
+        EP0_OUT_STATUS_PHASE,
+        EP0_IN_FAKE_STATUS_PHASE,
+        EP0_SHUTDOWN,
+};
+
+static const char __maybe_unused bcm63xx_ep0_state_names[][32] = {
+        "REQUEUE",
+        "IDLE",
+        "IN_DATA_PHASE_SETUP",
+        "IN_DATA_PHASE_COMPLETE",
+        "OUT_DATA_PHASE_SETUP",
+        "OUT_DATA_PHASE_COMPLETE",
+        "OUT_STATUS_PHASE",
+        "IN_FAKE_STATUS_PHASE",
+        "SHUTDOWN",
+};
+
+/**
+ * struct iudma_ch_cfg - Static configuration for an IUDMA channel.
+ * @ep_num: USB endpoint number.
+ * @n_bds: Number of buffer descriptors in the ring.
+ * @ep_type: Endpoint type (control, bulk, interrupt).
+ * @dir: Direction (in, out).
+ * @n_fifo_slots: Number of FIFO entries to allocate for this channel.
+ * @max_pkt_hs: Maximum packet size in high speed mode.
+ * @max_pkt_fs: Maximum packet size in full speed mode.
+ */
+struct iudma_ch_cfg {
+        int                             ep_num;
+        int                             n_bds;
+        int                             ep_type;
+        int                             dir;
+        int                             n_fifo_slots;
+        int                             max_pkt_hs;
+        int                             max_pkt_fs;
+};
+
+static const struct iudma_ch_cfg iudma_defaults[] = {
+
+        /* This controller was designed to support a CDC/RNDIS application.
+           It may be possible to reconfigure some of the endpoints, but
+           the hardware limitations (FIFO sizing and number of DMA channels)
+           may significantly impact flexibility and/or stability.  Change
+           these values at your own risk.
+
+              ep_num       ep_type           n_fifo_slots    max_pkt_fs
+        idx      |  n_bds     |         dir       |  max_pkt_hs  |
+         |       |    |       |          |        |      |       |       */
+        [0] = { -1,   4, BCMEP_CTRL, BCMEP_OUT,  32,    64,     64 },
+        [1] = {  0,   4, BCMEP_CTRL, BCMEP_OUT,  32,    64,     64 },
+        [2] = {  2,  16, BCMEP_BULK, BCMEP_OUT, 128,   512,     64 },
+        [3] = {  1,  16, BCMEP_BULK, BCMEP_IN,  128,   512,     64 },
+        [4] = {  4,   4, BCMEP_INTR, BCMEP_OUT,  32,    64,     64 },
+        [5] = {  3,   4, BCMEP_INTR, BCMEP_IN,   32,    64,     64 },
+};
+
+struct bcm63xx_udc;
+
+/**
+ * struct iudma_ch - Represents the current state of a single IUDMA channel.
+ * @ch_idx: IUDMA channel index (0 to BCM63XX_NUM_IUDMA-1).
+ * @ep_num: USB endpoint number.  -1 for ep0 RX.
+ * @enabled: Whether bcm63xx_ep_enable() has been called.
+ * @max_pkt: "Chunk size" on the USB interface.  Based on interface speed.
+ * @is_tx: true for TX, false for RX.
+ * @bep: Pointer to the associated endpoint.  NULL for ep0 RX.
+ * @udc: Reference to the device controller.
+ * @read_bd: Next buffer descriptor to reap from the hardware.
+ * @write_bd: Next BD available for a new packet.
+ * @end_bd: Points to the final BD in the ring.
+ * @n_bds_used: Number of BD entries currently occupied.
+ * @bd_ring: Base pointer to the BD ring.
+ * @bd_ring_dma: Physical (DMA) address of bd_ring.
+ * @n_bds: Total number of BDs in the ring.
+ *
+ * ep0 has two IUDMA channels (IUDMA_EP0_RXCHAN and IUDMA_EP0_TXCHAN), as it is
+ * bidirectional.  The "struct usb_ep" associated with ep0 is for TX (IN)
+ * only.
+ *
+ * Each bulk/intr endpoint has a single IUDMA channel and a single
+ * struct usb_ep.
+ */
+struct iudma_ch {
+        unsigned int                    ch_idx;
+        int                             ep_num;
+        bool                            enabled;
+        int                             max_pkt;
+        bool                            is_tx;
+        struct bcm63xx_ep               *bep;
+        struct bcm63xx_udc              *udc;
+
+        struct bcm_enet_desc            *read_bd;
+        struct bcm_enet_desc            *write_bd;
+        struct bcm_enet_desc            *end_bd;
+        int                             n_bds_used;
+
+        struct bcm_enet_desc            *bd_ring;
+        dma_addr_t                      bd_ring_dma;
+        unsigned int                    n_bds;
+};
+
+/**
+ * struct bcm63xx_ep - Internal (driver) state of a single endpoint.
+ * @ep_num: USB endpoint number.
+ * @iudma: Pointer to IUDMA channel state.
+ * @ep: USB gadget layer representation of the EP.
+ * @udc: Reference to the device controller.
+ * @queue: Linked list of outstanding requests for this EP.
+ * @halted: 1 if the EP is stalled; 0 otherwise.
+ */
+struct bcm63xx_ep {
+        unsigned int                    ep_num;
+        struct iudma_ch                 *iudma;
+        struct usb_ep                   ep;
+        struct bcm63xx_udc              *udc;
+        struct list_head                queue;
+        unsigned                        halted:1;
+};
+
+/**
+ * struct bcm63xx_req - Internal (driver) state of a single request.
+ * @queue: Links back to the EP's request list.
+ * @req: USB gadget layer representation of the request.
+ * @offset: Current byte offset into the data buffer (next byte to queue).
+ * @bd_bytes: Number of data bytes in outstanding BD entries.
+ * @iudma: IUDMA channel used for the request.
+ */
+struct bcm63xx_req {
+        struct list_head                queue;          /* ep's requests */
+        struct usb_request              req;
+        unsigned int                    offset;
+        unsigned int                    bd_bytes;
+        struct iudma_ch                 *iudma;
+};
+
+/**
+ * struct bcm63xx_udc - Driver/hardware private context.
+ * @lock: Spinlock to mediate access to this struct, and (most) HW regs.
+ * @dev: Generic Linux device structure.
+ * @pd: Platform data (board/port info).
+ * @usbd_clk: Clock descriptor for the USB device block.
+ * @usbh_clk: Clock descriptor for the USB host block.
+ * @gadget: USB slave device.
+ * @driver: Driver for USB slave devices.
+ * @usbd_regs: Base address of the USBD/USB20D block.
+ * @iudma_regs: Base address of the USBD's associated IUDMA block.
+ * @bep: Array of endpoints, including ep0.
+ * @iudma: Array of all IUDMA channels used by this controller.
+ * @cfg: USB configuration number, from SET_CONFIGURATION wValue.
+ * @iface: USB interface number, from SET_INTERFACE wIndex.
+ * @alt_iface: USB alt interface number, from SET_INTERFACE wValue.
+ * @ep0_ctrl_req: Request object for bcm63xx_udc-initiated ep0 transactions.
+ * @ep0_ctrl_buf: Data buffer for ep0_ctrl_req.
+ * @ep0state: Current state of the ep0 state machine.
+ * @ep0_wq: Workqueue struct used to wake up the ep0 state machine.
+ * @wedgemap: Bitmap of wedged endpoints.
+ * @ep0_req_reset: USB reset is pending.
+ * @ep0_req_set_cfg: Need to spoof a SET_CONFIGURATION packet.
+ * @ep0_req_set_iface: Need to spoof a SET_INTERFACE packet.
+ * @ep0_req_shutdown: Driver is shutting down; requesting ep0 to halt activity.
+ * @ep0_req_completed: ep0 request has completed; worker has not seen it yet.
+ * @ep0_reply: Pending reply from gadget driver.
+ * @ep0_request: Outstanding ep0 request.
+ * @debugfs_root: debugfs directory: /sys/kernel/debug/<DRV_MODULE_NAME>.
+ * @debugfs_usbd: debugfs file "usbd" for controller state.
+ * @debugfs_iudma: debugfs file "usbd" for IUDMA state.
+ */
+struct bcm63xx_udc {
+        spinlock_t                      lock;
+
+        struct device                   *dev;
+        struct bcm63xx_usbd_platform_data *pd;
+        struct clk                      *usbd_clk;
+        struct clk                      *usbh_clk;
+
+        struct usb_gadget               gadget;
+        struct usb_gadget_driver        *driver;
+
+        void __iomem                    *usbd_regs;
+        void __iomem                    *iudma_regs;
+
+        struct bcm63xx_ep               bep[BCM63XX_NUM_EP];
+        struct iudma_ch                 iudma[BCM63XX_NUM_IUDMA];
+
+        int                             cfg;
+        int                             iface;
+        int                             alt_iface;
+
+        struct bcm63xx_req              ep0_ctrl_req;
+        u8                              *ep0_ctrl_buf;
+
+        int                             ep0state;
+        struct work_struct              ep0_wq;
+
+        unsigned long                   wedgemap;
+
+        unsigned                        ep0_req_reset:1;
+        unsigned                        ep0_req_set_cfg:1;
+        unsigned                        ep0_req_set_iface:1;
+        unsigned                        ep0_req_shutdown:1;
+
+        unsigned                        ep0_req_completed:1;
+        struct usb_request              *ep0_reply;
+        struct usb_request              *ep0_request;
+
+        struct dentry                   *debugfs_root;
+        struct dentry                   *debugfs_usbd;
+        struct dentry                   *debugfs_iudma;
+};
+
+static const struct usb_ep_ops bcm63xx_udc_ep_ops;
+
+/***********************************************************************
+ * Convenience functions
+ ***********************************************************************/
+
+static inline struct bcm63xx_udc *gadget_to_udc(struct usb_gadget *g)
+{
+        return container_of(g, struct bcm63xx_udc, gadget);
+}
+
+static inline struct bcm63xx_ep *our_ep(struct usb_ep *ep)
+{
+        return container_of(ep, struct bcm63xx_ep, ep);
+}
+
+static inline struct bcm63xx_req *our_req(struct usb_request *req)
+{
+        return container_of(req, struct bcm63xx_req, req);
+}
+
+static inline u32 usbd_readl(struct bcm63xx_udc *udc, u32 off)
+{
+        return bcm_readl(udc->usbd_regs + off);
+}
+
+static inline void usbd_writel(struct bcm63xx_udc *udc, u32 val, u32 off)
+{
+        bcm_writel(val, udc->usbd_regs + off);
+}
+
+static inline u32 usb_dma_readl(struct bcm63xx_udc *udc, u32 off)
+{
+        return bcm_readl(udc->iudma_regs + off);
+}
+
+static inline void usb_dma_writel(struct bcm63xx_udc *udc, u32 val, u32 off)
+{
+        bcm_writel(val, udc->iudma_regs + off);
+}
+
+static inline u32 usb_dmac_readl(struct bcm63xx_udc *udc, u32 off)
+{
+        return bcm_readl(udc->iudma_regs + IUDMA_DMAC_OFFSET + off);
+}
+
+static inline void usb_dmac_writel(struct bcm63xx_udc *udc, u32 val, u32 off)
+{
+        bcm_writel(val, udc->iudma_regs + IUDMA_DMAC_OFFSET + off);
+}
+
+static inline u32 usb_dmas_readl(struct bcm63xx_udc *udc, u32 off)
+{
+        return bcm_readl(udc->iudma_regs + IUDMA_DMAS_OFFSET + off);
+}
+
+static inline void usb_dmas_writel(struct bcm63xx_udc *udc, u32 val, u32 off)
+{
+        bcm_writel(val, udc->iudma_regs + IUDMA_DMAS_OFFSET + off);
+}
+
+static inline void set_clocks(struct bcm63xx_udc *udc, bool is_enabled)
+{
+        if (is_enabled) {
+                clk_enable(udc->usbh_clk);
+                clk_enable(udc->usbd_clk);
+                udelay(10);
+        } else {
+                clk_disable(udc->usbd_clk);
+                clk_disable(udc->usbh_clk);
+        }
+}
+
+/***********************************************************************
+ * Low-level IUDMA / FIFO operations
+ ***********************************************************************/
+
+/**
+ * bcm63xx_ep_dma_select - Helper function to set up the init_sel signal.
+ * @udc: Reference to the device controller.
+ * @idx: Desired init_sel value.
+ *
+ * The "init_sel" signal is used as a selection index for both endpoints
+ * and IUDMA channels.  Since these do not map 1:1, the use of this signal
+ * depends on the context.
+ */
+static void bcm63xx_ep_dma_select(struct bcm63xx_udc *udc, int idx)
+{
+        u32 val = usbd_readl(udc, USBD_CONTROL_REG);
+
+        val &= ~USBD_CONTROL_INIT_SEL_MASK;
+        val |= idx << USBD_CONTROL_INIT_SEL_SHIFT;
+        usbd_writel(udc, val, USBD_CONTROL_REG);
+}
+
+/**
+ * bcm63xx_set_stall - Enable/disable stall on one endpoint.
+ * @udc: Reference to the device controller.
+ * @bep: Endpoint on which to operate.
+ * @is_stalled: true to enable stall, false to disable.
+ *
+ * See notes in bcm63xx_update_wedge() regarding automatic clearing of
+ * halt/stall conditions.
+ */
+static void bcm63xx_set_stall(struct bcm63xx_udc *udc, struct bcm63xx_ep *bep,
+        bool is_stalled)
+{
+        u32 val;
+
+        val = USBD_STALL_UPDATE_MASK |
+                (is_stalled ? USBD_STALL_ENABLE_MASK : 0) |
+                (bep->ep_num << USBD_STALL_EPNUM_SHIFT);
+        usbd_writel(udc, val, USBD_STALL_REG);
+}
+
+/**
+ * bcm63xx_fifo_setup - (Re)initialize FIFO boundaries and settings.
+ * @udc: Reference to the device controller.
+ *
+ * These parameters depend on the USB link speed.  Settings are
+ * per-IUDMA-channel-pair.
+ */
+static void bcm63xx_fifo_setup(struct bcm63xx_udc *udc)
+{
+        int is_hs = udc->gadget.speed == USB_SPEED_HIGH;
+        u32 i, val, rx_fifo_slot, tx_fifo_slot;
+
+        /* set up FIFO boundaries and packet sizes; this is done in pairs */
+        rx_fifo_slot = tx_fifo_slot = 0;
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i += 2) {
+                const struct iudma_ch_cfg *rx_cfg = &iudma_defaults[i];
+                const struct iudma_ch_cfg *tx_cfg = &iudma_defaults[i + 1];
+
+                bcm63xx_ep_dma_select(udc, i >> 1);
+
+                val = (rx_fifo_slot << USBD_RXFIFO_CONFIG_START_SHIFT) |
+                        ((rx_fifo_slot + rx_cfg->n_fifo_slots - 1) <<
+                         USBD_RXFIFO_CONFIG_END_SHIFT);
+                rx_fifo_slot += rx_cfg->n_fifo_slots;
+                usbd_writel(udc, val, USBD_RXFIFO_CONFIG_REG);
+                usbd_writel(udc,
+                            is_hs ? rx_cfg->max_pkt_hs : rx_cfg->max_pkt_fs,
+                            USBD_RXFIFO_EPSIZE_REG);
+
+                val = (tx_fifo_slot << USBD_TXFIFO_CONFIG_START_SHIFT) |
+                        ((tx_fifo_slot + tx_cfg->n_fifo_slots - 1) <<
+                         USBD_TXFIFO_CONFIG_END_SHIFT);
+                tx_fifo_slot += tx_cfg->n_fifo_slots;
+                usbd_writel(udc, val, USBD_TXFIFO_CONFIG_REG);
+                usbd_writel(udc,
+                            is_hs ? tx_cfg->max_pkt_hs : tx_cfg->max_pkt_fs,
+                            USBD_TXFIFO_EPSIZE_REG);
+
+                usbd_readl(udc, USBD_TXFIFO_EPSIZE_REG);
+        }
+}
+
+/**
+ * bcm63xx_fifo_reset_ep - Flush a single endpoint's FIFO.
+ * @udc: Reference to the device controller.
+ * @ep_num: Endpoint number.
+ */
+static void bcm63xx_fifo_reset_ep(struct bcm63xx_udc *udc, int ep_num)
+{
+        u32 val;
+
+        bcm63xx_ep_dma_select(udc, ep_num);
+
+        val = usbd_readl(udc, USBD_CONTROL_REG);
+        val |= USBD_CONTROL_FIFO_RESET_MASK;
+        usbd_writel(udc, val, USBD_CONTROL_REG);
+        usbd_readl(udc, USBD_CONTROL_REG);
+}
+
+/**
+ * bcm63xx_fifo_reset - Flush all hardware FIFOs.
+ * @udc: Reference to the device controller.
+ */
+static void bcm63xx_fifo_reset(struct bcm63xx_udc *udc)
+{
+        int i;
+
+        for (i = 0; i < BCM63XX_NUM_FIFO_PAIRS; i++)
+                bcm63xx_fifo_reset_ep(udc, i);
+}
+
+/**
+ * bcm63xx_ep_init - Initial (one-time) endpoint initialization.
+ * @udc: Reference to the device controller.
+ */
+static void bcm63xx_ep_init(struct bcm63xx_udc *udc)
+{
+        u32 i, val;
+
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i++) {
+                const struct iudma_ch_cfg *cfg = &iudma_defaults[i];
+
+                if (cfg->ep_num < 0)
+                        continue;
+
+                bcm63xx_ep_dma_select(udc, cfg->ep_num);
+                val = (cfg->ep_type << USBD_EPNUM_TYPEMAP_TYPE_SHIFT) |
+                        ((i >> 1) << USBD_EPNUM_TYPEMAP_DMA_CH_SHIFT);
+                usbd_writel(udc, val, USBD_EPNUM_TYPEMAP_REG);
+        }
+}
+
+/**
+ * bcm63xx_ep_setup - Configure per-endpoint settings.
+ * @udc: Reference to the device controller.
+ *
+ * This needs to be rerun if the speed/cfg/intf/altintf changes.
+ */
+static void bcm63xx_ep_setup(struct bcm63xx_udc *udc)
+{
+        u32 val, i;
+
+        usbd_writel(udc, USBD_CSR_SETUPADDR_DEF, USBD_CSR_SETUPADDR_REG);
+
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i++) {
+                const struct iudma_ch_cfg *cfg = &iudma_defaults[i];
+                int max_pkt = udc->gadget.speed == USB_SPEED_HIGH ?
+                              cfg->max_pkt_hs : cfg->max_pkt_fs;
+                int idx = cfg->ep_num;
+
+                udc->iudma[i].max_pkt = max_pkt;
+
+                if (idx < 0)
+                        continue;
+                udc->bep[idx].ep.maxpacket = max_pkt;
+
+                val = (idx << USBD_CSR_EP_LOG_SHIFT) |
+                      (cfg->dir << USBD_CSR_EP_DIR_SHIFT) |
+                      (cfg->ep_type << USBD_CSR_EP_TYPE_SHIFT) |
+                      (udc->cfg << USBD_CSR_EP_CFG_SHIFT) |
+                      (udc->iface << USBD_CSR_EP_IFACE_SHIFT) |
+                      (udc->alt_iface << USBD_CSR_EP_ALTIFACE_SHIFT) |
+                      (max_pkt << USBD_CSR_EP_MAXPKT_SHIFT);
+                usbd_writel(udc, val, USBD_CSR_EP_REG(idx));
+        }
+}
+
+/**
+ * iudma_write - Queue a single IUDMA transaction.
+ * @udc: Reference to the device controller.
+ * @iudma: IUDMA channel to use.
+ * @breq: Request containing the transaction data.
+ *
+ * For RX IUDMA, this will queue a single buffer descriptor, as RX IUDMA
+ * does not honor SOP/EOP so the handling of multiple buffers is ambiguous.
+ * So iudma_write() may be called several times to fulfill a single
+ * usb_request.
+ *
+ * For TX IUDMA, this can queue multiple buffer descriptors if needed.
+ */
+static void iudma_write(struct bcm63xx_udc *udc, struct iudma_ch *iudma,
+        struct bcm63xx_req *breq)
+{
+        int first_bd = 1, last_bd = 0, extra_zero_pkt = 0;
+        unsigned int bytes_left = breq->req.length - breq->offset;
+        const int max_bd_bytes = !irq_coalesce && !iudma->is_tx ?
+                iudma->max_pkt : IUDMA_MAX_FRAGMENT;
+
+        iudma->n_bds_used = 0;
+        breq->bd_bytes = 0;
+        breq->iudma = iudma;
+
+        if ((bytes_left % iudma->max_pkt == 0) && bytes_left && breq->req.zero)
+                extra_zero_pkt = 1;
+
+        do {
+                struct bcm_enet_desc *d = iudma->write_bd;
+                u32 dmaflags = 0;
+                unsigned int n_bytes;
+
+                if (d == iudma->end_bd) {
+                        dmaflags |= DMADESC_WRAP_MASK;
+                        iudma->write_bd = iudma->bd_ring;
+                } else {
+                        iudma->write_bd++;
+                }
+                iudma->n_bds_used++;
+
+                n_bytes = min_t(int, bytes_left, max_bd_bytes);
+                if (n_bytes)
+                        dmaflags |= n_bytes << DMADESC_LENGTH_SHIFT;
+                else
+                        dmaflags |= (1 << DMADESC_LENGTH_SHIFT) |
+                                    DMADESC_USB_ZERO_MASK;
+
+                dmaflags |= DMADESC_OWNER_MASK;
+                if (first_bd) {
+                        dmaflags |= DMADESC_SOP_MASK;
+                        first_bd = 0;
+                }
+
+                /*
+                 * extra_zero_pkt forces one more iteration through the loop
+                 * after all data is queued up, to send the zero packet
+                 */
+                if (extra_zero_pkt && !bytes_left)
+                        extra_zero_pkt = 0;
+
+                if (!iudma->is_tx || iudma->n_bds_used == iudma->n_bds ||
+                    (n_bytes == bytes_left && !extra_zero_pkt)) {
+                        last_bd = 1;
+                        dmaflags |= DMADESC_EOP_MASK;
+                }
+
+                d->address = breq->req.dma + breq->offset;
+                mb();
+                d->len_stat = dmaflags;
+
+                breq->offset += n_bytes;
+                breq->bd_bytes += n_bytes;
+                bytes_left -= n_bytes;
+        } while (!last_bd);
+
+        usb_dmac_writel(udc, ENETDMAC_CHANCFG_EN_MASK,
+                        ENETDMAC_CHANCFG_REG(iudma->ch_idx));
+}
+
+/**
+ * iudma_read - Check for IUDMA buffer completion.
+ * @udc: Reference to the device controller.
+ * @iudma: IUDMA channel to use.
+ *
+ * This checks to see if ALL of the outstanding BDs on the DMA channel
+ * have been filled.  If so, it returns the actual transfer length;
+ * otherwise it returns -EBUSY.
+ */
+static int iudma_read(struct bcm63xx_udc *udc, struct iudma_ch *iudma)
+{
+        int i, actual_len = 0;
+        struct bcm_enet_desc *d = iudma->read_bd;
+
+        if (!iudma->n_bds_used)
+                return -EINVAL;
+
+        for (i = 0; i < iudma->n_bds_used; i++) {
+                u32 dmaflags;
+
+                dmaflags = d->len_stat;
+
+                if (dmaflags & DMADESC_OWNER_MASK)
+                        return -EBUSY;
+
+                actual_len += (dmaflags & DMADESC_LENGTH_MASK) >>
+                              DMADESC_LENGTH_SHIFT;
+                if (d == iudma->end_bd)
+                        d = iudma->bd_ring;
+                else
+                        d++;
+        }
+
+        iudma->read_bd = d;
+        iudma->n_bds_used = 0;
+        return actual_len;
+}
+
+/**
+ * iudma_reset_channel - Stop DMA on a single channel.
+ * @udc: Reference to the device controller.
+ * @iudma: IUDMA channel to reset.
+ */
+static void iudma_reset_channel(struct bcm63xx_udc *udc, struct iudma_ch *iudma)
+{
+        int timeout = IUDMA_RESET_TIMEOUT_US;
+        struct bcm_enet_desc *d;
+        int ch_idx = iudma->ch_idx;
+
+        if (!iudma->is_tx)
+                bcm63xx_fifo_reset_ep(udc, max(0, iudma->ep_num));
+
+        /* stop DMA, then wait for the hardware to wrap up */
+        usb_dmac_writel(udc, 0, ENETDMAC_CHANCFG_REG(ch_idx));
+
+        while (usb_dmac_readl(udc, ENETDMAC_CHANCFG_REG(ch_idx)) &
+                                   ENETDMAC_CHANCFG_EN_MASK) {
+                udelay(1);
+
+                /* repeatedly flush the FIFO data until the BD completes */
+                if (iudma->is_tx && iudma->ep_num >= 0)
+                        bcm63xx_fifo_reset_ep(udc, iudma->ep_num);
+
+                if (!timeout--) {
+                        dev_err(udc->dev, "can't reset IUDMA channel %d\n",
+                                ch_idx);
+                        break;
+                }
+                if (timeout == IUDMA_RESET_TIMEOUT_US / 2) {
+                        dev_warn(udc->dev, "forcibly halting IUDMA channel %d\n",
+                                 ch_idx);
+                        usb_dmac_writel(udc, ENETDMAC_CHANCFG_BUFHALT_MASK,
+                                        ENETDMAC_CHANCFG_REG(ch_idx));
+                }
+        }
+        usb_dmac_writel(udc, ~0, ENETDMAC_IR_REG(ch_idx));
+
+        /* don't leave "live" HW-owned entries for the next guy to step on */
+        for (d = iudma->bd_ring; d <= iudma->end_bd; d++)
+                d->len_stat = 0;
+        mb();
+
+        iudma->read_bd = iudma->write_bd = iudma->bd_ring;
+        iudma->n_bds_used = 0;
+
+        /* set up IRQs, UBUS burst size, and BD base for this channel */
+        usb_dmac_writel(udc, ENETDMAC_IR_BUFDONE_MASK,
+                        ENETDMAC_IRMASK_REG(ch_idx));
+        usb_dmac_writel(udc, 8, ENETDMAC_MAXBURST_REG(ch_idx));
+
+        usb_dmas_writel(udc, iudma->bd_ring_dma, ENETDMAS_RSTART_REG(ch_idx));
+        usb_dmas_writel(udc, 0, ENETDMAS_SRAM2_REG(ch_idx));
+}
+
+/**
+ * iudma_init_channel - One-time IUDMA channel initialization.
+ * @udc: Reference to the device controller.
+ * @ch_idx: Channel to initialize.
+ */
+static int iudma_init_channel(struct bcm63xx_udc *udc, unsigned int ch_idx)
+{
+        struct iudma_ch *iudma = &udc->iudma[ch_idx];
+        const struct iudma_ch_cfg *cfg = &iudma_defaults[ch_idx];
+        unsigned int n_bds = cfg->n_bds;
+        struct bcm63xx_ep *bep = NULL;
+
+        iudma->ep_num = cfg->ep_num;
+        iudma->ch_idx = ch_idx;
+        iudma->is_tx = !!(ch_idx & 0x01);
+        if (iudma->ep_num >= 0) {
+                bep = &udc->bep[iudma->ep_num];
+                bep->iudma = iudma;
+                INIT_LIST_HEAD(&bep->queue);
+        }
+
+        iudma->bep = bep;
+        iudma->udc = udc;
+
+        /* ep0 is always active; others are controlled by the gadget driver */
+        if (iudma->ep_num <= 0)
+                iudma->enabled = true;
+
+        iudma->n_bds = n_bds;
+        iudma->bd_ring = dmam_alloc_coherent(udc->dev,
+                n_bds * sizeof(struct bcm_enet_desc),
+                &iudma->bd_ring_dma, GFP_KERNEL);
+        if (!iudma->bd_ring)
+                return -ENOMEM;
+        iudma->end_bd = &iudma->bd_ring[n_bds - 1];
+
+        return 0;
+}
+
+/**
+ * iudma_init - One-time initialization of all IUDMA channels.
+ * @udc: Reference to the device controller.
+ *
+ * Enable DMA, flush channels, and enable global IUDMA IRQs.
+ */
+static int iudma_init(struct bcm63xx_udc *udc)
+{
+        int i, rc;
+
+        usb_dma_writel(udc, ENETDMA_CFG_EN_MASK, ENETDMA_CFG_REG);
+
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i++) {
+                rc = iudma_init_channel(udc, i);
+                if (rc)
+                        return rc;
+                iudma_reset_channel(udc, &udc->iudma[i]);
+        }
+
+        usb_dma_writel(udc, BIT(BCM63XX_NUM_IUDMA)-1, ENETDMA_GLB_IRQMASK_REG);
+        return 0;
+}
+
+/**
+ * iudma_uninit - Uninitialize IUDMA channels.
+ * @udc: Reference to the device controller.
+ *
+ * Kill global IUDMA IRQs, flush channels, and kill DMA.
+ */
+static void iudma_uninit(struct bcm63xx_udc *udc)
+{
+        int i;
+
+        usb_dma_writel(udc, 0, ENETDMA_GLB_IRQMASK_REG);
+
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i++)
+                iudma_reset_channel(udc, &udc->iudma[i]);
+
+        usb_dma_writel(udc, 0, ENETDMA_CFG_REG);
+}
+
+/***********************************************************************
+ * Other low-level USBD operations
+ ***********************************************************************/
+
+/**
+ * bcm63xx_set_ctrl_irqs - Mask/unmask control path interrupts.
+ * @udc: Reference to the device controller.
+ * @enable_irqs: true to enable, false to disable.
+ */
+static void bcm63xx_set_ctrl_irqs(struct bcm63xx_udc *udc, bool enable_irqs)
+{
+        u32 val;
+
+        usbd_writel(udc, 0, USBD_STATUS_REG);
+
+        val = BIT(USBD_EVENT_IRQ_USB_RESET) |
+              BIT(USBD_EVENT_IRQ_SETUP) |
+              BIT(USBD_EVENT_IRQ_SETCFG) |
+              BIT(USBD_EVENT_IRQ_SETINTF) |
+              BIT(USBD_EVENT_IRQ_USB_LINK);
+        usbd_writel(udc, enable_irqs ? val : 0, USBD_EVENT_IRQ_MASK_REG);
+        usbd_writel(udc, val, USBD_EVENT_IRQ_STATUS_REG);
+}
+
+/**
+ * bcm63xx_select_phy_mode - Select between USB device and host mode.
+ * @udc: Reference to the device controller.
+ * @is_device: true for device, false for host.
+ *
+ * This should probably be reworked to use the drivers/usb/otg
+ * infrastructure.
+ *
+ * By default, the AFE/pullups are disabled in device mode, until
+ * bcm63xx_select_pullup() is called.
+ */
+static void bcm63xx_select_phy_mode(struct bcm63xx_udc *udc, bool is_device)
+{
+        u32 val, portmask = BIT(udc->pd->port_no);
+
+        if (BCMCPU_IS_6328()) {
+                /* configure pinmux to sense VBUS signal */
+                val = bcm_gpio_readl(GPIO_PINMUX_OTHR_REG);
+                val &= ~GPIO_PINMUX_OTHR_6328_USB_MASK;
+                val |= is_device ? GPIO_PINMUX_OTHR_6328_USB_DEV :
+                               GPIO_PINMUX_OTHR_6328_USB_HOST;
+                bcm_gpio_writel(val, GPIO_PINMUX_OTHR_REG);
+        }
+
+        val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_UTMI_CTL_6368_REG);
+        if (is_device) {
+                val |= (portmask << USBH_PRIV_UTMI_CTL_HOSTB_SHIFT);
+                val |= (portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT);
+        } else {
+                val &= ~(portmask << USBH_PRIV_UTMI_CTL_HOSTB_SHIFT);
+                val &= ~(portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT);
+        }
+        bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_UTMI_CTL_6368_REG);
+
+        val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_SWAP_6368_REG);
+        if (is_device)
+                val |= USBH_PRIV_SWAP_USBD_MASK;
+        else
+                val &= ~USBH_PRIV_SWAP_USBD_MASK;
+        bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_SWAP_6368_REG);
+}
+
+/**
+ * bcm63xx_select_pullup - Enable/disable the pullup on D+
+ * @udc: Reference to the device controller.
+ * @is_on: true to enable the pullup, false to disable.
+ *
+ * If the pullup is active, the host will sense a FS/HS device connected to
+ * the port.  If the pullup is inactive, the host will think the USB
+ * device has been disconnected.
+ */
+static void bcm63xx_select_pullup(struct bcm63xx_udc *udc, bool is_on)
+{
+        u32 val, portmask = BIT(udc->pd->port_no);
+
+        val = bcm_rset_readl(RSET_USBH_PRIV, USBH_PRIV_UTMI_CTL_6368_REG);
+        if (is_on)
+                val &= ~(portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT);
+        else
+                val |= (portmask << USBH_PRIV_UTMI_CTL_NODRIV_SHIFT);
+        bcm_rset_writel(RSET_USBH_PRIV, val, USBH_PRIV_UTMI_CTL_6368_REG);
+}
+
+/**
+ * bcm63xx_uninit_udc_hw - Shut down the hardware prior to driver removal.
+ * @udc: Reference to the device controller.
+ *
+ * This just masks the IUDMA IRQs and releases the clocks.  It is assumed
+ * that bcm63xx_udc_stop() has already run, and the clocks are stopped.
+ */
+static void bcm63xx_uninit_udc_hw(struct bcm63xx_udc *udc)
+{
+        set_clocks(udc, true);
+        iudma_uninit(udc);
+        set_clocks(udc, false);
+
+        clk_put(udc->usbd_clk);
+        clk_put(udc->usbh_clk);
+}
+
+/**
+ * bcm63xx_init_udc_hw - Initialize the controller hardware and data structures.
+ * @udc: Reference to the device controller.
+ */
+static int bcm63xx_init_udc_hw(struct bcm63xx_udc *udc)
+{
+        int i, rc = 0;
+        u32 val;
+
+        udc->ep0_ctrl_buf = devm_kzalloc(udc->dev, BCM63XX_MAX_CTRL_PKT,
+                                         GFP_KERNEL);
+        if (!udc->ep0_ctrl_buf)
+                return -ENOMEM;
+
+        INIT_LIST_HEAD(&udc->gadget.ep_list);
+        for (i = 0; i < BCM63XX_NUM_EP; i++) {
+                struct bcm63xx_ep *bep = &udc->bep[i];
+
+                bep->ep.name = bcm63xx_ep_name[i];
+                bep->ep_num = i;
+                bep->ep.ops = &bcm63xx_udc_ep_ops;
+                list_add_tail(&bep->ep.ep_list, &udc->gadget.ep_list);
+                bep->halted = 0;
+                bep->ep.maxpacket = BCM63XX_MAX_CTRL_PKT;
+                bep->udc = udc;
+                bep->ep.desc = NULL;
+                INIT_LIST_HEAD(&bep->queue);
+        }
+
+        udc->gadget.ep0 = &udc->bep[0].ep;
+        list_del(&udc->bep[0].ep.ep_list);
+
+        udc->gadget.speed = USB_SPEED_UNKNOWN;
+        udc->ep0state = EP0_SHUTDOWN;
+
+        udc->usbh_clk = clk_get(udc->dev, "usbh");
+        if (IS_ERR(udc->usbh_clk))
+                return -EIO;
+
+        udc->usbd_clk = clk_get(udc->dev, "usbd");
+        if (IS_ERR(udc->usbd_clk)) {
+                clk_put(udc->usbh_clk);
+                return -EIO;
+        }
+
+        set_clocks(udc, true);
+
+        val = USBD_CONTROL_AUTO_CSRS_MASK |
+              USBD_CONTROL_DONE_CSRS_MASK |
+              (irq_coalesce ? USBD_CONTROL_RXZSCFG_MASK : 0);
+        usbd_writel(udc, val, USBD_CONTROL_REG);
+
+        val = USBD_STRAPS_APP_SELF_PWR_MASK |
+              USBD_STRAPS_APP_RAM_IF_MASK |
+              USBD_STRAPS_APP_CSRPRGSUP_MASK |
+              USBD_STRAPS_APP_8BITPHY_MASK |
+              USBD_STRAPS_APP_RMTWKUP_MASK;
+
+        if (udc->gadget.max_speed == USB_SPEED_HIGH)
+                val |= (BCM63XX_SPD_HIGH << USBD_STRAPS_SPEED_SHIFT);
+        else
+                val |= (BCM63XX_SPD_FULL << USBD_STRAPS_SPEED_SHIFT);
+        usbd_writel(udc, val, USBD_STRAPS_REG);
+
+        bcm63xx_set_ctrl_irqs(udc, false);
+
+        usbd_writel(udc, 0, USBD_EVENT_IRQ_CFG_LO_REG);
+
+        val = USBD_EVENT_IRQ_CFG_FALLING(USBD_EVENT_IRQ_ENUM_ON) |
+              USBD_EVENT_IRQ_CFG_FALLING(USBD_EVENT_IRQ_SET_CSRS);
+        usbd_writel(udc, val, USBD_EVENT_IRQ_CFG_HI_REG);
+
+        rc = iudma_init(udc);
+        set_clocks(udc, false);
+        if (rc)
+                bcm63xx_uninit_udc_hw(udc);
+
+        return 0;
+}
+
+/***********************************************************************
+ * Standard EP gadget operations
+ ***********************************************************************/
+
+/**
+ * bcm63xx_ep_enable - Enable one endpoint.
+ * @ep: Endpoint to enable.
+ * @desc: Contains max packet, direction, etc.
+ *
+ * Most of the endpoint parameters are fixed in this controller, so there
+ * isn't much for this function to do.
+ */
+static int bcm63xx_ep_enable(struct usb_ep *ep,
+        const struct usb_endpoint_descriptor *desc)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        struct iudma_ch *iudma = bep->iudma;
+        unsigned long flags;
+
+        if (!ep || !desc || ep->name == bcm63xx_ep0name)
+                return -EINVAL;
+
+        if (!udc->driver)
+                return -ESHUTDOWN;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (iudma->enabled) {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                return -EINVAL;
+        }
+
+        iudma->enabled = true;
+        BUG_ON(!list_empty(&bep->queue));
+
+        iudma_reset_channel(udc, iudma);
+
+        bep->halted = 0;
+        bcm63xx_set_stall(udc, bep, false);
+        clear_bit(bep->ep_num, &udc->wedgemap);
+
+        ep->desc = desc;
+        ep->maxpacket = usb_endpoint_maxp(desc);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/**
+ * bcm63xx_ep_disable - Disable one endpoint.
+ * @ep: Endpoint to disable.
+ */
+static int bcm63xx_ep_disable(struct usb_ep *ep)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        struct iudma_ch *iudma = bep->iudma;
+        struct list_head *pos, *n;
+        unsigned long flags;
+
+        if (!ep || !ep->desc)
+                return -EINVAL;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (!iudma->enabled) {
+                spin_unlock_irqrestore(&udc->lock, flags);
+                return -EINVAL;
+        }
+        iudma->enabled = false;
+
+        iudma_reset_channel(udc, iudma);
+
+        if (!list_empty(&bep->queue)) {
+                list_for_each_safe(pos, n, &bep->queue) {
+                        struct bcm63xx_req *breq =
+                                list_entry(pos, struct bcm63xx_req, queue);
+
+                        usb_gadget_unmap_request(&udc->gadget, &breq->req,
+                                                 iudma->is_tx);
+                        list_del(&breq->queue);
+                        breq->req.status = -ESHUTDOWN;
+
+                        spin_unlock_irqrestore(&udc->lock, flags);
+                        breq->req.complete(&iudma->bep->ep, &breq->req);
+                        spin_lock_irqsave(&udc->lock, flags);
+                }
+        }
+        ep->desc = NULL;
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return 0;
+}
+
+/**
+ * bcm63xx_udc_alloc_request - Allocate a new request.
+ * @ep: Endpoint associated with the request.
+ * @mem_flags: Flags to pass to kzalloc().
+ */
+static struct usb_request *bcm63xx_udc_alloc_request(struct usb_ep *ep,
+        gfp_t mem_flags)
+{
+        struct bcm63xx_req *breq;
+
+        breq = kzalloc(sizeof(*breq), mem_flags);
+        if (!breq)
+                return NULL;
+        return &breq->req;
+}
+
+/**
+ * bcm63xx_udc_free_request - Free a request.
+ * @ep: Endpoint associated with the request.
+ * @req: Request to free.
+ */
+static void bcm63xx_udc_free_request(struct usb_ep *ep,
+        struct usb_request *req)
+{
+        struct bcm63xx_req *breq = our_req(req);
+        kfree(breq);
+}
+
+/**
+ * bcm63xx_udc_queue - Queue up a new request.
+ * @ep: Endpoint associated with the request.
+ * @req: Request to add.
+ * @mem_flags: Unused.
+ *
+ * If the queue is empty, start this request immediately.  Otherwise, add
+ * it to the list.
+ *
+ * ep0 replies are sent through this function from the gadget driver, but
+ * they are treated differently because they need to be handled by the ep0
+ * state machine.  (Sometimes they are replies to control requests that
+ * were spoofed by this driver, and so they shouldn't be transmitted at all.)
+ */
+static int bcm63xx_udc_queue(struct usb_ep *ep, struct usb_request *req,
+        gfp_t mem_flags)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        struct bcm63xx_req *breq = our_req(req);
+        unsigned long flags;
+        int rc = 0;
+
+        if (unlikely(!req || !req->complete || !req->buf || !ep))
+                return -EINVAL;
+
+        req->actual = 0;
+        req->status = 0;
+        breq->offset = 0;
+
+        if (bep == &udc->bep[0]) {
+                /* only one reply per request, please */
+                if (udc->ep0_reply)
+                        return -EINVAL;
+
+                udc->ep0_reply = req;
+                schedule_work(&udc->ep0_wq);
+                return 0;
+        }
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (!bep->iudma->enabled) {
+                rc = -ESHUTDOWN;
+                goto out;
+        }
+
+        rc = usb_gadget_map_request(&udc->gadget, req, bep->iudma->is_tx);
+        if (rc == 0) {
+                list_add_tail(&breq->queue, &bep->queue);
+                if (list_is_singular(&bep->queue))
+                        iudma_write(udc, bep->iudma, breq);
+        }
+
+out:
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return rc;
+}
+
+/**
+ * bcm63xx_udc_dequeue - Remove a pending request from the queue.
+ * @ep: Endpoint associated with the request.
+ * @req: Request to remove.
+ *
+ * If the request is not at the head of the queue, this is easy - just nuke
+ * it.  If the request is at the head of the queue, we'll need to stop the
+ * DMA transaction and then queue up the successor.
+ */
+static int bcm63xx_udc_dequeue(struct usb_ep *ep, struct usb_request *req)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        struct bcm63xx_req *breq = our_req(req), *cur;
+        unsigned long flags;
+        int rc = 0;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (list_empty(&bep->queue)) {
+                rc = -EINVAL;
+                goto out;
+        }
+
+        cur = list_first_entry(&bep->queue, struct bcm63xx_req, queue);
+        usb_gadget_unmap_request(&udc->gadget, &breq->req, bep->iudma->is_tx);
+
+        if (breq == cur) {
+                iudma_reset_channel(udc, bep->iudma);
+                list_del(&breq->queue);
+
+                if (!list_empty(&bep->queue)) {
+                        struct bcm63xx_req *next;
+
+                        next = list_first_entry(&bep->queue,
+                                struct bcm63xx_req, queue);
+                        iudma_write(udc, bep->iudma, next);
+                }
+        } else {
+                list_del(&breq->queue);
+        }
+
+out:
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        req->status = -ESHUTDOWN;
+        req->complete(ep, req);
+
+        return rc;
+}
+
+/**
+ * bcm63xx_udc_set_halt - Enable/disable STALL flag in the hardware.
+ * @ep: Endpoint to halt.
+ * @value: Zero to clear halt; nonzero to set halt.
+ *
+ * See comments in bcm63xx_update_wedge().
+ */
+static int bcm63xx_udc_set_halt(struct usb_ep *ep, int value)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        bcm63xx_set_stall(udc, bep, !!value);
+        bep->halted = value;
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/**
+ * bcm63xx_udc_set_wedge - Stall the endpoint until the next reset.
+ * @ep: Endpoint to wedge.
+ *
+ * See comments in bcm63xx_update_wedge().
+ */
+static int bcm63xx_udc_set_wedge(struct usb_ep *ep)
+{
+        struct bcm63xx_ep *bep = our_ep(ep);
+        struct bcm63xx_udc *udc = bep->udc;
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        set_bit(bep->ep_num, &udc->wedgemap);
+        bcm63xx_set_stall(udc, bep, true);
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static const struct usb_ep_ops bcm63xx_udc_ep_ops = {
+        .enable         = bcm63xx_ep_enable,
+        .disable        = bcm63xx_ep_disable,
+
+        .alloc_request  = bcm63xx_udc_alloc_request,
+        .free_request   = bcm63xx_udc_free_request,
+
+        .queue          = bcm63xx_udc_queue,
+        .dequeue        = bcm63xx_udc_dequeue,
+
+        .set_halt       = bcm63xx_udc_set_halt,
+        .set_wedge      = bcm63xx_udc_set_wedge,
+};
+
+/***********************************************************************
+ * EP0 handling
+ ***********************************************************************/
+
+/**
+ * bcm63xx_ep0_setup_callback - Drop spinlock to invoke ->setup callback.
+ * @udc: Reference to the device controller.
+ * @ctrl: 8-byte SETUP request.
+ */
+static int bcm63xx_ep0_setup_callback(struct bcm63xx_udc *udc,
+        struct usb_ctrlrequest *ctrl)
+{
+        int rc;
+
+        spin_unlock_irq(&udc->lock);
+        rc = udc->driver->setup(&udc->gadget, ctrl);
+        spin_lock_irq(&udc->lock);
+        return rc;
+}
+
+/**
+ * bcm63xx_ep0_spoof_set_cfg - Synthesize a SET_CONFIGURATION request.
+ * @udc: Reference to the device controller.
+ *
+ * Many standard requests are handled automatically in the hardware, but
+ * we still need to pass them to the gadget driver so that it can
+ * reconfigure the interfaces/endpoints if necessary.
+ *
+ * Unfortunately we are not able to send a STALL response if the host
+ * requests an invalid configuration.  If this happens, we'll have to be
+ * content with printing a warning.
+ */
+static int bcm63xx_ep0_spoof_set_cfg(struct bcm63xx_udc *udc)
+{
+        struct usb_ctrlrequest ctrl;
+        int rc;
+
+        ctrl.bRequestType = USB_DIR_OUT | USB_RECIP_DEVICE;
+        ctrl.bRequest = USB_REQ_SET_CONFIGURATION;
+        ctrl.wValue = cpu_to_le16(udc->cfg);
+        ctrl.wIndex = 0;
+        ctrl.wLength = 0;
+
+        rc = bcm63xx_ep0_setup_callback(udc, &ctrl);
+        if (rc < 0) {
+                dev_warn_ratelimited(udc->dev,
+                        "hardware auto-acked bad SET_CONFIGURATION(%d) request\n",
+                        udc->cfg);
+        }
+        return rc;
+}
+
+/**
+ * bcm63xx_ep0_spoof_set_iface - Synthesize a SET_INTERFACE request.
+ * @udc: Reference to the device controller.
+ */
+static int bcm63xx_ep0_spoof_set_iface(struct bcm63xx_udc *udc)
+{
+        struct usb_ctrlrequest ctrl;
+        int rc;
+
+        ctrl.bRequestType = USB_DIR_OUT | USB_RECIP_INTERFACE;
+        ctrl.bRequest = USB_REQ_SET_INTERFACE;
+        ctrl.wValue = cpu_to_le16(udc->alt_iface);
+        ctrl.wIndex = cpu_to_le16(udc->iface);
+        ctrl.wLength = 0;
+
+        rc = bcm63xx_ep0_setup_callback(udc, &ctrl);
+        if (rc < 0) {
+                dev_warn_ratelimited(udc->dev,
+                        "hardware auto-acked bad SET_INTERFACE(%d,%d) request\n",
+                        udc->iface, udc->alt_iface);
+        }
+        return rc;
+}
+
+/**
+ * bcm63xx_ep0_map_write - dma_map and iudma_write a single request.
+ * @udc: Reference to the device controller.
+ * @ch_idx: IUDMA channel number.
+ * @req: USB gadget layer representation of the request.
+ */
+static void bcm63xx_ep0_map_write(struct bcm63xx_udc *udc, int ch_idx,
+        struct usb_request *req)
+{
+        struct bcm63xx_req *breq = our_req(req);
+        struct iudma_ch *iudma = &udc->iudma[ch_idx];
+
+        BUG_ON(udc->ep0_request);
+        udc->ep0_request = req;
+
+        req->actual = 0;
+        breq->offset = 0;
+        usb_gadget_map_request(&udc->gadget, req, iudma->is_tx);
+        iudma_write(udc, iudma, breq);
+}
+
+/**
+ * bcm63xx_ep0_complete - Set completion status and "stage" the callback.
+ * @udc: Reference to the device controller.
+ * @req: USB gadget layer representation of the request.
+ * @status: Status to return to the gadget driver.
+ */
+static void bcm63xx_ep0_complete(struct bcm63xx_udc *udc,
+        struct usb_request *req, int status)
+{
+        req->status = status;
+        if (status)
+                req->actual = 0;
+        if (req->complete) {
+                spin_unlock_irq(&udc->lock);
+                req->complete(&udc->bep[0].ep, req);
+                spin_lock_irq(&udc->lock);
+        }
+}
+
+/**
+ * bcm63xx_ep0_nuke_reply - Abort request from the gadget driver due to
+ *   reset/shutdown.
+ * @udc: Reference to the device controller.
+ * @is_tx: Nonzero for TX (IN), zero for RX (OUT).
+ */
+static void bcm63xx_ep0_nuke_reply(struct bcm63xx_udc *udc, int is_tx)
+{
+        struct usb_request *req = udc->ep0_reply;
+
+        udc->ep0_reply = NULL;
+        usb_gadget_unmap_request(&udc->gadget, req, is_tx);
+        if (udc->ep0_request == req) {
+                udc->ep0_req_completed = 0;
+                udc->ep0_request = NULL;
+        }
+        bcm63xx_ep0_complete(udc, req, -ESHUTDOWN);
+}
+
+/**
+ * bcm63xx_ep0_read_complete - Close out the pending ep0 request; return
+ *   transfer len.
+ * @udc: Reference to the device controller.
+ */
+static int bcm63xx_ep0_read_complete(struct bcm63xx_udc *udc)
+{
+        struct usb_request *req = udc->ep0_request;
+
+        udc->ep0_req_completed = 0;
+        udc->ep0_request = NULL;
+
+        return req->actual;
+}
+
+/**
+ * bcm63xx_ep0_internal_request - Helper function to submit an ep0 request.
+ * @udc: Reference to the device controller.
+ * @ch_idx: IUDMA channel number.
+ * @length: Number of bytes to TX/RX.
+ *
+ * Used for simple transfers performed by the ep0 worker.  This will always
+ * use ep0_ctrl_req / ep0_ctrl_buf.
+ */
+static void bcm63xx_ep0_internal_request(struct bcm63xx_udc *udc, int ch_idx,
+        int length)
+{
+        struct usb_request *req = &udc->ep0_ctrl_req.req;
+
+        req->buf = udc->ep0_ctrl_buf;
+        req->length = length;
+        req->complete = NULL;
+
+        bcm63xx_ep0_map_write(udc, ch_idx, req);
+}
+
+/**
+ * bcm63xx_ep0_do_setup - Parse new SETUP packet and decide how to handle it.
+ * @udc: Reference to the device controller.
+ *
+ * EP0_IDLE probably shouldn't ever happen.  EP0_REQUEUE means we're ready
+ * for the next packet.  Anything else means the transaction requires multiple
+ * stages of handling.
+ */
+static enum bcm63xx_ep0_state bcm63xx_ep0_do_setup(struct bcm63xx_udc *udc)
+{
+        int rc;
+        struct usb_ctrlrequest *ctrl = (void *)udc->ep0_ctrl_buf;
+
+        rc = bcm63xx_ep0_read_complete(udc);
+
+        if (rc < 0) {
+                dev_err(udc->dev, "missing SETUP packet\n");
+                return EP0_IDLE;
+        }
+
+        /*
+         * Handle 0-byte IN STATUS acknowledgement.  The hardware doesn't
+         * ALWAYS deliver these 100% of the time, so if we happen to see one,
+         * just throw it away.
+         */
+        if (rc == 0)
+                return EP0_REQUEUE;
+
+        /* Drop malformed SETUP packets */
+        if (rc != sizeof(*ctrl)) {
+                dev_warn_ratelimited(udc->dev,
+                        "malformed SETUP packet (%d bytes)\n", rc);
+                return EP0_REQUEUE;
+        }
+
+        /* Process new SETUP packet arriving on ep0 */
+        rc = bcm63xx_ep0_setup_callback(udc, ctrl);
+        if (rc < 0) {
+                bcm63xx_set_stall(udc, &udc->bep[0], true);
+                return EP0_REQUEUE;
+        }
+
+        if (!ctrl->wLength)
+                return EP0_REQUEUE;
+        else if (ctrl->bRequestType & USB_DIR_IN)
+                return EP0_IN_DATA_PHASE_SETUP;
+        else
+                return EP0_OUT_DATA_PHASE_SETUP;
+}
+
+/**
+ * bcm63xx_ep0_do_idle - Check for outstanding requests if ep0 is idle.
+ * @udc: Reference to the device controller.
+ *
+ * In state EP0_IDLE, the RX descriptor is either pending, or has been
+ * filled with a SETUP packet from the host.  This function handles new
+ * SETUP packets, control IRQ events (which can generate fake SETUP packets),
+ * and reset/shutdown events.
+ *
+ * Returns 0 if work was done; -EAGAIN if nothing to do.
+ */
+static int bcm63xx_ep0_do_idle(struct bcm63xx_udc *udc)
+{
+        if (udc->ep0_req_reset) {
+                udc->ep0_req_reset = 0;
+        } else if (udc->ep0_req_set_cfg) {
+                udc->ep0_req_set_cfg = 0;
+                if (bcm63xx_ep0_spoof_set_cfg(udc) >= 0)
+                        udc->ep0state = EP0_IN_FAKE_STATUS_PHASE;
+        } else if (udc->ep0_req_set_iface) {
+                udc->ep0_req_set_iface = 0;
+                if (bcm63xx_ep0_spoof_set_iface(udc) >= 0)
+                        udc->ep0state = EP0_IN_FAKE_STATUS_PHASE;
+        } else if (udc->ep0_req_completed) {
+                udc->ep0state = bcm63xx_ep0_do_setup(udc);
+                return udc->ep0state == EP0_IDLE ? -EAGAIN : 0;
+        } else if (udc->ep0_req_shutdown) {
+                udc->ep0_req_shutdown = 0;
+                udc->ep0_req_completed = 0;
+                udc->ep0_request = NULL;
+                iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_RXCHAN]);
+                usb_gadget_unmap_request(&udc->gadget,
+                        &udc->ep0_ctrl_req.req, 0);
+
+                /* bcm63xx_udc_pullup() is waiting for this */
+                mb();
+                udc->ep0state = EP0_SHUTDOWN;
+        } else if (udc->ep0_reply) {
+                /*
+                 * This could happen if a USB RESET shows up during an ep0
+                 * transaction (especially if a laggy driver like gadgetfs
+                 * is in use).
+                 */
+                dev_warn(udc->dev, "nuking unexpected reply\n");
+                bcm63xx_ep0_nuke_reply(udc, 0);
+        } else {
+                return -EAGAIN;
+        }
+
+        return 0;
+}
+
+/**
+ * bcm63xx_ep0_one_round - Handle the current ep0 state.
+ * @udc: Reference to the device controller.
+ *
+ * Returns 0 if work was done; -EAGAIN if nothing to do.
+ */
+static int bcm63xx_ep0_one_round(struct bcm63xx_udc *udc)
+{
+        enum bcm63xx_ep0_state ep0state = udc->ep0state;
+        bool shutdown = udc->ep0_req_reset || udc->ep0_req_shutdown;
+
+        switch (udc->ep0state) {
+        case EP0_REQUEUE:
+                /* set up descriptor to receive SETUP packet */
+                bcm63xx_ep0_internal_request(udc, IUDMA_EP0_RXCHAN,
+                                             BCM63XX_MAX_CTRL_PKT);
+                ep0state = EP0_IDLE;
+                break;
+        case EP0_IDLE:
+                return bcm63xx_ep0_do_idle(udc);
+        case EP0_IN_DATA_PHASE_SETUP:
+                /*
+                 * Normal case: TX request is in ep0_reply (queued by the
+                 * callback), or will be queued shortly.  When it's here,
+                 * send it to the HW and go to EP0_IN_DATA_PHASE_COMPLETE.
+                 *
+                 * Shutdown case: Stop waiting for the reply.  Just
+                 * REQUEUE->IDLE.  The gadget driver is NOT expected to
+                 * queue anything else now.
+                 */
+                if (udc->ep0_reply) {
+                        bcm63xx_ep0_map_write(udc, IUDMA_EP0_TXCHAN,
+                                              udc->ep0_reply);
+                        ep0state = EP0_IN_DATA_PHASE_COMPLETE;
+                } else if (shutdown) {
+                        ep0state = EP0_REQUEUE;
+                }
+                break;
+        case EP0_IN_DATA_PHASE_COMPLETE: {
+                /*
+                 * Normal case: TX packet (ep0_reply) is in flight; wait for
+                 * it to finish, then go back to REQUEUE->IDLE.
+                 *
+                 * Shutdown case: Reset the TX channel, send -ESHUTDOWN
+                 * completion to the gadget driver, then REQUEUE->IDLE.
+                 */
+                if (udc->ep0_req_completed) {
+                        udc->ep0_reply = NULL;
+                        bcm63xx_ep0_read_complete(udc);
+                        /*
+                         * the "ack" sometimes gets eaten (see
+                         * bcm63xx_ep0_do_idle)
+                         */
+                        ep0state = EP0_REQUEUE;
+                } else if (shutdown) {
+                        iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_TXCHAN]);
+                        bcm63xx_ep0_nuke_reply(udc, 1);
+                        ep0state = EP0_REQUEUE;
+                }
+                break;
+        }
+        case EP0_OUT_DATA_PHASE_SETUP:
+                /* Similar behavior to EP0_IN_DATA_PHASE_SETUP */
+                if (udc->ep0_reply) {
+                        bcm63xx_ep0_map_write(udc, IUDMA_EP0_RXCHAN,
+                                              udc->ep0_reply);
+                        ep0state = EP0_OUT_DATA_PHASE_COMPLETE;
+                } else if (shutdown) {
+                        ep0state = EP0_REQUEUE;
+                }
+                break;
+        case EP0_OUT_DATA_PHASE_COMPLETE: {
+                /* Similar behavior to EP0_IN_DATA_PHASE_COMPLETE */
+                if (udc->ep0_req_completed) {
+                        udc->ep0_reply = NULL;
+                        bcm63xx_ep0_read_complete(udc);
+
+                        /* send 0-byte ack to host */
+                        bcm63xx_ep0_internal_request(udc, IUDMA_EP0_TXCHAN, 0);
+                        ep0state = EP0_OUT_STATUS_PHASE;
+                } else if (shutdown) {
+                        iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_RXCHAN]);
+                        bcm63xx_ep0_nuke_reply(udc, 0);
+                        ep0state = EP0_REQUEUE;
+                }
+                break;
+        }
+        case EP0_OUT_STATUS_PHASE:
+                /*
+                 * Normal case: 0-byte OUT ack packet is in flight; wait
+                 * for it to finish, then go back to REQUEUE->IDLE.
+                 *
+                 * Shutdown case: just cancel the transmission.  Don't bother
+                 * calling the completion, because it originated from this
+                 * function anyway.  Then go back to REQUEUE->IDLE.
+                 */
+                if (udc->ep0_req_completed) {
+                        bcm63xx_ep0_read_complete(udc);
+                        ep0state = EP0_REQUEUE;
+                } else if (shutdown) {
+                        iudma_reset_channel(udc, &udc->iudma[IUDMA_EP0_TXCHAN]);
+                        udc->ep0_request = NULL;
+                        ep0state = EP0_REQUEUE;
+                }
+                break;
+        case EP0_IN_FAKE_STATUS_PHASE: {
+                /*
+                 * Normal case: we spoofed a SETUP packet and are now
+                 * waiting for the gadget driver to send a 0-byte reply.
+                 * This doesn't actually get sent to the HW because the
+                 * HW has already sent its own reply.  Once we get the
+                 * response, return to IDLE.
+                 *
+                 * Shutdown case: return to IDLE immediately.
+                 *
+                 * Note that the ep0 RX descriptor has remained queued
+                 * (and possibly unfilled) during this entire transaction.
+                 * The HW datapath (IUDMA) never even sees SET_CONFIGURATION
+                 * or SET_INTERFACE transactions.
+                 */
+                struct usb_request *r = udc->ep0_reply;
+
+                if (!r) {
+                        if (shutdown)
+                                ep0state = EP0_IDLE;
+                        break;
+                }
+
+                bcm63xx_ep0_complete(udc, r, 0);
+                udc->ep0_reply = NULL;
+                ep0state = EP0_IDLE;
+                break;
+        }
+        case EP0_SHUTDOWN:
+                break;
+        }
+
+        if (udc->ep0state == ep0state)
+                return -EAGAIN;
+
+        udc->ep0state = ep0state;
+        return 0;
+}
+
+/**
+ * bcm63xx_ep0_process - ep0 worker thread / state machine.
+ * @w: Workqueue struct.
+ *
+ * bcm63xx_ep0_process is triggered any time an event occurs on ep0.  It
+ * is used to synchronize ep0 events and ensure that both HW and SW events
+ * occur in a well-defined order.  When the ep0 IUDMA queues are idle, it may
+ * synthesize SET_CONFIGURATION / SET_INTERFACE requests that were consumed
+ * by the USBD hardware.
+ *
+ * The worker function will continue iterating around the state machine
+ * until there is nothing left to do.  Usually "nothing left to do" means
+ * that we're waiting for a new event from the hardware.
+ */
+static void bcm63xx_ep0_process(struct work_struct *w)
+{
+        struct bcm63xx_udc *udc = container_of(w, struct bcm63xx_udc, ep0_wq);
+        spin_lock_irq(&udc->lock);
+        while (bcm63xx_ep0_one_round(udc) == 0)
+                ;
+        spin_unlock_irq(&udc->lock);
+}
+
+/***********************************************************************
+ * Standard UDC gadget operations
+ ***********************************************************************/
+
+/**
+ * bcm63xx_udc_get_frame - Read current SOF frame number from the HW.
+ * @gadget: USB slave device.
+ */
+static int bcm63xx_udc_get_frame(struct usb_gadget *gadget)
+{
+        struct bcm63xx_udc *udc = gadget_to_udc(gadget);
+
+        return (usbd_readl(udc, USBD_STATUS_REG) &
+                USBD_STATUS_SOF_MASK) >> USBD_STATUS_SOF_SHIFT;
+}
+
+/**
+ * bcm63xx_udc_pullup - Enable/disable pullup on D+ line.
+ * @gadget: USB slave device.
+ * @is_on: 0 to disable pullup, 1 to enable.
+ *
+ * See notes in bcm63xx_select_pullup().
+ */
+static int bcm63xx_udc_pullup(struct usb_gadget *gadget, int is_on)
+{
+        struct bcm63xx_udc *udc = gadget_to_udc(gadget);
+        unsigned long flags;
+        int i, rc = -EINVAL;
+
+        spin_lock_irqsave(&udc->lock, flags);
+        if (is_on && udc->ep0state == EP0_SHUTDOWN) {
+                udc->gadget.speed = USB_SPEED_UNKNOWN;
+                udc->ep0state = EP0_REQUEUE;
+                bcm63xx_fifo_setup(udc);
+                bcm63xx_fifo_reset(udc);
+                bcm63xx_ep_setup(udc);
+
+                bitmap_zero(&udc->wedgemap, BCM63XX_NUM_EP);
+                for (i = 0; i < BCM63XX_NUM_EP; i++)
+                        bcm63xx_set_stall(udc, &udc->bep[i], false);
+
+                bcm63xx_set_ctrl_irqs(udc, true);
+                bcm63xx_select_pullup(gadget_to_udc(gadget), true);
+                rc = 0;
+        } else if (!is_on && udc->ep0state != EP0_SHUTDOWN) {
+                bcm63xx_select_pullup(gadget_to_udc(gadget), false);
+
+                udc->ep0_req_shutdown = 1;
+                spin_unlock_irqrestore(&udc->lock, flags);
+
+                while (1) {
+                        schedule_work(&udc->ep0_wq);
+                        if (udc->ep0state == EP0_SHUTDOWN)
+                                break;
+                        msleep(50);
+                }
+                bcm63xx_set_ctrl_irqs(udc, false);
+                cancel_work_sync(&udc->ep0_wq);
+                return 0;
+        }
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+        return rc;
+}
+
+/**
+ * bcm63xx_udc_start - Start the controller.
+ * @gadget: USB slave device.
+ * @driver: Driver for USB slave devices.
+ */
+static int bcm63xx_udc_start(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
+{
+        struct bcm63xx_udc *udc = gadget_to_udc(gadget);
+        unsigned long flags;
+
+        if (!driver || driver->max_speed < USB_SPEED_HIGH ||
+            !driver->setup)
+                return -EINVAL;
+        if (!udc)
+                return -ENODEV;
+        if (udc->driver)
+                return -EBUSY;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        set_clocks(udc, true);
+        bcm63xx_fifo_setup(udc);
+        bcm63xx_ep_init(udc);
+        bcm63xx_ep_setup(udc);
+        bcm63xx_fifo_reset(udc);
+        bcm63xx_select_phy_mode(udc, true);
+
+        udc->driver = driver;
+        driver->driver.bus = NULL;
+        udc->gadget.dev.driver = &driver->driver;
+        udc->gadget.dev.of_node = udc->dev->of_node;
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+/**
+ * bcm63xx_udc_stop - Shut down the controller.
+ * @gadget: USB slave device.
+ * @driver: Driver for USB slave devices.
+ */
+static int bcm63xx_udc_stop(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
+{
+        struct bcm63xx_udc *udc = gadget_to_udc(gadget);
+        unsigned long flags;
+
+        spin_lock_irqsave(&udc->lock, flags);
+
+        udc->driver = NULL;
+        udc->gadget.dev.driver = NULL;
+
+        /*
+         * If we switch the PHY too abruptly after dropping D+, the host
+         * will often complain:
+         *
+         *     hub 1-0:1.0: port 1 disabled by hub (EMI?), re-enabling...
+         */
+        msleep(100);
+
+        bcm63xx_select_phy_mode(udc, false);
+        set_clocks(udc, false);
+
+        spin_unlock_irqrestore(&udc->lock, flags);
+
+        return 0;
+}
+
+static const struct usb_gadget_ops bcm63xx_udc_ops = {
+        .get_frame      = bcm63xx_udc_get_frame,
+        .pullup         = bcm63xx_udc_pullup,
+        .udc_start      = bcm63xx_udc_start,
+        .udc_stop       = bcm63xx_udc_stop,
+};
+
+/***********************************************************************
+ * IRQ handling
+ ***********************************************************************/
+
+/**
+ * bcm63xx_update_cfg_iface - Read current configuration/interface settings.
+ * @udc: Reference to the device controller.
+ *
+ * This controller intercepts SET_CONFIGURATION and SET_INTERFACE messages.
+ * The driver never sees the raw control packets coming in on the ep0
+ * IUDMA channel, but at least we get an interrupt event to tell us that
+ * new values are waiting in the USBD_STATUS register.
+ */
+static void bcm63xx_update_cfg_iface(struct bcm63xx_udc *udc)
+{
+        u32 reg = usbd_readl(udc, USBD_STATUS_REG);
+
+        udc->cfg = (reg & USBD_STATUS_CFG_MASK) >> USBD_STATUS_CFG_SHIFT;
+        udc->iface = (reg & USBD_STATUS_INTF_MASK) >> USBD_STATUS_INTF_SHIFT;
+        udc->alt_iface = (reg & USBD_STATUS_ALTINTF_MASK) >>
+                         USBD_STATUS_ALTINTF_SHIFT;
+        bcm63xx_ep_setup(udc);
+}
+
+/**
+ * bcm63xx_update_link_speed - Check to see if the link speed has changed.
+ * @udc: Reference to the device controller.
+ *
+ * The link speed update coincides with a SETUP IRQ.  Returns 1 if the
+ * speed has changed, so that the caller can update the endpoint settings.
+ */
+static int bcm63xx_update_link_speed(struct bcm63xx_udc *udc)
+{
+        u32 reg = usbd_readl(udc, USBD_STATUS_REG);
+        enum usb_device_speed oldspeed = udc->gadget.speed;
+
+        switch ((reg & USBD_STATUS_SPD_MASK) >> USBD_STATUS_SPD_SHIFT) {
+        case BCM63XX_SPD_HIGH:
+                udc->gadget.speed = USB_SPEED_HIGH;
+                break;
+        case BCM63XX_SPD_FULL:
+                udc->gadget.speed = USB_SPEED_FULL;
+                break;
+        default:
+                /* this should never happen */
+                udc->gadget.speed = USB_SPEED_UNKNOWN;
+                dev_err(udc->dev,
+                        "received SETUP packet with invalid link speed\n");
+                return 0;
+        }
+
+        if (udc->gadget.speed != oldspeed) {
+                dev_info(udc->dev, "link up, %s-speed mode\n",
+                         udc->gadget.speed == USB_SPEED_HIGH ? "high" : "full");
+                return 1;
+        } else {
+                return 0;
+        }
+}
+
+/**
+ * bcm63xx_update_wedge - Iterate through wedged endpoints.
+ * @udc: Reference to the device controller.
+ * @new_status: true to "refresh" wedge status; false to clear it.
+ *
+ * On a SETUP interrupt, we need to manually "refresh" the wedge status
+ * because the controller hardware is designed to automatically clear
+ * stalls in response to a CLEAR_FEATURE request from the host.
+ *
+ * On a RESET interrupt, we do want to restore all wedged endpoints.
+ */
+static void bcm63xx_update_wedge(struct bcm63xx_udc *udc, bool new_status)
+{
+        int i;
+
+        for_each_set_bit(i, &udc->wedgemap, BCM63XX_NUM_EP) {
+                bcm63xx_set_stall(udc, &udc->bep[i], new_status);
+                if (!new_status)
+                        clear_bit(i, &udc->wedgemap);
+        }
+}
+
+/**
+ * bcm63xx_udc_ctrl_isr - ISR for control path events (USBD).
+ * @irq: IRQ number (unused).
+ * @dev_id: Reference to the device controller.
+ *
+ * This is where we handle link (VBUS) down, USB reset, speed changes,
+ * SET_CONFIGURATION, and SET_INTERFACE events.
+ */
+static irqreturn_t bcm63xx_udc_ctrl_isr(int irq, void *dev_id)
+{
+        struct bcm63xx_udc *udc = dev_id;
+        u32 stat;
+        bool disconnected = false;
+
+        stat = usbd_readl(udc, USBD_EVENT_IRQ_STATUS_REG) &
+               usbd_readl(udc, USBD_EVENT_IRQ_MASK_REG);
+
+        usbd_writel(udc, stat, USBD_EVENT_IRQ_STATUS_REG);
+
+        spin_lock(&udc->lock);
+        if (stat & BIT(USBD_EVENT_IRQ_USB_LINK)) {
+                /* VBUS toggled */
+
+                if (!(usbd_readl(udc, USBD_EVENTS_REG) &
+                      USBD_EVENTS_USB_LINK_MASK) &&
+                      udc->gadget.speed != USB_SPEED_UNKNOWN)
+                        dev_info(udc->dev, "link down\n");
+
+                udc->gadget.speed = USB_SPEED_UNKNOWN;
+                disconnected = true;
+        }
+        if (stat & BIT(USBD_EVENT_IRQ_USB_RESET)) {
+                bcm63xx_fifo_setup(udc);
+                bcm63xx_fifo_reset(udc);
+                bcm63xx_ep_setup(udc);
+
+                bcm63xx_update_wedge(udc, false);
+
+                udc->ep0_req_reset = 1;
+                schedule_work(&udc->ep0_wq);
+                disconnected = true;
+        }
+        if (stat & BIT(USBD_EVENT_IRQ_SETUP)) {
+                if (bcm63xx_update_link_speed(udc)) {
+                        bcm63xx_fifo_setup(udc);
+                        bcm63xx_ep_setup(udc);
+                }
+                bcm63xx_update_wedge(udc, true);
+        }
+        if (stat & BIT(USBD_EVENT_IRQ_SETCFG)) {
+                bcm63xx_update_cfg_iface(udc);
+                udc->ep0_req_set_cfg = 1;
+                schedule_work(&udc->ep0_wq);
+        }
+        if (stat & BIT(USBD_EVENT_IRQ_SETINTF)) {
+                bcm63xx_update_cfg_iface(udc);
+                udc->ep0_req_set_iface = 1;
+                schedule_work(&udc->ep0_wq);
+        }
+        spin_unlock(&udc->lock);
+
+        if (disconnected && udc->driver)
+                udc->driver->disconnect(&udc->gadget);
+
+        return IRQ_HANDLED;
+}
+
+/**
+ * bcm63xx_udc_data_isr - ISR for data path events (IUDMA).
+ * @irq: IRQ number (unused).
+ * @dev_id: Reference to the IUDMA channel that generated the interrupt.
+ *
+ * For the two ep0 channels, we have special handling that triggers the
+ * ep0 worker thread.  For normal bulk/intr channels, either queue up
+ * the next buffer descriptor for the transaction (incomplete transaction),
+ * or invoke the completion callback (complete transactions).
+ */
+static irqreturn_t bcm63xx_udc_data_isr(int irq, void *dev_id)
+{
+        struct iudma_ch *iudma = dev_id;
+        struct bcm63xx_udc *udc = iudma->udc;
+        struct bcm63xx_ep *bep;
+        struct usb_request *req = NULL;
+        struct bcm63xx_req *breq = NULL;
+        int rc;
+        bool is_done = false;
+
+        spin_lock(&udc->lock);
+
+        usb_dmac_writel(udc, ENETDMAC_IR_BUFDONE_MASK,
+                        ENETDMAC_IR_REG(iudma->ch_idx));
+        bep = iudma->bep;
+        rc = iudma_read(udc, iudma);
+
+        /* special handling for EP0 RX (0) and TX (1) */
+        if (iudma->ch_idx == IUDMA_EP0_RXCHAN ||
+            iudma->ch_idx == IUDMA_EP0_TXCHAN) {
+                req = udc->ep0_request;
+                breq = our_req(req);
+
+                /* a single request could require multiple submissions */
+                if (rc >= 0) {
+                        req->actual += rc;
+
+                        if (req->actual >= req->length || breq->bd_bytes > rc) {
+                                udc->ep0_req_completed = 1;
+                                is_done = true;
+                                schedule_work(&udc->ep0_wq);
+
+                                /* "actual" on a ZLP is 1 byte */
+                                req->actual = min(req->actual, req->length);
+                        } else {
+                                /* queue up the next BD (same request) */
+                                iudma_write(udc, iudma, breq);
+                        }
+                }
+        } else if (!list_empty(&bep->queue)) {
+                breq = list_first_entry(&bep->queue, struct bcm63xx_req, queue);
+                req = &breq->req;
+
+                if (rc >= 0) {
+                        req->actual += rc;
+
+                        if (req->actual >= req->length || breq->bd_bytes > rc) {
+                                is_done = true;
+                                list_del(&breq->queue);
+
+                                req->actual = min(req->actual, req->length);
+
+                                if (!list_empty(&bep->queue)) {
+                                        struct bcm63xx_req *next;
+
+                                        next = list_first_entry(&bep->queue,
+                                                struct bcm63xx_req, queue);
+                                        iudma_write(udc, iudma, next);
+                                }
+                        } else {
+                                iudma_write(udc, iudma, breq);
+                        }
+                }
+        }
+        spin_unlock(&udc->lock);
+
+        if (is_done) {
+                usb_gadget_unmap_request(&udc->gadget, req, iudma->is_tx);
+                if (req->complete)
+                        req->complete(&bep->ep, req);
+        }
+
+        return IRQ_HANDLED;
+}
+
+/***********************************************************************
+ * Debug filesystem
+ ***********************************************************************/
+
+/*
+ * bcm63xx_usbd_dbg_show - Show USBD controller state.
+ * @s: seq_file to which the information will be written.
+ * @p: Unused.
+ *
+ * This file nominally shows up as /sys/kernel/debug/bcm63xx_udc/usbd
+ */
+static int bcm63xx_usbd_dbg_show(struct seq_file *s, void *p)
+{
+        struct bcm63xx_udc *udc = s->private;
+
+        if (!udc->driver)
+                return -ENODEV;
+
+        seq_printf(s, "ep0 state: %s\n",
+                   bcm63xx_ep0_state_names[udc->ep0state]);
+        seq_printf(s, "  pending requests: %s%s%s%s%s%s%s\n",
+                   udc->ep0_req_reset ? "reset " : "",
+                   udc->ep0_req_set_cfg ? "set_cfg " : "",
+                   udc->ep0_req_set_iface ? "set_iface " : "",
+                   udc->ep0_req_shutdown ? "shutdown " : "",
+                   udc->ep0_request ? "pending " : "",
+                   udc->ep0_req_completed ? "completed " : "",
+                   udc->ep0_reply ? "reply " : "");
+        seq_printf(s, "cfg: %d; iface: %d; alt_iface: %d\n",
+                   udc->cfg, udc->iface, udc->alt_iface);
+        seq_printf(s, "regs:\n");
+        seq_printf(s, "  control: %08x; straps: %08x; status: %08x\n",
+                   usbd_readl(udc, USBD_CONTROL_REG),
+                   usbd_readl(udc, USBD_STRAPS_REG),
+                   usbd_readl(udc, USBD_STATUS_REG));
+        seq_printf(s, "  events:  %08x; stall:  %08x\n",
+                   usbd_readl(udc, USBD_EVENTS_REG),
+                   usbd_readl(udc, USBD_STALL_REG));
+
+        return 0;
+}
+
+/*
+ * bcm63xx_iudma_dbg_show - Show IUDMA status and descriptors.
+ * @s: seq_file to which the information will be written.
+ * @p: Unused.
+ *
+ * This file nominally shows up as /sys/kernel/debug/bcm63xx_udc/iudma
+ */
+static int bcm63xx_iudma_dbg_show(struct seq_file *s, void *p)
+{
+        struct bcm63xx_udc *udc = s->private;
+        int ch_idx, i;
+        u32 sram2, sram3;
+
+        if (!udc->driver)
+                return -ENODEV;
+
+        for (ch_idx = 0; ch_idx < BCM63XX_NUM_IUDMA; ch_idx++) {
+                struct iudma_ch *iudma = &udc->iudma[ch_idx];
+                struct list_head *pos;
+
+                seq_printf(s, "IUDMA channel %d -- ", ch_idx);
+                switch (iudma_defaults[ch_idx].ep_type) {
+                case BCMEP_CTRL:
+                        seq_printf(s, "control");
+                        break;
+                case BCMEP_BULK:
+                        seq_printf(s, "bulk");
+                        break;
+                case BCMEP_INTR:
+                        seq_printf(s, "interrupt");
+                        break;
+                }
+                seq_printf(s, ch_idx & 0x01 ? " tx" : " rx");
+                seq_printf(s, " [ep%d]:\n",
+                           max_t(int, iudma_defaults[ch_idx].ep_num, 0));
+                seq_printf(s, "  cfg: %08x; irqstat: %08x; irqmask: %08x; maxburst: %08x\n",
+                           usb_dmac_readl(udc, ENETDMAC_CHANCFG_REG(ch_idx)),
+                           usb_dmac_readl(udc, ENETDMAC_IR_REG(ch_idx)),
+                           usb_dmac_readl(udc, ENETDMAC_IRMASK_REG(ch_idx)),
+                           usb_dmac_readl(udc, ENETDMAC_MAXBURST_REG(ch_idx)));
+
+                sram2 = usb_dmas_readl(udc, ENETDMAS_SRAM2_REG(ch_idx));
+                sram3 = usb_dmas_readl(udc, ENETDMAS_SRAM3_REG(ch_idx));
+                seq_printf(s, "  base: %08x; index: %04x_%04x; desc: %04x_%04x %08x\n",
+                           usb_dmas_readl(udc, ENETDMAS_RSTART_REG(ch_idx)),
+                           sram2 >> 16, sram2 & 0xffff,
+                           sram3 >> 16, sram3 & 0xffff,
+                           usb_dmas_readl(udc, ENETDMAS_SRAM4_REG(ch_idx)));
+                seq_printf(s, "  desc: %d/%d used", iudma->n_bds_used,
+                           iudma->n_bds);
+
+                if (iudma->bep) {
+                        i = 0;
+                        list_for_each(pos, &iudma->bep->queue)
+                                i++;
+                        seq_printf(s, "; %d queued\n", i);
+                } else {
+                        seq_printf(s, "\n");
+                }
+
+                for (i = 0; i < iudma->n_bds; i++) {
+                        struct bcm_enet_desc *d = &iudma->bd_ring[i];
+
+                        seq_printf(s, "  %03x (%02x): len_stat: %04x_%04x; pa %08x",
+                                   i * sizeof(*d), i,
+                                   d->len_stat >> 16, d->len_stat & 0xffff,
+                                   d->address);
+                        if (d == iudma->read_bd)
+                                seq_printf(s, "   <<RD");
+                        if (d == iudma->write_bd)
+                                seq_printf(s, "   <<WR");
+                        seq_printf(s, "\n");
+                }
+
+                seq_printf(s, "\n");
+        }
+
+        return 0;
+}
+
+static int bcm63xx_usbd_dbg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, bcm63xx_usbd_dbg_show, inode->i_private);
+}
+
+static int bcm63xx_iudma_dbg_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, bcm63xx_iudma_dbg_show, inode->i_private);
+}
+
+static const struct file_operations usbd_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = bcm63xx_usbd_dbg_open,
+        .llseek         = seq_lseek,
+        .read           = seq_read,
+        .release        = single_release,
+};
+
+static const struct file_operations iudma_dbg_fops = {
+        .owner          = THIS_MODULE,
+        .open           = bcm63xx_iudma_dbg_open,
+        .llseek         = seq_lseek,
+        .read           = seq_read,
+        .release        = single_release,
+};
+
+
+/**
+ * bcm63xx_udc_init_debugfs - Create debugfs entries.
+ * @udc: Reference to the device controller.
+ */
+static void bcm63xx_udc_init_debugfs(struct bcm63xx_udc *udc)
+{
+        struct dentry *root, *usbd, *iudma;
+
+        if (!IS_ENABLED(CONFIG_USB_GADGET_DEBUG_FS))
+                return;
+
+        root = debugfs_create_dir(udc->gadget.name, NULL);
+        if (IS_ERR(root) || !root)
+                goto err_root;
+
+        usbd = debugfs_create_file("usbd", 0400, root, udc,
+                        &usbd_dbg_fops);
+        if (!usbd)
+                goto err_usbd;
+        iudma = debugfs_create_file("iudma", 0400, root, udc,
+                        &iudma_dbg_fops);
+        if (!iudma)
+                goto err_iudma;
+
+        udc->debugfs_root = root;
+        udc->debugfs_usbd = usbd;
+        udc->debugfs_iudma = iudma;
+        return;
+err_iudma:
+        debugfs_remove(usbd);
+err_usbd:
+        debugfs_remove(root);
+err_root:
+        dev_err(udc->dev, "debugfs is not available\n");
+}
+
+/**
+ * bcm63xx_udc_cleanup_debugfs - Remove debugfs entries.
+ * @udc: Reference to the device controller.
+ *
+ * debugfs_remove() is safe to call with a NULL argument.
+ */
+static void bcm63xx_udc_cleanup_debugfs(struct bcm63xx_udc *udc)
+{
+        debugfs_remove(udc->debugfs_iudma);
+        debugfs_remove(udc->debugfs_usbd);
+        debugfs_remove(udc->debugfs_root);
+        udc->debugfs_iudma = NULL;
+        udc->debugfs_usbd = NULL;
+        udc->debugfs_root = NULL;
+}
+
+/***********************************************************************
+ * Driver init/exit
+ ***********************************************************************/
+
+/**
+ * bcm63xx_udc_gadget_release - Called from device_release().
+ * @dev: Unused.
+ *
+ * We get a warning if this function doesn't exist, but it's empty because
+ * we don't have to free any of the memory allocated with the devm_* APIs.
+ */
+static void bcm63xx_udc_gadget_release(struct device *dev)
+{
+}
+
+/**
+ * bcm63xx_udc_probe - Initialize a new instance of the UDC.
+ * @pdev: Platform device struct from the bcm63xx BSP code.
+ *
+ * Note that platform data is required, because pd.port_no varies from chip
+ * to chip and is used to switch the correct USB port to device mode.
+ */
+static int __devinit bcm63xx_udc_probe(struct platform_device *pdev)
+{
+        struct device *dev = &pdev->dev;
+        struct bcm63xx_usbd_platform_data *pd = dev->platform_data;
+        struct bcm63xx_udc *udc;
+        struct resource *res;
+        int rc = -ENOMEM, i, irq;
+
+        udc = devm_kzalloc(dev, sizeof(*udc), GFP_KERNEL);
+        if (!udc) {
+                dev_err(dev, "cannot allocate memory\n");
+                return -ENOMEM;
+        }
+
+        platform_set_drvdata(pdev, udc);
+        udc->dev = dev;
+        udc->pd = pd;
+
+        if (!pd) {
+                dev_err(dev, "missing platform data\n");
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "error finding USBD resource\n");
+                return -ENXIO;
+        }
+        udc->usbd_regs = devm_request_and_ioremap(dev, res);
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+        if (!res) {
+                dev_err(dev, "error finding IUDMA resource\n");
+                return -ENXIO;
+        }
+        udc->iudma_regs = devm_request_and_ioremap(dev, res);
+
+        if (!udc->usbd_regs || !udc->iudma_regs) {
+                dev_err(dev, "error requesting resources\n");
+                return -ENXIO;
+        }
+
+        spin_lock_init(&udc->lock);
+        INIT_WORK(&udc->ep0_wq, bcm63xx_ep0_process);
+        dev_set_name(&udc->gadget.dev, "gadget");
+
+        udc->gadget.ops = &bcm63xx_udc_ops;
+        udc->gadget.name = dev_name(dev);
+        udc->gadget.dev.parent = dev;
+        udc->gadget.dev.release = bcm63xx_udc_gadget_release;
+        udc->gadget.dev.dma_mask = dev->dma_mask;
+
+        if (!pd->use_fullspeed && !use_fullspeed)
+                udc->gadget.max_speed = USB_SPEED_HIGH;
+        else
+                udc->gadget.max_speed = USB_SPEED_FULL;
+
+        /* request clocks, allocate buffers, and clear any pending IRQs */
+        rc = bcm63xx_init_udc_hw(udc);
+        if (rc)
+                return rc;
+
+        rc = -ENXIO;
+
+        /* IRQ resource #0: control interrupt (VBUS, speed, etc.) */
+        irq = platform_get_irq(pdev, 0);
+        if (irq < 0) {
+                dev_err(dev, "missing IRQ resource #0\n");
+                goto out_uninit;
+        }
+        if (devm_request_irq(dev, irq, &bcm63xx_udc_ctrl_isr, 0,
+                             dev_name(dev), udc) < 0) {
+                dev_err(dev, "error requesting IRQ #%d\n", irq);
+                goto out_uninit;
+        }
+
+        /* IRQ resources #1-6: data interrupts for IUDMA channels 0-5 */
+        for (i = 0; i < BCM63XX_NUM_IUDMA; i++) {
+                irq = platform_get_irq(pdev, i + 1);
+                if (irq < 0) {
+                        dev_err(dev, "missing IRQ resource #%d\n", i + 1);
+                        goto out_uninit;
+                }
+                if (devm_request_irq(dev, irq, &bcm63xx_udc_data_isr, 0,
+                                     dev_name(dev), &udc->iudma[i]) < 0) {
+                        dev_err(dev, "error requesting IRQ #%d\n", irq);
+                        goto out_uninit;
+                }
+        }
+
+        rc = device_register(&udc->gadget.dev);
+        if (rc)
+                goto out_uninit;
+
+        bcm63xx_udc_init_debugfs(udc);
+        rc = usb_add_gadget_udc(dev, &udc->gadget);
+        if (!rc)
+                return 0;
+
+        bcm63xx_udc_cleanup_debugfs(udc);
+        device_unregister(&udc->gadget.dev);
+out_uninit:
+        bcm63xx_uninit_udc_hw(udc);
+        return rc;
+}
+
+/**
+ * bcm63xx_udc_remove - Remove the device from the system.
+ * @pdev: Platform device struct from the bcm63xx BSP code.
+ */
+static int __devexit bcm63xx_udc_remove(struct platform_device *pdev)
+{
+        struct bcm63xx_udc *udc = platform_get_drvdata(pdev);
+
+        bcm63xx_udc_cleanup_debugfs(udc);
+        usb_del_gadget_udc(&udc->gadget);
+        device_unregister(&udc->gadget.dev);
+        BUG_ON(udc->driver);
+
+        platform_set_drvdata(pdev, NULL);
+        bcm63xx_uninit_udc_hw(udc);
+
+        return 0;
+}
+
+static struct platform_driver bcm63xx_udc_driver = {
+        .probe          = bcm63xx_udc_probe,
+        .remove         = __devexit_p(bcm63xx_udc_remove),
+        .driver         = {
+                .name   = DRV_MODULE_NAME,
+                .owner  = THIS_MODULE,
+        },
+};
+module_platform_driver(bcm63xx_udc_driver);
+
+MODULE_DESCRIPTION("BCM63xx USB Peripheral Controller");
+MODULE_AUTHOR("Kevin Cernekee <cernekee@gmail.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_MODULE_NAME);
diff --git a/drivers/usb/gadget/cdc2.c b/drivers/usb/gadget/cdc2.c
index 725550f06fab..1e4bb77f00bb 100644
--- a/drivers/usb/gadget/cdc2.c
+++ b/drivers/usb/gadget/cdc2.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/module.h>
 
 #include "u_ether.h"
@@ -34,6 +33,7 @@
 #define CDC_PRODUCT_NUM         0xa4aa  /* CDC Composite: ECM + ACM */
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 /*
  * Kbuild is not very cooperative with respect to linking separately
@@ -43,10 +43,6 @@
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
 
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
 #include "u_serial.c"
 #include "f_acm.c"
 #include "f_ecm.c"
@@ -92,15 +88,10 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 
 /* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -152,7 +143,6 @@ static struct usb_configuration cdc_config_driver = {
 
 static int __init cdc_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
 
@@ -172,47 +162,22 @@ static int __init cdc_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 goto fail0;
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        else {
-                /* We assume that can_support_ecm() tells the truth;
-                 * but if the controller isn't recognized at all then
-                 * that assumption is a bit more likely to be wrong.
-                 */
-                WARNING(cdev, "controller '%s' not recognized; trying %s\n",
-                                gadget->name,
-                                cdc_config_driver.label);
-                device_desc.bcdDevice =
-                        cpu_to_le16(0x0300 | 0x0099);
-        }
-
-
         /* Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
 
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail1;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail1;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register our configuration */
         status = usb_add_config(cdev, &cdc_config_driver, cdc_do_config);
         if (status < 0)
                 goto fail1;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
                         DRIVER_DESC);
 
@@ -232,11 +197,12 @@ static int __exit cdc_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver cdc_driver = {
+static __refdata struct usb_composite_driver cdc_driver = {
         .name           = "g_cdc",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = cdc_bind,
         .unbind         = __exit_p(cdc_unbind),
 };
 
@@ -246,7 +212,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_probe(&cdc_driver, cdc_bind);
+        return usb_composite_probe(&cdc_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index 3f72110da1b0..957f973dd96a 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -28,44 +28,6 @@
  * with the relevant device-wide data.
  */
 
-/* big enough to hold our biggest descriptor */
-#define USB_BUFSIZ      1024
-
-static struct usb_composite_driver *composite;
-static int (*composite_gadget_bind)(struct usb_composite_dev *cdev);
-
-/* Some systems will need runtime overrides for the  product identifiers
- * published in the device descriptor, either numbers or strings or both.
- * String parameters are in UTF-8 (superset of ASCII's 7 bit characters).
- */
-
-static ushort idVendor;
-module_param(idVendor, ushort, 0644);
-MODULE_PARM_DESC(idVendor, "USB Vendor ID");
-
-static ushort idProduct;
-module_param(idProduct, ushort, 0644);
-MODULE_PARM_DESC(idProduct, "USB Product ID");
-
-static ushort bcdDevice;
-module_param(bcdDevice, ushort, 0644);
-MODULE_PARM_DESC(bcdDevice, "USB Device version (BCD)");
-
-static char *iManufacturer;
-module_param(iManufacturer, charp, 0644);
-MODULE_PARM_DESC(iManufacturer, "USB Manufacturer string");
-
-static char *iProduct;
-module_param(iProduct, charp, 0644);
-MODULE_PARM_DESC(iProduct, "USB Product string");
-
-static char *iSerialNumber;
-module_param(iSerialNumber, charp, 0644);
-MODULE_PARM_DESC(iSerialNumber, "SerialNumber string");
-
-static char composite_manufacturer[50];
-
-/*-------------------------------------------------------------------------*/
 /**
  * next_ep_desc() - advance to the next EP descriptor
  * @t: currect pointer within descriptor array
@@ -192,6 +154,7 @@ ep_found:
         }
         return 0;
 }
+EXPORT_SYMBOL_GPL(config_ep_by_speed);
 
 /**
  * usb_add_function() - add a function to a configuration
@@ -250,6 +213,7 @@ done:
                                 function->name, function, value);
         return value;
 }
+EXPORT_SYMBOL_GPL(usb_add_function);
 
 /**
  * usb_function_deactivate - prevent function and gadget enumeration
@@ -286,6 +250,7 @@ int usb_function_deactivate(struct usb_function *function)
         spin_unlock_irqrestore(&cdev->lock, flags);
         return status;
 }
+EXPORT_SYMBOL_GPL(usb_function_deactivate);
 
 /**
  * usb_function_activate - allow function and gadget enumeration
@@ -300,9 +265,10 @@ int usb_function_deactivate(struct usb_function *function)
 int usb_function_activate(struct usb_function *function)
 {
         struct usb_composite_dev        *cdev = function->config->cdev;
+        unsigned long                   flags;
         int                             status = 0;
 
-        spin_lock(&cdev->lock);
+        spin_lock_irqsave(&cdev->lock, flags);
 
         if (WARN_ON(cdev->deactivations == 0))
                 status = -EINVAL;
@@ -312,9 +278,10 @@ int usb_function_activate(struct usb_function *function)
                         status = usb_gadget_connect(cdev->gadget);
         }
 
-        spin_unlock(&cdev->lock);
+        spin_unlock_irqrestore(&cdev->lock, flags);
         return status;
 }
+EXPORT_SYMBOL_GPL(usb_function_activate);
 
 /**
  * usb_interface_id() - allocate an unused interface ID
@@ -351,16 +318,18 @@ int usb_interface_id(struct usb_configuration *config,
         }
         return -ENODEV;
 }
+EXPORT_SYMBOL_GPL(usb_interface_id);
 
 static int config_buf(struct usb_configuration *config,
                 enum usb_device_speed speed, void *buf, u8 type)
 {
         struct usb_config_descriptor    *c = buf;
         void                            *next = buf + USB_DT_CONFIG_SIZE;
-        int                             len = USB_BUFSIZ - USB_DT_CONFIG_SIZE;
+        int                             len;
         struct usb_function             *f;
         int                             status;
 
+        len = USB_COMP_EP0_BUFSIZ - USB_DT_CONFIG_SIZE;
         /* write the config descriptor */
         c = buf;
         c->bLength = USB_DT_CONFIG_SIZE;
@@ -790,6 +759,7 @@ done:
                                 config->bConfigurationValue, status);
         return status;
 }
+EXPORT_SYMBOL_GPL(usb_add_config);
 
 static void remove_config(struct usb_composite_dev *cdev,
                               struct usb_configuration *config)
@@ -889,10 +859,10 @@ static int lookup_string(
 static int get_string(struct usb_composite_dev *cdev,
                 void *buf, u16 language, int id)
 {
+        struct usb_composite_driver     *composite = cdev->driver;
         struct usb_configuration        *c;
         struct usb_function             *f;
         int                             len;
-        const char                      *str;
 
         /* Yes, not only is USB's I18N support probably more than most
          * folk will ever care about ... also, it's all supported here.
@@ -932,26 +902,6 @@ static int get_string(struct usb_composite_dev *cdev,
                 return s->bLength;
         }
 
-        /* Otherwise, look up and return a specified string.  First
-         * check if the string has not been overridden.
-         */
-        if (cdev->manufacturer_override == id)
-                str = iManufacturer ?: composite->iManufacturer ?:
-                        composite_manufacturer;
-        else if (cdev->product_override == id)
-                str = iProduct ?: composite->iProduct;
-        else if (cdev->serial_override == id)
-                str = iSerialNumber ?: composite->iSerialNumber;
-        else
-                str = NULL;
-        if (str) {
-                struct usb_gadget_strings strings = {
-                        .language = language,
-                        .strings  = &(struct usb_string) { 0xff, str }
-                };
-                return usb_gadget_get_string(&strings, 0xff, buf);
-        }
-
         /* String IDs are device-scoped, so we look up each string
          * table we're told about.  These lookups are infrequent;
          * simpler-is-better here.
@@ -1003,6 +953,7 @@ int usb_string_id(struct usb_composite_dev *cdev)
         }
         return -ENODEV;
 }
+EXPORT_SYMBOL_GPL(usb_string_id);
 
 /**
  * usb_string_ids() - allocate unused string IDs in batch
@@ -1034,6 +985,7 @@ int usb_string_ids_tab(struct usb_composite_dev *cdev, struct usb_string *str)
 
         return 0;
 }
+EXPORT_SYMBOL_GPL(usb_string_ids_tab);
 
 /**
  * usb_string_ids_n() - allocate unused string IDs in batch
@@ -1062,7 +1014,7 @@ int usb_string_ids_n(struct usb_composite_dev *c, unsigned n)
         c->next_string_id += n;
         return next + 1;
 }
-
+EXPORT_SYMBOL_GPL(usb_string_ids_n);
 
 /*-------------------------------------------------------------------------*/
 
@@ -1359,8 +1311,8 @@ static void composite_disconnect(struct usb_gadget *gadget)
         spin_lock_irqsave(&cdev->lock, flags);
         if (cdev->config)
                 reset_config(cdev);
-        if (composite->disconnect)
-                composite->disconnect(cdev);
+        if (cdev->driver->disconnect)
+                cdev->driver->disconnect(cdev);
         spin_unlock_irqrestore(&cdev->lock, flags);
 }
 
@@ -1396,35 +1348,67 @@ composite_unbind(struct usb_gadget *gadget)
                                 struct usb_configuration, list);
                 remove_config(cdev, c);
         }
-        if (composite->unbind)
-                composite->unbind(cdev);
+        if (cdev->driver->unbind)
+                cdev->driver->unbind(cdev);
 
         if (cdev->req) {
                 kfree(cdev->req->buf);
                 usb_ep_free_request(gadget->ep0, cdev->req);
         }
         device_remove_file(&gadget->dev, &dev_attr_suspended);
+        kfree(cdev->def_manufacturer);
         kfree(cdev);
         set_gadget_data(gadget, NULL);
-        composite = NULL;
 }
 
-static u8 override_id(struct usb_composite_dev *cdev, u8 *desc)
+static void update_unchanged_dev_desc(struct usb_device_descriptor *new,
+                const struct usb_device_descriptor *old)
 {
-        if (!*desc) {
-                int ret = usb_string_id(cdev);
-                if (unlikely(ret < 0))
-                        WARNING(cdev, "failed to override string ID\n");
-                else
-                        *desc = ret;
-        }
+        __le16 idVendor;
+        __le16 idProduct;
+        __le16 bcdDevice;
+        u8 iSerialNumber;
+        u8 iManufacturer;
+        u8 iProduct;
 
-        return *desc;
+        /*
+         * these variables may have been set in
+         * usb_composite_overwrite_options()
+         */
+        idVendor = new->idVendor;
+        idProduct = new->idProduct;
+        bcdDevice = new->bcdDevice;
+        iSerialNumber = new->iSerialNumber;
+        iManufacturer = new->iManufacturer;
+        iProduct = new->iProduct;
+
+        *new = *old;
+        if (idVendor)
+                new->idVendor = idVendor;
+        if (idProduct)
+                new->idProduct = idProduct;
+        if (bcdDevice)
+                new->bcdDevice = bcdDevice;
+        else
+                new->bcdDevice = cpu_to_le16(get_default_bcdDevice());
+        if (iSerialNumber)
+                new->iSerialNumber = iSerialNumber;
+        if (iManufacturer)
+                new->iManufacturer = iManufacturer;
+        if (iProduct)
+                new->iProduct = iProduct;
 }
 
-static int composite_bind(struct usb_gadget *gadget)
+static struct usb_composite_driver *to_cdriver(struct usb_gadget_driver *gdrv)
+{
+        return container_of(gdrv, struct usb_composite_driver, gadget_driver);
+}
+
+static int composite_bind(struct usb_gadget *gadget,
+                struct usb_gadget_driver *gdriver)
 {
         struct usb_composite_dev        *cdev;
+        struct usb_composite_driver     *composite = to_cdriver(gdriver);
         int                             status = -ENOMEM;
 
         cdev = kzalloc(sizeof *cdev, GFP_KERNEL);
@@ -1440,13 +1424,12 @@ static int composite_bind(struct usb_gadget *gadget)
         cdev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
         if (!cdev->req)
                 goto fail;
-        cdev->req->buf = kmalloc(USB_BUFSIZ, GFP_KERNEL);
+        cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
         if (!cdev->req->buf)
                 goto fail;
         cdev->req->complete = composite_setup_complete;
         gadget->ep0->driver_data = cdev;
 
-        cdev->bufsiz = USB_BUFSIZ;
         cdev->driver = composite;
 
         /*
@@ -1467,49 +1450,11 @@ static int composite_bind(struct usb_gadget *gadget)
          * serial number), register function drivers, potentially update
          * power state and consumption, etc
          */
-        status = composite_gadget_bind(cdev);
+        status = composite->bind(cdev);
         if (status < 0)
                 goto fail;
 
-        cdev->desc = *composite->dev;
-
-        /* standardized runtime overrides for device ID data */
-        if (idVendor)
-                cdev->desc.idVendor = cpu_to_le16(idVendor);
-        else
-                idVendor = le16_to_cpu(cdev->desc.idVendor);
-        if (idProduct)
-                cdev->desc.idProduct = cpu_to_le16(idProduct);
-        else
-                idProduct = le16_to_cpu(cdev->desc.idProduct);
-        if (bcdDevice)
-                cdev->desc.bcdDevice = cpu_to_le16(bcdDevice);
-        else
-                bcdDevice = le16_to_cpu(cdev->desc.bcdDevice);
-
-        /* string overrides */
-        if (iManufacturer || !cdev->desc.iManufacturer) {
-                if (!iManufacturer && !composite->iManufacturer &&
-                    !*composite_manufacturer)
-                        snprintf(composite_manufacturer,
-                                 sizeof composite_manufacturer,
-                                 "%s %s with %s",
-                                 init_utsname()->sysname,
-                                 init_utsname()->release,
-                                 gadget->name);
-
-                cdev->manufacturer_override =
-                        override_id(cdev, &cdev->desc.iManufacturer);
-        }
-
-        if (iProduct || (!cdev->desc.iProduct && composite->iProduct))
-                cdev->product_override =
-                        override_id(cdev, &cdev->desc.iProduct);
-
-        if (iSerialNumber ||
-            (!cdev->desc.iSerialNumber && composite->iSerialNumber))
-                cdev->serial_override =
-                        override_id(cdev, &cdev->desc.iSerialNumber);
+        update_unchanged_dev_desc(&cdev->desc, composite->dev);
 
         /* has userspace failed to provide a serial number? */
         if (composite->needs_serial && !cdev->desc.iSerialNumber)
@@ -1546,8 +1491,8 @@ composite_suspend(struct usb_gadget *gadget)
                                 f->suspend(f);
                 }
         }
-        if (composite->suspend)
-                composite->suspend(cdev);
+        if (cdev->driver->suspend)
+                cdev->driver->suspend(cdev);
 
         cdev->suspended = 1;
 
@@ -1565,8 +1510,8 @@ composite_resume(struct usb_gadget *gadget)
          * suspend/resume callbacks?
          */
         DBG(cdev, "resume\n");
-        if (composite->resume)
-                composite->resume(cdev);
+        if (cdev->driver->resume)
+                cdev->driver->resume(cdev);
         if (cdev->config) {
                 list_for_each_entry(f, &cdev->config->functions, list) {
                         if (f->resume)
@@ -1584,13 +1529,8 @@ composite_resume(struct usb_gadget *gadget)
 
 /*-------------------------------------------------------------------------*/
 
-static struct usb_gadget_driver composite_driver = {
-#ifdef CONFIG_USB_GADGET_SUPERSPEED
-        .max_speed      = USB_SPEED_SUPER,
-#else
-        .max_speed      = USB_SPEED_HIGH,
-#endif
-
+static const struct usb_gadget_driver composite_driver_template = {
+        .bind           = composite_bind,
         .unbind         = composite_unbind,
 
         .setup          = composite_setup,
@@ -1623,25 +1563,26 @@ static struct usb_gadget_driver composite_driver = {
  * while it was binding.  That would usually be done in order to wait for
  * some userspace participation.
  */
-int usb_composite_probe(struct usb_composite_driver *driver,
-                               int (*bind)(struct usb_composite_dev *cdev))
+int usb_composite_probe(struct usb_composite_driver *driver)
 {
-        if (!driver || !driver->dev || !bind || composite)
+        struct usb_gadget_driver *gadget_driver;
+
+        if (!driver || !driver->dev || !driver->bind)
                 return -EINVAL;
 
         if (!driver->name)
                 driver->name = "composite";
-        if (!driver->iProduct)
-                driver->iProduct = driver->name;
-        composite_driver.function =  (char *) driver->name;
-        composite_driver.driver.name = driver->name;
-        composite_driver.max_speed =
-                min_t(u8, composite_driver.max_speed, driver->max_speed);
-        composite = driver;
-        composite_gadget_bind = bind;
-
-        return usb_gadget_probe_driver(&composite_driver, composite_bind);
+
+        driver->gadget_driver = composite_driver_template;
+        gadget_driver = &driver->gadget_driver;
+
+        gadget_driver->function =  (char *) driver->name;
+        gadget_driver->driver.name = driver->name;
+        gadget_driver->max_speed = driver->max_speed;
+
+        return usb_gadget_probe_driver(gadget_driver);
 }
+EXPORT_SYMBOL_GPL(usb_composite_probe);
 
 /**
  * usb_composite_unregister() - unregister a composite driver
@@ -1652,10 +1593,9 @@ int usb_composite_probe(struct usb_composite_driver *driver,
  */
 void usb_composite_unregister(struct usb_composite_driver *driver)
 {
-        if (composite != driver)
-                return;
-        usb_gadget_unregister_driver(&composite_driver);
+        usb_gadget_unregister_driver(&driver->gadget_driver);
 }
+EXPORT_SYMBOL_GPL(usb_composite_unregister);
 
 /**
  * usb_composite_setup_continue() - Continue with the control transfer
@@ -1692,4 +1632,60 @@ void usb_composite_setup_continue(struct usb_composite_dev *cdev)
 
         spin_unlock_irqrestore(&cdev->lock, flags);
 }
+EXPORT_SYMBOL_GPL(usb_composite_setup_continue);
+
+static char *composite_default_mfr(struct usb_gadget *gadget)
+{
+        char *mfr;
+        int len;
+
+        len = snprintf(NULL, 0, "%s %s with %s", init_utsname()->sysname,
+                        init_utsname()->release, gadget->name);
+        len++;
+        mfr = kmalloc(len, GFP_KERNEL);
+        if (!mfr)
+                return NULL;
+        snprintf(mfr, len, "%s %s with %s", init_utsname()->sysname,
+                        init_utsname()->release, gadget->name);
+        return mfr;
+}
+
+void usb_composite_overwrite_options(struct usb_composite_dev *cdev,
+                struct usb_composite_overwrite *covr)
+{
+        struct usb_device_descriptor    *desc = &cdev->desc;
+        struct usb_gadget_strings       *gstr = cdev->driver->strings[0];
+        struct usb_string               *dev_str = gstr->strings;
+
+        if (covr->idVendor)
+                desc->idVendor = cpu_to_le16(covr->idVendor);
+
+        if (covr->idProduct)
+                desc->idProduct = cpu_to_le16(covr->idProduct);
+
+        if (covr->bcdDevice)
+                desc->bcdDevice = cpu_to_le16(covr->bcdDevice);
+
+        if (covr->serial_number) {
+                desc->iSerialNumber = dev_str[USB_GADGET_SERIAL_IDX].id;
+                dev_str[USB_GADGET_SERIAL_IDX].s = covr->serial_number;
+        }
+        if (covr->manufacturer) {
+                desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
+                dev_str[USB_GADGET_MANUFACTURER_IDX].s = covr->manufacturer;
+
+        } else if (!strlen(dev_str[USB_GADGET_MANUFACTURER_IDX].s)) {
+                desc->iManufacturer = dev_str[USB_GADGET_MANUFACTURER_IDX].id;
+                cdev->def_manufacturer = composite_default_mfr(cdev->gadget);
+                dev_str[USB_GADGET_MANUFACTURER_IDX].s = cdev->def_manufacturer;
+        }
+
+        if (covr->product) {
+                desc->iProduct = dev_str[USB_GADGET_PRODUCT_IDX].id;
+                dev_str[USB_GADGET_PRODUCT_IDX].s = covr->product;
+        }
+}
+EXPORT_SYMBOL_GPL(usb_composite_overwrite_options);
 
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("David Brownell");
diff --git a/drivers/usb/gadget/config.c b/drivers/usb/gadget/config.c
index 7542a72ce51a..e3a98929d346 100644
--- a/drivers/usb/gadget/config.c
+++ b/drivers/usb/gadget/config.c
@@ -12,6 +12,7 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/list.h>
 #include <linux/string.h>
 #include <linux/device.h>
@@ -53,7 +54,7 @@ usb_descriptor_fillbuf(void *buf, unsigned buflen,
         }
         return dest - (u8 *)buf;
 }
-
+EXPORT_SYMBOL_GPL(usb_descriptor_fillbuf);
 
 /**
  * usb_gadget_config_buf - builts a complete configuration descriptor
@@ -106,6 +107,7 @@ int usb_gadget_config_buf(
         cp->bmAttributes |= USB_CONFIG_ATT_ONE;
         return len;
 }
+EXPORT_SYMBOL_GPL(usb_gadget_config_buf);
 
 /**
  * usb_copy_descriptors - copy a vector of USB descriptors
@@ -155,4 +157,4 @@ usb_copy_descriptors(struct usb_descriptor_header **src)
 
         return ret;
 }
-
+EXPORT_SYMBOL_GPL(usb_copy_descriptors);
diff --git a/drivers/usb/gadget/dbgp.c b/drivers/usb/gadget/dbgp.c
index 19d7bb0df75a..87d165028162 100644
--- a/drivers/usb/gadget/dbgp.c
+++ b/drivers/usb/gadget/dbgp.c
@@ -13,9 +13,6 @@
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
-/* See comments in "zero.c" */
-#include "epautoconf.c"
-
 #ifdef CONFIG_USB_G_DBGP_SERIAL
 #include "u_serial.c"
 #endif
@@ -292,7 +289,8 @@ fail_1:
         return -ENODEV;
 }
 
-static int __init dbgp_bind(struct usb_gadget *gadget)
+static int __init dbgp_bind(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
 {
         int err, stp;
 
@@ -402,9 +400,10 @@ fail:
         return err;
 }
 
-static struct usb_gadget_driver dbgp_driver = {
+static __refdata struct usb_gadget_driver dbgp_driver = {
         .function = "dbgp",
         .max_speed = USB_SPEED_HIGH,
+        .bind = dbgp_bind,
         .unbind = dbgp_unbind,
         .setup = dbgp_setup,
         .disconnect = dbgp_disconnect,
@@ -416,7 +415,7 @@ static struct usb_gadget_driver dbgp_driver = {
 
 static int __init dbgp_init(void)
 {
-        return usb_gadget_probe_driver(&dbgp_driver, dbgp_bind);
+        return usb_gadget_probe_driver(&dbgp_driver);
 }
 
 static void __exit dbgp_exit(void)
diff --git a/drivers/usb/gadget/dummy_hcd.c b/drivers/usb/gadget/dummy_hcd.c
index afdbb1cbf5d9..0f7541be28f3 100644
--- a/drivers/usb/gadget/dummy_hcd.c
+++ b/drivers/usb/gadget/dummy_hcd.c
@@ -909,6 +909,7 @@ static int dummy_udc_start(struct usb_gadget *g,
         dum->devstatus = 0;
 
         dum->driver = driver;
+        dum->gadget.dev.driver = &driver->driver;
         dev_dbg(udc_dev(dum), "binding gadget driver '%s'\n",
                         driver->driver.name);
         return 0;
@@ -923,6 +924,7 @@ static int dummy_udc_stop(struct usb_gadget *g,
         dev_dbg(udc_dev(dum), "unregister gadget driver '%s'\n",
                         driver->driver.name);
 
+        dum->gadget.dev.driver = NULL;
         dum->driver = NULL;
 
         return 0;
diff --git a/drivers/usb/gadget/epautoconf.c b/drivers/usb/gadget/epautoconf.c
index 51f3d42f5a64..a777f7bd11b4 100644
--- a/drivers/usb/gadget/epautoconf.c
+++ b/drivers/usb/gadget/epautoconf.c
@@ -10,6 +10,7 @@
  */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/device.h>
@@ -22,17 +23,6 @@
 
 #include "gadget_chips.h"
 
-
-/* we must assign addresses for configurable endpoints (like net2280) */
-static unsigned epnum;
-
-// #define MANY_ENDPOINTS
-#ifdef MANY_ENDPOINTS
-/* more than 15 configurable endpoints */
-static unsigned in_epnum;
-#endif
-
-
 /*
  * This should work with endpoints from controller drivers sharing the
  * same endpoint naming convention.  By example:
@@ -176,16 +166,14 @@ ep_matches (
         if (isdigit (ep->name [2])) {
                 u8      num = simple_strtoul (&ep->name [2], NULL, 10);
                 desc->bEndpointAddress |= num;
-#ifdef  MANY_ENDPOINTS
         } else if (desc->bEndpointAddress & USB_DIR_IN) {
-                if (++in_epnum > 15)
+                if (++gadget->in_epnum > 15)
                         return 0;
-                desc->bEndpointAddress = USB_DIR_IN | in_epnum;
-#endif
+                desc->bEndpointAddress = USB_DIR_IN | gadget->in_epnum;
         } else {
-                if (++epnum > 15)
+                if (++gadget->out_epnum > 15)
                         return 0;
-                desc->bEndpointAddress |= epnum;
+                desc->bEndpointAddress |= gadget->out_epnum;
         }
 
         /* report (variable) full speed bulk maxpacket */
@@ -328,6 +316,7 @@ found_ep:
         ep->comp_desc = NULL;
         return ep;
 }
+EXPORT_SYMBOL_GPL(usb_ep_autoconfig_ss);
 
 /**
  * usb_ep_autoconfig() - choose an endpoint matching the
@@ -367,7 +356,7 @@ struct usb_ep *usb_ep_autoconfig(
 {
         return usb_ep_autoconfig_ss(gadget, desc, NULL);
 }
-
+EXPORT_SYMBOL_GPL(usb_ep_autoconfig);
 
 /**
  * usb_ep_autoconfig_reset - reset endpoint autoconfig state
@@ -385,9 +374,7 @@ void usb_ep_autoconfig_reset (struct usb_gadget *gadget)
         list_for_each_entry (ep, &gadget->ep_list, ep_list) {
                 ep->driver_data = NULL;
         }
-#ifdef  MANY_ENDPOINTS
-        in_epnum = 0;
-#endif
-        epnum = 0;
+        gadget->in_epnum = 0;
+        gadget->out_epnum = 0;
 }
-
+EXPORT_SYMBOL_GPL(usb_ep_autoconfig_reset);
diff --git a/drivers/usb/gadget/ether.c b/drivers/usb/gadget/ether.c
index a28f6ffcd0f3..18c3f423706e 100644
--- a/drivers/usb/gadget/ether.c
+++ b/drivers/usb/gadget/ether.c
@@ -14,8 +14,6 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
-
 
 #if defined USB_ETH_RNDIS
 #  undef USB_ETH_RNDIS
@@ -102,11 +100,6 @@ static inline bool has_rndis(void)
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_ecm.c"
 #include "f_subset.c"
 #ifdef  USB_ETH_RNDIS
@@ -117,6 +110,7 @@ static inline bool has_rndis(void)
 #include "u_ether.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 /* DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
  * Instead:  allocate your own, using normal USB-IF procedures.
@@ -195,17 +189,10 @@ static const struct usb_descriptor_header *otg_desc[] = {
         NULL,
 };
 
-
-/* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = PREFIX DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = PREFIX DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -288,7 +275,6 @@ static struct usb_configuration eth_config_driver = {
 
 static int __init eth_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
 
@@ -323,42 +309,15 @@ static int __init eth_bind(struct usb_composite_dev *cdev)
                 device_desc.bNumConfigurations = 2;
         }
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        else {
-                /* We assume that can_support_ecm() tells the truth;
-                 * but if the controller isn't recognized at all then
-                 * that assumption is a bit more likely to be wrong.
-                 */
-                dev_warn(&gadget->dev,
-                                "controller '%s' not recognized; trying %s\n",
-                                gadget->name,
-                                eth_config_driver.label);
-                device_desc.bcdDevice =
-                        cpu_to_le16(0x0300 | 0x0099);
-        }
-
-
         /* Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
 
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register our configuration(s); RNDIS first, if it's used */
         if (has_rndis()) {
@@ -372,6 +331,7 @@ static int __init eth_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 goto fail;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s, version: " DRIVER_VERSION "\n",
                         DRIVER_DESC);
 
@@ -388,11 +348,12 @@ static int __exit eth_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver eth_driver = {
+static __refdata struct usb_composite_driver eth_driver = {
         .name           = "g_ether",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_SUPER,
+        .bind           = eth_bind,
         .unbind         = __exit_p(eth_unbind),
 };
 
@@ -402,7 +363,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_probe(&eth_driver, eth_bind);
+        return usb_composite_probe(&eth_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/f_ecm.c b/drivers/usb/gadget/f_ecm.c
index 30b908f2a53d..95bc94f8e570 100644
--- a/drivers/usb/gadget/f_ecm.c
+++ b/drivers/usb/gadget/f_ecm.c
@@ -897,10 +897,7 @@ ecm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
                 return -ENOMEM;
 
         /* export host's Ethernet address in CDC format */
-        snprintf(ecm->ethaddr, sizeof ecm->ethaddr,
-                "%02X%02X%02X%02X%02X%02X",
-                ethaddr[0], ethaddr[1], ethaddr[2],
-                ethaddr[3], ethaddr[4], ethaddr[5]);
+        snprintf(ecm->ethaddr, sizeof ecm->ethaddr, "%pm", ethaddr);
         ecm_string_defs[1].s = ecm->ethaddr;
 
         ecm->port.cdc_filter = DEFAULT_FILTER;
diff --git a/drivers/usb/gadget/f_hid.c b/drivers/usb/gadget/f_hid.c
index 16a8b1c15c62..511e527178e2 100644
--- a/drivers/usb/gadget/f_hid.c
+++ b/drivers/usb/gadget/f_hid.c
@@ -10,7 +10,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/module.h>
 #include <linux/hid.h>
 #include <linux/cdev.h>
@@ -18,6 +17,7 @@
 #include <linux/poll.h>
 #include <linux/uaccess.h>
 #include <linux/wait.h>
+#include <linux/sched.h>
 #include <linux/usb/g_hid.h>
 
 static int major, minors;
diff --git a/drivers/usb/gadget/f_mass_storage.c b/drivers/usb/gadget/f_mass_storage.c
index 4f1142efa6d1..3a7668bde3ef 100644
--- a/drivers/usb/gadget/f_mass_storage.c
+++ b/drivers/usb/gadget/f_mass_storage.c
@@ -213,7 +213,6 @@
 #include <linux/spinlock.h>
 #include <linux/string.h>
 #include <linux/freezer.h>
-#include <linux/utsname.h>
 
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
@@ -349,7 +348,6 @@ struct fsg_config {
 
         const char *vendor_name;                /*  8 characters or less */
         const char *product_name;               /* 16 characters or less */
-        u16 release;
 
         char                    can_stall;
 };
@@ -2773,18 +2771,7 @@ buffhds_first_it:
         bh->next = common->buffhds;
 
         /* Prepare inquiryString */
-        if (cfg->release != 0xffff) {
-                i = cfg->release;
-        } else {
-                i = usb_gadget_controller_number(gadget);
-                if (i >= 0) {
-                        i = 0x0300 + i;
-                } else {
-                        WARNING(common, "controller '%s' not recognized\n",
-                                gadget->name);
-                        i = 0x0399;
-                }
-        }
+        i = get_default_bcdDevice();
         snprintf(common->inquiry_string, sizeof common->inquiry_string,
                  "%-8s%-16s%04x", cfg->vendor_name ?: "Linux",
                  /* Assume product name dependent on the first LUN */
@@ -3110,7 +3097,6 @@ fsg_config_from_params(struct fsg_config *cfg,
         /* Let MSF use defaults */
         cfg->vendor_name = 0;
         cfg->product_name = 0;
-        cfg->release = 0xffff;
 
         cfg->ops = NULL;
         cfg->private_data = NULL;
diff --git a/drivers/usb/gadget/f_midi.c b/drivers/usb/gadget/f_midi.c
index 2f7e8f2930cc..8ed1259fe80d 100644
--- a/drivers/usb/gadget/f_midi.c
+++ b/drivers/usb/gadget/f_midi.c
@@ -21,7 +21,6 @@
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/utsname.h>
 #include <linux/device.h>
 
 #include <sound/core.h>
diff --git a/drivers/usb/gadget/f_ncm.c b/drivers/usb/gadget/f_ncm.c
index aab8eded045b..b651b529c67f 100644
--- a/drivers/usb/gadget/f_ncm.c
+++ b/drivers/usb/gadget/f_ncm.c
@@ -1346,10 +1346,7 @@ int __init ncm_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
                 return -ENOMEM;
 
         /* export host's Ethernet address in CDC format */
-        snprintf(ncm->ethaddr, sizeof ncm->ethaddr,
-                "%02X%02X%02X%02X%02X%02X",
-                ethaddr[0], ethaddr[1], ethaddr[2],
-                ethaddr[3], ethaddr[4], ethaddr[5]);
+        snprintf(ncm->ethaddr, sizeof ncm->ethaddr, "%pm", ethaddr);
         ncm_string_defs[1].s = ncm->ethaddr;
 
         spin_lock_init(&ncm->lock);
diff --git a/drivers/usb/gadget/f_sourcesink.c b/drivers/usb/gadget/f_sourcesink.c
index 5c1b68b63c98..3c126fde6e7e 100644
--- a/drivers/usb/gadget/f_sourcesink.c
+++ b/drivers/usb/gadget/f_sourcesink.c
@@ -795,7 +795,7 @@ static int sourcesink_setup(struct usb_configuration *c,
         u16                     w_value = le16_to_cpu(ctrl->wValue);
         u16                     w_length = le16_to_cpu(ctrl->wLength);
 
-        req->length = USB_BUFSIZ;
+        req->length = USB_COMP_EP0_BUFSIZ;
 
         /* composite driver infrastructure handles everything except
          * the two control test requests.
diff --git a/drivers/usb/gadget/f_subset.c b/drivers/usb/gadget/f_subset.c
index 21ab474aca07..4060c0bd9785 100644
--- a/drivers/usb/gadget/f_subset.c
+++ b/drivers/usb/gadget/f_subset.c
@@ -436,10 +436,7 @@ int geth_bind_config(struct usb_configuration *c, u8 ethaddr[ETH_ALEN])
                 return -ENOMEM;
 
         /* export host's Ethernet address in CDC format */
-        snprintf(geth->ethaddr, sizeof geth->ethaddr,
-                "%02X%02X%02X%02X%02X%02X",
-                ethaddr[0], ethaddr[1], ethaddr[2],
-                ethaddr[3], ethaddr[4], ethaddr[5]);
+        snprintf(geth->ethaddr, sizeof geth->ethaddr, "%pm", ethaddr);
         geth_string_defs[1].s = geth->ethaddr;
 
         geth->port.cdc_filter = DEFAULT_FILTER;
diff --git a/drivers/usb/gadget/f_uac2.c b/drivers/usb/gadget/f_uac2.c
index e7cc4de93e33..d3c6cffccb72 100644
--- a/drivers/usb/gadget/f_uac2.c
+++ b/drivers/usb/gadget/f_uac2.c
@@ -463,7 +463,7 @@ snd_fail:
         return err;
 }
 
-static int __devexit snd_uac2_remove(struct platform_device *pdev)
+static int snd_uac2_remove(struct platform_device *pdev)
 {
         struct snd_card *card = platform_get_drvdata(pdev);
 
diff --git a/drivers/usb/gadget/file_storage.c b/drivers/usb/gadget/file_storage.c
index a896d73f7a93..3f7d640b6758 100644
--- a/drivers/usb/gadget/file_storage.c
+++ b/drivers/usb/gadget/file_storage.c
@@ -251,26 +251,12 @@
 #include <linux/freezer.h>
 #include <linux/utsname.h>
 
+#include <linux/usb/composite.h>
 #include <linux/usb/ch9.h>
 #include <linux/usb/gadget.h>
 
 #include "gadget_chips.h"
 
-
-
-/*
- * Kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
- */
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
-/*-------------------------------------------------------------------------*/
-
 #define DRIVER_DESC             "File-backed Storage Gadget"
 #define DRIVER_NAME             "g_file_storage"
 #define DRIVER_VERSION          "1 September 2010"
@@ -3213,7 +3199,6 @@ static void /* __init_or_exit */ fsg_unbind(struct usb_gadget *gadget)
 static int __init check_parameters(struct fsg_dev *fsg)
 {
         int     prot;
-        int     gcnum;
 
         /* Store the default values */
         mod_data.transport_type = USB_PR_BULK;
@@ -3228,16 +3213,8 @@ static int __init check_parameters(struct fsg_dev *fsg)
         if (gadget_is_at91(fsg->gadget))
                 mod_data.can_stall = 0;
 
-        if (mod_data.release == 0xffff) {       // Parameter wasn't set
-                gcnum = usb_gadget_controller_number(fsg->gadget);
-                if (gcnum >= 0)
-                        mod_data.release = 0x0300 + gcnum;
-                else {
-                        WARNING(fsg, "controller '%s' not recognized\n",
-                                fsg->gadget->name);
-                        mod_data.release = 0x0399;
-                }
-        }
+        if (mod_data.release == 0xffff)
+                mod_data.release = get_default_bcdDevice();
 
         prot = simple_strtol(mod_data.protocol_parm, NULL, 0);
 
@@ -3331,7 +3308,8 @@ static int __init check_parameters(struct fsg_dev *fsg)
 }
 
 
-static int __init fsg_bind(struct usb_gadget *gadget)
+static int __init fsg_bind(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
 {
         struct fsg_dev          *fsg = the_fsg;
         int                     rc;
@@ -3603,9 +3581,10 @@ static void fsg_resume(struct usb_gadget *gadget)
 
 /*-------------------------------------------------------------------------*/
 
-static struct usb_gadget_driver         fsg_driver = {
+static __refdata struct usb_gadget_driver               fsg_driver = {
         .max_speed      = USB_SPEED_SUPER,
         .function       = (char *) fsg_string_product,
+        .bind           = fsg_bind,
         .unbind         = fsg_unbind,
         .disconnect     = fsg_disconnect,
         .setup          = fsg_setup,
@@ -3653,7 +3632,8 @@ static int __init fsg_init(void)
         if ((rc = fsg_alloc()) != 0)
                 return rc;
         fsg = the_fsg;
-        if ((rc = usb_gadget_probe_driver(&fsg_driver, fsg_bind)) != 0)
+        rc = usb_gadget_probe_driver(&fsg_driver);
+        if (rc != 0)
                 kref_put(&fsg->ref, fsg_release);
         return rc;
 }
diff --git a/drivers/usb/gadget/fsl_udc_core.c b/drivers/usb/gadget/fsl_udc_core.c
index 3def828f85e7..6ae70cba0c4a 100644
--- a/drivers/usb/gadget/fsl_udc_core.c
+++ b/drivers/usb/gadget/fsl_udc_core.c
@@ -1255,7 +1255,7 @@ static int fsl_pullup(struct usb_gadget *gadget, int is_on)
 }
 
 static int fsl_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int fsl_stop(struct usb_gadget_driver *driver);
 /* defined in gadget.h */
 static struct usb_gadget_ops fsl_gadget_ops = {
@@ -1951,7 +1951,7 @@ static irqreturn_t fsl_udc_irq(int irq, void *_udc)
  * Called by initialization code of gadget drivers
 *----------------------------------------------------------------*/
 static int fsl_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         int retval = -ENODEV;
         unsigned long flags = 0;
@@ -1976,7 +1976,7 @@ static int fsl_start(struct usb_gadget_driver *driver,
         spin_unlock_irqrestore(&udc_controller->lock, flags);
 
         /* bind udc driver to gadget driver */
-        retval = bind(&udc_controller->gadget);
+        retval = bind(&udc_controller->gadget, driver);
         if (retval) {
                 VDBG("bind to %s --> %d", driver->driver.name, retval);
                 udc_controller->gadget.dev.driver = NULL;
diff --git a/drivers/usb/gadget/fusb300_udc.c b/drivers/usb/gadget/fusb300_udc.c
index cdd94540e1cd..72cd5e6719db 100644
--- a/drivers/usb/gadget/fusb300_udc.c
+++ b/drivers/usb/gadget/fusb300_udc.c
@@ -1311,7 +1311,7 @@ static void init_controller(struct fusb300 *fusb300)
 static struct fusb300 *the_controller;
 
 static int fusb300_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct fusb300 *fusb300 = the_controller;
         int retval;
@@ -1339,7 +1339,7 @@ static int fusb300_udc_start(struct usb_gadget_driver *driver,
                 goto error;
         }
 
-        retval = bind(&fusb300->gadget);
+        retval = bind(&fusb300->gadget, driver);
         if (retval) {
                 pr_err("bind to driver error (%d)\n", retval);
                 device_del(&fusb300->gadget.dev);
diff --git a/drivers/usb/gadget/g_ffs.c b/drivers/usb/gadget/g_ffs.c
index d3ace9002a6a..3953dd4d7186 100644
--- a/drivers/usb/gadget/g_ffs.c
+++ b/drivers/usb/gadget/g_ffs.c
@@ -13,7 +13,6 @@
 #define pr_fmt(fmt) "g_ffs: " fmt
 
 #include <linux/module.h>
-#include <linux/utsname.h>
 
 /*
  * kbuild is not very cooperative with respect to linking separately
@@ -22,12 +21,6 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #if defined CONFIG_USB_FUNCTIONFS_ETH || defined CONFIG_USB_FUNCTIONFS_RNDIS
 #  if defined USB_ETH_RNDIS
 #    undef USB_ETH_RNDIS
@@ -76,6 +69,8 @@ struct gfs_ffs_obj {
         struct ffs_data *ffs_data;
 };
 
+USB_GADGET_COMPOSITE_OPTIONS();
+
 static struct usb_device_descriptor gfs_dev_desc = {
         .bLength                = sizeof gfs_dev_desc,
         .bDescriptorType        = USB_DT_DEVICE,
@@ -117,6 +112,9 @@ static const struct usb_descriptor_header *gfs_otg_desc[] = {
 
 /* String IDs are assigned dynamically */
 static struct usb_string gfs_strings[] = {
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
 #ifdef CONFIG_USB_FUNCTIONFS_RNDIS
         { .s = "FunctionFS + RNDIS" },
 #endif
@@ -163,13 +161,13 @@ static int gfs_bind(struct usb_composite_dev *cdev);
 static int gfs_unbind(struct usb_composite_dev *cdev);
 static int gfs_do_config(struct usb_configuration *c);
 
-static struct usb_composite_driver gfs_driver = {
+static __refdata struct usb_composite_driver gfs_driver = {
         .name           = DRIVER_NAME,
         .dev            = &gfs_dev_desc,
         .strings        = gfs_dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = gfs_bind,
         .unbind         = gfs_unbind,
-        .iProduct       = DRIVER_DESC,
 };
 
 static DEFINE_MUTEX(gfs_lock);
@@ -268,7 +266,7 @@ static int functionfs_ready_callback(struct ffs_data *ffs)
         }
         gfs_registered = true;
 
-        ret = usb_composite_probe(&gfs_driver, gfs_bind);
+        ret = usb_composite_probe(&gfs_driver);
         if (unlikely(ret < 0))
                 gfs_registered = false;
 
@@ -357,6 +355,7 @@ static int gfs_bind(struct usb_composite_dev *cdev)
         ret = usb_string_ids_tab(cdev, gfs_strings);
         if (unlikely(ret < 0))
                 goto error;
+        gfs_dev_desc.iProduct = gfs_strings[USB_GADGET_PRODUCT_IDX].id;
 
         for (i = func_num; --i; ) {
                 ret = functionfs_bind(ffs_tab[i].ffs_data, cdev);
@@ -369,9 +368,10 @@ static int gfs_bind(struct usb_composite_dev *cdev)
 
         for (i = 0; i < ARRAY_SIZE(gfs_configurations); ++i) {
                 struct gfs_configuration *c = gfs_configurations + i;
+                int sid = USB_GADGET_FIRST_AVAIL_IDX + i;
 
-                c->c.label                      = gfs_strings[i].s;
-                c->c.iConfiguration             = gfs_strings[i].id;
+                c->c.label                      = gfs_strings[sid].s;
+                c->c.iConfiguration             = gfs_strings[sid].id;
                 c->c.bConfigurationValue        = 1 + i;
                 c->c.bmAttributes               = USB_CONFIG_ATT_SELFPOWER;
 
@@ -379,7 +379,7 @@ static int gfs_bind(struct usb_composite_dev *cdev)
                 if (unlikely(ret < 0))
                         goto error_unbind;
         }
-
+        usb_composite_overwrite_options(cdev, &coverwrite);
         return 0;
 
 error_unbind:
diff --git a/drivers/usb/gadget/gadget_chips.h b/drivers/usb/gadget/gadget_chips.h
index b8b3a3411218..bcd04bc66b98 100644
--- a/drivers/usb/gadget/gadget_chips.h
+++ b/drivers/usb/gadget/gadget_chips.h
@@ -15,6 +15,8 @@
 #ifndef __GADGET_CHIPS_H
 #define __GADGET_CHIPS_H
 
+#include <linux/usb/gadget.h>
+
 /*
  * NOTICE: the entries below are alphabetical and should be kept
  * that way.
@@ -25,106 +27,12 @@
  * If you have forgotten the alphabetical order let VIM/EMACS
  * do that for you.
  */
-#define gadget_is_amd5536udc(g)         (!strcmp("amd5536udc", (g)->name))
 #define gadget_is_at91(g)               (!strcmp("at91_udc", (g)->name))
-#define gadget_is_atmel_usba(g)         (!strcmp("atmel_usba_udc", (g)->name))
-#define gadget_is_ci13xxx_msm(g)        (!strcmp("ci13xxx_msm", (g)->name))
-#define gadget_is_ci13xxx_pci(g)        (!strcmp("ci13xxx_pci", (g)->name))
-#define gadget_is_dummy(g)              (!strcmp("dummy_udc", (g)->name))
-#define gadget_is_dwc3(g)               (!strcmp("dwc3-gadget", (g)->name))
-#define gadget_is_fsl_qe(g)             (!strcmp("fsl_qe_udc", (g)->name))
-#define gadget_is_fsl_usb2(g)           (!strcmp("fsl-usb2-udc", (g)->name))
 #define gadget_is_goku(g)               (!strcmp("goku_udc", (g)->name))
-#define gadget_is_imx(g)                (!strcmp("imx_udc", (g)->name))
-#define gadget_is_langwell(g)           (!strcmp("langwell_udc", (g)->name))
-#define gadget_is_lpc32xx(g)            (!strcmp("lpc32xx_udc", (g)->name))
-#define gadget_is_m66592(g)             (!strcmp("m66592_udc", (g)->name))
 #define gadget_is_musbhdrc(g)           (!strcmp("musb-hdrc", (g)->name))
-#define gadget_is_net2272(g)            (!strcmp("net2272", (g)->name))
 #define gadget_is_net2280(g)            (!strcmp("net2280", (g)->name))
-#define gadget_is_omap(g)               (!strcmp("omap_udc", (g)->name))
-#define gadget_is_pch(g)                (!strcmp("pch_udc", (g)->name))
 #define gadget_is_pxa(g)                (!strcmp("pxa25x_udc", (g)->name))
 #define gadget_is_pxa27x(g)             (!strcmp("pxa27x_udc", (g)->name))
-#define gadget_is_r8a66597(g)           (!strcmp("r8a66597_udc", (g)->name))
-#define gadget_is_renesas_usbhs(g)      (!strcmp("renesas_usbhs_udc", (g)->name))
-#define gadget_is_s3c2410(g)            (!strcmp("s3c2410_udc", (g)->name))
-#define gadget_is_s3c_hsotg(g)          (!strcmp("s3c-hsotg", (g)->name))
-#define gadget_is_s3c_hsudc(g)          (!strcmp("s3c-hsudc", (g)->name))
-
-/**
- * usb_gadget_controller_number - support bcdDevice id convention
- * @gadget: the controller being driven
- *
- * Return a 2-digit BCD value associated with the peripheral controller,
- * suitable for use as part of a bcdDevice value, or a negative error code.
- *
- * NOTE:  this convention is purely optional, and has no meaning in terms of
- * any USB specification.  If you want to use a different convention in your
- * gadget driver firmware -- maybe a more formal revision ID -- feel free.
- *
- * Hosts see these bcdDevice numbers, and are allowed (but not encouraged!)
- * to change their behavior accordingly.  For example it might help avoiding
- * some chip bug.
- */
-static inline int usb_gadget_controller_number(struct usb_gadget *gadget)
-{
-        if (gadget_is_net2280(gadget))
-                return 0x01;
-        else if (gadget_is_dummy(gadget))
-                return 0x02;
-        else if (gadget_is_pxa(gadget))
-                return 0x03;
-        else if (gadget_is_goku(gadget))
-                return 0x06;
-        else if (gadget_is_omap(gadget))
-                return 0x08;
-        else if (gadget_is_pxa27x(gadget))
-                return 0x11;
-        else if (gadget_is_s3c2410(gadget))
-                return 0x12;
-        else if (gadget_is_at91(gadget))
-                return 0x13;
-        else if (gadget_is_imx(gadget))
-                return 0x14;
-        else if (gadget_is_musbhdrc(gadget))
-                return 0x16;
-        else if (gadget_is_atmel_usba(gadget))
-                return 0x18;
-        else if (gadget_is_fsl_usb2(gadget))
-                return 0x19;
-        else if (gadget_is_amd5536udc(gadget))
-                return 0x20;
-        else if (gadget_is_m66592(gadget))
-                return 0x21;
-        else if (gadget_is_fsl_qe(gadget))
-                return 0x22;
-        else if (gadget_is_ci13xxx_pci(gadget))
-                return 0x23;
-        else if (gadget_is_langwell(gadget))
-                return 0x24;
-        else if (gadget_is_r8a66597(gadget))
-                return 0x25;
-        else if (gadget_is_s3c_hsotg(gadget))
-                return 0x26;
-        else if (gadget_is_pch(gadget))
-                return 0x27;
-        else if (gadget_is_ci13xxx_msm(gadget))
-                return 0x28;
-        else if (gadget_is_renesas_usbhs(gadget))
-                return 0x29;
-        else if (gadget_is_s3c_hsudc(gadget))
-                return 0x30;
-        else if (gadget_is_net2272(gadget))
-                return 0x31;
-        else if (gadget_is_dwc3(gadget))
-                return 0x32;
-        else if (gadget_is_lpc32xx(gadget))
-                return 0x33;
-
-        return -ENOENT;
-}
-
 
 /**
  * gadget_supports_altsettings - return true if altsettings work
diff --git a/drivers/usb/gadget/gmidi.c b/drivers/usb/gadget/gmidi.c
index 681bd038b1d8..881aab86ae99 100644
--- a/drivers/usb/gadget/gmidi.c
+++ b/drivers/usb/gadget/gmidi.c
@@ -22,7 +22,6 @@
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/utsname.h>
 #include <linux/module.h>
 #include <linux/device.h>
 
@@ -31,16 +30,13 @@
 #include <sound/rawmidi.h>
 
 #include <linux/usb/ch9.h>
+#include <linux/usb/composite.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/audio.h>
 #include <linux/usb/midi.h>
 
 #include "gadget_chips.h"
 
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
 #include "f_midi.c"
 
 /*-------------------------------------------------------------------------*/
@@ -51,6 +47,8 @@ MODULE_LICENSE("GPL v2");
 static const char shortname[] = "g_midi";
 static const char longname[] = "MIDI Gadget";
 
+USB_GADGET_COMPOSITE_OPTIONS();
+
 static int index = SNDRV_DEFAULT_IDX1;
 module_param(index, int, S_IRUGO);
 MODULE_PARM_DESC(index, "Index value for the USB MIDI Gadget adapter.");
@@ -85,9 +83,7 @@ MODULE_PARM_DESC(out_ports, "Number of MIDI output ports");
 
 /* string IDs are assigned dynamically */
 
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_DESCRIPTION_IDX          2
+#define STRING_DESCRIPTION_IDX          USB_GADGET_FIRST_AVAIL_IDX
 
 static struct usb_device_descriptor device_desc = {
         .bLength =              USB_DT_DEVICE_SIZE,
@@ -102,8 +98,9 @@ static struct usb_device_descriptor device_desc = {
 };
 
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s     = "Grey Innovation",
-        [STRING_PRODUCT_IDX].s          = "MIDI Gadget",
+        [USB_GADGET_MANUFACTURER_IDX].s = "Grey Innovation",
+        [USB_GADGET_PRODUCT_IDX].s      = "MIDI Gadget",
+        [USB_GADGET_SERIAL_IDX].s       = "",
         [STRING_DESCRIPTION_IDX].s      = "MIDI",
         {  } /* end of list */
 };
@@ -140,61 +137,35 @@ static int __init midi_bind_config(struct usb_configuration *c)
 
 static int __init midi_bind(struct usb_composite_dev *cdev)
 {
-        struct usb_gadget *gadget = cdev->gadget;
-        int gcnum, status;
-
-        status = usb_string_id(cdev);
-        if (status < 0)
-                return status;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
+        int status;
 
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 return status;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
-
-        /* config description */
-        status = usb_string_id(cdev);
-        if (status < 0)
-                return status;
-        strings_dev[STRING_DESCRIPTION_IDX].id = status;
-
-        midi_config.iConfiguration = status;
-
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum < 0) {
-                /* gmidi is so simple (no altsettings) that
-                 * it SHOULD NOT have problems with bulk-capable hardware.
-                 * so warn about unrecognized controllers, don't panic.
-                 */
-                pr_warning("%s: controller '%s' not recognized\n",
-                           __func__, gadget->name);
-                device_desc.bcdDevice = cpu_to_le16(0x9999);
-        } else {
-                device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
-        }
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
+        midi_config.iConfiguration = strings_dev[STRING_DESCRIPTION_IDX].id;
 
         status = usb_add_config(cdev, &midi_config, midi_bind_config);
         if (status < 0)
                 return status;
-
+        usb_composite_overwrite_options(cdev, &coverwrite);
         pr_info("%s\n", longname);
         return 0;
 }
 
-static struct usb_composite_driver midi_driver = {
+static __refdata struct usb_composite_driver midi_driver = {
         .name           = (char *) longname,
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = midi_bind,
         .unbind         = __exit_p(midi_unbind),
 };
 
 static int __init midi_init(void)
 {
-        return usb_composite_probe(&midi_driver, midi_bind);
+        return usb_composite_probe(&midi_driver);
 }
 module_init(midi_init);
 
diff --git a/drivers/usb/gadget/goku_udc.c b/drivers/usb/gadget/goku_udc.c
index 9fd7886cfa9a..51037cb78604 100644
--- a/drivers/usb/gadget/goku_udc.c
+++ b/drivers/usb/gadget/goku_udc.c
@@ -994,7 +994,7 @@ static int goku_get_frame(struct usb_gadget *_gadget)
 }
 
 static int goku_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int goku_stop(struct usb_gadget_driver *driver);
 
 static const struct usb_gadget_ops goku_ops = {
@@ -1348,7 +1348,7 @@ static struct goku_udc	*the_controller;
  * the driver might get unbound.
  */
 static int goku_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct goku_udc *dev = the_controller;
         int                     retval;
@@ -1368,7 +1368,7 @@ static int goku_start(struct usb_gadget_driver *driver,
         driver->driver.bus = NULL;
         dev->driver = driver;
         dev->gadget.dev.driver = &driver->driver;
-        retval = bind(&dev->gadget);
+        retval = bind(&dev->gadget, driver);
         if (retval) {
                 DBG(dev, "bind to driver %s --> error %d\n",
                                 driver->driver.name, retval);
diff --git a/drivers/usb/gadget/hid.c b/drivers/usb/gadget/hid.c
index 3493adf064f5..74130f6c12c0 100644
--- a/drivers/usb/gadget/hid.c
+++ b/drivers/usb/gadget/hid.c
@@ -15,7 +15,10 @@
 #include <linux/kernel.h>
 #include <linux/platform_device.h>
 #include <linux/list.h>
+#include <linux/module.h>
+#include <linux/usb/composite.h>
 
+#include "gadget_chips.h"
 #define DRIVER_DESC             "HID Gadget"
 #define DRIVER_VERSION          "2010/03/16"
 
@@ -33,12 +36,6 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_hid.c"
 
 
@@ -50,6 +47,7 @@ struct hidg_func_node {
 static LIST_HEAD(hidg_func_list);
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
@@ -92,15 +90,10 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 
 /* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -150,7 +143,7 @@ static int __init hid_bind(struct usb_composite_dev *cdev)
 {
         struct usb_gadget *gadget = cdev->gadget;
         struct list_head *tmp;
-        int status, gcnum, funcs = 0;
+        int status, funcs = 0;
 
         list_for_each(tmp, &hidg_func_list)
                 funcs++;
@@ -163,38 +156,22 @@ static int __init hid_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 return status;
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        else
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
-
-
         /* Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
 
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                return status;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 return status;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register our configuration */
         status = usb_add_config(cdev, &config_driver, do_config);
         if (status < 0)
                 return status;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, DRIVER_DESC ", version: " DRIVER_VERSION "\n");
 
         return 0;
@@ -242,11 +219,12 @@ static int __devexit hidg_plat_driver_remove(struct platform_device *pdev)
 /****************************** Some noise ******************************/
 
 
-static struct usb_composite_driver hidg_driver = {
+static __refdata struct usb_composite_driver hidg_driver = {
         .name           = "g_hid",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = hid_bind,
         .unbind         = __exit_p(hid_unbind),
 };
 
@@ -272,7 +250,7 @@ static int __init hidg_init(void)
         if (status < 0)
                 return status;
 
-        status = usb_composite_probe(&hidg_driver, hid_bind);
+        status = usb_composite_probe(&hidg_driver);
         if (status < 0)
                 platform_driver_unregister(&hidg_plat_driver);
 
diff --git a/drivers/usb/gadget/inode.c b/drivers/usb/gadget/inode.c
index e58b16442971..4bb6d53f2de3 100644
--- a/drivers/usb/gadget/inode.c
+++ b/drivers/usb/gadget/inode.c
@@ -828,7 +828,6 @@ ep_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
                 if (value == 0)
                         data->state = STATE_EP_ENABLED;
                 break;
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
         case USB_SPEED_HIGH:
                 /* fails if caller didn't provide that descriptor... */
                 ep->desc = &data->hs_desc;
@@ -836,7 +835,6 @@ ep_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
                 if (value == 0)
                         data->state = STATE_EP_ENABLED;
                 break;
-#endif
         default:
                 DBG(data->dev, "unconnected, %s init abandoned\n",
                                 data->name);
@@ -1324,7 +1322,6 @@ static const struct file_operations ep0_io_operations = {
  * Unrecognized ep0 requests may be handled in user space.
  */
 
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
 static void make_qualifier (struct dev_data *dev)
 {
         struct usb_qualifier_descriptor         qual;
@@ -1347,7 +1344,6 @@ static void make_qualifier (struct dev_data *dev)
 
         memcpy (dev->rbuf, &qual, sizeof qual);
 }
-#endif
 
 static int
 config_buf (struct dev_data *dev, u8 type, unsigned index)
@@ -1427,7 +1423,6 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         dev->dev->bMaxPacketSize0 = dev->gadget->ep0->maxpacket;
                         req->buf = dev->dev;
                         break;
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
                 case USB_DT_DEVICE_QUALIFIER:
                         if (!dev->hs_config)
                                 break;
@@ -1437,7 +1432,6 @@ gadgetfs_setup (struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
                         break;
                 case USB_DT_OTHER_SPEED_CONFIG:
                         // FALLTHROUGH
-#endif
                 case USB_DT_CONFIG:
                         value = config_buf (dev,
                                         w_value >> 8,
@@ -1685,8 +1679,8 @@ gadgetfs_unbind (struct usb_gadget *gadget)
 
 static struct dev_data          *the_device;
 
-static int
-gadgetfs_bind (struct usb_gadget *gadget)
+static int gadgetfs_bind(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
 {
         struct dev_data         *dev = the_device;
 
@@ -1763,12 +1757,8 @@ gadgetfs_suspend (struct usb_gadget *gadget)
 }
 
 static struct usb_gadget_driver gadgetfs_driver = {
-#ifdef  CONFIG_USB_GADGET_DUALSPEED
-        .max_speed      = USB_SPEED_HIGH,
-#else
-        .max_speed      = USB_SPEED_FULL,
-#endif
         .function       = (char *) driver_desc,
+        .bind           = gadgetfs_bind,
         .unbind         = gadgetfs_unbind,
         .setup          = gadgetfs_setup,
         .disconnect     = gadgetfs_disconnect,
@@ -1783,7 +1773,8 @@ static struct usb_gadget_driver gadgetfs_driver = {
 
 static void gadgetfs_nop(struct usb_gadget *arg) { }
 
-static int gadgetfs_probe (struct usb_gadget *gadget)
+static int gadgetfs_probe(struct usb_gadget *gadget,
+                struct usb_gadget_driver *driver)
 {
         CHIP = gadget->name;
         return -EISNAM;
@@ -1791,6 +1782,7 @@ static int gadgetfs_probe (struct usb_gadget *gadget)
 
 static struct usb_gadget_driver probe_driver = {
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = gadgetfs_probe,
         .unbind         = gadgetfs_nop,
         .setup          = (void *)gadgetfs_nop,
         .disconnect     = gadgetfs_nop,
@@ -1900,7 +1892,12 @@ dev_config (struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 
         /* triggers gadgetfs_bind(); then we can enumerate. */
         spin_unlock_irq (&dev->lock);
-        value = usb_gadget_probe_driver(&gadgetfs_driver, gadgetfs_bind);
+        if (dev->hs_config)
+                gadgetfs_driver.max_speed = USB_SPEED_HIGH;
+        else
+                gadgetfs_driver.max_speed = USB_SPEED_FULL;
+
+        value = usb_gadget_probe_driver(&gadgetfs_driver);
         if (value != 0) {
                 kfree (dev->buf);
                 dev->buf = NULL;
@@ -2039,7 +2036,7 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent)
                 return -ESRCH;
 
         /* fake probe to determine $CHIP */
-        (void) usb_gadget_probe_driver(&probe_driver, gadgetfs_probe);
+        usb_gadget_probe_driver(&probe_driver);
         if (!CHIP)
                 return -ENODEV;
 
diff --git a/drivers/usb/gadget/lpc32xx_udc.c b/drivers/usb/gadget/lpc32xx_udc.c
index f1ec99e69cb7..f696fb9b136d 100644
--- a/drivers/usb/gadget/lpc32xx_udc.c
+++ b/drivers/usb/gadget/lpc32xx_udc.c
@@ -141,8 +141,6 @@ struct lpc32xx_ep {
         u32                     totalints;
 
         bool                    wedge;
-
-        const struct usb_endpoint_descriptor *desc;
 };
 
 /*
@@ -556,10 +554,8 @@ static int proc_udc_show(struct seq_file *s, void *unused)
 
         if (udc->enabled && udc->vbus) {
                 proc_ep_show(s, &udc->ep[0]);
-                list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
-                        if (ep->desc)
-                                proc_ep_show(s, ep);
-                }
+                list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list)
+                        proc_ep_show(s, ep);
         }
 
         spin_unlock_irqrestore(&udc->lock, flags);
@@ -1453,7 +1449,6 @@ static void udc_reinit(struct lpc32xx_udc *udc)
 
                 if (i != 0)
                         list_add_tail(&ep->ep.ep_list, &udc->gadget.ep_list);
-                ep->desc = NULL;
                 ep->ep.maxpacket = ep->maxpacket;
                 INIT_LIST_HEAD(&ep->queue);
                 ep->req_pending = 0;
@@ -1515,7 +1510,7 @@ static void nuke(struct lpc32xx_ep *ep, int status)
                 done(ep, req, status);
         }
 
-        if (ep->desc && status == -ESHUTDOWN) {
+        if (status == -ESHUTDOWN) {
                 uda_disable_hwepint(ep->udc, ep->hwep_num);
                 udc_disable_hwep(ep->udc, ep->hwep_num);
         }
@@ -1658,9 +1653,6 @@ static int lpc32xx_ep_disable(struct usb_ep *_ep)
 
         nuke(ep, -ESHUTDOWN);
 
-        /* restore the endpoint's pristine config */
-        ep->desc = NULL;
-
         /* Clear all DMA statuses for this EP */
         udc_ep_dma_disable(udc, ep->hwep_num);
         writel(1 << ep->hwep_num, USBD_EOTINTCLR(udc->udp_baseaddr));
@@ -1696,7 +1688,7 @@ static int lpc32xx_ep_enable(struct usb_ep *_ep,
         unsigned long flags;
 
         /* Verify EP data */
-        if ((!_ep) || (!ep) || (!desc) || (ep->desc) ||
+        if ((!_ep) || (!ep) || (!desc) ||
             (desc->bDescriptorType != USB_DT_ENDPOINT)) {
                 dev_dbg(udc->dev, "bad ep or descriptor\n");
                 return -EINVAL;
@@ -1754,7 +1746,6 @@ static int lpc32xx_ep_enable(struct usb_ep *_ep,
 
         /* Initialize endpoint to match the selected descriptor */
         ep->is_in = (desc->bEndpointAddress & USB_DIR_IN) != 0;
-        ep->desc = desc;
         ep->ep.maxpacket = maxpacket;
 
         /* Map hardware endpoint from base and direction */
@@ -1837,7 +1828,7 @@ static int lpc32xx_ep_queue(struct usb_ep *_ep,
 
         udc = ep->udc;
 
-        if (!_ep || (!ep->desc && ep->hwep_num_base != 0)) {
+        if (!_ep) {
                 dev_dbg(udc->dev, "invalid ep\n");
                 return -EINVAL;
         }
@@ -1976,7 +1967,7 @@ static int lpc32xx_ep_set_halt(struct usb_ep *_ep, int value)
         struct lpc32xx_udc *udc = ep->udc;
         unsigned long flags;
 
-        if ((!ep) || (ep->desc == NULL) || (ep->hwep_num <= 1))
+        if ((!ep) || (ep->hwep_num <= 1))
                 return -EINVAL;
 
         /* Don't halt an IN EP */
@@ -2262,7 +2253,7 @@ static int udc_get_status(struct lpc32xx_udc *udc, u16 reqtype, u16 wIndex)
         case USB_RECIP_ENDPOINT:
                 tmp = wIndex & USB_ENDPOINT_NUMBER_MASK;
                 ep = &udc->ep[tmp];
-                if ((tmp == 0) || (tmp >= NUM_ENDPOINTS) || (tmp && !ep->desc))
+                if ((tmp == 0) || (tmp >= NUM_ENDPOINTS))
                         return -EOPNOTSUPP;
 
                 if (wIndex & USB_DIR_IN) {
@@ -2599,9 +2590,8 @@ static int lpc32xx_pullup(struct usb_gadget *gadget, int is_on)
         return 0;
 }
 
-static int lpc32xx_start(struct usb_gadget_driver *driver,
-                         int (*bind)(struct usb_gadget *));
-static int lpc32xx_stop(struct usb_gadget_driver *driver);
+static int lpc32xx_start(struct usb_gadget *, struct usb_gadget_driver *);
+static int lpc32xx_stop(struct usb_gadget *, struct usb_gadget_driver *);
 
 static const struct usb_gadget_ops lpc32xx_udc_ops = {
         .get_frame              = lpc32xx_get_frame,
@@ -2609,8 +2599,8 @@ static const struct usb_gadget_ops lpc32xx_udc_ops = {
         .set_selfpowered        = lpc32xx_set_selfpowered,
         .vbus_session           = lpc32xx_vbus_session,
         .pullup                 = lpc32xx_pullup,
-        .start                  = lpc32xx_start,
-        .stop                   = lpc32xx_stop,
+        .udc_start              = lpc32xx_start,
+        .udc_stop               = lpc32xx_stop,
 };
 
 static void nop_release(struct device *dev)
@@ -2618,10 +2608,9 @@ static void nop_release(struct device *dev)
         /* nothing to free */
 }
 
-static struct lpc32xx_udc controller = {
+static const struct lpc32xx_udc controller_template = {
         .gadget = {
                 .ops    = &lpc32xx_udc_ops,
-                .ep0    = &controller.ep[0].ep,
                 .name   = driver_name,
                 .dev    = {
                         .init_name = "gadget",
@@ -2633,7 +2622,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep0",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 0,
                 .hwep_num       = 0, /* Can be 0 or 1, has special handling */
@@ -2645,7 +2633,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep1-int",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 2,
                 .hwep_num       = 0, /* 2 or 3, will be set later */
@@ -2657,7 +2644,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep2-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 4,
                 .hwep_num       = 0, /* 4 or 5, will be set later */
@@ -2669,7 +2655,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep3-iso",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 1023,
                 .hwep_num_base  = 6,
                 .hwep_num       = 0, /* 6 or 7, will be set later */
@@ -2681,7 +2666,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep4-int",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 8,
                 .hwep_num       = 0, /* 8 or 9, will be set later */
@@ -2693,7 +2677,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep5-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 10,
                 .hwep_num       = 0, /* 10 or 11, will be set later */
@@ -2705,7 +2688,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep6-iso",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 1023,
                 .hwep_num_base  = 12,
                 .hwep_num       = 0, /* 12 or 13, will be set later */
@@ -2717,7 +2699,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep7-int",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 14,
                 .hwep_num       = 0,
@@ -2729,7 +2710,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep8-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 16,
                 .hwep_num       = 0,
@@ -2741,7 +2721,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep9-iso",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 1023,
                 .hwep_num_base  = 18,
                 .hwep_num       = 0,
@@ -2753,7 +2732,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep10-int",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 20,
                 .hwep_num       = 0,
@@ -2765,7 +2743,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep11-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 22,
                 .hwep_num       = 0,
@@ -2777,7 +2754,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep12-iso",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 1023,
                 .hwep_num_base  = 24,
                 .hwep_num       = 0,
@@ -2789,7 +2765,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep13-int",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 26,
                 .hwep_num       = 0,
@@ -2801,7 +2776,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep14-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 64,
                 .hwep_num_base  = 28,
                 .hwep_num       = 0,
@@ -2813,7 +2787,6 @@ static struct lpc32xx_udc controller = {
                         .name   = "ep15-bulk",
                         .ops    = &lpc32xx_ep_ops,
                 },
-                .udc            = &controller,
                 .maxpacket      = 1023,
                 .hwep_num_base  = 30,
                 .hwep_num       = 0,
@@ -2987,14 +2960,13 @@ static irqreturn_t lpc32xx_usb_vbus_irq(int irq, void *_udc)
         return IRQ_HANDLED;
 }
 
-static int lpc32xx_start(struct usb_gadget_driver *driver,
-                         int (*bind)(struct usb_gadget *))
+static int lpc32xx_start(struct usb_gadget *gadget,
+                         struct usb_gadget_driver *driver)
 {
-        struct lpc32xx_udc *udc = &controller;
-        int retval, i;
+        struct lpc32xx_udc *udc = to_udc(gadget);
+        int i;
 
-        if (!driver || driver->max_speed < USB_SPEED_FULL ||
-            !bind || !driver->setup) {
+        if (!driver || driver->max_speed < USB_SPEED_FULL || !driver->setup) {
                 dev_err(udc->dev, "bad parameter.\n");
                 return -EINVAL;
         }
@@ -3011,18 +2983,6 @@ static int lpc32xx_start(struct usb_gadget_driver *driver,
         udc->selfpowered = 1;
         udc->vbus = 0;
 
-        retval = bind(&udc->gadget);
-        if (retval) {
-                dev_err(udc->dev, "bind() returned %d\n", retval);
-                udc->enabled = 0;
-                udc->selfpowered = 0;
-                udc->driver = NULL;
-                udc->gadget.dev.driver = NULL;
-                return retval;
-        }
-
-        dev_dbg(udc->dev, "bound to %s\n", driver->driver.name);
-
         /* Force VBUS process once to check for cable insertion */
         udc->last_vbus = udc->vbus = 0;
         schedule_work(&udc->vbus_job);
@@ -3034,22 +2994,19 @@ static int lpc32xx_start(struct usb_gadget_driver *driver,
         return 0;
 }
 
-static int lpc32xx_stop(struct usb_gadget_driver *driver)
+static int lpc32xx_stop(struct usb_gadget *gadget,
+                        struct usb_gadget_driver *driver)
 {
         int i;
-        struct lpc32xx_udc *udc = &controller;
+        struct lpc32xx_udc *udc = to_udc(gadget);
 
-        if (!driver || driver != udc->driver || !driver->unbind)
+        if (!driver || driver != udc->driver)
                 return -EINVAL;
 
-        /* Disable USB pullup */
-        isp1301_pullup_enable(udc, 0, 1);
-
         for (i = IRQ_USB_LP; i <= IRQ_USB_ATX; i++)
                 disable_irq(udc->udp_irq[i]);
 
         if (udc->clocked) {
-
                 spin_lock(&udc->lock);
                 stop_activity(udc);
                 spin_unlock(&udc->lock);
@@ -3069,20 +3026,16 @@ static int lpc32xx_stop(struct usb_gadget_driver *driver)
         }
 
         udc->enabled = 0;
-        pullup(udc, 0);
-
-        driver->unbind(&udc->gadget);
         udc->gadget.dev.driver = NULL;
         udc->driver = NULL;
 
-        dev_dbg(udc->dev, "unbound from %s\n", driver->driver.name);
         return 0;
 }
 
 static void lpc32xx_udc_shutdown(struct platform_device *dev)
 {
         /* Force disconnect on reboot */
-        struct lpc32xx_udc *udc = &controller;
+        struct lpc32xx_udc *udc = platform_get_drvdata(dev);
 
         pullup(udc, 0);
 }
@@ -3120,12 +3073,21 @@ static u64 lpc32xx_usbd_dmamask = ~(u32) 0x7F;
 static int __init lpc32xx_udc_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
-        struct lpc32xx_udc *udc = &controller;
+        struct lpc32xx_udc *udc;
         int retval, i;
         struct resource *res;
         dma_addr_t dma_handle;
         struct device_node *isp1301_node;
 
+        udc = kzalloc(sizeof(*udc), GFP_KERNEL);
+        if (!udc)
+                return -ENOMEM;
+
+        memcpy(udc, &controller_template, sizeof(*udc));
+        for (i = 0; i <= 15; i++)
+                udc->ep[i].udc = udc;
+        udc->gadget.ep0 = &udc->ep[0].ep;
+
         /* init software state */
         udc->gadget.dev.parent = dev;
         udc->pdev = pdev;
@@ -3140,8 +3102,10 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
         }
 
         udc->isp1301_i2c_client = isp1301_get_client(isp1301_node);
-        if (!udc->isp1301_i2c_client)
-                return -EPROBE_DEFER;
+        if (!udc->isp1301_i2c_client) {
+                retval = -EPROBE_DEFER;
+                goto phy_fail;
+        }
 
         dev_info(udc->dev, "ISP1301 I2C device at address 0x%x\n",
                  udc->isp1301_i2c_client->addr);
@@ -3160,8 +3124,10 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
          *  IORESOURCE_IRQ, USB transceiver interrupt number
          */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res)
-                return -ENXIO;
+        if (!res) {
+                retval = -ENXIO;
+                goto resource_fail;
+        }
 
         spin_lock_init(&udc->lock);
 
@@ -3171,7 +3137,8 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
                 if (udc->udp_irq[i] < 0) {
                         dev_err(udc->dev,
                                 "irq resource %d not available!\n", i);
-                        return udc->udp_irq[i];
+                        retval = udc->udp_irq[i];
+                        goto irq_fail;
                 }
         }
 
@@ -3179,7 +3146,8 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
         udc->io_p_size = resource_size(res);
         if (!request_mem_region(udc->io_p_start, udc->io_p_size, driver_name)) {
                 dev_err(udc->dev, "someone's using UDC memory\n");
-                return -EBUSY;
+                retval = -EBUSY;
+                goto request_mem_region_fail;
         }
 
         udc->udp_baseaddr = ioremap(udc->io_p_start, udc->io_p_size);
@@ -3208,7 +3176,7 @@ static int __init lpc32xx_udc_probe(struct platform_device *pdev)
         udc->usb_otg_clk = clk_get(&pdev->dev, "ck_usb_otg");
         if (IS_ERR(udc->usb_otg_clk)) {
                 dev_err(udc->dev, "failed to acquire USB otg clock\n");
-                retval = PTR_ERR(udc->usb_slv_clk);
+                retval = PTR_ERR(udc->usb_otg_clk);
                 goto usb_otg_clk_get_fail;
         }
 
@@ -3376,7 +3344,11 @@ pll_get_fail:
 io_map_fail:
         release_mem_region(udc->io_p_start, udc->io_p_size);
         dev_err(udc->dev, "%s probe failed, %d\n", driver_name, retval);
-
+request_mem_region_fail:
+irq_fail:
+resource_fail:
+phy_fail:
+        kfree(udc);
         return retval;
 }
 
@@ -3414,6 +3386,7 @@ static int __devexit lpc32xx_udc_remove(struct platform_device *pdev)
         clk_put(udc->usb_pll_clk);
         iounmap(udc->udp_baseaddr);
         release_mem_region(udc->io_p_start, udc->io_p_size);
+        kfree(udc);
 
         return 0;
 }
diff --git a/drivers/usb/gadget/m66592-udc.c b/drivers/usb/gadget/m66592-udc.c
index cf6bd626f3fe..b6401f1b56ce 100644
--- a/drivers/usb/gadget/m66592-udc.c
+++ b/drivers/usb/gadget/m66592-udc.c
@@ -1466,7 +1466,7 @@ static struct usb_ep_ops m66592_ep_ops = {
 static struct m66592 *the_controller;
 
 static int m66592_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct m66592 *m66592 = the_controller;
         int retval;
@@ -1492,7 +1492,7 @@ static int m66592_start(struct usb_gadget_driver *driver,
                 goto error;
         }
 
-        retval = bind(&m66592->gadget);
+        retval = bind(&m66592->gadget, driver);
         if (retval) {
                 pr_err("bind to driver error (%d)\n", retval);
                 device_del(&m66592->gadget.dev);
diff --git a/drivers/usb/gadget/mass_storage.c b/drivers/usb/gadget/mass_storage.c
index 1f376eba31f6..080e577773d5 100644
--- a/drivers/usb/gadget/mass_storage.c
+++ b/drivers/usb/gadget/mass_storage.c
@@ -29,9 +29,8 @@
 
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/usb/ch9.h>
-
+#include <linux/module.h>
 
 /*-------------------------------------------------------------------------*/
 
@@ -47,14 +46,10 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
 #include "f_mass_storage.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 static struct usb_device_descriptor msg_device_desc = {
         .bLength =              sizeof msg_device_desc,
@@ -85,6 +80,22 @@ static const struct usb_descriptor_header *otg_desc[] = {
         NULL,
 };
 
+static struct usb_string strings_dev[] = {
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
+        {  } /* end of list */
+};
+
+static struct usb_gadget_strings stringtab_dev = {
+        .language       = 0x0409,       /* en-us */
+        .strings        = strings_dev,
+};
+
+static struct usb_gadget_strings *dev_strings[] = {
+        &stringtab_dev,
+        NULL,
+};
 
 /****************************** Configurations ******************************/
 
@@ -143,10 +154,15 @@ static int __init msg_bind(struct usb_composite_dev *cdev)
 {
         int status;
 
-        status = usb_add_config(cdev, &msg_config_driver, msg_do_config);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 return status;
+        msg_device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
+        status = usb_add_config(cdev, &msg_config_driver, msg_do_config);
+        if (status < 0)
+                return status;
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&cdev->gadget->dev,
                  DRIVER_DESC ", version: " DRIVER_VERSION "\n");
         set_bit(0, &msg_registered);
@@ -156,12 +172,13 @@ static int __init msg_bind(struct usb_composite_dev *cdev)
 
 /****************************** Some noise ******************************/
 
-static struct usb_composite_driver msg_driver = {
+static __refdata struct usb_composite_driver msg_driver = {
         .name           = "g_mass_storage",
         .dev            = &msg_device_desc,
-        .iProduct       = DRIVER_DESC,
         .max_speed      = USB_SPEED_SUPER,
         .needs_serial   = 1,
+        .strings        = dev_strings,
+        .bind           = msg_bind,
 };
 
 MODULE_DESCRIPTION(DRIVER_DESC);
@@ -170,7 +187,7 @@ MODULE_LICENSE("GPL");
 
 static int __init msg_init(void)
 {
-        return usb_composite_probe(&msg_driver, msg_bind);
+        return usb_composite_probe(&msg_driver);
 }
 module_init(msg_init);
 
diff --git a/drivers/usb/gadget/multi.c b/drivers/usb/gadget/multi.c
index c37fb33a3d1b..88472bf7dbb7 100644
--- a/drivers/usb/gadget/multi.c
+++ b/drivers/usb/gadget/multi.c
@@ -14,10 +14,8 @@
 
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/module.h>
 
-
 #if defined USB_ETH_RNDIS
 #  undef USB_ETH_RNDIS
 #endif
@@ -42,12 +40,6 @@ MODULE_LICENSE("GPL");
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_mass_storage.c"
 
 #include "u_serial.c"
@@ -61,7 +53,7 @@ MODULE_LICENSE("GPL");
 #endif
 #include "u_ether.c"
 
-
+USB_GADGET_COMPOSITE_OPTIONS();
 
 /***************************** Device Descriptor ****************************/
 
@@ -112,21 +104,16 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 
 enum {
-#ifdef CONFIG_USB_G_MULTI_RNDIS
-        MULTI_STRING_RNDIS_CONFIG_IDX,
-#endif
-#ifdef CONFIG_USB_G_MULTI_CDC
+        MULTI_STRING_RNDIS_CONFIG_IDX = USB_GADGET_FIRST_AVAIL_IDX,
         MULTI_STRING_CDC_CONFIG_IDX,
-#endif
 };
 
 static struct usb_string strings_dev[] = {
-#ifdef CONFIG_USB_G_MULTI_RNDIS
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         [MULTI_STRING_RNDIS_CONFIG_IDX].s = "Multifunction with RNDIS",
-#endif
-#ifdef CONFIG_USB_G_MULTI_CDC
         [MULTI_STRING_CDC_CONFIG_IDX].s   = "Multifunction with CDC ECM",
-#endif
         {  } /* end of list */
 };
 
@@ -260,7 +247,7 @@ static int cdc_config_register(struct usb_composite_dev *cdev)
 static int __ref multi_bind(struct usb_composite_dev *cdev)
 {
         struct usb_gadget *gadget = cdev->gadget;
-        int status, gcnum;
+        int status;
 
         if (!can_support_ecm(cdev->gadget)) {
                 dev_err(&gadget->dev, "controller '%s' not usable\n",
@@ -288,19 +275,11 @@ static int __ref multi_bind(struct usb_composite_dev *cdev)
                 }
         }
 
-        /* set bcdDevice */
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0) {
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        } else {
-                WARNING(cdev, "controller '%s' not recognized\n", gadget->name);
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | 0x0099);
-        }
-
         /* allocate string IDs */
         status = usb_string_ids_tab(cdev, strings_dev);
         if (unlikely(status < 0))
                 goto fail2;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         /* register configurations */
         status = rndis_config_register(cdev);
@@ -310,6 +289,7 @@ static int __ref multi_bind(struct usb_composite_dev *cdev)
         status = cdc_config_register(cdev);
         if (unlikely(status < 0))
                 goto fail2;
+        usb_composite_overwrite_options(cdev, &coverwrite);
 
         /* we're done */
         dev_info(&gadget->dev, DRIVER_DESC "\n");
@@ -338,20 +318,20 @@ static int __exit multi_unbind(struct usb_composite_dev *cdev)
 /****************************** Some noise ******************************/
 
 
-static struct usb_composite_driver multi_driver = {
+static __refdata struct usb_composite_driver multi_driver = {
         .name           = "g_multi",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = multi_bind,
         .unbind         = __exit_p(multi_unbind),
-        .iProduct       = DRIVER_DESC,
         .needs_serial   = 1,
 };
 
 
 static int __init multi_init(void)
 {
-        return usb_composite_probe(&multi_driver, multi_bind);
+        return usb_composite_probe(&multi_driver);
 }
 module_init(multi_init);
 
diff --git a/drivers/usb/gadget/mv_udc_core.c b/drivers/usb/gadget/mv_udc_core.c
index 75db2c306cea..ea45224f78c8 100644
--- a/drivers/usb/gadget/mv_udc_core.c
+++ b/drivers/usb/gadget/mv_udc_core.c
@@ -51,9 +51,8 @@
 #define EPSTATUS_TIMEOUT        10000
 #define PRIME_TIMEOUT           10000
 #define READSAFE_TIMEOUT        1000
-#define DTD_TIMEOUT             1000
 
-#define LOOPS_USEC_SHIFT        4
+#define LOOPS_USEC_SHIFT        1
 #define LOOPS_USEC              (1 << LOOPS_USEC_SHIFT)
 #define LOOPS(timeout)          ((timeout) >> LOOPS_USEC_SHIFT)
 
@@ -64,7 +63,6 @@ static const char driver_desc[] = DRIVER_DESC;
 
 /* controller device global variable */
 static struct mv_udc    *the_controller;
-int mv_usb_otgsc;
 
 static void nuke(struct mv_ep *ep, int status);
 static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver);
@@ -357,17 +355,24 @@ done:
         return retval;
 }
 
-
 static struct mv_dtd *build_dtd(struct mv_req *req, unsigned *length,
                 dma_addr_t *dma, int *is_last)
 {
-        u32 temp;
         struct mv_dtd *dtd;
         struct mv_udc *udc;
+        struct mv_dqh *dqh;
+        u32 temp, mult = 0;
 
         /* how big will this transfer be? */
-        *length = min(req->req.length - req->req.actual,
-                        (unsigned)EP_MAX_LENGTH_TRANSFER);
+        if (usb_endpoint_xfer_isoc(req->ep->ep.desc)) {
+                dqh = req->ep->dqh;
+                mult = (dqh->max_packet_length >> EP_QUEUE_HEAD_MULT_POS)
+                                & 0x3;
+                *length = min(req->req.length - req->req.actual,
+                                (unsigned)(mult * req->ep->ep.maxpacket));
+        } else
+                *length = min(req->req.length - req->req.actual,
+                                (unsigned)EP_MAX_LENGTH_TRANSFER);
 
         udc = req->ep->udc;
 
@@ -375,7 +380,7 @@ static struct mv_dtd *build_dtd(struct mv_req *req, unsigned *length,
          * Be careful that no _GFP_HIGHMEM is set,
          * or we can not use dma_to_virt
          */
-        dtd = dma_pool_alloc(udc->dtd_pool, GFP_KERNEL, dma);
+        dtd = dma_pool_alloc(udc->dtd_pool, GFP_ATOMIC, dma);
         if (dtd == NULL)
                 return dtd;
 
@@ -409,6 +414,8 @@ static struct mv_dtd *build_dtd(struct mv_req *req, unsigned *length,
         if (*is_last && !req->req.no_interrupt)
                 temp |= DTD_IOC;
 
+        temp |= mult << 10;
+
         dtd->size_ioc_sts = temp;
 
         mb();
@@ -708,6 +715,7 @@ mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         struct mv_req *req = container_of(_req, struct mv_req, req);
         struct mv_udc *udc = ep->udc;
         unsigned long flags;
+        int retval;
 
         /* catch various bogus parameters */
         if (!_req || !req->req.complete || !req->req.buf
@@ -719,10 +727,6 @@ mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
                 dev_err(&udc->dev->dev, "%s, bad ep", __func__);
                 return -EINVAL;
         }
-        if (ep->ep.desc->bmAttributes == USB_ENDPOINT_XFER_ISOC) {
-                if (req->req.length > ep->ep.maxpacket)
-                        return -EMSGSIZE;
-        }
 
         udc = ep->udc;
         if (!udc->driver || udc->gadget.speed == USB_SPEED_UNKNOWN)
@@ -755,15 +759,17 @@ mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
 
         /* build dtds and push them to device queue */
         if (!req_to_dtd(req)) {
-                int retval;
                 retval = queue_dtd(ep, req);
                 if (retval) {
                         spin_unlock_irqrestore(&udc->lock, flags);
-                        return retval;
+                        dev_err(&udc->dev->dev, "Failed to queue dtd\n");
+                        goto err_unmap_dma;
                 }
         } else {
                 spin_unlock_irqrestore(&udc->lock, flags);
-                return -ENOMEM;
+                dev_err(&udc->dev->dev, "Failed to dma_pool_alloc\n");
+                retval = -ENOMEM;
+                goto err_unmap_dma;
         }
 
         /* Update ep0 state */
@@ -775,6 +781,22 @@ mv_ep_queue(struct usb_ep *_ep, struct usb_request *_req, gfp_t gfp_flags)
         spin_unlock_irqrestore(&udc->lock, flags);
 
         return 0;
+
+err_unmap_dma:
+        if (req->mapped) {
+                dma_unmap_single(ep->udc->gadget.dev.parent,
+                                req->req.dma, req->req.length,
+                                ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+                req->req.dma = DMA_ADDR_INVALID;
+                req->mapped = 0;
+        } else
+                dma_sync_single_for_cpu(ep->udc->gadget.dev.parent,
+                                req->req.dma, req->req.length,
+                                ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+
+        return retval;
 }
 
 static void mv_prime_ep(struct mv_ep *ep, struct mv_req *req)
@@ -1065,7 +1087,7 @@ static int udc_reset(struct mv_udc *udc)
         tmp |= USBMODE_CTRL_MODE_DEVICE;
 
         /* turn setup lockout off, require setup tripwire in usbcmd */
-        tmp |= USBMODE_SETUP_LOCK_OFF | USBMODE_STREAM_DISABLE;
+        tmp |= USBMODE_SETUP_LOCK_OFF;
 
         writel(tmp, &udc->op_regs->usbmode);
 
@@ -1199,12 +1221,16 @@ static int mv_udc_vbus_session(struct usb_gadget *gadget, int is_active)
                         udc_start(udc);
                 }
         } else if (udc->driver && udc->softconnect) {
+                if (!udc->active)
+                        goto out;
+
                 /* stop all the transfer in queue*/
                 stop_activity(udc, udc->driver);
                 udc_stop(udc);
                 mv_udc_disable(udc);
         }
 
+out:
         spin_unlock_irqrestore(&udc->lock, flags);
         return retval;
 }
@@ -1243,7 +1269,7 @@ static int mv_udc_pullup(struct usb_gadget *gadget, int is_on)
 }
 
 static int mv_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int mv_udc_stop(struct usb_gadget_driver *driver);
 /* device controller usb_gadget_ops structure */
 static const struct usb_gadget_ops mv_ops = {
@@ -1348,7 +1374,7 @@ static void stop_activity(struct mv_udc *udc, struct usb_gadget_driver *driver)
 }
 
 static int mv_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct mv_udc *udc = the_controller;
         int retval = 0;
@@ -1373,7 +1399,7 @@ static int mv_udc_start(struct usb_gadget_driver *driver,
 
         spin_unlock_irqrestore(&udc->lock, flags);
 
-        retval = bind(&udc->gadget);
+        retval = bind(&udc->gadget, driver);
         if (retval) {
                 dev_err(&udc->dev->dev, "bind to driver %s --> %d\n",
                                 driver->driver.name, retval);
@@ -1499,15 +1525,17 @@ udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty)
         }
 
         /* prime the data phase */
-        if (!req_to_dtd(req))
+        if (!req_to_dtd(req)) {
                 retval = queue_dtd(ep, req);
-        else{   /* no mem */
+                if (retval) {
+                        dev_err(&udc->dev->dev,
+                                "Failed to queue dtd when prime status\n");
+                        goto out;
+                }
+        } else{ /* no mem */
                 retval = -ENOMEM;
-                goto out;
-        }
-
-        if (retval) {
-                dev_err(&udc->dev->dev, "response error on GET_STATUS request\n");
+                dev_err(&udc->dev->dev,
+                        "Failed to dma_pool_alloc when prime status\n");
                 goto out;
         }
 
@@ -1515,6 +1543,15 @@ udc_prime_status(struct mv_udc *udc, u8 direction, u16 status, bool empty)
 
         return 0;
 out:
+        if (req->mapped) {
+                dma_unmap_single(ep->udc->gadget.dev.parent,
+                                req->req.dma, req->req.length,
+                                ((ep_dir(ep) == EP_DIR_IN) ?
+                                DMA_TO_DEVICE : DMA_FROM_DEVICE));
+                req->req.dma = DMA_ADDR_INVALID;
+                req->mapped = 0;
+        }
+
         return retval;
 }
 
@@ -2468,9 +2505,11 @@ static void mv_udc_shutdown(struct platform_device *dev)
         u32 mode;
 
         /* reset controller mode to IDLE */
+        mv_udc_enable(udc);
         mode = readl(&udc->op_regs->usbmode);
         mode &= ~3;
         writel(mode, &udc->op_regs->usbmode);
+        mv_udc_disable(udc);
 }
 
 static struct platform_driver udc_driver = {
diff --git a/drivers/usb/gadget/ncm.c b/drivers/usb/gadget/ncm.c
index 89530034dff1..a22ad9af0565 100644
--- a/drivers/usb/gadget/ncm.c
+++ b/drivers/usb/gadget/ncm.c
@@ -20,8 +20,8 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
-
+#include <linux/module.h>
+#include <linux/usb/composite.h>
 
 #include "u_ether.h"
 
@@ -36,11 +36,6 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_ncm.c"
 #include "u_ether.c"
 
@@ -57,6 +52,7 @@
 #define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
@@ -97,17 +93,11 @@ static const struct usb_descriptor_header *otg_desc[] = {
         NULL,
 };
 
-
 /* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-
-static char manufacturer[50];
-
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = DRIVER_DESC,
+        [USB_GADGET_SERIAL_IDX].s = "",
         {  } /* end of list */
 };
 
@@ -149,7 +139,6 @@ static struct usb_configuration ncm_config_driver = {
 
 static int __init gncm_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
 
@@ -158,48 +147,22 @@ static int __init gncm_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 return status;
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0300 | gcnum);
-        else {
-                /* We assume that can_support_ecm() tells the truth;
-                 * but if the controller isn't recognized at all then
-                 * that assumption is a bit more likely to be wrong.
-                 */
-                dev_warn(&gadget->dev,
-                         "controller '%s' not recognized; trying %s\n",
-                         gadget->name,
-                         ncm_config_driver.label);
-                device_desc.bcdDevice =
-                        cpu_to_le16(0x0300 | 0x0099);
-        }
-
-
         /* Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
 
-        /* device descriptor strings: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-        device_desc.iProduct = status;
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
 
         status = usb_add_config(cdev, &ncm_config_driver,
                                 ncm_do_config);
         if (status < 0)
                 goto fail;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s\n", DRIVER_DESC);
 
         return 0;
@@ -215,11 +178,12 @@ static int __exit gncm_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver ncm_driver = {
+static __refdata struct usb_composite_driver ncm_driver = {
         .name           = "g_ncm",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = gncm_bind,
         .unbind         = __exit_p(gncm_unbind),
 };
 
@@ -229,7 +193,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_probe(&ncm_driver, gncm_bind);
+        return usb_composite_probe(&ncm_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/nokia.c b/drivers/usb/gadget/nokia.c
index c7fb7723c014..661600abace8 100644
--- a/drivers/usb/gadget/nokia.c
+++ b/drivers/usb/gadget/nokia.c
@@ -16,7 +16,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/device.h>
 
 #include "u_serial.h"
@@ -38,11 +37,6 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "u_serial.c"
 #include "f_acm.c"
 #include "f_ecm.c"
@@ -52,23 +46,23 @@
 #include "u_ether.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 #define NOKIA_VENDOR_ID                 0x0421  /* Nokia */
 #define NOKIA_PRODUCT_ID                0x01c8  /* Nokia Gadget */
 
 /* string IDs are assigned dynamically */
 
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_DESCRIPTION_IDX          2
+#define STRING_DESCRIPTION_IDX          USB_GADGET_FIRST_AVAIL_IDX
 
 static char manufacturer_nokia[] = "Nokia";
 static const char product_nokia[] = NOKIA_LONG_NAME;
 static const char description_nokia[] = "PC-Suite Configuration";
 
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer_nokia,
-        [STRING_PRODUCT_IDX].s = NOKIA_LONG_NAME,
+        [USB_GADGET_MANUFACTURER_IDX].s = manufacturer_nokia,
+        [USB_GADGET_PRODUCT_IDX].s = NOKIA_LONG_NAME,
+        [USB_GADGET_SERIAL_IDX].s = "",
         [STRING_DESCRIPTION_IDX].s = description_nokia,
         {  } /* end of list */
 };
@@ -90,6 +84,7 @@ static struct usb_device_descriptor device_desc = {
         .bDeviceClass           = USB_CLASS_COMM,
         .idVendor               = __constant_cpu_to_le16(NOKIA_VENDOR_ID),
         .idProduct              = __constant_cpu_to_le16(NOKIA_PRODUCT_ID),
+        .bcdDevice              = cpu_to_le16(NOKIA_VERSION_NUM),
         /* .iManufacturer = DYNAMIC */
         /* .iProduct = DYNAMIC */
         .bNumConfigurations =   1,
@@ -151,7 +146,6 @@ static struct usb_configuration nokia_config_100ma_driver = {
 
 static int __init nokia_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
         struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
 
@@ -167,41 +161,17 @@ static int __init nokia_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 goto err_ether;
 
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto err_usb;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto err_usb;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-
-        device_desc.iProduct = status;
-
-        /* config description */
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto err_usb;
-        strings_dev[STRING_DESCRIPTION_IDX].id = status;
-
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
+        status = strings_dev[STRING_DESCRIPTION_IDX].id;
         nokia_config_500ma_driver.iConfiguration = status;
         nokia_config_100ma_driver.iConfiguration = status;
 
-        /* set up other descriptors */
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(NOKIA_VERSION_NUM);
-        else {
-                /* this should only work with hw that supports altsettings
-                 * and several endpoints, anything else, panic.
-                 */
-                pr_err("nokia_bind: controller '%s' not recognized\n",
-                        gadget->name);
+        if (!gadget_supports_altsettings(gadget))
                 goto err_usb;
-        }
 
         /* finally register the configuration */
         status = usb_add_config(cdev, &nokia_config_500ma_driver,
@@ -214,6 +184,7 @@ static int __init nokia_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 goto err_usb;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         dev_info(&gadget->dev, "%s\n", NOKIA_LONG_NAME);
 
         return 0;
@@ -237,17 +208,18 @@ static int __exit nokia_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver nokia_driver = {
+static __refdata struct usb_composite_driver nokia_driver = {
         .name           = "g_nokia",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = nokia_bind,
         .unbind         = __exit_p(nokia_unbind),
 };
 
 static int __init nokia_init(void)
 {
-        return usb_composite_probe(&nokia_driver, nokia_bind);
+        return usb_composite_probe(&nokia_driver);
 }
 module_init(nokia_init);
 
diff --git a/drivers/usb/gadget/omap_udc.c b/drivers/usb/gadget/omap_udc.c
index f9132ada53b5..2a4749c3eb3f 100644
--- a/drivers/usb/gadget/omap_udc.c
+++ b/drivers/usb/gadget/omap_udc.c
@@ -1308,7 +1308,7 @@ static int omap_pullup(struct usb_gadget *gadget, int is_on)
 }
 
 static int omap_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int omap_udc_stop(struct usb_gadget_driver *driver);
 
 static struct usb_gadget_ops omap_gadget_ops = {
@@ -2040,7 +2040,7 @@ static inline int machine_without_vbus_sense(void)
 }
 
 static int omap_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         int             status = -ENODEV;
         struct omap_ep  *ep;
@@ -2082,7 +2082,7 @@ static int omap_udc_start(struct usb_gadget_driver *driver,
         if (udc->dc_clk != NULL)
                 omap_udc_enable_clock(1);
 
-        status = bind(&udc->gadget);
+        status = bind(&udc->gadget, driver);
         if (status) {
                 DBG("bind to %s --> %d\n", driver->driver.name, status);
                 udc->gadget.dev.driver = NULL;
diff --git a/drivers/usb/gadget/pch_udc.c b/drivers/usb/gadget/pch_udc.c
index f4fb71c9ae08..6490c0040e3a 100644
--- a/drivers/usb/gadget/pch_udc.c
+++ b/drivers/usb/gadget/pch_udc.c
@@ -1236,7 +1236,7 @@ static int pch_udc_pcd_vbus_draw(struct usb_gadget *gadget, unsigned int mA)
 }
 
 static int pch_udc_start(struct usb_gadget_driver *driver,
-        int (*bind)(struct usb_gadget *));
+        int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int pch_udc_stop(struct usb_gadget_driver *driver);
 static const struct usb_gadget_ops pch_udc_ops = {
         .get_frame = pch_udc_pcd_get_frame,
@@ -2982,7 +2982,7 @@ static int init_dma_pools(struct pch_udc_dev *dev)
 }
 
 static int pch_udc_start(struct usb_gadget_driver *driver,
-        int (*bind)(struct usb_gadget *))
+        int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct pch_udc_dev      *dev = pch_udc;
         int                     retval;
@@ -3006,7 +3006,7 @@ static int pch_udc_start(struct usb_gadget_driver *driver,
         dev->gadget.dev.driver = &driver->driver;
 
         /* Invoke the bind routine of the gadget driver */
-        retval = bind(&dev->gadget);
+        retval = bind(&dev->gadget, driver);
 
         if (retval) {
                 dev_err(&dev->pdev->dev, "%s: binding to %s returning %d\n",
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index f1f9290a2f47..e156e3f26727 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -22,7 +22,6 @@
 #include <linux/timer.h>
 #include <linux/list.h>
 #include <linux/interrupt.h>
-#include <linux/utsname.h>
 #include <linux/device.h>
 #include <linux/moduleparam.h>
 #include <linux/fs.h>
@@ -38,25 +37,13 @@
 #include <asm/unaligned.h>
 
 #include <linux/usb/ch9.h>
+#include <linux/usb/composite.h>
 #include <linux/usb/gadget.h>
 #include <linux/usb/g_printer.h>
 
 #include "gadget_chips.h"
 
-
-/*
- * Kbuild is not very cooperative with respect to linking separately
- * compiled library objects into one module.  So for now we won't use
- * separate compilation ... ensuring init/exit sections work to shrink
- * the runtime footprint, and giving us at least some parts of what
- * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
- */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
-/*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 #define DRIVER_DESC             "Printer Gadget"
 #define DRIVER_VERSION          "2007 OCT 06"
@@ -120,8 +107,7 @@ static struct printer_dev usb_printer_gadget;
  * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
  */
 
-static char *iSerialNum;
-module_param(iSerialNum, charp, S_IRUGO);
+module_param_named(iSerialNum, coverwrite.serial_number, charp, S_IRUGO);
 MODULE_PARM_DESC(iSerialNum, "1");
 
 static char *iPNPstring;
@@ -141,18 +127,10 @@ module_param(qlen, uint, S_IRUGO|S_IWUSR);
  * descriptors are built on demand.
  */
 
-#define STRING_MANUFACTURER             1
-#define STRING_PRODUCT                  2
-#define STRING_SERIALNUM                3
-
 /* holds our biggest descriptor */
 #define USB_DESC_BUFSIZE                256
 #define USB_BUFSIZE                     8192
 
-/* This device advertises one configuration. */
-#define DEV_CONFIG_VALUE                1
-#define PRINTER_INTERFACE               0
-
 static struct usb_device_descriptor device_desc = {
         .bLength =              sizeof device_desc,
         .bDescriptorType =      USB_DT_DEVICE,
@@ -162,16 +140,12 @@ static struct usb_device_descriptor device_desc = {
         .bDeviceProtocol =      0,
         .idVendor =             cpu_to_le16(PRINTER_VENDOR_NUM),
         .idProduct =            cpu_to_le16(PRINTER_PRODUCT_NUM),
-        .iManufacturer =        STRING_MANUFACTURER,
-        .iProduct =             STRING_PRODUCT,
-        .iSerialNumber =        STRING_SERIALNUM,
         .bNumConfigurations =   1
 };
 
 static struct usb_interface_descriptor intf_desc = {
         .bLength =              sizeof intf_desc,
         .bDescriptorType =      USB_DT_INTERFACE,
-        .bInterfaceNumber =     PRINTER_INTERFACE,
         .bNumEndpoints =        2,
         .bInterfaceClass =      USB_CLASS_PRINTER,
         .bInterfaceSubClass =   1,      /* Printer Sub-Class */
@@ -252,7 +226,6 @@ static const struct usb_descriptor_header *otg_desc[] = {
 
 /* descriptors that are built on-demand */
 
-static char                             manufacturer [50];
 static char                             product_desc [40] = DRIVER_DESC;
 static char                             serial_num [40] = "1";
 static char                             pnp_string [1024] =
@@ -260,9 +233,9 @@ static char				pnp_string [1024] =
 
 /* static strings, in UTF-8 */
 static struct usb_string                strings [] = {
-        { STRING_MANUFACTURER,  manufacturer, },
-        { STRING_PRODUCT,       product_desc, },
-        { STRING_SERIALNUM,     serial_num, },
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = product_desc,
+        [USB_GADGET_SERIAL_IDX].s =     serial_num,
         {  }            /* end of list */
 };
 
@@ -871,25 +844,13 @@ static int set_interface(struct printer_dev *dev, unsigned number)
         int                     result = 0;
 
         /* Free the current interface */
-        switch (dev->interface) {
-        case PRINTER_INTERFACE:
-                printer_reset_interface(dev);
-                break;
-        }
+        printer_reset_interface(dev);
 
-        switch (number) {
-        case PRINTER_INTERFACE:
-                result = set_printer_interface(dev);
-                if (result) {
-                        printer_reset_interface(dev);
-                } else {
-                        dev->interface = PRINTER_INTERFACE;
-                }
-                break;
-        default:
-                result = -EINVAL;
-                /* FALL THROUGH */
-        }
+        result = set_printer_interface(dev);
+        if (result)
+                printer_reset_interface(dev);
+        else
+                dev->interface = number;
 
         if (!result)
                 INFO(dev, "Using interface %x\n", number);
@@ -972,7 +933,7 @@ static int printer_func_setup(struct usb_function *f,
                 switch (ctrl->bRequest) {
                 case 0: /* Get the IEEE-1284 PNP String */
                         /* Only one printer interface is supported. */
-                        if ((wIndex>>8) != PRINTER_INTERFACE)
+                        if ((wIndex>>8) != dev->interface)
                                 break;
 
                         value = (pnp_string[0]<<8)|pnp_string[1];
@@ -983,7 +944,7 @@ static int printer_func_setup(struct usb_function *f,
 
                 case 1: /* Get Port Status */
                         /* Only one printer interface is supported. */
-                        if (wIndex != PRINTER_INTERFACE)
+                        if (wIndex != dev->interface)
                                 break;
 
                         *(u8 *)req->buf = dev->printer_status;
@@ -992,7 +953,7 @@ static int printer_func_setup(struct usb_function *f,
 
                 case 2: /* Soft Reset */
                         /* Only one printer interface is supported. */
-                        if (wIndex != PRINTER_INTERFACE)
+                        if (wIndex != dev->interface)
                                 break;
 
                         printer_soft_reset(dev);
@@ -1020,6 +981,37 @@ unknown:
 static int __init printer_func_bind(struct usb_configuration *c,
                 struct usb_function *f)
 {
+        struct printer_dev *dev = container_of(f, struct printer_dev, function);
+        struct usb_composite_dev *cdev = c->cdev;
+        struct usb_ep           *in_ep, *out_ep;
+        int id;
+
+        id = usb_interface_id(c, f);
+        if (id < 0)
+                return id;
+        intf_desc.bInterfaceNumber = id;
+
+        /* all we really need is bulk IN/OUT */
+        in_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_in_desc);
+        if (!in_ep) {
+autoconf_fail:
+                dev_err(&cdev->gadget->dev, "can't autoconfigure on %s\n",
+                        cdev->gadget->name);
+                return -ENODEV;
+        }
+        in_ep->driver_data = in_ep;     /* claim */
+
+        out_ep = usb_ep_autoconfig(cdev->gadget, &fs_ep_out_desc);
+        if (!out_ep)
+                goto autoconf_fail;
+        out_ep->driver_data = out_ep;   /* claim */
+
+        /* assumes that all endpoints are dual-speed */
+        hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
+        hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
+
+        dev->in_ep = in_ep;
+        dev->out_ep = out_ep;
         return 0;
 }
 
@@ -1035,7 +1027,8 @@ static int printer_func_set_alt(struct usb_function *f,
         int ret = -ENOTSUPP;
 
         if (!alt)
-                ret = set_interface(dev, PRINTER_INTERFACE);
+                ret = set_interface(dev, intf);
+
         return ret;
 }
 
@@ -1107,13 +1100,13 @@ static int __init printer_bind_config(struct usb_configuration *c)
 {
         struct usb_gadget       *gadget = c->cdev->gadget;
         struct printer_dev      *dev;
-        struct usb_ep           *in_ep, *out_ep;
         int                     status = -ENOMEM;
-        int                     gcnum;
         size_t                  len;
         u32                     i;
         struct usb_request      *req;
 
+        usb_ep_autoconfig_reset(gadget);
+
         dev = &usb_printer_gadget;
 
         dev->function.name = shortname;
@@ -1125,6 +1118,10 @@ static int __init printer_bind_config(struct usb_configuration *c)
         dev->function.set_alt = printer_func_set_alt;
         dev->function.disable = printer_func_disable;
 
+        status = usb_add_function(c, &dev->function);
+        if (status)
+                return status;
+
         /* Setup the sysfs files for the printer gadget. */
         dev->pdev = device_create(usb_gadget_class, NULL, g_printer_devno,
                                   NULL, "g_printer");
@@ -1145,23 +1142,6 @@ static int __init printer_bind_config(struct usb_configuration *c)
                 goto fail;
         }
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0) {
-                device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
-        } else {
-                dev_warn(&gadget->dev, "controller '%s' not recognized\n",
-                        gadget->name);
-                /* unrecognized, but safe unless bulk is REALLY quirky */
-                device_desc.bcdDevice =
-                        cpu_to_le16(0xFFFF);
-        }
-        snprintf(manufacturer, sizeof(manufacturer), "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-
-        if (iSerialNum)
-                strlcpy(serial_num, iSerialNum, sizeof serial_num);
-
         if (iPNPstring)
                 strlcpy(&pnp_string[2], iPNPstring, (sizeof pnp_string)-2);
 
@@ -1169,26 +1149,6 @@ static int __init printer_bind_config(struct usb_configuration *c)
         pnp_string[0] = (len >> 8) & 0xFF;
         pnp_string[1] = len & 0xFF;
 
-        /* all we really need is bulk IN/OUT */
-        usb_ep_autoconfig_reset(gadget);
-        in_ep = usb_ep_autoconfig(gadget, &fs_ep_in_desc);
-        if (!in_ep) {
-autoconf_fail:
-                dev_err(&gadget->dev, "can't autoconfigure on %s\n",
-                        gadget->name);
-                return -ENODEV;
-        }
-        in_ep->driver_data = in_ep;     /* claim */
-
-        out_ep = usb_ep_autoconfig(gadget, &fs_ep_out_desc);
-        if (!out_ep)
-                goto autoconf_fail;
-        out_ep->driver_data = out_ep;   /* claim */
-
-        /* assumes that all endpoints are dual-speed */
-        hs_ep_in_desc.bEndpointAddress = fs_ep_in_desc.bEndpointAddress;
-        hs_ep_out_desc.bEndpointAddress = fs_ep_out_desc.bEndpointAddress;
-
         usb_gadget_set_selfpowered(gadget);
 
         if (gadget->is_otg) {
@@ -1215,9 +1175,6 @@ autoconf_fail:
         dev->current_rx_bytes = 0;
         dev->current_rx_buf = NULL;
 
-        dev->in_ep = in_ep;
-        dev->out_ep = out_ep;
-
         for (i = 0; i < QLEN; i++) {
                 req = printer_req_alloc(dev->in_ep, USB_BUFSIZE, GFP_KERNEL);
                 if (!req) {
@@ -1250,8 +1207,6 @@ autoconf_fail:
         dev->gadget = gadget;
 
         INFO(dev, "%s, version: " DRIVER_VERSION "\n", driver_desc);
-        INFO(dev, "using %s, OUT %s IN %s\n", gadget->name, out_ep->name,
-                        in_ep->name);
         return 0;
 
 fail:
@@ -1266,14 +1221,28 @@ static int printer_unbind(struct usb_composite_dev *cdev)
 
 static int __init printer_bind(struct usb_composite_dev *cdev)
 {
-        return usb_add_config(cdev, &printer_cfg_driver, printer_bind_config);
+        int ret;
+
+        ret = usb_string_ids_tab(cdev, strings);
+        if (ret < 0)
+                return ret;
+        device_desc.iManufacturer = strings[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings[USB_GADGET_PRODUCT_IDX].id;
+        device_desc.iSerialNumber = strings[USB_GADGET_SERIAL_IDX].id;
+
+        ret = usb_add_config(cdev, &printer_cfg_driver, printer_bind_config);
+        if (ret)
+                return ret;
+        usb_composite_overwrite_options(cdev, &coverwrite);
+        return ret;
 }
 
-static struct usb_composite_driver printer_driver = {
+static __refdata struct usb_composite_driver printer_driver = {
         .name           = shortname,
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_HIGH,
+        .bind           = printer_bind,
         .unbind         = printer_unbind,
 };
 
@@ -1297,7 +1266,7 @@ init(void)
                 return status;
         }
 
-        status = usb_composite_probe(&printer_driver, printer_bind);
+        status = usb_composite_probe(&printer_driver);
         if (status) {
                 class_destroy(usb_gadget_class);
                 unregister_chrdev_region(g_printer_devno, 1);
diff --git a/drivers/usb/gadget/pxa25x_udc.c b/drivers/usb/gadget/pxa25x_udc.c
index 907ad3ecb341..8efbf08c3561 100644
--- a/drivers/usb/gadget/pxa25x_udc.c
+++ b/drivers/usb/gadget/pxa25x_udc.c
@@ -33,7 +33,6 @@
 #include <linux/dma-mapping.h>
 #include <linux/irq.h>
 #include <linux/clk.h>
-#include <linux/err.h>
 #include <linux/seq_file.h>
 #include <linux/debugfs.h>
 #include <linux/io.h>
@@ -1000,7 +999,7 @@ static int pxa25x_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
 }
 
 static int pxa25x_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int pxa25x_stop(struct usb_gadget_driver *driver);
 
 static const struct usb_gadget_ops pxa25x_udc_ops = {
@@ -1258,7 +1257,7 @@ static void udc_enable (struct pxa25x_udc *dev)
  * the driver might get unbound.
  */
 static int pxa25x_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct pxa25x_udc       *dev = the_controller;
         int                     retval;
@@ -1286,7 +1285,7 @@ fail:
                 dev->gadget.dev.driver = NULL;
                 return retval;
         }
-        retval = bind(&dev->gadget);
+        retval = bind(&dev->gadget, driver);
         if (retval) {
                 DMSG("bind to driver %s --> error %d\n",
                                 driver->driver.name, retval);
diff --git a/drivers/usb/gadget/pxa25x_udc.h b/drivers/usb/gadget/pxa25x_udc.h
index 861f4df6ea22..2eca1e71fecd 100644
--- a/drivers/usb/gadget/pxa25x_udc.h
+++ b/drivers/usb/gadget/pxa25x_udc.h
@@ -225,7 +225,7 @@ dump_state(struct pxa25x_udc *dev)
                 dev->stats.read.bytes, dev->stats.read.ops);
 
         for (i = 1; i < PXA_UDC_NUM_ENDPOINTS; i++) {
-                if (dev->ep [i].desc == NULL)
+                if (dev->ep[i].ep.desc == NULL)
                         continue;
                 DMSG ("udccs%d = %02x\n", i, *dev->ep->reg_udccs);
         }
diff --git a/drivers/usb/gadget/pxa27x_udc.c b/drivers/usb/gadget/pxa27x_udc.c
index 644b4305cb99..979ddaddb0f8 100644
--- a/drivers/usb/gadget/pxa27x_udc.c
+++ b/drivers/usb/gadget/pxa27x_udc.c
@@ -1672,7 +1672,7 @@ static int pxa_udc_vbus_draw(struct usb_gadget *_gadget, unsigned mA)
 }
 
 static int pxa27x_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int pxa27x_udc_stop(struct usb_gadget_driver *driver);
 
 static const struct usb_gadget_ops pxa_udc_ops = {
@@ -1803,7 +1803,7 @@ static void udc_enable(struct pxa_udc *udc)
  * Returns 0 if no error, -EINVAL, -ENODEV, -EBUSY otherwise
  */
 static int pxa27x_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct pxa_udc *udc = the_controller;
         int retval;
@@ -1826,7 +1826,7 @@ static int pxa27x_udc_start(struct usb_gadget_driver *driver,
                 dev_err(udc->dev, "device_add error %d\n", retval);
                 goto add_fail;
         }
-        retval = bind(&udc->gadget);
+        retval = bind(&udc->gadget, driver);
         if (retval) {
                 dev_err(udc->dev, "bind to driver %s --> error %d\n",
                         driver->driver.name, retval);
diff --git a/drivers/usb/gadget/rndis.c b/drivers/usb/gadget/rndis.c
index b35babed6fcb..e4192b887de9 100644
--- a/drivers/usb/gadget/rndis.c
+++ b/drivers/usb/gadget/rndis.c
@@ -863,26 +863,8 @@ int rndis_msg_parser(u8 configNr, u8 *buf)
                  */
                 pr_warning("%s: unknown RNDIS message 0x%08X len %d\n",
                         __func__, MsgType, MsgLength);
-                {
-                        unsigned i;
-                        for (i = 0; i < MsgLength; i += 16) {
-                                pr_debug("%03d: "
-                                        " %02x %02x %02x %02x"
-                                        " %02x %02x %02x %02x"
-                                        " %02x %02x %02x %02x"
-                                        " %02x %02x %02x %02x"
-                                        "\n",
-                                        i,
-                                        buf[i], buf [i+1],
-                                                buf[i+2], buf[i+3],
-                                        buf[i+4], buf [i+5],
-                                                buf[i+6], buf[i+7],
-                                        buf[i+8], buf [i+9],
-                                                buf[i+10], buf[i+11],
-                                        buf[i+12], buf [i+13],
-                                                buf[i+14], buf[i+15]);
-                        }
-                }
+                print_hex_dump_bytes(__func__, DUMP_PREFIX_OFFSET,
+                                     buf, MsgLength);
                 break;
         }
 
diff --git a/drivers/usb/gadget/s3c-hsotg.c b/drivers/usb/gadget/s3c-hsotg.c
index 0bb617e1dda2..6f696ee8b817 100644
--- a/drivers/usb/gadget/s3c-hsotg.c
+++ b/drivers/usb/gadget/s3c-hsotg.c
@@ -2197,7 +2197,7 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
         /* issue soft reset */
         writel(GRSTCTL_CSftRst, hsotg->regs + GRSTCTL);
 
-        timeout = 1000;
+        timeout = 10000;
         do {
                 grstctl = readl(hsotg->regs + GRSTCTL);
         } while ((grstctl & GRSTCTL_CSftRst) && timeout-- > 0);
@@ -2207,7 +2207,7 @@ static int s3c_hsotg_corereset(struct s3c_hsotg *hsotg)
                 return -EINVAL;
         }
 
-        timeout = 1000;
+        timeout = 10000;
 
         while (1) {
                 u32 grstctl = readl(hsotg->regs + GRSTCTL);
@@ -3516,7 +3516,7 @@ static int __devinit s3c_hsotg_probe(struct platform_device *pdev)
         hsotg->dev = dev;
         hsotg->plat = plat;
 
-        hsotg->clk = clk_get(&pdev->dev, "otg");
+        hsotg->clk = devm_clk_get(&pdev->dev, "otg");
         if (IS_ERR(hsotg->clk)) {
                 dev_err(dev, "cannot get otg clock\n");
                 return PTR_ERR(hsotg->clk);
@@ -3667,7 +3667,6 @@ err_supplies:
 
 err_clk:
         clk_disable_unprepare(hsotg->clk);
-        clk_put(hsotg->clk);
 
         return ret;
 }
@@ -3693,7 +3692,6 @@ static int __devexit s3c_hsotg_remove(struct platform_device *pdev)
         regulator_bulk_free(ARRAY_SIZE(hsotg->supplies), hsotg->supplies);
 
         clk_disable_unprepare(hsotg->clk);
-        clk_put(hsotg->clk);
 
         device_unregister(&hsotg->gadget.dev);
         return 0;
diff --git a/drivers/usb/gadget/s3c-hsudc.c b/drivers/usb/gadget/s3c-hsudc.c
index e26a4e7ed2bf..d8e785d4ad59 100644
--- a/drivers/usb/gadget/s3c-hsudc.c
+++ b/drivers/usb/gadget/s3c-hsudc.c
@@ -135,7 +135,6 @@ struct s3c_hsudc_req {
  * @dev: The device reference used by probe function.
  * @lock: Lock to synchronize the usage of Endpoints (EP's are indexed).
  * @regs: Remapped base address of controller's register space.
- * @mem_rsrc: Device memory resource used for remapping device register space.
  * irq: IRQ number used by the controller.
  * uclk: Reference to the controller clock.
  * ep0state: Current state of EP0.
@@ -150,7 +149,6 @@ struct s3c_hsudc {
         struct regulator_bulk_data supplies[ARRAY_SIZE(s3c_hsudc_supply_names)];
         spinlock_t lock;
         void __iomem *regs;
-        struct resource *mem_rsrc;
         int irq;
         struct clk *uclk;
         int ep0state;
@@ -835,9 +833,9 @@ static struct usb_request *s3c_hsudc_alloc_request(struct usb_ep *_ep,
 {
         struct s3c_hsudc_req *hsreq;
 
-        hsreq = kzalloc(sizeof *hsreq, gfp_flags);
+        hsreq = kzalloc(sizeof(*hsreq), gfp_flags);
         if (!hsreq)
-                return 0;
+                return NULL;
 
         INIT_LIST_HEAD(&hsreq->queue);
         return &hsreq->req;
@@ -906,16 +904,16 @@ static int s3c_hsudc_queue(struct usb_ep *_ep, struct usb_request *_req,
                         csr = readl((u32)hsudc->regs + offset);
                         if (!(csr & S3C_ESR_TX_SUCCESS) &&
                                 (s3c_hsudc_write_fifo(hsep, hsreq) == 1))
-                                hsreq = 0;
+                                hsreq = NULL;
                 } else {
                         csr = readl((u32)hsudc->regs + offset);
                         if ((csr & S3C_ESR_RX_SUCCESS)
                                    && (s3c_hsudc_read_fifo(hsep, hsreq) == 1))
-                                hsreq = 0;
+                                hsreq = NULL;
                 }
         }
 
-        if (hsreq != 0)
+        if (hsreq)
                 list_add_tail(&hsreq->queue, &hsep->queue);
 
         spin_unlock_irqrestore(&hsudc->lock, flags);
@@ -1271,7 +1269,7 @@ static int __devinit s3c_hsudc_probe(struct platform_device *pdev)
         struct s3c24xx_hsudc_platdata *pd = pdev->dev.platform_data;
         int ret, i;
 
-        hsudc = kzalloc(sizeof(struct s3c_hsudc) +
+        hsudc = devm_kzalloc(&pdev->dev, sizeof(struct s3c_hsudc) +
                         sizeof(struct s3c_hsudc_ep) * pd->epnum,
                         GFP_KERNEL);
         if (!hsudc) {
@@ -1296,25 +1294,12 @@ static int __devinit s3c_hsudc_probe(struct platform_device *pdev)
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        if (!res) {
-                dev_err(dev, "unable to obtain driver resource data\n");
-                ret = -ENODEV;
-                goto err_res;
-        }
-
-        hsudc->mem_rsrc = request_mem_region(res->start, resource_size(res),
-                                dev_name(&pdev->dev));
-        if (!hsudc->mem_rsrc) {
-                dev_err(dev, "failed to reserve register area\n");
-                ret = -ENODEV;
-                goto err_res;
-        }
 
-        hsudc->regs = ioremap(res->start, resource_size(res));
+        hsudc->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (!hsudc->regs) {
                 dev_err(dev, "error mapping device register area\n");
                 ret = -EBUSY;
-                goto err_remap;
+                goto err_res;
         }
 
         spin_lock_init(&hsudc->lock);
@@ -1337,21 +1322,22 @@ static int __devinit s3c_hsudc_probe(struct platform_device *pdev)
         ret = platform_get_irq(pdev, 0);
         if (ret < 0) {
                 dev_err(dev, "unable to obtain IRQ number\n");
-                goto err_irq;
+                goto err_res;
         }
         hsudc->irq = ret;
 
-        ret = request_irq(hsudc->irq, s3c_hsudc_irq, 0, driver_name, hsudc);
+        ret = devm_request_irq(&pdev->dev, hsudc->irq, s3c_hsudc_irq, 0,
+                                driver_name, hsudc);
         if (ret < 0) {
                 dev_err(dev, "irq request failed\n");
-                goto err_irq;
+                goto err_res;
         }
 
-        hsudc->uclk = clk_get(&pdev->dev, "usb-device");
+        hsudc->uclk = devm_clk_get(&pdev->dev, "usb-device");
         if (IS_ERR(hsudc->uclk)) {
                 dev_err(dev, "failed to find usb-device clock source\n");
                 ret = PTR_ERR(hsudc->uclk);
-                goto err_clk;
+                goto err_res;
         }
         clk_enable(hsudc->uclk);
 
@@ -1377,21 +1363,12 @@ err_add_udc:
         device_unregister(&hsudc->gadget.dev);
 err_add_device:
         clk_disable(hsudc->uclk);
-        clk_put(hsudc->uclk);
-err_clk:
-        free_irq(hsudc->irq, hsudc);
-err_irq:
-        iounmap(hsudc->regs);
-
-err_remap:
-        release_mem_region(res->start, resource_size(res));
 err_res:
         if (!IS_ERR_OR_NULL(hsudc->transceiver))
                 usb_put_phy(hsudc->transceiver);
 
         regulator_bulk_free(ARRAY_SIZE(hsudc->supplies), hsudc->supplies);
 err_supplies:
-        kfree(hsudc);
         return ret;
 }
 
diff --git a/drivers/usb/gadget/s3c2410_udc.c b/drivers/usb/gadget/s3c2410_udc.c
index f2e51f50e528..c33e942d119c 100644
--- a/drivers/usb/gadget/s3c2410_udc.c
+++ b/drivers/usb/gadget/s3c2410_udc.c
@@ -12,6 +12,8 @@
  * (at your option) any later version.
  */
 
+#define pr_fmt(fmt) "s3c2410_udc: " fmt
+
 #include <linux/module.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
@@ -27,6 +29,7 @@
 #include <linux/clk.h>
 #include <linux/gpio.h>
 #include <linux/prefetch.h>
+#include <linux/io.h>
 
 #include <linux/debugfs.h>
 #include <linux/seq_file.h>
@@ -35,7 +38,6 @@
 #include <linux/usb/gadget.h>
 
 #include <asm/byteorder.h>
-#include <asm/io.h>
 #include <asm/irq.h>
 #include <asm/unaligned.h>
 #include <mach/irqs.h>
@@ -115,7 +117,7 @@ static int dprintk(int level, const char *fmt, ...)
                         sizeof(printk_buf)-len, fmt, args);
         va_end(args);
 
-        return printk(KERN_DEBUG "%s", printk_buf);
+        return pr_debug("%s", printk_buf);
 }
 #else
 static int dprintk(int level, const char *fmt, ...)
@@ -125,10 +127,10 @@ static int dprintk(int level, const char *fmt, ...)
 #endif
 static int s3c2410_udc_debugfs_seq_show(struct seq_file *m, void *p)
 {
-        u32 addr_reg,pwr_reg,ep_int_reg,usb_int_reg;
+        u32 addr_reg, pwr_reg, ep_int_reg, usb_int_reg;
         u32 ep_int_en_reg, usb_int_en_reg, ep0_csr;
-        u32 ep1_i_csr1,ep1_i_csr2,ep1_o_csr1,ep1_o_csr2;
-        u32 ep2_i_csr1,ep2_i_csr2,ep2_o_csr1,ep2_o_csr2;
+        u32 ep1_i_csr1, ep1_i_csr2, ep1_o_csr1, ep1_o_csr2;
+        u32 ep2_i_csr1, ep2_i_csr2, ep2_o_csr1, ep2_o_csr2;
 
         addr_reg       = udc_read(S3C2410_UDC_FUNC_ADDR_REG);
         pwr_reg        = udc_read(S3C2410_UDC_PWR_REG);
@@ -164,10 +166,10 @@ static int s3c2410_udc_debugfs_seq_show(struct seq_file *m, void *p)
                  "EP2_I_CSR2     : 0x%04X\n"
                  "EP2_O_CSR1     : 0x%04X\n"
                  "EP2_O_CSR2     : 0x%04X\n",
-                        addr_reg,pwr_reg,ep_int_reg,usb_int_reg,
+                        addr_reg, pwr_reg, ep_int_reg, usb_int_reg,
                         ep_int_en_reg, usb_int_en_reg, ep0_csr,
-                        ep1_i_csr1,ep1_i_csr2,ep1_o_csr1,ep1_o_csr2,
-                        ep2_i_csr1,ep2_i_csr2,ep2_o_csr1,ep2_o_csr2
+                        ep1_i_csr1, ep1_i_csr2, ep1_o_csr1, ep1_o_csr2,
+                        ep2_i_csr1, ep2_i_csr2, ep2_o_csr1, ep2_o_csr2
                 );
 
         return 0;
@@ -230,7 +232,7 @@ static inline void s3c2410_udc_set_ep0_de_out(void __iomem *base)
 {
         udc_writeb(base, S3C2410_UDC_INDEX_EP0, S3C2410_UDC_INDEX_REG);
 
-        udc_writeb(base,(S3C2410_UDC_EP0_CSR_SOPKTRDY
+        udc_writeb(base, (S3C2410_UDC_EP0_CSR_SOPKTRDY
                                 | S3C2410_UDC_EP0_CSR_DE),
                         S3C2410_UDC_EP0_CSR_REG);
 }
@@ -263,7 +265,7 @@ static void s3c2410_udc_done(struct s3c2410_ep *ep,
 
         list_del_init(&req->queue);
 
-        if (likely (req->req.status == -EINPROGRESS))
+        if (likely(req->req.status == -EINPROGRESS))
                 req->req.status = status;
         else
                 status = req->req.status;
@@ -280,9 +282,9 @@ static void s3c2410_udc_nuke(struct s3c2410_udc *udc,
         if (&ep->queue == NULL)
                 return;
 
-        while (!list_empty (&ep->queue)) {
+        while (!list_empty(&ep->queue)) {
                 struct s3c2410_request *req;
-                req = list_entry (ep->queue.next, struct s3c2410_request,
+                req = list_entry(ep->queue.next, struct s3c2410_request,
                                 queue);
                 s3c2410_udc_done(ep, req, status);
         }
@@ -389,10 +391,10 @@ static int s3c2410_udc_write_fifo(struct s3c2410_ep *ep,
 
                 if (idx == 0) {
                         /* Reset signal => no need to say 'data sent' */
-                        if (! (udc_read(S3C2410_UDC_USB_INT_REG)
+                        if (!(udc_read(S3C2410_UDC_USB_INT_REG)
                                         & S3C2410_UDC_USBINT_RESET))
                                 s3c2410_udc_set_ep0_de_in(base_addr);
-                        ep->dev->ep0state=EP0_IDLE;
+                        ep->dev->ep0state = EP0_IDLE;
                 } else {
                         udc_write(idx, S3C2410_UDC_INDEX_REG);
                         ep_csr = udc_read(S3C2410_UDC_IN_CSR1_REG);
@@ -406,7 +408,7 @@ static int s3c2410_udc_write_fifo(struct s3c2410_ep *ep,
         } else {
                 if (idx == 0) {
                         /* Reset signal => no need to say 'data sent' */
-                        if (! (udc_read(S3C2410_UDC_USB_INT_REG)
+                        if (!(udc_read(S3C2410_UDC_USB_INT_REG)
                                         & S3C2410_UDC_USBINT_RESET))
                                 s3c2410_udc_set_ep0_ipr(base_addr);
                 } else {
@@ -442,7 +444,7 @@ static int s3c2410_udc_read_fifo(struct s3c2410_ep *ep,
         u8              *buf;
         u32             ep_csr;
         unsigned        bufferspace;
-        int             is_last=1;
+        int             is_last = 1;
         unsigned        avail;
         int             fifo_count = 0;
         u32             idx;
@@ -510,7 +512,7 @@ static int s3c2410_udc_read_fifo(struct s3c2410_ep *ep,
         /* Only ep0 debug messages are interesting */
         if (idx == 0)
                 dprintk(DEBUG_VERBOSE, "%s fifo count : %d [last %d]\n",
-                        __func__, fifo_count,is_last);
+                        __func__, fifo_count, is_last);
 
         if (is_last) {
                 if (idx == 0) {
@@ -542,7 +544,7 @@ static int s3c2410_udc_read_fifo(struct s3c2410_ep *ep,
 
 static int s3c2410_udc_read_fifo_crq(struct usb_ctrlrequest *crq)
 {
-        unsigned char *outbuf = (unsigned char*)crq;
+        unsigned char *outbuf = (unsigned char *)crq;
         int bytes_read = 0;
 
         udc_write(0, S3C2410_UDC_INDEX_REG);
@@ -648,7 +650,7 @@ static void s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
 
         switch (crq->bRequest) {
         case USB_REQ_SET_CONFIGURATION:
-                dprintk(DEBUG_NORMAL, "USB_REQ_SET_CONFIGURATION ... \n");
+                dprintk(DEBUG_NORMAL, "USB_REQ_SET_CONFIGURATION ...\n");
 
                 if (crq->bRequestType == USB_RECIP_DEVICE) {
                         dev->req_config = 1;
@@ -657,7 +659,7 @@ static void s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
                 break;
 
         case USB_REQ_SET_INTERFACE:
-                dprintk(DEBUG_NORMAL, "USB_REQ_SET_INTERFACE ... \n");
+                dprintk(DEBUG_NORMAL, "USB_REQ_SET_INTERFACE ...\n");
 
                 if (crq->bRequestType == USB_RECIP_INTERFACE) {
                         dev->req_config = 1;
@@ -666,7 +668,7 @@ static void s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
                 break;
 
         case USB_REQ_SET_ADDRESS:
-                dprintk(DEBUG_NORMAL, "USB_REQ_SET_ADDRESS ... \n");
+                dprintk(DEBUG_NORMAL, "USB_REQ_SET_ADDRESS ...\n");
 
                 if (crq->bRequestType == USB_RECIP_DEVICE) {
                         tmp = crq->wValue & 0x7F;
@@ -679,13 +681,12 @@ static void s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
                 break;
 
         case USB_REQ_GET_STATUS:
-                dprintk(DEBUG_NORMAL, "USB_REQ_GET_STATUS ... \n");
+                dprintk(DEBUG_NORMAL, "USB_REQ_GET_STATUS ...\n");
                 s3c2410_udc_clear_ep0_opr(base_addr);
 
                 if (dev->req_std) {
-                        if (!s3c2410_udc_get_status(dev, crq)) {
+                        if (!s3c2410_udc_get_status(dev, crq))
                                 return;
-                        }
                 }
                 break;
 
@@ -750,7 +751,7 @@ static void s3c2410_udc_handle_ep0_idle(struct s3c2410_udc *dev,
                 /* deferred i/o == no response yet */
         } else if (dev->req_pending) {
                 dprintk(DEBUG_VERBOSE, "dev->req_pending... what now?\n");
-                dev->req_pending=0;
+                dev->req_pending = 0;
         }
 
         dprintk(DEBUG_VERBOSE, "ep0state %s\n", ep0states[dev->ep0state]);
@@ -801,16 +802,14 @@ static void s3c2410_udc_handle_ep0(struct s3c2410_udc *dev)
 
         case EP0_IN_DATA_PHASE:                 /* GET_DESCRIPTOR etc */
                 dprintk(DEBUG_NORMAL, "EP0_IN_DATA_PHASE ... what now?\n");
-                if (!(ep0csr & S3C2410_UDC_EP0_CSR_IPKRDY) && req) {
+                if (!(ep0csr & S3C2410_UDC_EP0_CSR_IPKRDY) && req)
                         s3c2410_udc_write_fifo(ep, req);
-                }
                 break;
 
         case EP0_OUT_DATA_PHASE:                /* SET_DESCRIPTOR etc */
                 dprintk(DEBUG_NORMAL, "EP0_OUT_DATA_PHASE ... what now?\n");
-                if ((ep0csr & S3C2410_UDC_EP0_CSR_OPKRDY) && req ) {
-                        s3c2410_udc_read_fifo(ep,req);
-                }
+                if ((ep0csr & S3C2410_UDC_EP0_CSR_OPKRDY) && req)
+                        s3c2410_udc_read_fifo(ep, req);
                 break;
 
         case EP0_END_XFER:
@@ -836,7 +835,7 @@ static void s3c2410_udc_handle_ep(struct s3c2410_ep *ep)
         u32                     ep_csr1;
         u32                     idx;
 
-        if (likely (!list_empty(&ep->queue)))
+        if (likely(!list_empty(&ep->queue)))
                 req = list_entry(ep->queue.next,
                                 struct s3c2410_request, queue);
         else
@@ -858,9 +857,8 @@ static void s3c2410_udc_handle_ep(struct s3c2410_ep *ep)
                         return;
                 }
 
-                if (!(ep_csr1 & S3C2410_UDC_ICSR1_PKTRDY) && req) {
-                        s3c2410_udc_write_fifo(ep,req);
-                }
+                if (!(ep_csr1 & S3C2410_UDC_ICSR1_PKTRDY) && req)
+                        s3c2410_udc_write_fifo(ep, req);
         } else {
                 udc_write(idx, S3C2410_UDC_INDEX_REG);
                 ep_csr1 = udc_read(S3C2410_UDC_OUT_CSR1_REG);
@@ -873,9 +871,8 @@ static void s3c2410_udc_handle_ep(struct s3c2410_ep *ep)
                         return;
                 }
 
-                if ((ep_csr1 & S3C2410_UDC_OCSR1_PKTRDY) && req) {
-                        s3c2410_udc_read_fifo(ep,req);
-                }
+                if ((ep_csr1 & S3C2410_UDC_OCSR1_PKTRDY) && req)
+                        s3c2410_udc_read_fifo(ep, req);
         }
 }
 
@@ -1057,7 +1054,7 @@ static int s3c2410_udc_ep_enable(struct usb_ep *_ep,
         struct s3c2410_ep       *ep;
         u32                     max, tmp;
         unsigned long           flags;
-        u32                     csr1,csr2;
+        u32                     csr1, csr2;
         u32                     int_en_reg;
 
         ep = to_s3c2410_ep(_ep);
@@ -1073,7 +1070,7 @@ static int s3c2410_udc_ep_enable(struct usb_ep *_ep,
 
         max = usb_endpoint_maxp(desc) & 0x1fff;
 
-        local_irq_save (flags);
+        local_irq_save(flags);
         _ep->maxpacket = max & 0x7ff;
         ep->ep.desc = desc;
         ep->halted = 0;
@@ -1117,11 +1114,11 @@ static int s3c2410_udc_ep_enable(struct usb_ep *_ep,
 
         /* print some debug message */
         tmp = desc->bEndpointAddress;
-        dprintk (DEBUG_NORMAL, "enable %s(%d) ep%x%s-blk max %02x\n",
-                 _ep->name,ep->num, tmp,
+        dprintk(DEBUG_NORMAL, "enable %s(%d) ep%x%s-blk max %02x\n",
+                 _ep->name, ep->num, tmp,
                  desc->bEndpointAddress & USB_DIR_IN ? "in" : "out", max);
 
-        local_irq_restore (flags);
+        local_irq_restore(flags);
         s3c2410_udc_set_halt(_ep, 0);
 
         return 0;
@@ -1149,7 +1146,7 @@ static int s3c2410_udc_ep_disable(struct usb_ep *_ep)
         ep->ep.desc = NULL;
         ep->halted = 1;
 
-        s3c2410_udc_nuke (ep->dev, ep, -ESHUTDOWN);
+        s3c2410_udc_nuke(ep->dev, ep, -ESHUTDOWN);
 
         /* disable irqs */
         int_en_reg = udc_read(S3C2410_UDC_EP_INT_EN_REG);
@@ -1170,16 +1167,16 @@ s3c2410_udc_alloc_request(struct usb_ep *_ep, gfp_t mem_flags)
 {
         struct s3c2410_request *req;
 
-        dprintk(DEBUG_VERBOSE,"%s(%p,%d)\n", __func__, _ep, mem_flags);
+        dprintk(DEBUG_VERBOSE, "%s(%p,%d)\n", __func__, _ep, mem_flags);
 
         if (!_ep)
                 return NULL;
 
-        req = kzalloc (sizeof(struct s3c2410_request), mem_flags);
+        req = kzalloc(sizeof(struct s3c2410_request), mem_flags);
         if (!req)
                 return NULL;
 
-        INIT_LIST_HEAD (&req->queue);
+        INIT_LIST_HEAD(&req->queue);
         return &req->req;
 }
 
@@ -1197,7 +1194,7 @@ s3c2410_udc_free_request(struct usb_ep *_ep, struct usb_request *_req)
         if (!ep || !_req || (!ep->ep.desc && _ep->name != ep0name))
                 return;
 
-        WARN_ON (!list_empty (&req->queue));
+        WARN_ON(!list_empty(&req->queue));
         kfree(req);
 }
 
@@ -1220,12 +1217,12 @@ static int s3c2410_udc_queue(struct usb_ep *_ep, struct usb_request *_req,
         }
 
         dev = ep->dev;
-        if (unlikely (!dev->driver
+        if (unlikely(!dev->driver
                         || dev->gadget.speed == USB_SPEED_UNKNOWN)) {
                 return -ESHUTDOWN;
         }
 
-        local_irq_save (flags);
+        local_irq_save(flags);
 
         if (unlikely(!_req || !_req->complete
                         || !_req->buf || !list_empty(&req->queue))) {
@@ -1233,7 +1230,7 @@ static int s3c2410_udc_queue(struct usb_ep *_ep, struct usb_request *_req,
                         dprintk(DEBUG_NORMAL, "%s: 1 X X X\n", __func__);
                 else {
                         dprintk(DEBUG_NORMAL, "%s: 0 %01d %01d %01d\n",
-                                __func__, !_req->complete,!_req->buf,
+                                __func__, !_req->complete, !_req->buf,
                                 !list_empty(&req->queue));
                 }
 
@@ -1299,7 +1296,7 @@ static int s3c2410_udc_queue(struct usb_ep *_ep, struct usb_request *_req,
         }
 
         /* pio or dma irq handler advances the queue. */
-        if (likely (req != 0))
+        if (likely(req))
                 list_add_tail(&req->queue, &ep->queue);
 
         local_irq_restore(flags);
@@ -1329,11 +1326,11 @@ static int s3c2410_udc_dequeue(struct usb_ep *_ep, struct usb_request *_req)
 
         udc = to_s3c2410_udc(ep->gadget);
 
-        local_irq_save (flags);
+        local_irq_save(flags);
 
-        list_for_each_entry (req, &ep->queue, queue) {
+        list_for_each_entry(req, &ep->queue, queue) {
                 if (&req->req == _req) {
-                        list_del_init (&req->queue);
+                        list_del_init(&req->queue);
                         _req->status = -ECONNRESET;
                         retval = 0;
                         break;
@@ -1348,7 +1345,7 @@ static int s3c2410_udc_dequeue(struct usb_ep *_ep, struct usb_request *_req)
                 s3c2410_udc_done(ep, req, -ECONNRESET);
         }
 
-        local_irq_restore (flags);
+        local_irq_restore(flags);
         return retval;
 }
 
@@ -1367,7 +1364,7 @@ static int s3c2410_udc_set_halt(struct usb_ep *_ep, int value)
                 return -EINVAL;
         }
 
-        local_irq_save (flags);
+        local_irq_save(flags);
 
         idx = ep->bEndpointAddress & 0x7F;
 
@@ -1376,7 +1373,7 @@ static int s3c2410_udc_set_halt(struct usb_ep *_ep, int value)
                 s3c2410_udc_set_ep0_de_out(base_addr);
         } else {
                 udc_write(idx, S3C2410_UDC_INDEX_REG);
-                ep_csr = udc_read((ep->bEndpointAddress &USB_DIR_IN)
+                ep_csr = udc_read((ep->bEndpointAddress & USB_DIR_IN)
                                 ? S3C2410_UDC_IN_CSR1_REG
                                 : S3C2410_UDC_OUT_CSR1_REG);
 
@@ -1404,7 +1401,7 @@ static int s3c2410_udc_set_halt(struct usb_ep *_ep, int value)
         }
 
         ep->halted = value ? 1 : 0;
-        local_irq_restore (flags);
+        local_irq_restore(flags);
 
         return 0;
 }
@@ -1484,9 +1481,9 @@ static int s3c2410_udc_set_pullup(struct s3c2410_udc *udc, int is_on)
                         }
                         s3c2410_udc_disable(udc);
                 }
-        }
-        else
+        } else {
                 return -EOPNOTSUPP;
+        }
 
         return 0;
 }
@@ -1542,7 +1539,7 @@ static int s3c2410_vbus_draw(struct usb_gadget *_gadget, unsigned ma)
 }
 
 static int s3c2410_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *));
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *));
 static int s3c2410_udc_stop(struct usb_gadget_driver *driver);
 
 static const struct usb_gadget_ops s3c2410_ops = {
@@ -1617,20 +1614,20 @@ static void s3c2410_udc_reinit(struct s3c2410_udc *dev)
         u32 i;
 
         /* device/ep0 records init */
-        INIT_LIST_HEAD (&dev->gadget.ep_list);
-        INIT_LIST_HEAD (&dev->gadget.ep0->ep_list);
+        INIT_LIST_HEAD(&dev->gadget.ep_list);
+        INIT_LIST_HEAD(&dev->gadget.ep0->ep_list);
         dev->ep0state = EP0_IDLE;
 
         for (i = 0; i < S3C2410_ENDPOINTS; i++) {
                 struct s3c2410_ep *ep = &dev->ep[i];
 
                 if (i != 0)
-                        list_add_tail (&ep->ep.ep_list, &dev->gadget.ep_list);
+                        list_add_tail(&ep->ep.ep_list, &dev->gadget.ep_list);
 
                 ep->dev = dev;
                 ep->ep.desc = NULL;
                 ep->halted = 0;
-                INIT_LIST_HEAD (&ep->queue);
+                INIT_LIST_HEAD(&ep->queue);
         }
 }
 
@@ -1668,7 +1665,7 @@ static void s3c2410_udc_enable(struct s3c2410_udc *dev)
 }
 
 static int s3c2410_udc_start(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         struct s3c2410_udc *udc = the_controller;
         int             retval;
@@ -1683,13 +1680,13 @@ static int s3c2410_udc_start(struct usb_gadget_driver *driver,
                 return -EBUSY;
 
         if (!bind || !driver->setup || driver->max_speed < USB_SPEED_FULL) {
-                printk(KERN_ERR "Invalid driver: bind %p setup %p speed %d\n",
+                dev_err(&udc->gadget.dev, "Invalid driver: bind %p setup %p speed %d\n",
                         bind, driver->setup, driver->max_speed);
                 return -EINVAL;
         }
 #if defined(MODULE)
         if (!driver->unbind) {
-                printk(KERN_ERR "Invalid driver: no unbind method\n");
+                dev_err(&udc->gadget.dev, "Invalid driver: no unbind method\n");
                 return -EINVAL;
         }
 #endif
@@ -1699,15 +1696,17 @@ static int s3c2410_udc_start(struct usb_gadget_driver *driver,
         udc->gadget.dev.driver = &driver->driver;
 
         /* Bind the driver */
-        if ((retval = device_add(&udc->gadget.dev)) != 0) {
-                printk(KERN_ERR "Error in device_add() : %d\n",retval);
+        retval = device_add(&udc->gadget.dev);
+        if (retval) {
+                dev_err(&udc->gadget.dev, "Error in device_add() : %d\n", retval);
                 goto register_error;
         }
 
         dprintk(DEBUG_NORMAL, "binding gadget driver '%s'\n",
                 driver->driver.name);
 
-        if ((retval = bind(&udc->gadget)) != 0) {
+        retval = bind(&udc->gadget, driver);
+        if (retval) {
                 device_del(&udc->gadget.dev);
                 goto register_error;
         }
@@ -1865,7 +1864,7 @@ static int s3c2410_udc_probe(struct platform_device *pdev)
                 memory.ep[4].fifo_size = S3C2440_EP_FIFO_SIZE;
         }
 
-        spin_lock_init (&udc->lock);
+        spin_lock_init(&udc->lock);
         udc_info = pdev->dev.platform_data;
 
         rsrc_start = S3C2410_PA_USBDEV;
@@ -2028,7 +2027,8 @@ static int s3c2410_udc_remove(struct platform_device *pdev)
 }
 
 #ifdef CONFIG_PM
-static int s3c2410_udc_suspend(struct platform_device *pdev, pm_message_t message)
+static int
+s3c2410_udc_suspend(struct platform_device *pdev, pm_message_t message)
 {
         s3c2410_udc_command(S3C2410_UDC_P_DISABLE);
 
@@ -2073,7 +2073,7 @@ static int __init udc_init(void)
 
         s3c2410_udc_debugfs_root = debugfs_create_dir(gadget_name, NULL);
         if (IS_ERR(s3c2410_udc_debugfs_root)) {
-                printk(KERN_ERR "%s: debugfs dir creation failed %ld\n",
+                pr_err("%s: debugfs dir creation failed %ld\n",
                         gadget_name, PTR_ERR(s3c2410_udc_debugfs_root));
                 s3c2410_udc_debugfs_root = NULL;
         }
diff --git a/drivers/usb/gadget/serial.c b/drivers/usb/gadget/serial.c
index 665c07422c26..44752f531e85 100644
--- a/drivers/usb/gadget/serial.c
+++ b/drivers/usb/gadget/serial.c
@@ -11,7 +11,6 @@
  */
 
 #include <linux/kernel.h>
-#include <linux/utsname.h>
 #include <linux/device.h>
 #include <linux/tty.h>
 #include <linux/tty_flip.h>
@@ -37,17 +36,13 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_acm.c"
 #include "f_obex.c"
 #include "f_serial.c"
 #include "u_serial.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 /* Thanks to NetChip Technologies for donating this product ID.
 *
@@ -61,15 +56,12 @@
 
 /* string IDs are assigned dynamically */
 
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_DESCRIPTION_IDX          2
-
-static char manufacturer[50];
+#define STRING_DESCRIPTION_IDX          USB_GADGET_FIRST_AVAIL_IDX
 
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = GS_VERSION_NAME,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = GS_VERSION_NAME,
+        [USB_GADGET_SERIAL_IDX].s = "",
         [STRING_DESCRIPTION_IDX].s = NULL /* updated; f(use_acm) */,
         {  } /* end of list */
 };
@@ -94,7 +86,7 @@ static struct usb_device_descriptor device_desc = {
         /* .bMaxPacketSize0 = f(hardware) */
         .idVendor =             cpu_to_le16(GS_VENDOR_ID),
         /* .idProduct = f(use_acm) */
-        /* .bcdDevice = f(hardware) */
+        .bcdDevice = cpu_to_le16(GS_VERSION_NUM),
         /* .iManufacturer = DYNAMIC */
         /* .iProduct = DYNAMIC */
         .bNumConfigurations =   1,
@@ -162,8 +154,6 @@ static struct usb_configuration serial_config_driver = {
 
 static int __init gs_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
-        struct usb_gadget       *gadget = cdev->gadget;
         int                     status;
 
         status = gserial_setup(cdev->gadget, n_ports);
@@ -174,50 +164,14 @@ static int __init gs_bind(struct usb_composite_dev *cdev)
          * contents can be overridden by the composite_dev glue.
          */
 
-        /* device description: manufacturer, product */
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-        status = usb_string_id(cdev);
+        status = usb_string_ids_tab(cdev, strings_dev);
         if (status < 0)
                 goto fail;
-        strings_dev[STRING_MANUFACTURER_IDX].id = status;
-
-        device_desc.iManufacturer = status;
-
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail;
-        strings_dev[STRING_PRODUCT_IDX].id = status;
-
-        device_desc.iProduct = status;
-
-        /* config description */
-        status = usb_string_id(cdev);
-        if (status < 0)
-                goto fail;
-        strings_dev[STRING_DESCRIPTION_IDX].id = status;
-
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
+        status = strings_dev[STRING_DESCRIPTION_IDX].id;
         serial_config_driver.iConfiguration = status;
 
-        /* set up other descriptors */
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(GS_VERSION_NUM | gcnum);
-        else {
-                /* this is so simple (for now, no altsettings) that it
-                 * SHOULD NOT have problems with bulk-capable hardware.
-                 * so warn about unrcognized controllers -- don't panic.
-                 *
-                 * things like configuration and altsetting numbering
-                 * can need hardware-specific attention though.
-                 */
-                pr_warning("gs_bind: controller '%s' not recognized\n",
-                        gadget->name);
-                device_desc.bcdDevice =
-                        cpu_to_le16(GS_VERSION_NUM | 0x0099);
-        }
-
         if (gadget_is_otg(cdev->gadget)) {
                 serial_config_driver.descriptors = otg_desc;
                 serial_config_driver.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
@@ -229,6 +183,7 @@ static int __init gs_bind(struct usb_composite_dev *cdev)
         if (status < 0)
                 goto fail;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         INFO(cdev, "%s\n", GS_VERSION_NAME);
 
         return 0;
@@ -238,11 +193,12 @@ fail:
         return status;
 }
 
-static struct usb_composite_driver gserial_driver = {
+static __refdata struct usb_composite_driver gserial_driver = {
         .name           = "g_serial",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_SUPER,
+        .bind           = gs_bind,
 };
 
 static int __init init(void)
@@ -271,7 +227,7 @@ static int __init init(void)
         }
         strings_dev[STRING_DESCRIPTION_IDX].s = serial_config_driver.label;
 
-        return usb_composite_probe(&gserial_driver, gs_bind);
+        return usb_composite_probe(&gserial_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/gadget/tcm_usb_gadget.c b/drivers/usb/gadget/tcm_usb_gadget.c
index 5444866e13ef..eaa1005377fc 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.c
+++ b/drivers/usb/gadget/tcm_usb_gadget.c
@@ -25,13 +25,10 @@
 #include <target/configfs_macros.h>
 #include <asm/unaligned.h>
 
-#include "usbstring.c"
-#include "epautoconf.c"
-#include "config.c"
-#include "composite.c"
-
 #include "tcm_usb_gadget.h"
 
+USB_GADGET_COMPOSITE_OPTIONS();
+
 static struct target_fabric_configfs *usbg_fabric_configfs;
 
 static inline struct f_uas *to_f_uas(struct usb_function *f)
@@ -1977,7 +1974,6 @@ static struct usb_interface_descriptor bot_intf_desc = {
         .bInterfaceClass =      USB_CLASS_MASS_STORAGE,
         .bInterfaceSubClass =   USB_SC_SCSI,
         .bInterfaceProtocol =   USB_PR_BULK,
-        .iInterface =           USB_G_STR_INT_UAS,
 };
 
 static struct usb_interface_descriptor uasp_intf_desc = {
@@ -1988,7 +1984,6 @@ static struct usb_interface_descriptor uasp_intf_desc = {
         .bInterfaceClass =      USB_CLASS_MASS_STORAGE,
         .bInterfaceSubClass =   USB_SC_SCSI,
         .bInterfaceProtocol =   USB_PR_UAS,
-        .iInterface =           USB_G_STR_INT_BBB,
 };
 
 static struct usb_endpoint_descriptor uasp_bi_desc = {
@@ -2209,20 +2204,16 @@ static struct usb_device_descriptor usbg_device_desc = {
         .bDeviceClass =         USB_CLASS_PER_INTERFACE,
         .idVendor =             cpu_to_le16(UAS_VENDOR_ID),
         .idProduct =            cpu_to_le16(UAS_PRODUCT_ID),
-        .iManufacturer =        USB_G_STR_MANUFACTOR,
-        .iProduct =             USB_G_STR_PRODUCT,
-        .iSerialNumber =        USB_G_STR_SERIAL,
-
         .bNumConfigurations =   1,
 };
 
 static struct usb_string        usbg_us_strings[] = {
-        { USB_G_STR_MANUFACTOR, "Target Manufactor"},
-        { USB_G_STR_PRODUCT,    "Target Product"},
-        { USB_G_STR_SERIAL,     "000000000001"},
-        { USB_G_STR_CONFIG,     "default config"},
-        { USB_G_STR_INT_UAS,    "USB Attached SCSI"},
-        { USB_G_STR_INT_BBB,    "Bulk Only Transport"},
+        [USB_GADGET_MANUFACTURER_IDX].s = "Target Manufactor",
+        [USB_GADGET_PRODUCT_IDX].s      = "Target Product",
+        [USB_GADGET_SERIAL_IDX].s       = "000000000001",
+        [USB_G_STR_CONFIG].s            = "default config",
+        [USB_G_STR_INT_UAS].s           = "USB Attached SCSI",
+        [USB_G_STR_INT_BBB].s           = "Bulk Only Transport",
         { },
 };
 
@@ -2244,7 +2235,6 @@ static int guas_unbind(struct usb_composite_dev *cdev)
 static struct usb_configuration usbg_config_driver = {
         .label                  = "Linux Target",
         .bConfigurationValue    = 1,
-        .iConfiguration         = USB_G_STR_CONFIG,
         .bmAttributes           = USB_CONFIG_ATT_SELFPOWER,
 };
 
@@ -2417,6 +2407,9 @@ static int usbg_cfg_bind(struct usb_configuration *c)
         fu->function.disable = usbg_disable;
         fu->tpg = the_only_tpg_I_currently_have;
 
+        bot_intf_desc.iInterface = usbg_us_strings[USB_G_STR_INT_BBB].id;
+        uasp_intf_desc.iInterface = usbg_us_strings[USB_G_STR_INT_UAS].id;
+
         ret = usb_add_function(c, &fu->function);
         if (ret)
                 goto err;
@@ -2431,22 +2424,38 @@ static int usb_target_bind(struct usb_composite_dev *cdev)
 {
         int ret;
 
+        ret = usb_string_ids_tab(cdev, usbg_us_strings);
+        if (ret)
+                return ret;
+
+        usbg_device_desc.iManufacturer =
+                usbg_us_strings[USB_GADGET_MANUFACTURER_IDX].id;
+        usbg_device_desc.iProduct = usbg_us_strings[USB_GADGET_PRODUCT_IDX].id;
+        usbg_device_desc.iSerialNumber =
+                usbg_us_strings[USB_GADGET_SERIAL_IDX].id;
+        usbg_config_driver.iConfiguration =
+                usbg_us_strings[USB_G_STR_CONFIG].id;
+
         ret = usb_add_config(cdev, &usbg_config_driver,
                         usbg_cfg_bind);
+        if (ret)
+                return ret;
+        usb_composite_overwrite_options(cdev, &coverwrite);
         return 0;
 }
 
-static struct usb_composite_driver usbg_driver = {
+static __refdata struct usb_composite_driver usbg_driver = {
         .name           = "g_target",
         .dev            = &usbg_device_desc,
         .strings        = usbg_strings,
         .max_speed      = USB_SPEED_SUPER,
+        .bind           = usb_target_bind,
         .unbind         = guas_unbind,
 };
 
 static int usbg_attach(struct usbg_tpg *tpg)
 {
-        return usb_composite_probe(&usbg_driver, usb_target_bind);
+        return usb_composite_probe(&usbg_driver);
 }
 
 static void usbg_detach(struct usbg_tpg *tpg)
diff --git a/drivers/usb/gadget/tcm_usb_gadget.h b/drivers/usb/gadget/tcm_usb_gadget.h
index bb18999a9a8d..8289219925b8 100644
--- a/drivers/usb/gadget/tcm_usb_gadget.h
+++ b/drivers/usb/gadget/tcm_usb_gadget.h
@@ -16,12 +16,11 @@
 #define UASP_SS_EP_COMP_LOG_STREAMS 4
 #define UASP_SS_EP_COMP_NUM_STREAMS (1 << UASP_SS_EP_COMP_LOG_STREAMS)
 
-#define USB_G_STR_MANUFACTOR    1
-#define USB_G_STR_PRODUCT       2
-#define USB_G_STR_SERIAL        3
-#define USB_G_STR_CONFIG        4
-#define USB_G_STR_INT_UAS       5
-#define USB_G_STR_INT_BBB       6
+enum {
+        USB_G_STR_CONFIG = USB_GADGET_FIRST_AVAIL_IDX,
+        USB_G_STR_INT_UAS,
+        USB_G_STR_INT_BBB,
+};
 
 #define USB_G_ALT_INT_BBB       0
 #define USB_G_ALT_INT_UAS       1
diff --git a/drivers/usb/gadget/u_ether.c b/drivers/usb/gadget/u_ether.c
index 0e5230926154..b9c46900c2c1 100644
--- a/drivers/usb/gadget/u_ether.c
+++ b/drivers/usb/gadget/u_ether.c
@@ -14,6 +14,7 @@
 /* #define VERBOSE_DEBUG */
 
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/gfp.h>
 #include <linux/device.h>
 #include <linux/ctype.h>
@@ -83,17 +84,10 @@ struct eth_dev {
 
 #define DEFAULT_QLEN    2       /* double buffering by default */
 
-
-#ifdef CONFIG_USB_GADGET_DUALSPEED
-
 static unsigned qmult = 5;
 module_param(qmult, uint, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(qmult, "queue length multiplier at high/super speed");
 
-#else   /* full speed (low speed doesn't do bulk) */
-#define qmult           1
-#endif
-
 /* for dual-speed hardware, use deeper queues at high/super speed */
 static inline int qlen(struct usb_gadget *gadget)
 {
diff --git a/drivers/usb/gadget/udc-core.c b/drivers/usb/gadget/udc-core.c
index e5e44f8cde9a..f3cd9690b101 100644
--- a/drivers/usb/gadget/udc-core.c
+++ b/drivers/usb/gadget/udc-core.c
@@ -118,7 +118,7 @@ EXPORT_SYMBOL_GPL(usb_gadget_unmap_request);
  */
 static inline int usb_gadget_start(struct usb_gadget *gadget,
                 struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+                int (*bind)(struct usb_gadget *, struct usb_gadget_driver *))
 {
         return gadget->ops->start(driver, bind);
 }
@@ -262,8 +262,8 @@ static void usb_gadget_remove_driver(struct usb_udc *udc)
         kobject_uevent(&udc->dev.kobj, KOBJ_CHANGE);
 
         if (udc_is_newstyle(udc)) {
-                udc->driver->disconnect(udc->gadget);
                 usb_gadget_disconnect(udc->gadget);
+                udc->driver->disconnect(udc->gadget);
                 udc->driver->unbind(udc->gadget);
                 usb_gadget_udc_stop(udc->gadget, udc->driver);
         } else {
@@ -311,13 +311,12 @@ EXPORT_SYMBOL_GPL(usb_del_gadget_udc);
 
 /* ------------------------------------------------------------------------- */
 
-int usb_gadget_probe_driver(struct usb_gadget_driver *driver,
-                int (*bind)(struct usb_gadget *))
+int usb_gadget_probe_driver(struct usb_gadget_driver *driver)
 {
         struct usb_udc          *udc = NULL;
         int                     ret;
 
-        if (!driver || !bind || !driver->setup)
+        if (!driver || !driver->bind || !driver->setup)
                 return -EINVAL;
 
         mutex_lock(&udc_lock);
@@ -339,7 +338,7 @@ found:
         udc->dev.driver = &driver->driver;
 
         if (udc_is_newstyle(udc)) {
-                ret = bind(udc->gadget);
+                ret = driver->bind(udc->gadget, driver);
                 if (ret)
                         goto err1;
                 ret = usb_gadget_udc_start(udc->gadget, driver);
@@ -350,7 +349,7 @@ found:
                 usb_gadget_connect(udc->gadget);
         } else {
 
-                ret = usb_gadget_start(udc->gadget, driver, bind);
+                ret = usb_gadget_start(udc->gadget, driver, driver->bind);
                 if (ret)
                         goto err1;
 
diff --git a/drivers/usb/gadget/usbstring.c b/drivers/usb/gadget/usbstring.c
index 4d25b9009edf..1f49fce0f0b7 100644
--- a/drivers/usb/gadget/usbstring.c
+++ b/drivers/usb/gadget/usbstring.c
@@ -9,6 +9,7 @@
 
 #include <linux/errno.h>
 #include <linux/kernel.h>
+#include <linux/module.h>
 #include <linux/list.h>
 #include <linux/string.h>
 #include <linux/device.h>
@@ -68,4 +69,4 @@ usb_gadget_get_string (struct usb_gadget_strings *table, int id, u8 *buf)
         buf [1] = USB_DT_STRING;
         return buf [0];
 }
-
+EXPORT_SYMBOL_GPL(usb_gadget_get_string);
diff --git a/drivers/usb/gadget/webcam.c b/drivers/usb/gadget/webcam.c
index 120e134e805e..69cf5c2cd335 100644
--- a/drivers/usb/gadget/webcam.c
+++ b/drivers/usb/gadget/webcam.c
@@ -23,16 +23,12 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "uvc_queue.c"
 #include "uvc_video.c"
 #include "uvc_v4l2.c"
 #include "f_uvc.c"
 
+USB_GADGET_COMPOSITE_OPTIONS();
 /* --------------------------------------------------------------------------
  * Device descriptor
  */
@@ -47,13 +43,12 @@ static char webcam_config_label[] = "Video";
 
 /* string IDs are assigned dynamically */
 
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_DESCRIPTION_IDX          2
+#define STRING_DESCRIPTION_IDX          USB_GADGET_FIRST_AVAIL_IDX
 
 static struct usb_string webcam_strings[] = {
-        [STRING_MANUFACTURER_IDX].s = webcam_vendor_label,
-        [STRING_PRODUCT_IDX].s = webcam_product_label,
+        [USB_GADGET_MANUFACTURER_IDX].s = webcam_vendor_label,
+        [USB_GADGET_PRODUCT_IDX].s = webcam_product_label,
+        [USB_GADGET_SERIAL_IDX].s = "",
         [STRING_DESCRIPTION_IDX].s = webcam_config_label,
         {  }
 };
@@ -358,26 +353,22 @@ webcam_bind(struct usb_composite_dev *cdev)
         /* Allocate string descriptor numbers ... note that string contents
          * can be overridden by the composite_dev glue.
          */
-        if ((ret = usb_string_id(cdev)) < 0)
-                goto error;
-        webcam_strings[STRING_MANUFACTURER_IDX].id = ret;
-        webcam_device_descriptor.iManufacturer = ret;
-
-        if ((ret = usb_string_id(cdev)) < 0)
-                goto error;
-        webcam_strings[STRING_PRODUCT_IDX].id = ret;
-        webcam_device_descriptor.iProduct = ret;
-
-        if ((ret = usb_string_id(cdev)) < 0)
+        ret = usb_string_ids_tab(cdev, webcam_strings);
+        if (ret < 0)
                 goto error;
-        webcam_strings[STRING_DESCRIPTION_IDX].id = ret;
-        webcam_config_driver.iConfiguration = ret;
+        webcam_device_descriptor.iManufacturer =
+                webcam_strings[USB_GADGET_MANUFACTURER_IDX].id;
+        webcam_device_descriptor.iProduct =
+                webcam_strings[USB_GADGET_PRODUCT_IDX].id;
+        webcam_config_driver.iConfiguration =
+                webcam_strings[STRING_DESCRIPTION_IDX].id;
 
         /* Register our configuration. */
         if ((ret = usb_add_config(cdev, &webcam_config_driver,
                                         webcam_config_bind)) < 0)
                 goto error;
 
+        usb_composite_overwrite_options(cdev, &coverwrite);
         INFO(cdev, "Webcam Video Gadget\n");
         return 0;
 
@@ -390,18 +381,19 @@ error:
  * Driver
  */
 
-static struct usb_composite_driver webcam_driver = {
+static __refdata struct usb_composite_driver webcam_driver = {
         .name           = "g_webcam",
         .dev            = &webcam_device_descriptor,
         .strings        = webcam_device_strings,
         .max_speed      = USB_SPEED_SUPER,
+        .bind           = webcam_bind,
         .unbind         = webcam_unbind,
 };
 
 static int __init
 webcam_init(void)
 {
-        return usb_composite_probe(&webcam_driver, webcam_bind);
+        return usb_composite_probe(&webcam_driver);
 }
 
 static void __exit
diff --git a/drivers/usb/gadget/zero.c b/drivers/usb/gadget/zero.c
index 12ad516ada77..6bf4c0611365 100644
--- a/drivers/usb/gadget/zero.c
+++ b/drivers/usb/gadget/zero.c
@@ -42,7 +42,6 @@
 
 #include <linux/kernel.h>
 #include <linux/slab.h>
-#include <linux/utsname.h>
 #include <linux/device.h>
 
 #include "g_zero.h"
@@ -58,15 +57,11 @@
  * the runtime footprint, and giving us at least some parts of what
  * a "gcc --combine ... part1.c part2.c part3.c ... " build would.
  */
-#include "composite.c"
-#include "usbstring.c"
-#include "config.c"
-#include "epautoconf.c"
-
 #include "f_sourcesink.c"
 #include "f_loopback.c"
 
 /*-------------------------------------------------------------------------*/
+USB_GADGET_COMPOSITE_OPTIONS();
 
 #define DRIVER_VERSION          "Cinco de Mayo 2008"
 
@@ -141,20 +136,13 @@ const struct usb_descriptor_header *otg_desc[] = {
 #endif
 
 /* string IDs are assigned dynamically */
-
-#define STRING_MANUFACTURER_IDX         0
-#define STRING_PRODUCT_IDX              1
-#define STRING_SERIAL_IDX               2
-
-static char manufacturer[50];
-
 /* default serial number takes at least two packets */
 static char serial[] = "0123456789.0123456789.0123456789";
 
 static struct usb_string strings_dev[] = {
-        [STRING_MANUFACTURER_IDX].s = manufacturer,
-        [STRING_PRODUCT_IDX].s = longname,
-        [STRING_SERIAL_IDX].s = serial,
+        [USB_GADGET_MANUFACTURER_IDX].s = "",
+        [USB_GADGET_PRODUCT_IDX].s = longname,
+        [USB_GADGET_SERIAL_IDX].s = serial,
         {  }                    /* end of list */
 };
 
@@ -265,30 +253,18 @@ static void zero_resume(struct usb_composite_dev *cdev)
 
 static int __init zero_bind(struct usb_composite_dev *cdev)
 {
-        int                     gcnum;
-        struct usb_gadget       *gadget = cdev->gadget;
-        int                     id;
+        int                     status;
 
         /* Allocate string descriptor numbers ... note that string
          * contents can be overridden by the composite_dev glue.
          */
-        id = usb_string_id(cdev);
-        if (id < 0)
-                return id;
-        strings_dev[STRING_MANUFACTURER_IDX].id = id;
-        device_desc.iManufacturer = id;
-
-        id = usb_string_id(cdev);
-        if (id < 0)
-                return id;
-        strings_dev[STRING_PRODUCT_IDX].id = id;
-        device_desc.iProduct = id;
-
-        id = usb_string_id(cdev);
-        if (id < 0)
-                return id;
-        strings_dev[STRING_SERIAL_IDX].id = id;
-        device_desc.iSerialNumber = id;
+        status = usb_string_ids_tab(cdev, strings_dev);
+        if (status < 0)
+                return status;
+
+        device_desc.iManufacturer = strings_dev[USB_GADGET_MANUFACTURER_IDX].id;
+        device_desc.iProduct = strings_dev[USB_GADGET_PRODUCT_IDX].id;
+        device_desc.iSerialNumber = strings_dev[USB_GADGET_SERIAL_IDX].id;
 
         setup_timer(&autoresume_timer, zero_autoresume, (unsigned long) cdev);
 
@@ -303,28 +279,10 @@ static int __init zero_bind(struct usb_composite_dev *cdev)
                 loopback_add(cdev, autoresume != 0);
         }
 
-        gcnum = usb_gadget_controller_number(gadget);
-        if (gcnum >= 0)
-                device_desc.bcdDevice = cpu_to_le16(0x0200 + gcnum);
-        else {
-                /* gadget zero is so simple (for now, no altsettings) that
-                 * it SHOULD NOT have problems with bulk-capable hardware.
-                 * so just warn about unrcognized controllers -- don't panic.
-                 *
-                 * things like configuration and altsetting numbering
-                 * can need hardware-specific attention though.
-                 */
-                pr_warning("%s: controller '%s' not recognized\n",
-                        longname, gadget->name);
-                device_desc.bcdDevice = cpu_to_le16(0x9999);
-        }
+        usb_composite_overwrite_options(cdev, &coverwrite);
 
         INFO(cdev, "%s, version: " DRIVER_VERSION "\n", longname);
 
-        snprintf(manufacturer, sizeof manufacturer, "%s %s with %s",
-                init_utsname()->sysname, init_utsname()->release,
-                gadget->name);
-
         return 0;
 }
 
@@ -334,11 +292,12 @@ static int zero_unbind(struct usb_composite_dev *cdev)
         return 0;
 }
 
-static struct usb_composite_driver zero_driver = {
+static __refdata struct usb_composite_driver zero_driver = {
         .name           = "zero",
         .dev            = &device_desc,
         .strings        = dev_strings,
         .max_speed      = USB_SPEED_SUPER,
+        .bind           = zero_bind,
         .unbind         = zero_unbind,
         .suspend        = zero_suspend,
         .resume         = zero_resume,
@@ -349,7 +308,7 @@ MODULE_LICENSE("GPL");
 
 static int __init init(void)
 {
-        return usb_composite_probe(&zero_driver, zero_bind);
+        return usb_composite_probe(&zero_driver);
 }
 module_init(init);
 
diff --git a/drivers/usb/host/Kconfig b/drivers/usb/host/Kconfig
index 075d2eca8108..b1deb0fd4197 100644
--- a/drivers/usb/host/Kconfig
+++ b/drivers/usb/host/Kconfig
@@ -18,8 +18,8 @@ config USB_C67X00_HCD
           module will be called c67x00.
 
 config USB_XHCI_HCD
-        tristate "xHCI HCD (USB 3.0) support (EXPERIMENTAL)"
-        depends on USB && USB_ARCH_HAS_XHCI && EXPERIMENTAL
+        tristate "xHCI HCD (USB 3.0) support"
+        depends on USB && USB_ARCH_HAS_XHCI
         ---help---
           The eXtensible Host Controller Interface (xHCI) is standard for USB 3.0
           "SuperSpeed" host controller hardware.
@@ -262,7 +262,7 @@ config USB_ISP116X_HCD
 
 config USB_ISP1760_HCD
         tristate "ISP 1760 HCD support"
-        depends on USB && EXPERIMENTAL
+        depends on USB
         ---help---
           The ISP1760 chip is a USB 2.0 host controller.
 
@@ -292,7 +292,7 @@ config USB_OHCI_HCD
         depends on USB && USB_ARCH_HAS_OHCI
         select ISP1301_OMAP if MACH_OMAP_H2 || MACH_OMAP_H3
         select USB_OTG_UTILS if ARCH_OMAP
-        select USB_ISP1301 if ARCH_LPC32XX || ARCH_PNX4008
+        depends on USB_ISP1301 || !(ARCH_LPC32XX || ARCH_PNX4008)
         ---help---
           The Open Host Controller Interface (OHCI) is a standard for accessing
           USB 1.1 host controller hardware.  It does more in hardware than Intel's
@@ -376,7 +376,7 @@ config USB_OHCI_HCD_PCI
 
 config USB_OHCI_HCD_SSB
         bool "OHCI support for Broadcom SSB OHCI core (DEPRECATED)"
-        depends on USB_OHCI_HCD && (SSB = y || SSB = USB_OHCI_HCD) && EXPERIMENTAL
+        depends on USB_OHCI_HCD && (SSB = y || SSB = USB_OHCI_HCD)
         select USB_HCD_SSB
         select USB_OHCI_HCD_PLATFORM
         default n
@@ -414,21 +414,21 @@ config USB_CNS3XXX_OHCI
 
 config USB_OHCI_HCD_PLATFORM
         bool "Generic OHCI driver for a platform device"
-        depends on USB_OHCI_HCD && EXPERIMENTAL
+        depends on USB_OHCI_HCD
         default n
         ---help---
           Adds an OHCI host driver for a generic platform device, which
-          provieds a memory space and an irq.
+          provides a memory space and an irq.
 
           If unsure, say N.
 
 config USB_EHCI_HCD_PLATFORM
         bool "Generic EHCI driver for a platform device"
-        depends on USB_EHCI_HCD && EXPERIMENTAL
+        depends on USB_EHCI_HCD
         default n
         ---help---
           Adds an EHCI host driver for a generic platform device, which
-          provieds a memory space and an irq.
+          provides a memory space and an irq.
 
           If unsure, say N.
 
@@ -450,7 +450,7 @@ config USB_OHCI_LITTLE_ENDIAN
 
 config USB_UHCI_HCD
         tristate "UHCI HCD (most Intel and VIA) support"
-        depends on USB && (PCI || SPARC_LEON)
+        depends on USB && (PCI || SPARC_LEON || ARCH_VT8500)
         ---help---
           The Universal Host Controller Interface is a standard by Intel for
           accessing the USB hardware in the PC (which is also called the USB
@@ -468,7 +468,15 @@ config USB_UHCI_HCD
 config USB_UHCI_SUPPORT_NON_PCI_HC
         bool
         depends on USB_UHCI_HCD
-        default y if SPARC_LEON
+        default y if (SPARC_LEON || ARCH_VT8500)
+
+config USB_UHCI_PLATFORM
+        bool "Generic UHCI Platform Driver support"
+        depends on USB_UHCI_SUPPORT_NON_PCI_HC
+        default y if ARCH_VT8500
+        ---help---
+          Enable support for generic UHCI platform devices that require no
+          additional configuration.
 
 config USB_UHCI_BIG_ENDIAN_MMIO
         bool
@@ -583,8 +591,7 @@ config USB_RENESAS_USBHS_HCD
           module will be called renesas-usbhs.
 
 config USB_WHCI_HCD
-        tristate "Wireless USB Host Controller Interface (WHCI) driver (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Wireless USB Host Controller Interface (WHCI) driver"
         depends on PCI && USB && UWB
         select USB_WUSB
         select UWB_WHCI
@@ -596,8 +603,7 @@ config USB_WHCI_HCD
           will be called "whci-hcd".
 
 config USB_HWA_HCD
-        tristate "Host Wire Adapter (HWA) driver (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Host Wire Adapter (HWA) driver"
         depends on USB && UWB
         select USB_WUSB
         select UWB_HWA
@@ -648,7 +654,7 @@ config USB_OCTEON2_COMMON
 
 config USB_HCD_BCMA
         tristate "BCMA usb host driver"
-        depends on BCMA && EXPERIMENTAL
+        depends on BCMA
         select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
         select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
         help
@@ -660,7 +666,7 @@ config USB_HCD_BCMA
 
 config USB_HCD_SSB
         tristate "SSB usb host driver"
-        depends on SSB && EXPERIMENTAL
+        depends on SSB
         select USB_OHCI_HCD_PLATFORM if USB_OHCI_HCD
         select USB_EHCI_HCD_PLATFORM if USB_EHCI_HCD
         help
diff --git a/drivers/usb/host/ehci-atmel.c b/drivers/usb/host/ehci-atmel.c
index a47e2cffaaf8..411bb74152eb 100644
--- a/drivers/usb/host/ehci-atmel.c
+++ b/drivers/usb/host/ehci-atmel.c
@@ -150,31 +150,24 @@ static int __devinit ehci_atmel_drv_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                dev_dbg(&pdev->dev, "controller already in use\n");
-                retval = -EBUSY;
-                goto fail_request_resource;
-        }
-
-        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (hcd->regs == NULL) {
                 dev_dbg(&pdev->dev, "error mapping memory\n");
                 retval = -EFAULT;
-                goto fail_ioremap;
+                goto fail_request_resource;
         }
 
-        iclk = clk_get(&pdev->dev, "ehci_clk");
+        iclk = devm_clk_get(&pdev->dev, "ehci_clk");
         if (IS_ERR(iclk)) {
                 dev_err(&pdev->dev, "Error getting interface clock\n");
                 retval = -ENOENT;
-                goto fail_get_iclk;
+                goto fail_request_resource;
         }
-        fclk = clk_get(&pdev->dev, "uhpck");
+        fclk = devm_clk_get(&pdev->dev, "uhpck");
         if (IS_ERR(fclk)) {
                 dev_err(&pdev->dev, "Error getting function clock\n");
                 retval = -ENOENT;
-                goto fail_get_fclk;
+                goto fail_request_resource;
         }
 
         atmel_start_ehci(pdev);
@@ -187,13 +180,6 @@ static int __devinit ehci_atmel_drv_probe(struct platform_device *pdev)
 
 fail_add_hcd:
         atmel_stop_ehci(pdev);
-        clk_put(fclk);
-fail_get_fclk:
-        clk_put(iclk);
-fail_get_iclk:
-        iounmap(hcd->regs);
-fail_ioremap:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 fail_request_resource:
         usb_put_hcd(hcd);
 fail_create_hcd:
@@ -209,13 +195,9 @@ static int __devexit ehci_atmel_drv_remove(struct platform_device *pdev)
 
         ehci_shutdown(hcd);
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 
         atmel_stop_ehci(pdev);
-        clk_put(fclk);
-        clk_put(iclk);
         fclk = iclk = NULL;
 
         return 0;
diff --git a/drivers/usb/host/ehci-au1xxx.c b/drivers/usb/host/ehci-au1xxx.c
index cba10d625a5d..65c945eb4144 100644
--- a/drivers/usb/host/ehci-au1xxx.c
+++ b/drivers/usb/host/ehci-au1xxx.c
@@ -98,23 +98,17 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug("request_mem_region failed");
-                ret = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (!hcd->regs) {
-                pr_debug("ioremap failed");
+                pr_debug("devm_request_and_ioremap failed");
                 ret = -ENOMEM;
-                goto err2;
+                goto err1;
         }
 
         if (alchemy_usb_control(ALCHEMY_USB_EHCI0, 1)) {
                 printk(KERN_INFO "%s: controller init failed!\n", pdev->name);
                 ret = -ENODEV;
-                goto err3;
+                goto err1;
         }
 
         ret = usb_add_hcd(hcd, pdev->resource[1].start,
@@ -125,10 +119,6 @@ static int ehci_hcd_au1xxx_drv_probe(struct platform_device *pdev)
         }
 
         alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
-err3:
-        iounmap(hcd->regs);
-err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
         return ret;
@@ -140,8 +130,6 @@ static int ehci_hcd_au1xxx_drv_remove(struct platform_device *pdev)
 
         usb_remove_hcd(hcd);
         alchemy_usb_control(ALCHEMY_USB_EHCI0, 0);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
diff --git a/drivers/usb/host/ehci-cns3xxx.c b/drivers/usb/host/ehci-cns3xxx.c
index caaa3e5be334..d91708d2e729 100644
--- a/drivers/usb/host/ehci-cns3xxx.c
+++ b/drivers/usb/host/ehci-cns3xxx.c
@@ -105,27 +105,17 @@ static int cns3xxx_ehci_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                dev_dbg(dev, "controller already in use\n");
-                retval = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (hcd->regs == NULL) {
                 dev_dbg(dev, "error mapping memory\n");
                 retval = -EFAULT;
-                goto err2;
+                goto err1;
         }
 
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval == 0)
                 return retval;
 
-        iounmap(hcd->regs);
-err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
 
@@ -137,8 +127,6 @@ static int cns3xxx_ehci_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
         /*
          * EHCI and OHCI share the same clock and power,
diff --git a/drivers/usb/host/ehci-dbg.c b/drivers/usb/host/ehci-dbg.c
index f0c00de035ef..1599806e3d47 100644
--- a/drivers/usb/host/ehci-dbg.c
+++ b/drivers/usb/host/ehci-dbg.c
@@ -653,10 +653,8 @@ static ssize_t fill_periodic_buffer(struct debug_buffer *buf)
                                                 seen [seen_count++].qh = p.qh;
                                 } else
                                         temp = 0;
-                                if (p.qh) {
-                                        tag = Q_NEXT_TYPE(ehci, hw->hw_next);
-                                        p = p.qh->qh_next;
-                                }
+                                tag = Q_NEXT_TYPE(ehci, hw->hw_next);
+                                p = p.qh->qh_next;
                                 break;
                         case Q_TYPE_FSTN:
                                 temp = scnprintf (next, size,
diff --git a/drivers/usb/host/ehci-fsl.c b/drivers/usb/host/ehci-fsl.c
index b7451b29c5ac..9bfde82078ec 100644
--- a/drivers/usb/host/ehci-fsl.c
+++ b/drivers/usb/host/ehci-fsl.c
@@ -210,11 +210,11 @@ static void usb_hcd_fsl_remove(struct usb_hcd *hcd,
         usb_put_hcd(hcd);
 }
 
-static void ehci_fsl_setup_phy(struct usb_hcd *hcd,
+static int ehci_fsl_setup_phy(struct usb_hcd *hcd,
                                enum fsl_usb2_phy_modes phy_mode,
                                unsigned int port_offset)
 {
-        u32 portsc, temp;
+        u32 portsc;
         struct ehci_hcd *ehci = hcd_to_ehci(hcd);
         void __iomem *non_ehci = hcd->regs;
         struct device *dev = hcd->self.controller;
@@ -232,9 +232,15 @@ static void ehci_fsl_setup_phy(struct usb_hcd *hcd,
         case FSL_USB2_PHY_ULPI:
                 if (pdata->controller_ver) {
                         /* controller version 1.6 or above */
-                        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
-                        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp |
-                                USB_CTRL_USB_EN | ULPI_PHY_CLK_SEL);
+                        setbits32(non_ehci + FSL_SOC_USB_CTRL,
+                                        ULPI_PHY_CLK_SEL);
+                        /*
+                         * Due to controller issue of PHY_CLK_VALID in ULPI
+                         * mode, we set USB_CTRL_USB_EN before checking
+                         * PHY_CLK_VALID, otherwise PHY_CLK_VALID doesn't work.
+                         */
+                        clrsetbits_be32(non_ehci + FSL_SOC_USB_CTRL,
+                                        UTMI_PHY_EN, USB_CTRL_USB_EN);
                 }
                 portsc |= PORT_PTS_ULPI;
                 break;
@@ -247,9 +253,7 @@ static void ehci_fsl_setup_phy(struct usb_hcd *hcd,
         case FSL_USB2_PHY_UTMI:
                 if (pdata->controller_ver) {
                         /* controller version 1.6 or above */
-                        temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
-                        out_be32(non_ehci + FSL_SOC_USB_CTRL, temp |
-                                UTMI_PHY_EN | USB_CTRL_USB_EN);
+                        setbits32(non_ehci + FSL_SOC_USB_CTRL, UTMI_PHY_EN);
                         mdelay(FSL_UTMI_PHY_DLY);  /* Delay for UTMI PHY CLK to
                                                 become stable - 10ms*/
                 }
@@ -262,23 +266,33 @@ static void ehci_fsl_setup_phy(struct usb_hcd *hcd,
         case FSL_USB2_PHY_NONE:
                 break;
         }
+
+        if (pdata->controller_ver && (phy_mode == FSL_USB2_PHY_ULPI)) {
+                /* check PHY_CLK_VALID to get phy clk valid */
+                if (!spin_event_timeout(in_be32(non_ehci + FSL_SOC_USB_CTRL) &
+                                PHY_CLK_VALID, FSL_USB_PHY_CLK_TIMEOUT, 0)) {
+                        printk(KERN_WARNING "fsl-ehci: USB PHY clock invalid\n");
+                        return -EINVAL;
+                }
+        }
+
         ehci_writel(ehci, portsc, &ehci->regs->port_status[port_offset]);
+
+        if (phy_mode != FSL_USB2_PHY_ULPI)
+                setbits32(non_ehci + FSL_SOC_USB_CTRL, USB_CTRL_USB_EN);
+
+        return 0;
 }
 
-static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
+static int ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 {
         struct usb_hcd *hcd = ehci_to_hcd(ehci);
         struct fsl_usb2_platform_data *pdata;
         void __iomem *non_ehci = hcd->regs;
-        u32 temp;
 
         pdata = hcd->self.controller->platform_data;
 
-        /* Enable PHY interface in the control reg. */
         if (pdata->have_sysif_regs) {
-                temp = in_be32(non_ehci + FSL_SOC_USB_CTRL);
-                out_be32(non_ehci + FSL_SOC_USB_CTRL, temp | 0x00000004);
-
                 /*
                 * Turn on cache snooping hardware, since some PowerPC platforms
                 * wholly rely on hardware to deal with cache coherent
@@ -293,7 +307,8 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 
         if ((pdata->operating_mode == FSL_USB2_DR_HOST) ||
                         (pdata->operating_mode == FSL_USB2_DR_OTG))
-                ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0);
+                if (ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0))
+                        return -EINVAL;
 
         if (pdata->operating_mode == FSL_USB2_MPH_HOST) {
                 unsigned int chip, rev, svr;
@@ -307,9 +322,12 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
                         ehci->has_fsl_port_bug = 1;
 
                 if (pdata->port_enables & FSL_USB2_PORT0_ENABLED)
-                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0);
+                        if (ehci_fsl_setup_phy(hcd, pdata->phy_mode, 0))
+                                return -EINVAL;
+
                 if (pdata->port_enables & FSL_USB2_PORT1_ENABLED)
-                        ehci_fsl_setup_phy(hcd, pdata->phy_mode, 1);
+                        if (ehci_fsl_setup_phy(hcd, pdata->phy_mode, 1))
+                                return -EINVAL;
         }
 
         if (pdata->have_sysif_regs) {
@@ -322,12 +340,15 @@ static void ehci_fsl_usb_setup(struct ehci_hcd *ehci)
 #endif
                 out_be32(non_ehci + FSL_SOC_USB_SICTRL, 0x00000001);
         }
+
+        return 0;
 }
 
 /* called after powerup, by probe or system-pm "wakeup" */
 static int ehci_fsl_reinit(struct ehci_hcd *ehci)
 {
-        ehci_fsl_usb_setup(ehci);
+        if (ehci_fsl_usb_setup(ehci))
+                return -EINVAL;
         ehci_port_power(ehci, 0);
 
         return 0;
diff --git a/drivers/usb/host/ehci-fsl.h b/drivers/usb/host/ehci-fsl.h
index 88403684d10b..dbd292e9f0a7 100644
--- a/drivers/usb/host/ehci-fsl.h
+++ b/drivers/usb/host/ehci-fsl.h
@@ -61,4 +61,5 @@
 #define PLL_RESET               (1<<8)
 #define UTMI_PHY_EN             (1<<9)
 #define ULPI_PHY_CLK_SEL        (1<<10)
+#define PHY_CLK_VALID           (1<<17)
 #endif                          /* _EHCI_FSL_H */
diff --git a/drivers/usb/host/ehci-grlib.c b/drivers/usb/host/ehci-grlib.c
index 22ca45c079a4..3180cb3624d9 100644
--- a/drivers/usb/host/ehci-grlib.c
+++ b/drivers/usb/host/ehci-grlib.c
@@ -127,12 +127,6 @@ static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
         hcd->rsrc_start = res.start;
         hcd->rsrc_len = resource_size(&res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
-                rv = -EBUSY;
-                goto err_rmr;
-        }
-
         irq = irq_of_parse_and_map(dn, 0);
         if (irq == NO_IRQ) {
                 printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
@@ -140,9 +134,9 @@ static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
                 goto err_irq;
         }
 
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&op->dev, &res);
         if (!hcd->regs) {
-                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                pr_err("%s: devm_request_and_ioremap failed\n", __FILE__);
                 rv = -ENOMEM;
                 goto err_ioremap;
         }
@@ -161,17 +155,13 @@ static int __devinit ehci_hcd_grlib_probe(struct platform_device *op)
 
         rv = usb_add_hcd(hcd, irq, 0);
         if (rv)
-                goto err_ehci;
+                goto err_ioremap;
 
         return 0;
 
-err_ehci:
-        iounmap(hcd->regs);
 err_ioremap:
         irq_dispose_mapping(irq);
 err_irq:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-err_rmr:
         usb_put_hcd(hcd);
 
         return rv;
@@ -188,9 +178,7 @@ static int ehci_hcd_grlib_remove(struct platform_device *op)
 
         usb_remove_hcd(hcd);
 
-        iounmap(hcd->regs);
         irq_dispose_mapping(hcd->irq);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
         usb_put_hcd(hcd);
 
diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c
index b05c6865b610..6bf6c42481e8 100644
--- a/drivers/usb/host/ehci-hcd.c
+++ b/drivers/usb/host/ehci-hcd.c
@@ -228,7 +228,7 @@ static int ehci_reset (struct ehci_hcd *ehci)
 
         /* If the EHCI debug controller is active, special care must be
          * taken before and after a host controller reset */
-        if (ehci->debug && !dbgp_reset_prep())
+        if (ehci->debug && !dbgp_reset_prep(ehci_to_hcd(ehci)))
                 ehci->debug = NULL;
 
         command |= CMD_RESET;
@@ -251,7 +251,7 @@ static int ehci_reset (struct ehci_hcd *ehci)
                 tdi_reset (ehci);
 
         if (ehci->debug)
-                dbgp_external_startup();
+                dbgp_external_startup(ehci_to_hcd(ehci));
 
         ehci->port_c_suspend = ehci->suspended_ports =
                         ehci->resuming_ports = 0;
diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c
index c7880223738a..914ce9370e70 100644
--- a/drivers/usb/host/ehci-hub.c
+++ b/drivers/usb/host/ehci-hub.c
@@ -353,10 +353,10 @@ static int ehci_bus_resume (struct usb_hcd *hcd)
                 goto shutdown;
 
         if (unlikely(ehci->debug)) {
-                if (!dbgp_reset_prep())
+                if (!dbgp_reset_prep(hcd))
                         ehci->debug = NULL;
                 else
-                        dbgp_external_startup();
+                        dbgp_external_startup(hcd);
         }
 
         /* Ideally and we've got a real resume here, and no port's power
diff --git a/drivers/usb/host/ehci-ixp4xx.c b/drivers/usb/host/ehci-ixp4xx.c
index 488d401942e9..f224c0a48bed 100644
--- a/drivers/usb/host/ehci-ixp4xx.c
+++ b/drivers/usb/host/ehci-ixp4xx.c
@@ -98,30 +98,19 @@ static int ixp4xx_ehci_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                dev_dbg(&pdev->dev, "controller already in use\n");
-                retval = -EBUSY;
-                goto fail_request_resource;
-        }
-
-        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (hcd->regs == NULL) {
                 dev_dbg(&pdev->dev, "error mapping memory\n");
                 retval = -EFAULT;
-                goto fail_ioremap;
+                goto fail_request_resource;
         }
 
         retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval)
-                goto fail_add_hcd;
+                goto fail_request_resource;
 
         return retval;
 
-fail_add_hcd:
-        iounmap(hcd->regs);
-fail_ioremap:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 fail_request_resource:
         usb_put_hcd(hcd);
 fail_create_hcd:
@@ -134,8 +123,6 @@ static int ixp4xx_ehci_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 
         return 0;
diff --git a/drivers/usb/host/ehci-ls1x.c b/drivers/usb/host/ehci-ls1x.c
index a283e59709d6..ca759652626b 100644
--- a/drivers/usb/host/ehci-ls1x.c
+++ b/drivers/usb/host/ehci-ls1x.c
@@ -106,29 +106,19 @@ static int ehci_hcd_ls1x_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len   = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                dev_dbg(&pdev->dev, "controller already in use\n");
-                ret = -EBUSY;
-                goto err_put_hcd;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (hcd->regs == NULL) {
                 dev_dbg(&pdev->dev, "error mapping memory\n");
                 ret = -EFAULT;
-                goto err_release_region;
+                goto err_put_hcd;
         }
 
-        ret = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        ret = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (ret)
-                goto err_iounmap;
+                goto err_put_hcd;
 
         return ret;
 
-err_iounmap:
-        iounmap(hcd->regs);
-err_release_region:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err_put_hcd:
         usb_put_hcd(hcd);
         return ret;
@@ -139,8 +129,6 @@ static int ehci_hcd_ls1x_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
 
         return 0;
diff --git a/drivers/usb/host/ehci-msm.c b/drivers/usb/host/ehci-msm.c
index 17dd9e94001e..4af4dc5b618c 100644
--- a/drivers/usb/host/ehci-msm.c
+++ b/drivers/usb/host/ehci-msm.c
@@ -133,7 +133,7 @@ static int ehci_msm_probe(struct platform_device *pdev)
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_ioremap(&pdev->dev, hcd->rsrc_start, hcd->rsrc_len);
         if (!hcd->regs) {
                 dev_err(&pdev->dev, "ioremap failed\n");
                 ret = -ENOMEM;
@@ -145,17 +145,17 @@ static int ehci_msm_probe(struct platform_device *pdev)
          * powering up VBUS, mapping of registers address space and power
          * management.
          */
-        phy = usb_get_phy(USB_PHY_TYPE_USB2);
+        phy = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(phy)) {
                 dev_err(&pdev->dev, "unable to find transceiver\n");
                 ret = -ENODEV;
-                goto unmap;
+                goto put_hcd;
         }
 
         ret = otg_set_host(phy->otg, &hcd->self);
         if (ret < 0) {
                 dev_err(&pdev->dev, "unable to register with transceiver\n");
-                goto put_transceiver;
+                goto put_hcd;
         }
 
         device_init_wakeup(&pdev->dev, 1);
@@ -168,10 +168,6 @@ static int ehci_msm_probe(struct platform_device *pdev)
 
         return 0;
 
-put_transceiver:
-        usb_put_phy(phy);
-unmap:
-        iounmap(hcd->regs);
 put_hcd:
         usb_put_hcd(hcd);
 
@@ -187,7 +183,6 @@ static int __devexit ehci_msm_remove(struct platform_device *pdev)
         pm_runtime_set_suspended(&pdev->dev);
 
         otg_set_host(phy->otg, NULL);
-        usb_put_phy(phy);
 
         usb_put_hcd(hcd);
 
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index f6df1ccc9617..f7bfc0b898b9 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -161,7 +161,7 @@ static int mv_ehci_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         size = sizeof(*ehci_mv) + sizeof(struct clk *) * pdata->clknum;
-        ehci_mv = kzalloc(size, GFP_KERNEL);
+        ehci_mv = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
         if (ehci_mv == NULL) {
                 dev_err(&pdev->dev, "cannot allocate ehci_hcd_mv\n");
                 retval = -ENOMEM;
@@ -175,12 +175,12 @@ static int mv_ehci_probe(struct platform_device *pdev)
         ehci_mv->clknum = pdata->clknum;
         for (clk_i = 0; clk_i < ehci_mv->clknum; clk_i++) {
                 ehci_mv->clk[clk_i] =
-                    clk_get(&pdev->dev, pdata->clkname[clk_i]);
+                    devm_clk_get(&pdev->dev, pdata->clkname[clk_i]);
                 if (IS_ERR(ehci_mv->clk[clk_i])) {
                         dev_err(&pdev->dev, "error get clck \"%s\"\n",
                                 pdata->clkname[clk_i]);
                         retval = PTR_ERR(ehci_mv->clk[clk_i]);
-                        goto err_put_clk;
+                        goto err_clear_drvdata;
                 }
         }
 
@@ -188,34 +188,36 @@ static int mv_ehci_probe(struct platform_device *pdev)
         if (r == NULL) {
                 dev_err(&pdev->dev, "no phy I/O memory resource defined\n");
                 retval = -ENODEV;
-                goto err_put_clk;
+                goto err_clear_drvdata;
         }
 
-        ehci_mv->phy_regs = ioremap(r->start, resource_size(r));
+        ehci_mv->phy_regs = devm_ioremap(&pdev->dev, r->start,
+                                         resource_size(r));
         if (ehci_mv->phy_regs == 0) {
                 dev_err(&pdev->dev, "failed to map phy I/O memory\n");
                 retval = -EFAULT;
-                goto err_put_clk;
+                goto err_clear_drvdata;
         }
 
         r = platform_get_resource_byname(pdev, IORESOURCE_MEM, "capregs");
         if (!r) {
                 dev_err(&pdev->dev, "no I/O memory resource defined\n");
                 retval = -ENODEV;
-                goto err_iounmap_phyreg;
+                goto err_clear_drvdata;
         }
 
-        ehci_mv->cap_regs = ioremap(r->start, resource_size(r));
+        ehci_mv->cap_regs = devm_ioremap(&pdev->dev, r->start,
+                                         resource_size(r));
         if (ehci_mv->cap_regs == NULL) {
                 dev_err(&pdev->dev, "failed to map I/O memory\n");
                 retval = -EFAULT;
-                goto err_iounmap_phyreg;
+                goto err_clear_drvdata;
         }
 
         retval = mv_ehci_enable(ehci_mv);
         if (retval) {
                 dev_err(&pdev->dev, "init phy error %d\n", retval);
-                goto err_iounmap_capreg;
+                goto err_clear_drvdata;
         }
 
         offset = readl(ehci_mv->cap_regs) & CAPLENGTH_MASK;
@@ -239,7 +241,7 @@ static int mv_ehci_probe(struct platform_device *pdev)
         ehci_mv->mode = pdata->mode;
         if (ehci_mv->mode == MV_USB_MODE_OTG) {
 #ifdef CONFIG_USB_OTG_UTILS
-                ehci_mv->otg = usb_get_phy(USB_PHY_TYPE_USB2);
+                ehci_mv->otg = devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
                 if (IS_ERR_OR_NULL(ehci_mv->otg)) {
                         dev_err(&pdev->dev,
                                 "unable to find transceiver\n");
@@ -252,7 +254,7 @@ static int mv_ehci_probe(struct platform_device *pdev)
                         dev_err(&pdev->dev,
                                 "unable to register with transceiver\n");
                         retval = -ENODEV;
-                        goto err_put_transceiver;
+                        goto err_disable_clk;
                 }
                 /* otg will enable clock before use as host */
                 mv_ehci_disable(ehci_mv);
@@ -286,22 +288,10 @@ static int mv_ehci_probe(struct platform_device *pdev)
 err_set_vbus:
         if (pdata->set_vbus)
                 pdata->set_vbus(0);
-#ifdef CONFIG_USB_OTG_UTILS
-err_put_transceiver:
-        if (!IS_ERR_OR_NULL(ehci_mv->otg))
-                usb_put_phy(ehci_mv->otg);
-#endif
 err_disable_clk:
         mv_ehci_disable(ehci_mv);
-err_iounmap_capreg:
-        iounmap(ehci_mv->cap_regs);
-err_iounmap_phyreg:
-        iounmap(ehci_mv->phy_regs);
-err_put_clk:
-        for (clk_i--; clk_i >= 0; clk_i--)
-                clk_put(ehci_mv->clk[clk_i]);
+err_clear_drvdata:
         platform_set_drvdata(pdev, NULL);
-        kfree(ehci_mv);
 err_put_hcd:
         usb_put_hcd(hcd);
 
@@ -317,10 +307,8 @@ static int mv_ehci_remove(struct platform_device *pdev)
         if (hcd->rh_registered)
                 usb_remove_hcd(hcd);
 
-        if (!IS_ERR_OR_NULL(ehci_mv->otg)) {
+        if (!IS_ERR_OR_NULL(ehci_mv->otg))
                 otg_set_host(ehci_mv->otg->otg, NULL);
-                usb_put_phy(ehci_mv->otg);
-        }
 
         if (ehci_mv->mode == MV_USB_MODE_HOST) {
                 if (ehci_mv->pdata->set_vbus)
@@ -329,15 +317,8 @@ static int mv_ehci_remove(struct platform_device *pdev)
                 mv_ehci_disable(ehci_mv);
         }
 
-        iounmap(ehci_mv->cap_regs);
-        iounmap(ehci_mv->phy_regs);
-
-        for (clk_i = 0; clk_i < ehci_mv->clknum; clk_i++)
-                clk_put(ehci_mv->clk[clk_i]);
-
         platform_set_drvdata(pdev, NULL);
 
-        kfree(ehci_mv);
         usb_put_hcd(hcd);
 
         return 0;
diff --git a/drivers/usb/host/ehci-mxc.c b/drivers/usb/host/ehci-mxc.c
index 34201372c85f..959e1a4c3491 100644
--- a/drivers/usb/host/ehci-mxc.c
+++ b/drivers/usb/host/ehci-mxc.c
@@ -121,7 +121,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (!hcd)
                 return -ENOMEM;
 
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
         if (!priv) {
                 ret = -ENOMEM;
                 goto err_alloc;
@@ -131,34 +131,28 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         if (!res) {
                 dev_err(dev, "Found HC with no register addr. Check setup!\n");
                 ret = -ENODEV;
-                goto err_get_resource;
+                goto err_alloc;
         }
 
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                dev_dbg(dev, "controller already in use\n");
-                ret = -EBUSY;
-                goto err_request_mem;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (!hcd->regs) {
                 dev_err(dev, "error mapping memory\n");
                 ret = -EFAULT;
-                goto err_ioremap;
+                goto err_alloc;
         }
 
         /* enable clocks */
-        priv->usbclk = clk_get(dev, "ipg");
+        priv->usbclk = devm_clk_get(&pdev->dev, "ipg");
         if (IS_ERR(priv->usbclk)) {
                 ret = PTR_ERR(priv->usbclk);
-                goto err_clk;
+                goto err_alloc;
         }
         clk_prepare_enable(priv->usbclk);
 
-        priv->ahbclk = clk_get(dev, "ahb");
+        priv->ahbclk = devm_clk_get(&pdev->dev, "ahb");
         if (IS_ERR(priv->ahbclk)) {
                 ret = PTR_ERR(priv->ahbclk);
                 goto err_clk_ahb;
@@ -166,7 +160,7 @@ static int ehci_mxc_drv_probe(struct platform_device *pdev)
         clk_prepare_enable(priv->ahbclk);
 
         /* "dr" device has its own clock on i.MX51 */
-        priv->phyclk = clk_get(dev, "phy");
+        priv->phyclk = devm_clk_get(&pdev->dev, "phy");
         if (IS_ERR(priv->phyclk))
                 priv->phyclk = NULL;
         if (priv->phyclk)
@@ -245,23 +239,12 @@ err_add:
         if (pdata && pdata->exit)
                 pdata->exit(pdev);
 err_init:
-        if (priv->phyclk) {
+        if (priv->phyclk)
                 clk_disable_unprepare(priv->phyclk);
-                clk_put(priv->phyclk);
-        }
 
         clk_disable_unprepare(priv->ahbclk);
-        clk_put(priv->ahbclk);
 err_clk_ahb:
         clk_disable_unprepare(priv->usbclk);
-        clk_put(priv->usbclk);
-err_clk:
-        iounmap(hcd->regs);
-err_ioremap:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-err_request_mem:
-err_get_resource:
-        kfree(priv);
 err_alloc:
         usb_put_hcd(hcd);
         return ret;
@@ -280,22 +263,14 @@ static int __exit ehci_mxc_drv_remove(struct platform_device *pdev)
                 usb_phy_shutdown(pdata->otg);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
         clk_disable_unprepare(priv->usbclk);
-        clk_put(priv->usbclk);
         clk_disable_unprepare(priv->ahbclk);
-        clk_put(priv->ahbclk);
 
-        if (priv->phyclk) {
+        if (priv->phyclk)
                 clk_disable_unprepare(priv->phyclk);
-                clk_put(priv->phyclk);
-        }
-
-        kfree(priv);
 
         return 0;
 }
diff --git a/drivers/usb/host/ehci-platform.c b/drivers/usb/host/ehci-platform.c
index 4b1d896d5a22..764e0100b6f4 100644
--- a/drivers/usb/host/ehci-platform.c
+++ b/drivers/usb/host/ehci-platform.c
@@ -82,10 +82,14 @@ static int __devinit ehci_platform_probe(struct platform_device *dev)
 {
         struct usb_hcd *hcd;
         struct resource *res_mem;
+        struct usb_ehci_pdata *pdata = dev->dev.platform_data;
         int irq;
         int err = -ENOMEM;
 
-        BUG_ON(!dev->dev.platform_data);
+        if (!pdata) {
+                WARN_ON(1);
+                return -ENODEV;
+        }
 
         if (usb_disabled())
                 return -ENODEV;
@@ -101,10 +105,18 @@ static int __devinit ehci_platform_probe(struct platform_device *dev)
                 return -ENXIO;
         }
 
+        if (pdata->power_on) {
+                err = pdata->power_on(dev);
+                if (err < 0)
+                        return err;
+        }
+
         hcd = usb_create_hcd(&ehci_platform_hc_driver, &dev->dev,
                              dev_name(&dev->dev));
-        if (!hcd)
-                return -ENOMEM;
+        if (!hcd) {
+                err = -ENOMEM;
+                goto err_power;
+        }
 
         hcd->rsrc_start = res_mem->start;
         hcd->rsrc_len = resource_size(res_mem);
@@ -116,8 +128,10 @@ static int __devinit ehci_platform_probe(struct platform_device *dev)
         }
 
         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs)
+        if (!hcd->regs) {
+                err = -ENOMEM;
                 goto err_release_region;
+        }
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
                 goto err_iounmap;
@@ -132,12 +146,17 @@ err_release_region:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err_put_hcd:
         usb_put_hcd(hcd);
+err_power:
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
         return err;
 }
 
 static int __devexit ehci_platform_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev->dev.platform_data;
 
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
@@ -145,6 +164,9 @@ static int __devexit ehci_platform_remove(struct platform_device *dev)
         usb_put_hcd(hcd);
         platform_set_drvdata(dev, NULL);
 
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
         return 0;
 }
 
@@ -153,14 +175,32 @@ static int __devexit ehci_platform_remove(struct platform_device *dev)
 static int ehci_platform_suspend(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev->platform_data;
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
         bool do_wakeup = device_may_wakeup(dev);
+        int ret;
+
+        ret = ehci_suspend(hcd, do_wakeup);
 
-        return ehci_suspend(hcd, do_wakeup);
+        if (pdata->power_suspend)
+                pdata->power_suspend(pdev);
+
+        return ret;
 }
 
 static int ehci_platform_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ehci_pdata *pdata = dev->platform_data;
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+
+        if (pdata->power_on) {
+                int err = pdata->power_on(pdev);
+                if (err < 0)
+                        return err;
+        }
 
         ehci_resume(hcd, false);
         return 0;
diff --git a/drivers/usb/host/ehci-ppc-of.c b/drivers/usb/host/ehci-ppc-of.c
index bbbe89dfd886..fa937d05a02b 100644
--- a/drivers/usb/host/ehci-ppc-of.c
+++ b/drivers/usb/host/ehci-ppc-of.c
@@ -114,12 +114,6 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
         hcd->rsrc_start = res.start;
         hcd->rsrc_len = resource_size(&res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
-                rv = -EBUSY;
-                goto err_rmr;
-        }
-
         irq = irq_of_parse_and_map(dn, 0);
         if (irq == NO_IRQ) {
                 printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
@@ -127,9 +121,9 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
                 goto err_irq;
         }
 
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&op->dev, &res);
         if (!hcd->regs) {
-                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                pr_err("%s: devm_request_and_ioremap failed\n", __FILE__);
                 rv = -ENOMEM;
                 goto err_ioremap;
         }
@@ -139,8 +133,10 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
         if (np != NULL) {
                 /* claim we really affected by usb23 erratum */
                 if (!of_address_to_resource(np, 0, &res))
-                        ehci->ohci_hcctrl_reg = ioremap(res.start +
-                                        OHCI_HCCTRL_OFFSET, OHCI_HCCTRL_LEN);
+                        ehci->ohci_hcctrl_reg =
+                                devm_ioremap(&op->dev,
+                                             res.start + OHCI_HCCTRL_OFFSET,
+                                             OHCI_HCCTRL_LEN);
                 else
                         pr_debug("%s: no ohci offset in fdt\n", __FILE__);
                 if (!ehci->ohci_hcctrl_reg) {
@@ -169,19 +165,13 @@ static int __devinit ehci_hcd_ppc_of_probe(struct platform_device *op)
 
         rv = usb_add_hcd(hcd, irq, 0);
         if (rv)
-                goto err_ehci;
+                goto err_ioremap;
 
         return 0;
 
-err_ehci:
-        if (ehci->has_amcc_usb23)
-                iounmap(ehci->ohci_hcctrl_reg);
-        iounmap(hcd->regs);
 err_ioremap:
         irq_dispose_mapping(irq);
 err_irq:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-err_rmr:
         usb_put_hcd(hcd);
 
         return rv;
@@ -202,9 +192,7 @@ static int ehci_hcd_ppc_of_remove(struct platform_device *op)
 
         usb_remove_hcd(hcd);
 
-        iounmap(hcd->regs);
         irq_dispose_mapping(hcd->irq);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 
         /* use request_mem_region to test if the ohci driver is loaded.  if so
          * ensure the ohci core is operational.
@@ -222,8 +210,6 @@ static int ehci_hcd_ppc_of_remove(struct platform_device *op)
                                 pr_debug("%s: no ohci offset in fdt\n", __FILE__);
                         of_node_put(np);
                 }
-
-                iounmap(ehci->ohci_hcctrl_reg);
         }
         usb_put_hcd(hcd);
 
diff --git a/drivers/usb/host/ehci-s5p.c b/drivers/usb/host/ehci-s5p.c
index 9d8f1dd57cb3..d055503e4183 100644
--- a/drivers/usb/host/ehci-s5p.c
+++ b/drivers/usb/host/ehci-s5p.c
@@ -128,7 +128,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
         }
 
         s5p_ehci->hcd = hcd;
-        s5p_ehci->clk = clk_get(&pdev->dev, "usbhost");
+        s5p_ehci->clk = devm_clk_get(&pdev->dev, "usbhost");
 
         if (IS_ERR(s5p_ehci->clk)) {
                 dev_err(&pdev->dev, "Failed to get usbhost clock\n");
@@ -138,7 +138,7 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
 
         err = clk_enable(s5p_ehci->clk);
         if (err)
-                goto fail_clken;
+                goto fail_clk;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         if (!res) {
@@ -184,8 +184,6 @@ static int __devinit s5p_ehci_probe(struct platform_device *pdev)
 
 fail_io:
         clk_disable(s5p_ehci->clk);
-fail_clken:
-        clk_put(s5p_ehci->clk);
 fail_clk:
         usb_put_hcd(hcd);
         return err;
@@ -203,7 +201,6 @@ static int __devexit s5p_ehci_remove(struct platform_device *pdev)
                 pdata->phy_exit(pdev, S5P_USB_PHY_HOST);
 
         clk_disable(s5p_ehci->clk);
-        clk_put(s5p_ehci->clk);
 
         usb_put_hcd(hcd);
 
diff --git a/drivers/usb/host/ehci-sead3.c b/drivers/usb/host/ehci-sead3.c
index 0c9e43cfaff5..efad02d947f2 100644
--- a/drivers/usb/host/ehci-sead3.c
+++ b/drivers/usb/host/ehci-sead3.c
@@ -112,17 +112,11 @@ static int ehci_hcd_sead3_drv_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug("request_mem_region failed");
-                ret = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (!hcd->regs) {
                 pr_debug("ioremap failed");
                 ret = -ENOMEM;
-                goto err2;
+                goto err1;
         }
 
         /* Root hub has integrated TT. */
@@ -135,9 +129,6 @@ static int ehci_hcd_sead3_drv_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        iounmap(hcd->regs);
-err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
         return ret;
@@ -148,8 +139,6 @@ static int ehci_hcd_sead3_drv_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
diff --git a/drivers/usb/host/ehci-sh.c b/drivers/usb/host/ehci-sh.c
index b3f1e3650da0..6081e1ed3ac9 100644
--- a/drivers/usb/host/ehci-sh.c
+++ b/drivers/usb/host/ehci-sh.c
@@ -125,33 +125,27 @@ static int ehci_hcd_sh_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len,
-                                driver->description)) {
-                dev_dbg(&pdev->dev, "controller already in use\n");
-                ret = -EBUSY;
-                goto fail_request_resource;
-        }
-
-        hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (hcd->regs == NULL) {
                 dev_dbg(&pdev->dev, "error mapping memory\n");
                 ret = -ENXIO;
-                goto fail_ioremap;
+                goto fail_request_resource;
         }
 
-        priv = kmalloc(sizeof(struct ehci_sh_priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(struct ehci_sh_priv),
+                            GFP_KERNEL);
         if (!priv) {
                 dev_dbg(&pdev->dev, "error allocating priv data\n");
                 ret = -ENOMEM;
-                goto fail_alloc;
+                goto fail_request_resource;
         }
 
         /* These are optional, we don't care if they fail */
-        priv->fclk = clk_get(&pdev->dev, "usb_fck");
+        priv->fclk = devm_clk_get(&pdev->dev, "usb_fck");
         if (IS_ERR(priv->fclk))
                 priv->fclk = NULL;
 
-        priv->iclk = clk_get(&pdev->dev, "usb_ick");
+        priv->iclk = devm_clk_get(&pdev->dev, "usb_ick");
         if (IS_ERR(priv->iclk))
                 priv->iclk = NULL;
 
@@ -176,14 +170,6 @@ fail_add_hcd:
         clk_disable(priv->iclk);
         clk_disable(priv->fclk);
 
-        clk_put(priv->iclk);
-        clk_put(priv->fclk);
-
-        kfree(priv);
-fail_alloc:
-        iounmap(hcd->regs);
-fail_ioremap:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 fail_request_resource:
         usb_put_hcd(hcd);
 fail_create_hcd:
@@ -198,19 +184,12 @@ static int __exit ehci_hcd_sh_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = priv->hcd;
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
         clk_disable(priv->fclk);
         clk_disable(priv->iclk);
 
-        clk_put(priv->fclk);
-        clk_put(priv->iclk);
-
-        kfree(priv);
-
         return 0;
 }
 
diff --git a/drivers/usb/host/ehci-tegra.c b/drivers/usb/host/ehci-tegra.c
index 26dedb30ad0b..6223d1757848 100644
--- a/drivers/usb/host/ehci-tegra.c
+++ b/drivers/usb/host/ehci-tegra.c
@@ -27,7 +27,7 @@
 #include <linux/of_gpio.h>
 #include <linux/pm_runtime.h>
 
-#include <mach/usb_phy.h>
+#include <linux/usb/tegra_usb_phy.h>
 #include <mach/iomap.h>
 
 #define TEGRA_USB_DMA_ALIGN 32
@@ -49,7 +49,7 @@ static void tegra_ehci_power_up(struct usb_hcd *hcd)
 
         clk_prepare_enable(tegra->emc_clk);
         clk_prepare_enable(tegra->clk);
-        tegra_usb_phy_power_on(tegra->phy);
+        usb_phy_set_suspend(&tegra->phy->u_phy, 0);
         tegra->host_resumed = 1;
 }
 
@@ -58,7 +58,7 @@ static void tegra_ehci_power_down(struct usb_hcd *hcd)
         struct tegra_ehci_hcd *tegra = dev_get_drvdata(hcd->self.controller);
 
         tegra->host_resumed = 0;
-        tegra_usb_phy_power_off(tegra->phy);
+        usb_phy_set_suspend(&tegra->phy->u_phy, 1);
         clk_disable_unprepare(tegra->clk);
         clk_disable_unprepare(tegra->emc_clk);
 }
@@ -634,7 +634,8 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 
         setup_vbus_gpio(pdev, pdata);
 
-        tegra = kzalloc(sizeof(struct tegra_ehci_hcd), GFP_KERNEL);
+        tegra = devm_kzalloc(&pdev->dev, sizeof(struct tegra_ehci_hcd),
+                             GFP_KERNEL);
         if (!tegra)
                 return -ENOMEM;
 
@@ -642,13 +643,12 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                                         dev_name(&pdev->dev));
         if (!hcd) {
                 dev_err(&pdev->dev, "Unable to create HCD\n");
-                err = -ENOMEM;
-                goto fail_hcd;
+                return -ENOMEM;
         }
 
         platform_set_drvdata(pdev, tegra);
 
-        tegra->clk = clk_get(&pdev->dev, NULL);
+        tegra->clk = devm_clk_get(&pdev->dev, NULL);
         if (IS_ERR(tegra->clk)) {
                 dev_err(&pdev->dev, "Can't get ehci clock\n");
                 err = PTR_ERR(tegra->clk);
@@ -657,9 +657,9 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 
         err = clk_prepare_enable(tegra->clk);
         if (err)
-                goto fail_clken;
+                goto fail_clk;
 
-        tegra->emc_clk = clk_get(&pdev->dev, "emc");
+        tegra->emc_clk = devm_clk_get(&pdev->dev, "emc");
         if (IS_ERR(tegra->emc_clk)) {
                 dev_err(&pdev->dev, "Can't get emc clock\n");
                 err = PTR_ERR(tegra->emc_clk);
@@ -677,7 +677,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         }
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
-        hcd->regs = ioremap(res->start, resource_size(res));
+        hcd->regs = devm_ioremap(&pdev->dev, res->start, resource_size(res));
         if (!hcd->regs) {
                 dev_err(&pdev->dev, "Failed to remap I/O memory\n");
                 err = -ENOMEM;
@@ -702,7 +702,7 @@ static int tegra_ehci_probe(struct platform_device *pdev)
                 default:
                         err = -ENODEV;
                         dev_err(&pdev->dev, "unknown usb instance\n");
-                        goto fail_phy;
+                        goto fail_io;
                 }
         }
 
@@ -712,10 +712,12 @@ static int tegra_ehci_probe(struct platform_device *pdev)
         if (IS_ERR(tegra->phy)) {
                 dev_err(&pdev->dev, "Failed to open USB phy\n");
                 err = -ENXIO;
-                goto fail_phy;
+                goto fail_io;
         }
 
-        err = tegra_usb_phy_power_on(tegra->phy);
+        usb_phy_init(&tegra->phy->u_phy);
+
+        err = usb_phy_set_suspend(&tegra->phy->u_phy, 0);
         if (err) {
                 dev_err(&pdev->dev, "Failed to power on the phy\n");
                 goto fail;
@@ -733,7 +735,8 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 
 #ifdef CONFIG_USB_OTG_UTILS
         if (pdata->operating_mode == TEGRA_USB_OTG) {
-                tegra->transceiver = usb_get_phy(USB_PHY_TYPE_USB2);
+                tegra->transceiver =
+                        devm_usb_get_phy(&pdev->dev, USB_PHY_TYPE_USB2);
                 if (!IS_ERR_OR_NULL(tegra->transceiver))
                         otg_set_host(tegra->transceiver->otg, &hcd->self);
         }
@@ -757,25 +760,16 @@ static int tegra_ehci_probe(struct platform_device *pdev)
 
 fail:
 #ifdef CONFIG_USB_OTG_UTILS
-        if (!IS_ERR_OR_NULL(tegra->transceiver)) {
+        if (!IS_ERR_OR_NULL(tegra->transceiver))
                 otg_set_host(tegra->transceiver->otg, NULL);
-                usb_put_phy(tegra->transceiver);
-        }
 #endif
-        tegra_usb_phy_close(tegra->phy);
-fail_phy:
-        iounmap(hcd->regs);
+        usb_phy_shutdown(&tegra->phy->u_phy);
 fail_io:
         clk_disable_unprepare(tegra->emc_clk);
-        clk_put(tegra->emc_clk);
 fail_emc_clk:
         clk_disable_unprepare(tegra->clk);
-fail_clken:
-        clk_put(tegra->clk);
 fail_clk:
         usb_put_hcd(hcd);
-fail_hcd:
-        kfree(tegra);
         return err;
 }
 
@@ -792,26 +786,19 @@ static int tegra_ehci_remove(struct platform_device *pdev)
         pm_runtime_put_noidle(&pdev->dev);
 
 #ifdef CONFIG_USB_OTG_UTILS
-        if (!IS_ERR_OR_NULL(tegra->transceiver)) {
+        if (!IS_ERR_OR_NULL(tegra->transceiver))
                 otg_set_host(tegra->transceiver->otg, NULL);
-                usb_put_phy(tegra->transceiver);
-        }
 #endif
 
         usb_remove_hcd(hcd);
-
-        tegra_usb_phy_close(tegra->phy);
-        iounmap(hcd->regs);
-
         usb_put_hcd(hcd);
 
+        usb_phy_shutdown(&tegra->phy->u_phy);
+
         clk_disable_unprepare(tegra->clk);
-        clk_put(tegra->clk);
 
         clk_disable_unprepare(tegra->emc_clk);
-        clk_put(tegra->emc_clk);
 
-        kfree(tegra);
         return 0;
 }
 
diff --git a/drivers/usb/host/ehci-timer.c b/drivers/usb/host/ehci-timer.c
index eb896a2c8f2e..20dbdcbe9b0f 100644
--- a/drivers/usb/host/ehci-timer.c
+++ b/drivers/usb/host/ehci-timer.c
@@ -118,7 +118,8 @@ static void ehci_poll_ASS(struct ehci_hcd *ehci)
                         ehci_enable_event(ehci, EHCI_HRTIMER_POLL_ASS, true);
                         return;
                 }
-                ehci_warn(ehci, "Waited too long for the async schedule status, giving up\n");
+                ehci_dbg(ehci, "Waited too long for the async schedule status (%x/%x), giving up\n",
+                                want, actual);
         }
         ehci->ASS_poll_count = 0;
 
@@ -163,7 +164,8 @@ static void ehci_poll_PSS(struct ehci_hcd *ehci)
                         ehci_enable_event(ehci, EHCI_HRTIMER_POLL_PSS, true);
                         return;
                 }
-                ehci_warn(ehci, "Waited too long for the periodic schedule status, giving up\n");
+                ehci_dbg(ehci, "Waited too long for the periodic schedule status (%x/%x), giving up\n",
+                                want, actual);
         }
         ehci->PSS_poll_count = 0;
 
diff --git a/drivers/usb/host/ehci-vt8500.c b/drivers/usb/host/ehci-vt8500.c
index 4d147c4e33f5..96722bfebc84 100644
--- a/drivers/usb/host/ehci-vt8500.c
+++ b/drivers/usb/host/ehci-vt8500.c
@@ -16,6 +16,7 @@
  *
  */
 
+#include <linux/of.h>
 #include <linux/platform_device.h>
 
 static int ehci_update_device(struct usb_hcd *hcd, struct usb_device *udev)
@@ -106,17 +107,11 @@ static int vt8500_ehci_drv_probe(struct platform_device *pdev)
         hcd->rsrc_start = res->start;
         hcd->rsrc_len = resource_size(res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                pr_debug("request_mem_region failed");
-                ret = -EBUSY;
-                goto err1;
-        }
-
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&pdev->dev, res);
         if (!hcd->regs) {
                 pr_debug("ioremap failed");
                 ret = -ENOMEM;
-                goto err2;
+                goto err1;
         }
 
         ehci = hcd_to_ehci(hcd);
@@ -129,9 +124,6 @@ static int vt8500_ehci_drv_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        iounmap(hcd->regs);
-err2:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err1:
         usb_put_hcd(hcd);
         return ret;
@@ -142,14 +134,18 @@ static int vt8500_ehci_drv_remove(struct platform_device *pdev)
         struct usb_hcd *hcd = platform_get_drvdata(pdev);
 
         usb_remove_hcd(hcd);
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
         usb_put_hcd(hcd);
         platform_set_drvdata(pdev, NULL);
 
         return 0;
 }
 
+static const struct of_device_id vt8500_ehci_ids[] = {
+        { .compatible = "via,vt8500-ehci", },
+        { .compatible = "wm,prizm-ehci", },
+        {}
+};
+
 static struct platform_driver vt8500_ehci_driver = {
         .probe          = vt8500_ehci_drv_probe,
         .remove         = vt8500_ehci_drv_remove,
@@ -157,7 +153,9 @@ static struct platform_driver vt8500_ehci_driver = {
         .driver = {
                 .name   = "vt8500-ehci",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(vt8500_ehci_ids),
         }
 };
 
 MODULE_ALIAS("platform:vt8500-ehci");
+MODULE_DEVICE_TABLE(of, vt8500_ehci_ids);
diff --git a/drivers/usb/host/ehci-xilinx-of.c b/drivers/usb/host/ehci-xilinx-of.c
index 39f24fa37ebe..6a3f921a5d76 100644
--- a/drivers/usb/host/ehci-xilinx-of.c
+++ b/drivers/usb/host/ehci-xilinx-of.c
@@ -152,12 +152,6 @@ static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
         hcd->rsrc_start = res.start;
         hcd->rsrc_len = resource_size(&res);
 
-        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
-                printk(KERN_ERR "%s: request_mem_region failed\n", __FILE__);
-                rv = -EBUSY;
-                goto err_rmr;
-        }
-
         irq = irq_of_parse_and_map(dn, 0);
         if (!irq) {
                 printk(KERN_ERR "%s: irq_of_parse_and_map failed\n", __FILE__);
@@ -165,11 +159,11 @@ static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
                 goto err_irq;
         }
 
-        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        hcd->regs = devm_request_and_ioremap(&op->dev, &res);
         if (!hcd->regs) {
-                printk(KERN_ERR "%s: ioremap failed\n", __FILE__);
+                pr_err("%s: devm_request_and_ioremap failed\n", __FILE__);
                 rv = -ENOMEM;
-                goto err_ioremap;
+                goto err_irq;
         }
 
         ehci = hcd_to_ehci(hcd);
@@ -200,12 +194,7 @@ static int __devinit ehci_hcd_xilinx_of_probe(struct platform_device *op)
         if (rv == 0)
                 return 0;
 
-        iounmap(hcd->regs);
-
-err_ioremap:
 err_irq:
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-err_rmr:
         usb_put_hcd(hcd);
 
         return rv;
@@ -227,9 +216,6 @@ static int ehci_hcd_xilinx_of_remove(struct platform_device *op)
 
         usb_remove_hcd(hcd);
 
-        iounmap(hcd->regs);
-        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
-
         usb_put_hcd(hcd);
 
         return 0;
diff --git a/drivers/usb/host/fhci-sched.c b/drivers/usb/host/fhci-sched.c
index 2dc8a40e39d7..8f18538e0ff7 100644
--- a/drivers/usb/host/fhci-sched.c
+++ b/drivers/usb/host/fhci-sched.c
@@ -261,8 +261,7 @@ static void move_head_to_tail(struct list_head *list)
         struct list_head *node = list->next;
 
         if (!list_empty(list)) {
-                list_del(node);
-                list_add_tail(node, list);
+                list_move_tail(node, list);
         }
 }
 
diff --git a/drivers/usb/host/fsl-mph-dr-of.c b/drivers/usb/host/fsl-mph-dr-of.c
index 22ff6b3a676f..1e771292383f 100644
--- a/drivers/usb/host/fsl-mph-dr-of.c
+++ b/drivers/usb/host/fsl-mph-dr-of.c
@@ -133,6 +133,8 @@ static int usb_get_ver_info(struct device_node *np)
                         ver = FSL_USB_VER_1_6;
                 else if (of_device_is_compatible(np, "fsl-usb2-dr-v2.2"))
                         ver = FSL_USB_VER_2_2;
+                else if (of_device_is_compatible(np, "fsl-usb2-dr-v2.4"))
+                        ver = FSL_USB_VER_2_4;
                 else /* for previous controller versions */
                         ver = FSL_USB_VER_OLD;
 
diff --git a/drivers/usb/host/ohci-nxp.c b/drivers/usb/host/ohci-nxp.c
index a446386bf779..c60066a63606 100644
--- a/drivers/usb/host/ohci-nxp.c
+++ b/drivers/usb/host/ohci-nxp.c
@@ -355,7 +355,7 @@ static int __devinit usb_hcd_nxp_probe(struct platform_device *pdev)
         usb_otg_clk = clk_get(&pdev->dev, "ck_usb_otg");
         if (IS_ERR(usb_otg_clk)) {
                 dev_err(&pdev->dev, "failed to acquire USB DEV Clock\n");
-                ret = PTR_ERR(usb_dev_clk);
+                ret = PTR_ERR(usb_otg_clk);
                 goto out6;
         }
 
diff --git a/drivers/usb/host/ohci-platform.c b/drivers/usb/host/ohci-platform.c
index 670c7059c9ae..e24ec9f79164 100644
--- a/drivers/usb/host/ohci-platform.c
+++ b/drivers/usb/host/ohci-platform.c
@@ -83,10 +83,14 @@ static int __devinit ohci_platform_probe(struct platform_device *dev)
 {
         struct usb_hcd *hcd;
         struct resource *res_mem;
+        struct usb_ohci_pdata *pdata = dev->dev.platform_data;
         int irq;
         int err = -ENOMEM;
 
-        BUG_ON(!dev->dev.platform_data);
+        if (!pdata) {
+                WARN_ON(1);
+                return -ENODEV;
+        }
 
         if (usb_disabled())
                 return -ENODEV;
@@ -103,10 +107,18 @@ static int __devinit ohci_platform_probe(struct platform_device *dev)
                 return -ENXIO;
         }
 
+        if (pdata->power_on) {
+                err = pdata->power_on(dev);
+                if (err < 0)
+                        return err;
+        }
+
         hcd = usb_create_hcd(&ohci_platform_hc_driver, &dev->dev,
                         dev_name(&dev->dev));
-        if (!hcd)
-                return -ENOMEM;
+        if (!hcd) {
+                err = -ENOMEM;
+                goto err_power;
+        }
 
         hcd->rsrc_start = res_mem->start;
         hcd->rsrc_len = resource_size(res_mem);
@@ -118,8 +130,10 @@ static int __devinit ohci_platform_probe(struct platform_device *dev)
         }
 
         hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
-        if (!hcd->regs)
+        if (!hcd->regs) {
+                err = -ENOMEM;
                 goto err_release_region;
+        }
         err = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (err)
                 goto err_iounmap;
@@ -134,12 +148,17 @@ err_release_region:
         release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
 err_put_hcd:
         usb_put_hcd(hcd);
+err_power:
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
         return err;
 }
 
 static int __devexit ohci_platform_remove(struct platform_device *dev)
 {
         struct usb_hcd *hcd = platform_get_drvdata(dev);
+        struct usb_ohci_pdata *pdata = dev->dev.platform_data;
 
         usb_remove_hcd(hcd);
         iounmap(hcd->regs);
@@ -147,6 +166,9 @@ static int __devexit ohci_platform_remove(struct platform_device *dev)
         usb_put_hcd(hcd);
         platform_set_drvdata(dev, NULL);
 
+        if (pdata->power_off)
+                pdata->power_off(dev);
+
         return 0;
 }
 
@@ -154,12 +176,28 @@ static int __devexit ohci_platform_remove(struct platform_device *dev)
 
 static int ohci_platform_suspend(struct device *dev)
 {
+        struct usb_ohci_pdata *pdata = dev->platform_data;
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+
+        if (pdata->power_suspend)
+                pdata->power_suspend(pdev);
+
         return 0;
 }
 
 static int ohci_platform_resume(struct device *dev)
 {
         struct usb_hcd *hcd = dev_get_drvdata(dev);
+        struct usb_ohci_pdata *pdata = dev->platform_data;
+        struct platform_device *pdev =
+                container_of(dev, struct platform_device, dev);
+
+        if (pdata->power_on) {
+                int err = pdata->power_on(pdev);
+                if (err < 0)
+                        return err;
+        }
 
         ohci_finish_controller_resume(hcd);
         return 0;
diff --git a/drivers/usb/host/ohci-pxa27x.c b/drivers/usb/host/ohci-pxa27x.c
index e1a3cc6d28dc..77f4402aca03 100644
--- a/drivers/usb/host/ohci-pxa27x.c
+++ b/drivers/usb/host/ohci-pxa27x.c
@@ -23,6 +23,8 @@
 #include <linux/signal.h>
 #include <linux/platform_device.h>
 #include <linux/clk.h>
+#include <linux/of_platform.h>
+#include <linux/of_gpio.h>
 #include <mach/hardware.h>
 #include <mach/ohci.h>
 #include <mach/pxa3xx-u2d.h>
@@ -272,6 +274,67 @@ static void pxa27x_stop_hc(struct pxa27x_ohci *ohci, struct device *dev)
         clk_disable_unprepare(ohci->clk);
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id pxa_ohci_dt_ids[] = {
+        { .compatible = "marvell,pxa-ohci" },
+        { }
+};
+
+MODULE_DEVICE_TABLE(of, pxa_ohci_dt_ids);
+
+static u64 pxa_ohci_dma_mask = DMA_BIT_MASK(32);
+
+static int __devinit ohci_pxa_of_init(struct platform_device *pdev)
+{
+        struct device_node *np = pdev->dev.of_node;
+        struct pxaohci_platform_data *pdata;
+        u32 tmp;
+
+        if (!np)
+                return 0;
+
+        /* Right now device-tree probed devices don't get dma_mask set.
+         * Since shared usb code relies on it, set it here for now.
+         * Once we have dma capability bindings this can go away.
+         */
+        if (!pdev->dev.dma_mask)
+                pdev->dev.dma_mask = &pxa_ohci_dma_mask;
+
+        pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+        if (!pdata)
+                return -ENOMEM;
+
+        if (of_get_property(np, "marvell,enable-port1", NULL))
+                pdata->flags |= ENABLE_PORT1;
+        if (of_get_property(np, "marvell,enable-port2", NULL))
+                pdata->flags |= ENABLE_PORT2;
+        if (of_get_property(np, "marvell,enable-port3", NULL))
+                pdata->flags |= ENABLE_PORT3;
+        if (of_get_property(np, "marvell,port-sense-low", NULL))
+                pdata->flags |= POWER_SENSE_LOW;
+        if (of_get_property(np, "marvell,power-control-low", NULL))
+                pdata->flags |= POWER_CONTROL_LOW;
+        if (of_get_property(np, "marvell,no-oc-protection", NULL))
+                pdata->flags |= NO_OC_PROTECTION;
+        if (of_get_property(np, "marvell,oc-mode-perport", NULL))
+                pdata->flags |= OC_MODE_PERPORT;
+        if (!of_property_read_u32(np, "marvell,power-on-delay", &tmp))
+                pdata->power_on_delay = tmp;
+        if (!of_property_read_u32(np, "marvell,port-mode", &tmp))
+                pdata->port_mode = tmp;
+        if (!of_property_read_u32(np, "marvell,power-budget", &tmp))
+                pdata->power_budget = tmp;
+
+        pdev->dev.platform_data = pdata;
+
+        return 0;
+}
+#else
+static int __devinit ohci_pxa_of_init(struct platform_device *pdev)
+{
+        return 0;
+}
+#endif
 
 /*-------------------------------------------------------------------------*/
 
@@ -297,6 +360,10 @@ int usb_hcd_pxa27x_probe (const struct hc_driver *driver, struct platform_device
         struct resource *r;
         struct clk *usb_clk;
 
+        retval = ohci_pxa_of_init(pdev);
+        if (retval)
+                return retval;
+
         inf = pdev->dev.platform_data;
 
         if (!inf)
@@ -544,6 +611,7 @@ static struct platform_driver ohci_hcd_pxa27x_driver = {
         .driver         = {
                 .name   = "pxa27x-ohci",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(pxa_ohci_dt_ids),
 #ifdef CONFIG_PM
                 .pm     = &ohci_hcd_pxa27x_pm_ops,
 #endif
diff --git a/drivers/usb/host/ohci-xls.c b/drivers/usb/host/ohci-xls.c
index 41e378f17c66..84201cd1a472 100644
--- a/drivers/usb/host/ohci-xls.c
+++ b/drivers/usb/host/ohci-xls.c
@@ -56,7 +56,7 @@ static int ohci_xls_probe_internal(const struct hc_driver *driver,
                 goto err3;
         }
 
-        retval = usb_add_hcd(hcd, irq, IRQF_DISABLED | IRQF_SHARED);
+        retval = usb_add_hcd(hcd, irq, IRQF_SHARED);
         if (retval != 0)
                 goto err4;
         return retval;
diff --git a/drivers/usb/host/r8a66597-hcd.c b/drivers/usb/host/r8a66597-hcd.c
index 4c634eb56358..fcc09e5ec0ad 100644
--- a/drivers/usb/host/r8a66597-hcd.c
+++ b/drivers/usb/host/r8a66597-hcd.c
@@ -2029,15 +2029,14 @@ static int r8a66597_get_frame(struct usb_hcd *hcd)
 static void collect_usb_address_map(struct usb_device *udev, unsigned long *map)
 {
         int chix;
+        struct usb_device *childdev;
 
         if (udev->state == USB_STATE_CONFIGURED &&
             udev->parent && udev->parent->devnum > 1 &&
             udev->parent->descriptor.bDeviceClass == USB_CLASS_HUB)
                 map[udev->devnum/32] |= (1 << (udev->devnum % 32));
 
-        for (chix = 0; chix < udev->maxchild; chix++) {
-                struct usb_device *childdev = udev->children[chix];
-
+        usb_hub_for_each_child(udev, chix, childdev) {
                 if (childdev)
                         collect_usb_address_map(childdev, map);
         }
diff --git a/drivers/usb/host/sl811-hcd.c b/drivers/usb/host/sl811-hcd.c
index 91ce1c02e617..619b05f42d4f 100644
--- a/drivers/usb/host/sl811-hcd.c
+++ b/drivers/usb/host/sl811-hcd.c
@@ -156,7 +156,7 @@ static void setup_packet(
         writeb(SL_SETUP /* | ep->epnum */, data_reg);
         writeb(usb_pipedevice(urb->pipe), data_reg);
 
-        /* always OUT/data0 */ ;
+        /* always OUT/data0 */
         sl811_write(sl811, bank + SL11H_HOSTCTLREG,
                         control | SL11H_HCTLMASK_OUT);
         ep->length = 0;
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index e4db350602b8..4b9e9aba2665 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -846,6 +846,11 @@ static const char hcd_name[] = "uhci_hcd";
 #define PLATFORM_DRIVER         uhci_grlib_driver
 #endif
 
+#ifdef CONFIG_USB_UHCI_PLATFORM
+#include "uhci-platform.c"
+#define PLATFORM_DRIVER         uhci_platform_driver
+#endif
+
 #if !defined(PCI_DRIVER) && !defined(PLATFORM_DRIVER)
 #error "missing bus glue for uhci-hcd"
 #endif
diff --git a/drivers/usb/host/uhci-platform.c b/drivers/usb/host/uhci-platform.c
new file mode 100644
index 000000000000..e4780491df4a
--- /dev/null
+++ b/drivers/usb/host/uhci-platform.c
@@ -0,0 +1,157 @@
+/*
+ * Generic UHCI HCD (Host Controller Driver) for Platform Devices
+ *
+ * Copyright (c) 2011 Tony Prisk <linux@prisktech.co.nz>
+ *
+ * This file is based on uhci-grlib.c
+ * (C) Copyright 2004-2007 Alan Stern, stern@rowland.harvard.edu
+ */
+
+#include <linux/of.h>
+#include <linux/platform_device.h>
+
+static int uhci_platform_init(struct usb_hcd *hcd)
+{
+        struct uhci_hcd *uhci = hcd_to_uhci(hcd);
+
+        uhci->rh_numports = uhci_count_ports(hcd);
+
+        /* Set up pointers to to generic functions */
+        uhci->reset_hc = uhci_generic_reset_hc;
+        uhci->check_and_reset_hc = uhci_generic_check_and_reset_hc;
+
+        /* No special actions need to be taken for the functions below */
+        uhci->configure_hc = NULL;
+        uhci->resume_detect_interrupts_are_broken = NULL;
+        uhci->global_suspend_mode_is_broken = NULL;
+
+        /* Reset if the controller isn't already safely quiescent. */
+        check_and_reset_hc(uhci);
+        return 0;
+}
+
+static const struct hc_driver uhci_platform_hc_driver = {
+        .description =          hcd_name,
+        .product_desc =         "Generic UHCI Host Controller",
+        .hcd_priv_size =        sizeof(struct uhci_hcd),
+
+        /* Generic hardware linkage */
+        .irq =                  uhci_irq,
+        .flags =                HCD_MEMORY | HCD_USB11,
+
+        /* Basic lifecycle operations */
+        .reset =                uhci_platform_init,
+        .start =                uhci_start,
+#ifdef CONFIG_PM
+        .pci_suspend =          NULL,
+        .pci_resume =           NULL,
+        .bus_suspend =          uhci_rh_suspend,
+        .bus_resume =           uhci_rh_resume,
+#endif
+        .stop =                 uhci_stop,
+
+        .urb_enqueue =          uhci_urb_enqueue,
+        .urb_dequeue =          uhci_urb_dequeue,
+
+        .endpoint_disable =     uhci_hcd_endpoint_disable,
+        .get_frame_number =     uhci_hcd_get_frame_number,
+
+        .hub_status_data =      uhci_hub_status_data,
+        .hub_control =          uhci_hub_control,
+};
+
+
+static int __devinit uhci_hcd_platform_probe(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd;
+        struct uhci_hcd *uhci;
+        struct resource *res;
+        int ret;
+
+        if (usb_disabled())
+                return -ENODEV;
+
+        hcd = usb_create_hcd(&uhci_platform_hc_driver, &pdev->dev,
+                        pdev->name);
+        if (!hcd)
+                return -ENOMEM;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        hcd->rsrc_start = res->start;
+        hcd->rsrc_len = resource_size(res);
+
+        if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
+                pr_err("%s: request_mem_region failed\n", __func__);
+                ret = -EBUSY;
+                goto err_rmr;
+        }
+
+        hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
+        if (!hcd->regs) {
+                pr_err("%s: ioremap failed\n", __func__);
+                ret = -ENOMEM;
+                goto err_irq;
+        }
+        uhci = hcd_to_uhci(hcd);
+
+        uhci->regs = hcd->regs;
+
+        ret = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED |
+                                                                IRQF_SHARED);
+        if (ret)
+                goto err_uhci;
+
+        return 0;
+
+err_uhci:
+        iounmap(hcd->regs);
+err_irq:
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+err_rmr:
+        usb_put_hcd(hcd);
+
+        return ret;
+}
+
+static int uhci_hcd_platform_remove(struct platform_device *pdev)
+{
+        struct usb_hcd *hcd = platform_get_drvdata(pdev);
+
+        usb_remove_hcd(hcd);
+        iounmap(hcd->regs);
+        release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
+        usb_put_hcd(hcd);
+        platform_set_drvdata(pdev, NULL);
+
+        return 0;
+}
+
+/* Make sure the controller is quiescent and that we're not using it
+ * any more.  This is mainly for the benefit of programs which, like kexec,
+ * expect the hardware to be idle: not doing DMA or generating IRQs.
+ *
+ * This routine may be called in a damaged or failing kernel.  Hence we
+ * do not acquire the spinlock before shutting down the controller.
+ */
+static void uhci_hcd_platform_shutdown(struct platform_device *op)
+{
+        struct usb_hcd *hcd = dev_get_drvdata(&op->dev);
+
+        uhci_hc_died(hcd_to_uhci(hcd));
+}
+
+static const struct of_device_id platform_uhci_ids[] = {
+        { .compatible = "platform-uhci", },
+        {}
+};
+
+static struct platform_driver uhci_platform_driver = {
+        .probe          = uhci_hcd_platform_probe,
+        .remove         = uhci_hcd_platform_remove,
+        .shutdown       = uhci_hcd_platform_shutdown,
+        .driver = {
+                .name = "platform-uhci",
+                .owner = THIS_MODULE,
+                .of_match_table = of_match_ptr(platform_uhci_ids),
+        },
+};
diff --git a/drivers/usb/host/whci/hcd.c b/drivers/usb/host/whci/hcd.c
index 1e141f755b26..c3a647816af0 100644
--- a/drivers/usb/host/whci/hcd.c
+++ b/drivers/usb/host/whci/hcd.c
@@ -238,16 +238,16 @@ static struct hc_driver whc_hc_driver = {
 
 static int whc_probe(struct umc_dev *umc)
 {
-        int ret = -ENOMEM;
+        int ret;
         struct usb_hcd *usb_hcd;
-        struct wusbhc *wusbhc = NULL;
-        struct whc *whc = NULL;
+        struct wusbhc *wusbhc;
+        struct whc *whc;
         struct device *dev = &umc->dev;
 
         usb_hcd = usb_create_hcd(&whc_hc_driver, dev, "whci");
         if (usb_hcd == NULL) {
                 dev_err(dev, "unable to create hcd\n");
-                goto error;
+                return -ENOMEM;
         }
 
         usb_hcd->wireless = 1;
diff --git a/drivers/usb/host/whci/qset.c b/drivers/usb/host/whci/qset.c
index 76083ae92138..dc31c425ce01 100644
--- a/drivers/usb/host/whci/qset.c
+++ b/drivers/usb/host/whci/qset.c
@@ -436,7 +436,7 @@ static int qset_add_urb_sg(struct whc *whc, struct whc_qset *qset, struct urb *u
         int i;
         int ntds = 0;
         struct whc_std *std = NULL;
-        struct whc_page_list_entry *entry;
+        struct whc_page_list_entry *new_pl_virt;
         dma_addr_t prev_end = 0;
         size_t pl_len;
         int p = 0;
@@ -508,12 +508,15 @@ static int qset_add_urb_sg(struct whc *whc, struct whc_qset *qset, struct urb *u
 
                         pl_len = std->num_pointers * sizeof(struct whc_page_list_entry);
 
-                        std->pl_virt = krealloc(std->pl_virt, pl_len, mem_flags);
-                        if (std->pl_virt == NULL) {
+                        new_pl_virt = krealloc(std->pl_virt, pl_len, mem_flags);
+                        if (new_pl_virt == NULL) {
+                                kfree(std->pl_virt);
+                                std->pl_virt = NULL;
                                 return -ENOMEM;
                         }
+                        std->pl_virt = new_pl_virt;
 
-                        for (;p < std->num_pointers; p++, entry++) {
+                        for (;p < std->num_pointers; p++) {
                                 std->pl_virt[p].buf_ptr = cpu_to_le64(dma_addr);
                                 dma_addr = (dma_addr + WHCI_PAGE_SIZE) & ~(WHCI_PAGE_SIZE-1);
                         }
diff --git a/drivers/usb/host/xhci-hub.c b/drivers/usb/host/xhci-hub.c
index d5eb357aa5c4..aa90ad4d4fd5 100644
--- a/drivers/usb/host/xhci-hub.c
+++ b/drivers/usb/host/xhci-hub.c
@@ -29,7 +29,7 @@
 #define PORT_RWC_BITS   (PORT_CSC | PORT_PEC | PORT_WRC | PORT_OCC | \
                          PORT_RC | PORT_PLC | PORT_PE)
 
-/* usb 1.1 root hub device descriptor */
+/* USB 3.0 BOS descriptor and a capability descriptor, combined */
 static u8 usb_bos_descriptor [] = {
         USB_DT_BOS_SIZE,                /*  __u8 bLength, 5 bytes */
         USB_DT_BOS,                     /*  __u8 bDescriptorType */
@@ -422,7 +422,7 @@ void xhci_set_link_state(struct xhci_hcd *xhci, __le32 __iomem **port_array,
         xhci_writel(xhci, temp, port_array[port_id]);
 }
 
-void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
+static void xhci_set_remote_wake_mask(struct xhci_hcd *xhci,
                 __le32 __iomem **port_array, int port_id, u16 wake_mask)
 {
         u32 temp;
@@ -808,6 +808,12 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
 
                         temp = xhci_readl(xhci, port_array[wIndex]);
                         xhci_dbg(xhci, "set port power, actual port %d status  = 0x%x\n", wIndex, temp);
+
+                        temp = usb_acpi_power_manageable(hcd->self.root_hub,
+                                        wIndex);
+                        if (temp)
+                                usb_acpi_set_power_state(hcd->self.root_hub,
+                                                wIndex, true);
                         break;
                 case USB_PORT_FEAT_RESET:
                         temp = (temp | PORT_RESET);
@@ -907,6 +913,16 @@ int xhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
                         xhci_disable_port(hcd, xhci, wIndex,
                                         port_array[wIndex], temp);
                         break;
+                case USB_PORT_FEAT_POWER:
+                        xhci_writel(xhci, temp & ~PORT_POWER,
+                                port_array[wIndex]);
+
+                        temp = usb_acpi_power_manageable(hcd->self.root_hub,
+                                        wIndex);
+                        if (temp)
+                                usb_acpi_set_power_state(hcd->self.root_hub,
+                                                wIndex, false);
+                        break;
                 default:
                         goto error;
                 }
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 77689bd64cac..487bc083dead 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1772,6 +1772,7 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
 {
         struct pci_dev  *pdev = to_pci_dev(xhci_to_hcd(xhci)->self.controller);
         struct dev_info *dev_info, *next;
+        struct xhci_cd  *cur_cd, *next_cd;
         unsigned long   flags;
         int size;
         int i, j, num_ports;
@@ -1795,6 +1796,11 @@ void xhci_mem_cleanup(struct xhci_hcd *xhci)
                 xhci_ring_free(xhci, xhci->cmd_ring);
         xhci->cmd_ring = NULL;
         xhci_dbg(xhci, "Freed command ring\n");
+        list_for_each_entry_safe(cur_cd, next_cd,
+                        &xhci->cancel_cmd_list, cancel_cmd_list) {
+                list_del(&cur_cd->cancel_cmd_list);
+                kfree(cur_cd);
+        }
 
         for (i = 1; i < MAX_HC_SLOTS; ++i)
                 xhci_free_virt_device(xhci, i);
@@ -2340,6 +2346,7 @@ int xhci_mem_init(struct xhci_hcd *xhci, gfp_t flags)
         xhci->cmd_ring = xhci_ring_alloc(xhci, 1, 1, TYPE_COMMAND, flags);
         if (!xhci->cmd_ring)
                 goto fail;
+        INIT_LIST_HEAD(&xhci->cancel_cmd_list);
         xhci_dbg(xhci, "Allocated command ring at %p\n", xhci->cmd_ring);
         xhci_dbg(xhci, "First segment DMA is 0x%llx\n",
                         (unsigned long long)xhci->cmd_ring->first_seg->dma);
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index 9bfd4ca1153c..8345d7c23061 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -103,6 +103,7 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                  * PPT chipsets.
                  */
                 xhci->quirks |= XHCI_SPURIOUS_REBOOT;
+                xhci->quirks |= XHCI_AVOID_BEI;
         }
         if (pdev->vendor == PCI_VENDOR_ID_ETRON &&
                         pdev->device == PCI_DEVICE_ID_ASROCK_P67) {
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 643c2f3f3e73..c6ebb176dc4f 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -280,12 +280,123 @@ static inline int room_on_ring(struct xhci_hcd *xhci, struct xhci_ring *ring,
 /* Ring the host controller doorbell after placing a command on the ring */
 void xhci_ring_cmd_db(struct xhci_hcd *xhci)
 {
+        if (!(xhci->cmd_ring_state & CMD_RING_STATE_RUNNING))
+                return;
+
         xhci_dbg(xhci, "// Ding dong!\n");
         xhci_writel(xhci, DB_VALUE_HOST, &xhci->dba->doorbell[0]);
         /* Flush PCI posted writes */
         xhci_readl(xhci, &xhci->dba->doorbell[0]);
 }
 
+static int xhci_abort_cmd_ring(struct xhci_hcd *xhci)
+{
+        u64 temp_64;
+        int ret;
+
+        xhci_dbg(xhci, "Abort command ring\n");
+
+        if (!(xhci->cmd_ring_state & CMD_RING_STATE_RUNNING)) {
+                xhci_dbg(xhci, "The command ring isn't running, "
+                                "Have the command ring been stopped?\n");
+                return 0;
+        }
+
+        temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring);
+        if (!(temp_64 & CMD_RING_RUNNING)) {
+                xhci_dbg(xhci, "Command ring had been stopped\n");
+                return 0;
+        }
+        xhci->cmd_ring_state = CMD_RING_STATE_ABORTED;
+        xhci_write_64(xhci, temp_64 | CMD_RING_ABORT,
+                        &xhci->op_regs->cmd_ring);
+
+        /* Section 4.6.1.2 of xHCI 1.0 spec says software should
+         * time the completion od all xHCI commands, including
+         * the Command Abort operation. If software doesn't see
+         * CRR negated in a timely manner (e.g. longer than 5
+         * seconds), then it should assume that the there are
+         * larger problems with the xHC and assert HCRST.
+         */
+        ret = handshake(xhci, &xhci->op_regs->cmd_ring,
+                        CMD_RING_RUNNING, 0, 5 * 1000 * 1000);
+        if (ret < 0) {
+                xhci_err(xhci, "Stopped the command ring failed, "
+                                "maybe the host is dead\n");
+                xhci->xhc_state |= XHCI_STATE_DYING;
+                xhci_quiesce(xhci);
+                xhci_halt(xhci);
+                return -ESHUTDOWN;
+        }
+
+        return 0;
+}
+
+static int xhci_queue_cd(struct xhci_hcd *xhci,
+                struct xhci_command *command,
+                union xhci_trb *cmd_trb)
+{
+        struct xhci_cd *cd;
+        cd = kzalloc(sizeof(struct xhci_cd), GFP_ATOMIC);
+        if (!cd)
+                return -ENOMEM;
+        INIT_LIST_HEAD(&cd->cancel_cmd_list);
+
+        cd->command = command;
+        cd->cmd_trb = cmd_trb;
+        list_add_tail(&cd->cancel_cmd_list, &xhci->cancel_cmd_list);
+
+        return 0;
+}
+
+/*
+ * Cancel the command which has issue.
+ *
+ * Some commands may hang due to waiting for acknowledgement from
+ * usb device. It is outside of the xHC's ability to control and
+ * will cause the command ring is blocked. When it occurs software
+ * should intervene to recover the command ring.
+ * See Section 4.6.1.1 and 4.6.1.2
+ */
+int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
+                union xhci_trb *cmd_trb)
+{
+        int retval = 0;
+        unsigned long flags;
+
+        spin_lock_irqsave(&xhci->lock, flags);
+
+        if (xhci->xhc_state & XHCI_STATE_DYING) {
+                xhci_warn(xhci, "Abort the command ring,"
+                                " but the xHCI is dead.\n");
+                retval = -ESHUTDOWN;
+                goto fail;
+        }
+
+        /* queue the cmd desriptor to cancel_cmd_list */
+        retval = xhci_queue_cd(xhci, command, cmd_trb);
+        if (retval) {
+                xhci_warn(xhci, "Queuing command descriptor failed.\n");
+                goto fail;
+        }
+
+        /* abort command ring */
+        retval = xhci_abort_cmd_ring(xhci);
+        if (retval) {
+                xhci_err(xhci, "Abort command ring failed\n");
+                if (unlikely(retval == -ESHUTDOWN)) {
+                        spin_unlock_irqrestore(&xhci->lock, flags);
+                        usb_hc_died(xhci_to_hcd(xhci)->primary_hcd);
+                        xhci_dbg(xhci, "xHCI host controller is dead.\n");
+                        return retval;
+                }
+        }
+
+fail:
+        spin_unlock_irqrestore(&xhci->lock, flags);
+        return retval;
+}
+
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci,
                 unsigned int slot_id,
                 unsigned int ep_index,
@@ -1059,6 +1170,20 @@ static void handle_reset_ep_completion(struct xhci_hcd *xhci,
         }
 }
 
+/* Complete the command and detele it from the devcie's command queue.
+ */
+static void xhci_complete_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
+                struct xhci_command *command, u32 status)
+{
+        command->status = status;
+        list_del(&command->cmd_list);
+        if (command->completion)
+                complete(command->completion);
+        else
+                xhci_free_command(xhci, command);
+}
+
+
 /* Check to see if a command in the device's command queue matches this one.
  * Signal the completion or free the command, and return 1.  Return 0 if the
  * completed command isn't at the head of the command list.
@@ -1077,15 +1202,144 @@ static int handle_cmd_in_cmd_wait_list(struct xhci_hcd *xhci,
         if (xhci->cmd_ring->dequeue != command->command_trb)
                 return 0;
 
-        command->status = GET_COMP_CODE(le32_to_cpu(event->status));
-        list_del(&command->cmd_list);
-        if (command->completion)
-                complete(command->completion);
-        else
-                xhci_free_command(xhci, command);
+        xhci_complete_cmd_in_cmd_wait_list(xhci, command,
+                        GET_COMP_CODE(le32_to_cpu(event->status)));
         return 1;
 }
 
+/*
+ * Finding the command trb need to be cancelled and modifying it to
+ * NO OP command. And if the command is in device's command wait
+ * list, finishing and freeing it.
+ *
+ * If we can't find the command trb, we think it had already been
+ * executed.
+ */
+static void xhci_cmd_to_noop(struct xhci_hcd *xhci, struct xhci_cd *cur_cd)
+{
+        struct xhci_segment *cur_seg;
+        union xhci_trb *cmd_trb;
+        u32 cycle_state;
+
+        if (xhci->cmd_ring->dequeue == xhci->cmd_ring->enqueue)
+                return;
+
+        /* find the current segment of command ring */
+        cur_seg = find_trb_seg(xhci->cmd_ring->first_seg,
+                        xhci->cmd_ring->dequeue, &cycle_state);
+
+        /* find the command trb matched by cd from command ring */
+        for (cmd_trb = xhci->cmd_ring->dequeue;
+                        cmd_trb != xhci->cmd_ring->enqueue;
+                        next_trb(xhci, xhci->cmd_ring, &cur_seg, &cmd_trb)) {
+                /* If the trb is link trb, continue */
+                if (TRB_TYPE_LINK_LE32(cmd_trb->generic.field[3]))
+                        continue;
+
+                if (cur_cd->cmd_trb == cmd_trb) {
+
+                        /* If the command in device's command list, we should
+                         * finish it and free the command structure.
+                         */
+                        if (cur_cd->command)
+                                xhci_complete_cmd_in_cmd_wait_list(xhci,
+                                        cur_cd->command, COMP_CMD_STOP);
+
+                        /* get cycle state from the origin command trb */
+                        cycle_state = le32_to_cpu(cmd_trb->generic.field[3])
+                                & TRB_CYCLE;
+
+                        /* modify the command trb to NO OP command */
+                        cmd_trb->generic.field[0] = 0;
+                        cmd_trb->generic.field[1] = 0;
+                        cmd_trb->generic.field[2] = 0;
+                        cmd_trb->generic.field[3] = cpu_to_le32(
+                                        TRB_TYPE(TRB_CMD_NOOP) | cycle_state);
+                        break;
+                }
+        }
+}
+
+static void xhci_cancel_cmd_in_cd_list(struct xhci_hcd *xhci)
+{
+        struct xhci_cd *cur_cd, *next_cd;
+
+        if (list_empty(&xhci->cancel_cmd_list))
+                return;
+
+        list_for_each_entry_safe(cur_cd, next_cd,
+                        &xhci->cancel_cmd_list, cancel_cmd_list) {
+                xhci_cmd_to_noop(xhci, cur_cd);
+                list_del(&cur_cd->cancel_cmd_list);
+                kfree(cur_cd);
+        }
+}
+
+/*
+ * traversing the cancel_cmd_list. If the command descriptor according
+ * to cmd_trb is found, the function free it and return 1, otherwise
+ * return 0.
+ */
+static int xhci_search_cmd_trb_in_cd_list(struct xhci_hcd *xhci,
+                union xhci_trb *cmd_trb)
+{
+        struct xhci_cd *cur_cd, *next_cd;
+
+        if (list_empty(&xhci->cancel_cmd_list))
+                return 0;
+
+        list_for_each_entry_safe(cur_cd, next_cd,
+                        &xhci->cancel_cmd_list, cancel_cmd_list) {
+                if (cur_cd->cmd_trb == cmd_trb) {
+                        if (cur_cd->command)
+                                xhci_complete_cmd_in_cmd_wait_list(xhci,
+                                        cur_cd->command, COMP_CMD_STOP);
+                        list_del(&cur_cd->cancel_cmd_list);
+                        kfree(cur_cd);
+                        return 1;
+                }
+        }
+
+        return 0;
+}
+
+/*
+ * If the cmd_trb_comp_code is COMP_CMD_ABORT, we just check whether the
+ * trb pointed by the command ring dequeue pointer is the trb we want to
+ * cancel or not. And if the cmd_trb_comp_code is COMP_CMD_STOP, we will
+ * traverse the cancel_cmd_list to trun the all of the commands according
+ * to command descriptor to NO-OP trb.
+ */
+static int handle_stopped_cmd_ring(struct xhci_hcd *xhci,
+                int cmd_trb_comp_code)
+{
+        int cur_trb_is_good = 0;
+
+        /* Searching the cmd trb pointed by the command ring dequeue
+         * pointer in command descriptor list. If it is found, free it.
+         */
+        cur_trb_is_good = xhci_search_cmd_trb_in_cd_list(xhci,
+                        xhci->cmd_ring->dequeue);
+
+        if (cmd_trb_comp_code == COMP_CMD_ABORT)
+                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
+        else if (cmd_trb_comp_code == COMP_CMD_STOP) {
+                /* traversing the cancel_cmd_list and canceling
+                 * the command according to command descriptor
+                 */
+                xhci_cancel_cmd_in_cd_list(xhci);
+
+                xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
+                /*
+                 * ring command ring doorbell again to restart the
+                 * command ring
+                 */
+                if (xhci->cmd_ring->dequeue != xhci->cmd_ring->enqueue)
+                        xhci_ring_cmd_db(xhci);
+        }
+        return cur_trb_is_good;
+}
+
 static void handle_cmd_completion(struct xhci_hcd *xhci,
                 struct xhci_event_cmd *event)
 {
@@ -1111,6 +1365,22 @@ static void handle_cmd_completion(struct xhci_hcd *xhci,
                 xhci->error_bitmask |= 1 << 5;
                 return;
         }
+
+        if ((GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_CMD_ABORT) ||
+                (GET_COMP_CODE(le32_to_cpu(event->status)) == COMP_CMD_STOP)) {
+                /* If the return value is 0, we think the trb pointed by
+                 * command ring dequeue pointer is a good trb. The good
+                 * trb means we don't want to cancel the trb, but it have
+                 * been stopped by host. So we should handle it normally.
+                 * Otherwise, driver should invoke inc_deq() and return.
+                 */
+                if (handle_stopped_cmd_ring(xhci,
+                                GET_COMP_CODE(le32_to_cpu(event->status)))) {
+                        inc_deq(xhci, xhci->cmd_ring);
+                        return;
+                }
+        }
+
         switch (le32_to_cpu(xhci->cmd_ring->dequeue->generic.field[3])
                 & TRB_TYPE_BITMASK) {
         case TRB_TYPE(TRB_ENABLE_SLOT):
@@ -2003,6 +2273,8 @@ static int process_bulk_intr_td(struct xhci_hcd *xhci, struct xhci_td *td,
  */
 static int handle_tx_event(struct xhci_hcd *xhci,
                 struct xhci_transfer_event *event)
+        __releases(&xhci->lock)
+        __acquires(&xhci->lock)
 {
         struct xhci_virt_device *xdev;
         struct xhci_virt_ep *ep;
@@ -2580,7 +2852,7 @@ static int prepare_ring(struct xhci_hcd *xhci, struct xhci_ring *ep_ring,
                         xhci_err(xhci, "Ring expansion failed\n");
                         return -ENOMEM;
                 }
-        };
+        }
 
         if (enqueue_is_link_trb(ep_ring)) {
                 struct xhci_ring *ring = ep_ring;
@@ -3400,7 +3672,9 @@ static int xhci_queue_isoc_tx(struct xhci_hcd *xhci, gfp_t mem_flags,
                         } else {
                                 td->last_trb = ep_ring->enqueue;
                                 field |= TRB_IOC;
-                                if (xhci->hci_version == 0x100) {
+                                if (xhci->hci_version == 0x100 &&
+                                                !(xhci->quirks &
+                                                        XHCI_AVOID_BEI)) {
                                         /* Set BEI bit except for the last td */
                                         if (i < num_tds - 1)
                                                 field |= TRB_BEI;
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index 6ece0ed288d4..8d7fcbbe6ade 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -52,7 +52,7 @@ MODULE_PARM_DESC(link_quirk, "Don't clear the chain bit on a link TRB");
  * handshake done).  There are two failure modes:  "usec" have passed (major
  * hardware flakeout), or the register reads as all-ones (hardware removed).
  */
-static int handshake(struct xhci_hcd *xhci, void __iomem *ptr,
+int handshake(struct xhci_hcd *xhci, void __iomem *ptr,
                       u32 mask, u32 done, int usec)
 {
         u32     result;
@@ -105,9 +105,10 @@ int xhci_halt(struct xhci_hcd *xhci)
 
         ret = handshake(xhci, &xhci->op_regs->status,
                         STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC);
-        if (!ret)
+        if (!ret) {
                 xhci->xhc_state |= XHCI_STATE_HALTED;
-        else
+                xhci->cmd_ring_state = CMD_RING_STATE_STOPPED;
+        } else
                 xhci_warn(xhci, "Host not halted after %u microseconds.\n",
                                 XHCI_MAX_HALT_USEC);
         return ret;
@@ -470,6 +471,8 @@ static bool compliance_mode_recovery_timer_quirk_check(void)
 
         dmi_product_name = dmi_get_system_info(DMI_PRODUCT_NAME);
         dmi_sys_vendor = dmi_get_system_info(DMI_SYS_VENDOR);
+        if (!dmi_product_name || !dmi_sys_vendor)
+                return false;
 
         if (!(strstr(dmi_sys_vendor, "Hewlett-Packard")))
                 return false;
@@ -581,6 +584,7 @@ static int xhci_run_finished(struct xhci_hcd *xhci)
                 return -ENODEV;
         }
         xhci->shared_hcd->state = HC_STATE_RUNNING;
+        xhci->cmd_ring_state = CMD_RING_STATE_RUNNING;
 
         if (xhci->quirks & XHCI_NEC_HOST)
                 xhci_ring_cmd_db(xhci);
@@ -886,7 +890,7 @@ int xhci_suspend(struct xhci_hcd *xhci)
         command &= ~CMD_RUN;
         xhci_writel(xhci, command, &xhci->op_regs->command);
         if (handshake(xhci, &xhci->op_regs->status,
-                      STS_HALT, STS_HALT, 100*100)) {
+                      STS_HALT, STS_HALT, XHCI_MAX_HALT_USEC)) {
                 xhci_warn(xhci, "WARN: xHC CMD_RUN timeout\n");
                 spin_unlock_irq(&xhci->lock);
                 return -ETIMEDOUT;
@@ -1948,7 +1952,7 @@ static void xhci_finish_resource_reservation(struct xhci_hcd *xhci,
                                 xhci->num_active_eps);
 }
 
-unsigned int xhci_get_block_size(struct usb_device *udev)
+static unsigned int xhci_get_block_size(struct usb_device *udev)
 {
         switch (udev->speed) {
         case USB_SPEED_LOW:
@@ -1966,7 +1970,8 @@ unsigned int xhci_get_block_size(struct usb_device *udev)
         }
 }
 
-unsigned int xhci_get_largest_overhead(struct xhci_interval_bw *interval_bw)
+static unsigned int
+xhci_get_largest_overhead(struct xhci_interval_bw *interval_bw)
 {
         if (interval_bw->overhead[LS_OVERHEAD_TYPE])
                 return LS_OVERHEAD;
@@ -2521,6 +2526,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         struct completion *cmd_completion;
         u32 *cmd_status;
         struct xhci_virt_device *virt_dev;
+        union xhci_trb *cmd_trb;
 
         spin_lock_irqsave(&xhci->lock, flags);
         virt_dev = xhci->devs[udev->slot_id];
@@ -2566,6 +2572,7 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         }
         init_completion(cmd_completion);
 
+        cmd_trb = xhci->cmd_ring->dequeue;
         if (!ctx_change)
                 ret = xhci_queue_configure_endpoint(xhci, in_ctx->dma,
                                 udev->slot_id, must_succeed);
@@ -2587,14 +2594,17 @@ static int xhci_configure_endpoint(struct xhci_hcd *xhci,
         /* Wait for the configure endpoint command to complete */
         timeleft = wait_for_completion_interruptible_timeout(
                         cmd_completion,
-                        USB_CTRL_SET_TIMEOUT);
+                        XHCI_CMD_DEFAULT_TIMEOUT);
         if (timeleft <= 0) {
                 xhci_warn(xhci, "%s while waiting for %s command\n",
                                 timeleft == 0 ? "Timeout" : "Signal",
                                 ctx_change == 0 ?
                                         "configure endpoint" :
                                         "evaluate context");
-                /* FIXME cancel the configure endpoint command */
+                /* cancel the configure endpoint command */
+                ret = xhci_cancel_cmd(xhci, command, cmd_trb);
+                if (ret < 0)
+                        return ret;
                 return -ETIME;
         }
 
@@ -3543,8 +3553,10 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
         unsigned long flags;
         int timeleft;
         int ret;
+        union xhci_trb *cmd_trb;
 
         spin_lock_irqsave(&xhci->lock, flags);
+        cmd_trb = xhci->cmd_ring->dequeue;
         ret = xhci_queue_slot_control(xhci, TRB_ENABLE_SLOT, 0);
         if (ret) {
                 spin_unlock_irqrestore(&xhci->lock, flags);
@@ -3556,12 +3568,12 @@ int xhci_alloc_dev(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* XXX: how much time for xHC slot assignment? */
         timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        USB_CTRL_SET_TIMEOUT);
+                        XHCI_CMD_DEFAULT_TIMEOUT);
         if (timeleft <= 0) {
                 xhci_warn(xhci, "%s while waiting for a slot\n",
                                 timeleft == 0 ? "Timeout" : "Signal");
-                /* FIXME cancel the enable slot request */
-                return 0;
+                /* cancel the enable slot request */
+                return xhci_cancel_cmd(xhci, NULL, cmd_trb);
         }
 
         if (!xhci->slot_id) {
@@ -3622,6 +3634,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         struct xhci_slot_ctx *slot_ctx;
         struct xhci_input_control_ctx *ctrl_ctx;
         u64 temp_64;
+        union xhci_trb *cmd_trb;
 
         if (!udev->slot_id) {
                 xhci_dbg(xhci, "Bad Slot ID %d\n", udev->slot_id);
@@ -3660,6 +3673,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         xhci_dbg_ctx(xhci, virt_dev->in_ctx, 2);
 
         spin_lock_irqsave(&xhci->lock, flags);
+        cmd_trb = xhci->cmd_ring->dequeue;
         ret = xhci_queue_address_device(xhci, virt_dev->in_ctx->dma,
                                         udev->slot_id);
         if (ret) {
@@ -3672,7 +3686,7 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
 
         /* ctrl tx can take up to 5 sec; XXX: need more time for xHC? */
         timeleft = wait_for_completion_interruptible_timeout(&xhci->addr_dev,
-                        USB_CTRL_SET_TIMEOUT);
+                        XHCI_CMD_DEFAULT_TIMEOUT);
         /* FIXME: From section 4.3.4: "Software shall be responsible for timing
          * the SetAddress() "recovery interval" required by USB and aborting the
          * command on a timeout.
@@ -3680,7 +3694,10 @@ int xhci_address_device(struct usb_hcd *hcd, struct usb_device *udev)
         if (timeleft <= 0) {
                 xhci_warn(xhci, "%s while waiting for address device command\n",
                                 timeleft == 0 ? "Timeout" : "Signal");
-                /* FIXME cancel the address device command */
+                /* cancel the address device command */
+                ret = xhci_cancel_cmd(xhci, NULL, cmd_trb);
+                if (ret < 0)
+                        return ret;
                 return -ETIME;
         }
 
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index 1a05908c6673..53df4e70ca07 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1256,6 +1256,16 @@ struct xhci_td {
         union xhci_trb          *last_trb;
 };
 
+/* xHCI command default timeout value */
+#define XHCI_CMD_DEFAULT_TIMEOUT        (5 * HZ)
+
+/* command descriptor */
+struct xhci_cd {
+        struct list_head        cancel_cmd_list;
+        struct xhci_command     *command;
+        union xhci_trb          *cmd_trb;
+};
+
 struct xhci_dequeue_state {
         struct xhci_segment *new_deq_seg;
         union xhci_trb *new_deq_ptr;
@@ -1421,6 +1431,11 @@ struct xhci_hcd {
         /* data structures */
         struct xhci_device_context_array *dcbaa;
         struct xhci_ring        *cmd_ring;
+        unsigned int            cmd_ring_state;
+#define CMD_RING_STATE_RUNNING         (1 << 0)
+#define CMD_RING_STATE_ABORTED         (1 << 1)
+#define CMD_RING_STATE_STOPPED         (1 << 2)
+        struct list_head        cancel_cmd_list;
         unsigned int            cmd_ring_reserved_trbs;
         struct xhci_ring        *event_ring;
         struct xhci_erst        erst;
@@ -1496,6 +1511,7 @@ struct xhci_hcd {
 #define XHCI_INTEL_HOST         (1 << 12)
 #define XHCI_SPURIOUS_REBOOT    (1 << 13)
 #define XHCI_COMP_MODE_QUIRK    (1 << 14)
+#define XHCI_AVOID_BEI          (1 << 15)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
@@ -1704,6 +1720,8 @@ static inline void xhci_unregister_plat(void)
 
 /* xHCI host controller glue */
 typedef void (*xhci_get_quirks_t)(struct device *, struct xhci_hcd *);
+int handshake(struct xhci_hcd *xhci, void __iomem *ptr,
+                u32 mask, u32 done, int usec);
 void xhci_quiesce(struct xhci_hcd *xhci);
 int xhci_halt(struct xhci_hcd *xhci);
 int xhci_reset(struct xhci_hcd *xhci);
@@ -1794,6 +1812,8 @@ void xhci_queue_config_ep_quirk(struct xhci_hcd *xhci,
                 unsigned int slot_id, unsigned int ep_index,
                 struct xhci_dequeue_state *deq_state);
 void xhci_stop_endpoint_command_watchdog(unsigned long arg);
+int xhci_cancel_cmd(struct xhci_hcd *xhci, struct xhci_command *command,
+                union xhci_trb *cmd_trb);
 void xhci_ring_ep_doorbell(struct xhci_hcd *xhci, unsigned int slot_id,
                 unsigned int ep_index, unsigned int stream_id);
 
diff --git a/drivers/usb/misc/Kconfig b/drivers/usb/misc/Kconfig
index 1bfcd02ebeb5..a8f05239350e 100644
--- a/drivers/usb/misc/Kconfig
+++ b/drivers/usb/misc/Kconfig
@@ -244,3 +244,8 @@ config USB_YUREX
           To compile this driver as a module, choose M here: the
           module will be called yurex.
 
+config USB_EZUSB_FX2
+        tristate "Functions for loading firmware on EZUSB chips"
+        help
+          Say Y here if you need EZUSB device support.
+          (Cypress FX/FX2/FX2LP microcontrollers)
diff --git a/drivers/usb/misc/Makefile b/drivers/usb/misc/Makefile
index 796ce7ebccc8..3e99a643294b 100644
--- a/drivers/usb/misc/Makefile
+++ b/drivers/usb/misc/Makefile
@@ -11,6 +11,7 @@ obj-$(CONFIG_USB_CYPRESS_CY7C63)	+= cypress_cy7c63.o
 obj-$(CONFIG_USB_CYTHERM)               += cytherm.o
 obj-$(CONFIG_USB_EMI26)                 += emi26.o
 obj-$(CONFIG_USB_EMI62)                 += emi62.o
+obj-$(CONFIG_USB_EZUSB_FX2)             += ezusb.o
 obj-$(CONFIG_USB_FTDI_ELAN)             += ftdi-elan.o
 obj-$(CONFIG_USB_IDMOUSE)               += idmouse.o
 obj-$(CONFIG_USB_IOWARRIOR)             += iowarrior.o
diff --git a/drivers/usb/misc/ezusb.c b/drivers/usb/misc/ezusb.c
new file mode 100644
index 000000000000..4223d761223d
--- /dev/null
+++ b/drivers/usb/misc/ezusb.c
@@ -0,0 +1,160 @@
+/*
+ * EZ-USB specific functions used by some of the USB to Serial drivers.
+ *
+ * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
+ *
+ *      This program is free software; you can redistribute it and/or
+ *      modify it under the terms of the GNU General Public License version
+ *      2 as published by the Free Software Foundation.
+ */
+
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/firmware.h>
+#include <linux/ihex.h>
+
+struct ezusb_fx_type {
+        /* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */
+        unsigned short cpucs_reg;
+        unsigned short max_internal_adress;
+};
+
+struct ezusb_fx_type ezusb_fx1 = {
+        .cpucs_reg = 0x7F92,
+        .max_internal_adress = 0x1B3F,
+};
+
+struct ezusb_fx_type ezusb_fx2 = {
+        .cpucs_reg = 0xE600,
+        .max_internal_adress = 0x3FFF,
+};
+
+/* Commands for writing to memory */
+#define WRITE_INT_RAM 0xA0
+#define WRITE_EXT_RAM 0xA3
+
+int ezusb_writememory(struct usb_device *dev, int address,
+                                unsigned char *data, int length, __u8 request)
+{
+        int result;
+        unsigned char *transfer_buffer;
+
+        if (!dev)
+                return -ENODEV;
+
+        transfer_buffer = kmemdup(data, length, GFP_KERNEL);
+        if (!transfer_buffer) {
+                dev_err(&dev->dev, "%s - kmalloc(%d) failed.\n",
+                                                        __func__, length);
+                return -ENOMEM;
+        }
+        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
+                                 USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                                 address, 0, transfer_buffer, length, 3000);
+
+        kfree(transfer_buffer);
+        return result;
+}
+EXPORT_SYMBOL_GPL(ezusb_writememory);
+
+int ezusb_set_reset(struct usb_device *dev, unsigned short cpucs_reg,
+                         unsigned char reset_bit)
+{
+        int response = ezusb_writememory(dev, cpucs_reg, &reset_bit, 1, WRITE_INT_RAM);
+        if (response < 0)
+                dev_err(&dev->dev, "%s-%d failed: %d\n",
+                                                __func__, reset_bit, response);
+        return response;
+}
+
+int ezusb_fx1_set_reset(struct usb_device *dev, unsigned char reset_bit)
+{
+        return ezusb_set_reset(dev, ezusb_fx1.cpucs_reg, reset_bit);
+}
+EXPORT_SYMBOL_GPL(ezusb_fx1_set_reset);
+
+int ezusb_fx2_set_reset(struct usb_device *dev, unsigned char reset_bit)
+{
+        return ezusb_set_reset(dev, ezusb_fx2.cpucs_reg, reset_bit);
+}
+EXPORT_SYMBOL_GPL(ezusb_fx2_set_reset);
+
+static int ezusb_ihex_firmware_download(struct usb_device *dev,
+                                        struct ezusb_fx_type fx,
+                                        const char *firmware_path)
+{
+        int ret = -ENOENT;
+        const struct firmware *firmware = NULL;
+        const struct ihex_binrec *record;
+
+        if (request_ihex_firmware(&firmware, firmware_path,
+                                  &dev->dev)) {
+                dev_err(&dev->dev,
+                        "%s - request \"%s\" failed\n",
+                        __func__, firmware_path);
+                goto out;
+        }
+
+        ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
+        if (ret < 0)
+                goto out;
+
+        record = (const struct ihex_binrec *)firmware->data;
+        for (; record; record = ihex_next_binrec(record)) {
+                if (be32_to_cpu(record->addr) > fx.max_internal_adress) {
+                        ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
+                                                (unsigned char *)record->data,
+                                                be16_to_cpu(record->len), WRITE_EXT_RAM);
+                        if (ret < 0) {
+                                dev_err(&dev->dev, "%s - ezusb_writememory "
+                                        "failed writing internal memory "
+                                        "(%d %04X %p %d)\n", __func__, ret,
+                                        be32_to_cpu(record->addr), record->data,
+                                        be16_to_cpu(record->len));
+                                goto out;
+                        }
+                }
+        }
+
+        ret = ezusb_set_reset(dev, fx.cpucs_reg, 1);
+        if (ret < 0)
+                goto out;
+        record = (const struct ihex_binrec *)firmware->data;
+        for (; record; record = ihex_next_binrec(record)) {
+                if (be32_to_cpu(record->addr) <= fx.max_internal_adress) {
+                        ret = ezusb_writememory(dev, be32_to_cpu(record->addr),
+                                                (unsigned char *)record->data,
+                                                be16_to_cpu(record->len), WRITE_INT_RAM);
+                        if (ret < 0) {
+                                dev_err(&dev->dev, "%s - ezusb_writememory "
+                                        "failed writing external memory "
+                                        "(%d %04X %p %d)\n", __func__, ret,
+                                        be32_to_cpu(record->addr), record->data,
+                                        be16_to_cpu(record->len));
+                                goto out;
+                        }
+                }
+        }
+        ret = ezusb_set_reset(dev, fx.cpucs_reg, 0);
+out:
+        release_firmware(firmware);
+        return ret;
+}
+
+int ezusb_fx1_ihex_firmware_download(struct usb_device *dev,
+                                     const char *firmware_path)
+{
+        return ezusb_ihex_firmware_download(dev, ezusb_fx1, firmware_path);
+}
+EXPORT_SYMBOL_GPL(ezusb_fx1_ihex_firmware_download);
+
+int ezusb_fx2_ihex_firmware_download(struct usb_device *dev,
+                                     const char *firmware_path)
+{
+        return ezusb_ihex_firmware_download(dev, ezusb_fx2, firmware_path);
+}
+EXPORT_SYMBOL_GPL(ezusb_fx2_ihex_firmware_download);
+
diff --git a/drivers/usb/misc/legousbtower.c b/drivers/usb/misc/legousbtower.c
index a2702cbfe804..80894791c020 100644
--- a/drivers/usb/misc/legousbtower.c
+++ b/drivers/usb/misc/legousbtower.c
@@ -868,9 +868,6 @@ static int tower_probe (struct usb_interface *interface, const struct usb_device
 
         dbg(2, "%s: enter", __func__);
 
-        if (udev == NULL)
-                dev_info(&interface->dev, "udev is NULL.\n");
-
         /* allocate memory for our device state and initialize it */
 
         dev = kmalloc (sizeof(struct lego_usb_tower), GFP_KERNEL);
diff --git a/drivers/usb/misc/rio500.c b/drivers/usb/misc/rio500.c
index 1084124c4a44..b9b356a9dd11 100644
--- a/drivers/usb/misc/rio500.c
+++ b/drivers/usb/misc/rio500.c
@@ -338,7 +338,7 @@ write_rio(struct file *file, const char __user *buffer,
                                 thistime -= partial;
                         } else
                                 break;
-                };
+                }
                 if (result) {
                         dev_err(&rio->rio_dev->dev, "Write Whoops - %x\n",
                                 result);
diff --git a/drivers/usb/musb/Kconfig b/drivers/usb/musb/Kconfig
index 6259f0d99324..23a0b7f0892d 100644
--- a/drivers/usb/musb/Kconfig
+++ b/drivers/usb/musb/Kconfig
@@ -12,7 +12,6 @@ config USB_MUSB_HDRC
         select TWL4030_USB if MACH_OMAP_3430SDP
         select TWL6030_USB if MACH_OMAP_4430SDP || MACH_OMAP4_PANDA
         select USB_OTG_UTILS
-        select USB_GADGET_DUALSPEED
         help
           Say Y here if your system has a dual role high speed USB
           controller based on the Mentor Graphics silicon IP.  Then
@@ -20,7 +19,7 @@ config USB_MUSB_HDRC
           it's being used with, including the USB peripheral role,
           or the USB host role, or both.
 
-          Texas Instruments familiies using this IP include DaVinci
+          Texas Instruments families using this IP include DaVinci
           (35x, 644x ...), OMAP 243x, OMAP 3, and TUSB 6010.
 
           Analog Devices parts using this IP include Blackfin BF54x,
diff --git a/drivers/usb/musb/am35x.c b/drivers/usb/musb/am35x.c
index 7a95ab87ac00..457f25e62c51 100644
--- a/drivers/usb/musb/am35x.c
+++ b/drivers/usb/musb/am35x.c
@@ -33,6 +33,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include <plat/usb.h>
 
@@ -107,9 +108,8 @@ static void am35x_musb_enable(struct musb *musb)
         musb_writel(reg_base, CORE_INTR_MASK_SET_REG, AM35X_INTR_USB_MASK);
 
         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
-        if (is_otg_enabled(musb))
-                musb_writel(reg_base, CORE_INTR_SRC_SET_REG,
-                            AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);
+        musb_writel(reg_base, CORE_INTR_SRC_SET_REG,
+                        AM35X_INTR_DRVVBUS << AM35X_INTR_USB_SHIFT);
 }
 
 /*
@@ -173,9 +173,6 @@ static void otg_timer(unsigned long _musb)
                             MUSB_INTR_VBUSERROR << AM35X_INTR_USB_SHIFT);
                 break;
         case OTG_STATE_B_IDLE:
-                if (!is_peripheral_enabled(musb))
-                        break;
-
                 devctl = musb_readb(mregs, MUSB_DEVCTL);
                 if (devctl & MUSB_DEVCTL_BDEVICE)
                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
@@ -192,9 +189,6 @@ static void am35x_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         static unsigned long last_timer;
 
-        if (!is_otg_enabled(musb))
-                return;
-
         if (timeout == 0)
                 timeout = jiffies + msecs_to_jiffies(3);
 
@@ -271,8 +265,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                 u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
                 int err;
 
-                err = is_host_enabled(musb) && (musb->int_usb &
-                                                MUSB_INTR_VBUSERROR);
+                err = musb->int_usb & MUSB_INTR_VBUSERROR;
                 if (err) {
                         /*
                          * The Mentor core doesn't debounce VBUS as needed
@@ -289,7 +282,7 @@ static irqreturn_t am35x_musb_interrupt(int irq, void *hci)
                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
                         WARNING("VBUS error workaround (delay coming)\n");
-                } else if (is_host_enabled(musb) && drvvbus) {
+                } else if (drvvbus) {
                         MUSB_HST_MODE(musb);
                         otg->default_a = 1;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -326,7 +319,7 @@ eoi:
         }
 
         /* Poll for ID change */
-        if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+        if (musb->xceiv->state == OTG_STATE_B_IDLE)
                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -369,8 +362,7 @@ static int am35x_musb_init(struct musb *musb)
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -ENODEV;
 
-        if (is_host_enabled(musb))
-                setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+        setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
         /* Reset the musb */
         if (data->reset)
@@ -400,8 +392,7 @@ static int am35x_musb_exit(struct musb *musb)
         struct musb_hdrc_platform_data *plat = dev->platform_data;
         struct omap_musb_board_data *data = plat->board_data;
 
-        if (is_host_enabled(musb))
-                del_timer_sync(&otg_workaround);
+        del_timer_sync(&otg_workaround);
 
         /* Shutdown the on-chip PHY and its PLL. */
         if (data->set_phy_power)
@@ -468,6 +459,7 @@ static int __devinit am35x_probe(struct platform_device *pdev)
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -475,38 +467,47 @@ static int __devinit am35x_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
         phy_clk = clk_get(&pdev->dev, "fck");
         if (IS_ERR(phy_clk)) {
                 dev_err(&pdev->dev, "failed to get PHY clock\n");
                 ret = PTR_ERR(phy_clk);
-                goto err2;
+                goto err3;
         }
 
         clk = clk_get(&pdev->dev, "ick");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
-                goto err3;
+                goto err4;
         }
 
         ret = clk_enable(phy_clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable PHY clock\n");
-                goto err4;
+                goto err5;
         }
 
         ret = clk_enable(clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable clock\n");
-                goto err5;
+                goto err6;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &am35x_dmamask;
         musb->dev.coherent_dma_mask     = am35x_dmamask;
@@ -524,38 +525,41 @@ static int __devinit am35x_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err6;
+                goto err7;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err6;
+                goto err7;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err6;
+                goto err7;
         }
 
         return 0;
 
-err6:
+err7:
         clk_disable(clk);
 
-err5:
+err6:
         clk_disable(phy_clk);
 
-err4:
+err5:
         clk_put(clk);
 
-err3:
+err4:
         clk_put(phy_clk);
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -567,6 +571,7 @@ static int __devexit am35x_remove(struct platform_device *pdev)
 {
         struct am35x_glue       *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         clk_disable(glue->clk);
diff --git a/drivers/usb/musb/blackfin.c b/drivers/usb/musb/blackfin.c
index 428e6aa3e78a..e8cff9bb9d23 100644
--- a/drivers/usb/musb/blackfin.c
+++ b/drivers/usb/musb/blackfin.c
@@ -19,6 +19,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/prefetch.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include <asm/cacheflush.h>
 
@@ -184,8 +185,8 @@ static irqreturn_t blackfin_interrupt(int irq, void *__hci)
         }
 
         /* Start sampling ID pin, when plug is removed from MUSB */
-        if ((is_otg_enabled(musb) && (musb->xceiv->state == OTG_STATE_B_IDLE
-                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) ||
+        if ((musb->xceiv->state == OTG_STATE_B_IDLE
+                || musb->xceiv->state == OTG_STATE_A_WAIT_BCON) ||
                 (musb->int_usb & MUSB_INTR_DISCONNECT && is_host_active(musb))) {
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
                 musb->a_wait_bcon = TIMER_DELAY;
@@ -228,18 +229,13 @@ static void musb_conn_timer_handler(unsigned long _musb)
 
                         val = MUSB_INTR_SUSPEND | MUSB_INTR_VBUSERROR;
                         musb_writeb(musb->mregs, MUSB_INTRUSB, val);
-                        if (is_otg_enabled(musb))
-                                musb->xceiv->state = OTG_STATE_B_IDLE;
-                        else
-                                musb_writeb(musb->mregs, MUSB_POWER, MUSB_POWER_HSENAB);
+                        musb->xceiv->state = OTG_STATE_B_IDLE;
                 }
                 mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
                 break;
         case OTG_STATE_B_IDLE:
-
-                if (!is_peripheral_enabled(musb))
-                        break;
-                /* Start a new session.  It seems that MUSB needs taking
+                /*
+                 * Start a new session.  It seems that MUSB needs taking
                  * some time to recognize the type of the plug inserted?
                  */
                 val = musb_readw(musb->mregs, MUSB_DEVCTL);
@@ -295,10 +291,7 @@ static void musb_conn_timer_handler(unsigned long _musb)
 
 static void bfin_musb_enable(struct musb *musb)
 {
-        if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
-                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
-                musb->a_wait_bcon = TIMER_DELAY;
-        }
+        /* REVISIT is this really correct ? */
 }
 
 static void bfin_musb_disable(struct musb *musb)
@@ -323,12 +316,6 @@ static int bfin_musb_set_power(struct usb_phy *x, unsigned mA)
         return 0;
 }
 
-static void bfin_musb_try_idle(struct musb *musb, unsigned long timeout)
-{
-        if (!is_otg_enabled(musb) && is_host_enabled(musb))
-                mod_timer(&musb_conn_timer, jiffies + TIMER_DELAY);
-}
-
 static int bfin_musb_vbus_status(struct musb *musb)
 {
         return 0;
@@ -424,12 +411,10 @@ static int bfin_musb_init(struct musb *musb)
 
         bfin_musb_reg_init(musb);
 
-        if (is_host_enabled(musb)) {
-                setup_timer(&musb_conn_timer,
-                        musb_conn_timer_handler, (unsigned long) musb);
-        }
-        if (is_peripheral_enabled(musb))
-                musb->xceiv->set_power = bfin_musb_set_power;
+        setup_timer(&musb_conn_timer, musb_conn_timer_handler,
+                        (unsigned long) musb);
+
+        musb->xceiv->set_power = bfin_musb_set_power;
 
         musb->isr = blackfin_interrupt;
         musb->double_buffer_not_ok = true;
@@ -454,7 +439,6 @@ static const struct musb_platform_ops bfin_ops = {
         .disable        = bfin_musb_disable,
 
         .set_mode       = bfin_musb_set_mode,
-        .try_idle       = bfin_musb_try_idle,
 
         .vbus_status    = bfin_musb_vbus_status,
         .set_vbus       = bfin_musb_set_vbus,
@@ -471,6 +455,7 @@ static int __devinit bfin_probe(struct platform_device *pdev)
         struct bfin_glue                *glue;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -478,12 +463,21 @@ static int __devinit bfin_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &bfin_dmamask;
         musb->dev.coherent_dma_mask     = bfin_dmamask;
@@ -499,26 +493,29 @@ static int __devinit bfin_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err2;
+                goto err3;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err2;
+                goto err3;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err2;
+                goto err3;
         }
 
         return 0;
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -530,6 +527,7 @@ static int __devexit bfin_remove(struct platform_device *pdev)
 {
         struct bfin_glue                *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         kfree(glue);
diff --git a/drivers/usb/musb/cppi_dma.c b/drivers/usb/musb/cppi_dma.c
index 8637c1f69fc3..e19da82b4782 100644
--- a/drivers/usb/musb/cppi_dma.c
+++ b/drivers/usb/musb/cppi_dma.c
@@ -1316,7 +1316,7 @@ irqreturn_t cppi_interrupt(int irq, void *dev_id)
 }
 
 /* Instantiate a software object representing a DMA controller. */
-struct dma_controller *__init
+struct dma_controller *__devinit
 dma_controller_create(struct musb *musb, void __iomem *mregs)
 {
         struct cppi             *controller;
diff --git a/drivers/usb/musb/da8xx.c b/drivers/usb/musb/da8xx.c
index 0f9fcec4e1d3..ce11d20b90f4 100644
--- a/drivers/usb/musb/da8xx.c
+++ b/drivers/usb/musb/da8xx.c
@@ -33,6 +33,7 @@
 #include <linux/io.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include <mach/da8xx.h>
 #include <mach/usb.h>
@@ -155,9 +156,8 @@ static void da8xx_musb_enable(struct musb *musb)
         musb_writel(reg_base, DA8XX_USB_INTR_MASK_SET_REG, mask);
 
         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
-        if (is_otg_enabled(musb))
-                musb_writel(reg_base, DA8XX_USB_INTR_SRC_SET_REG,
-                            DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT);
+        musb_writel(reg_base, DA8XX_USB_INTR_SRC_SET_REG,
+                        DA8XX_INTR_DRVVBUS << DA8XX_INTR_USB_SHIFT);
 }
 
 /**
@@ -231,9 +231,6 @@ static void otg_timer(unsigned long _musb)
                             MUSB_INTR_VBUSERROR << DA8XX_INTR_USB_SHIFT);
                 break;
         case OTG_STATE_B_IDLE:
-                if (!is_peripheral_enabled(musb))
-                        break;
-
                 /*
                  * There's no ID-changed IRQ, so we have no good way to tell
                  * when to switch to the A-Default state machine (by setting
@@ -263,9 +260,6 @@ static void da8xx_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         static unsigned long last_timer;
 
-        if (!is_otg_enabled(musb))
-                return;
-
         if (timeout == 0)
                 timeout = jiffies + msecs_to_jiffies(3);
 
@@ -333,8 +327,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                 u8 devctl = musb_readb(mregs, MUSB_DEVCTL);
                 int err;
 
-                err = is_host_enabled(musb) && (musb->int_usb &
-                                                MUSB_INTR_VBUSERROR);
+                err = musb->int_usb & USB_INTR_VBUSERROR;
                 if (err) {
                         /*
                          * The Mentor core doesn't debounce VBUS as needed
@@ -351,7 +344,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
                         WARNING("VBUS error workaround (delay coming)\n");
-                } else if (is_host_enabled(musb) && drvvbus) {
+                } else if (drvvbus) {
                         MUSB_HST_MODE(musb);
                         otg->default_a = 1;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -382,7 +375,7 @@ static irqreturn_t da8xx_musb_interrupt(int irq, void *hci)
                 musb_writel(reg_base, DA8XX_USB_END_OF_INTR_REG, 0);
 
         /* Poll for ID change */
-        if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
+        if (musb->xceiv->state == OTG_STATE_B_IDLE)
                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -430,8 +423,7 @@ static int da8xx_musb_init(struct musb *musb)
         if (IS_ERR_OR_NULL(musb->xceiv))
                 goto fail;
 
-        if (is_host_enabled(musb))
-                setup_timer(&otg_workaround, otg_timer, (unsigned long)musb);
+        setup_timer(&otg_workaround, otg_timer, (unsigned long)musb);
 
         /* Reset the controller */
         musb_writel(reg_base, DA8XX_USB_CTRL_REG, DA8XX_SOFT_RESET_MASK);
@@ -454,8 +446,7 @@ fail:
 
 static int da8xx_musb_exit(struct musb *musb)
 {
-        if (is_host_enabled(musb))
-                del_timer_sync(&otg_workaround);
+        del_timer_sync(&otg_workaround);
 
         phy_off();
 
@@ -489,6 +480,7 @@ static int __devinit da8xx_probe(struct platform_device *pdev)
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -496,25 +488,34 @@ static int __devinit da8xx_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
         clk = clk_get(&pdev->dev, "usb20");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
-                goto err2;
+                goto err3;
         }
 
         ret = clk_enable(clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable clock\n");
-                goto err3;
+                goto err4;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &da8xx_dmamask;
         musb->dev.coherent_dma_mask     = da8xx_dmamask;
@@ -531,32 +532,35 @@ static int __devinit da8xx_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err4;
+                goto err5;
         }
 
         return 0;
 
-err4:
+err5:
         clk_disable(clk);
 
-err3:
+err4:
         clk_put(clk);
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -568,6 +572,7 @@ static int __devexit da8xx_remove(struct platform_device *pdev)
 {
         struct da8xx_glue               *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         clk_disable(glue->clk);
diff --git a/drivers/usb/musb/davinci.c b/drivers/usb/musb/davinci.c
index 472c8b42d38b..606bfd00cde6 100644
--- a/drivers/usb/musb/davinci.c
+++ b/drivers/usb/musb/davinci.c
@@ -33,6 +33,7 @@
 #include <linux/gpio.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include <mach/cputype.h>
 #include <mach/hardware.h>
@@ -115,8 +116,7 @@ static void davinci_musb_enable(struct musb *musb)
                 dma_off = 0;
 
         /* force a DRVVBUS irq so we can start polling for ID change */
-        if (is_otg_enabled(musb))
-                musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
+        musb_writel(musb->ctrl_base, DAVINCI_USB_INT_SET_REG,
                         DAVINCI_INTR_DRVVBUS << DAVINCI_USB_USBINT_SHIFT);
 }
 
@@ -234,10 +234,8 @@ static void otg_timer(unsigned long _musb)
                         MUSB_INTR_VBUSERROR << DAVINCI_USB_USBINT_SHIFT);
                 break;
         case OTG_STATE_B_IDLE:
-                if (!is_peripheral_enabled(musb))
-                        break;
-
-                /* There's no ID-changed IRQ, so we have no good way to tell
+                /*
+                 * There's no ID-changed IRQ, so we have no good way to tell
                  * when to switch to the A-Default state machine (by setting
                  * the DEVCTL.SESSION flag).
                  *
@@ -315,8 +313,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                 u8      devctl = musb_readb(mregs, MUSB_DEVCTL);
                 int     err = musb->int_usb & MUSB_INTR_VBUSERROR;
 
-                err = is_host_enabled(musb)
-                                && (musb->int_usb & MUSB_INTR_VBUSERROR);
+                err = musb->int_usb & MUSB_INTR_VBUSERROR;
                 if (err) {
                         /* The Mentor core doesn't debounce VBUS as needed
                          * to cope with device connect current spikes. This
@@ -332,7 +329,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
                         mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
                         WARNING("VBUS error workaround (delay coming)\n");
-                } else if (is_host_enabled(musb) && drvvbus) {
+                } else if (drvvbus) {
                         MUSB_HST_MODE(musb);
                         otg->default_a = 1;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
@@ -365,8 +362,7 @@ static irqreturn_t davinci_musb_interrupt(int irq, void *__hci)
         musb_writel(tibase, DAVINCI_USB_EOI_REG, 0);
 
         /* poll for ID change */
-        if (is_otg_enabled(musb)
-                        && musb->xceiv->state == OTG_STATE_B_IDLE)
+        if (musb->xceiv->state == OTG_STATE_B_IDLE)
                 mod_timer(&otg_workaround, jiffies + POLL_SECONDS * HZ);
 
         spin_unlock_irqrestore(&musb->lock, flags);
@@ -397,8 +393,7 @@ static int davinci_musb_init(struct musb *musb)
         if (revision == 0)
                 goto fail;
 
-        if (is_host_enabled(musb))
-                setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
+        setup_timer(&otg_workaround, otg_timer, (unsigned long) musb);
 
         davinci_musb_source_power(musb, 0, 1);
 
@@ -419,12 +414,7 @@ static int davinci_musb_init(struct musb *musb)
         if (cpu_is_davinci_dm355()) {
                 u32     deepsleep = __raw_readl(DM355_DEEPSLEEP);
 
-                if (is_host_enabled(musb)) {
-                        deepsleep &= ~DRVVBUS_OVERRIDE;
-                } else {
-                        deepsleep &= ~DRVVBUS_FORCE;
-                        deepsleep |= DRVVBUS_OVERRIDE;
-                }
+                deepsleep &= ~DRVVBUS_FORCE;
                 __raw_writel(deepsleep, DM355_DEEPSLEEP);
         }
 
@@ -453,8 +443,7 @@ unregister:
 
 static int davinci_musb_exit(struct musb *musb)
 {
-        if (is_host_enabled(musb))
-                del_timer_sync(&otg_workaround);
+        del_timer_sync(&otg_workaround);
 
         /* force VBUS off */
         if (cpu_is_davinci_dm355()) {
@@ -468,7 +457,7 @@ static int davinci_musb_exit(struct musb *musb)
         davinci_musb_source_power(musb, 0 /*off*/, 1);
 
         /* delay, to avoid problems with module reload */
-        if (is_host_enabled(musb) && musb->xceiv->otg->default_a) {
+        if (musb->xceiv->otg->default_a) {
                 int     maxdelay = 30;
                 u8      devctl, warn = 0;
 
@@ -523,6 +512,7 @@ static int __devinit davinci_probe(struct platform_device *pdev)
         struct clk                      *clk;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -530,25 +520,34 @@ static int __devinit davinci_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
         clk = clk_get(&pdev->dev, "usb");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
-                goto err2;
+                goto err3;
         }
 
         ret = clk_enable(clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable clock\n");
-                goto err3;
+                goto err4;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &davinci_dmamask;
         musb->dev.coherent_dma_mask     = davinci_dmamask;
@@ -565,32 +564,35 @@ static int __devinit davinci_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err4;
+                goto err5;
         }
 
         return 0;
 
-err4:
+err5:
         clk_disable(clk);
 
-err3:
+err4:
         clk_put(clk);
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -602,6 +604,7 @@ static int __devexit davinci_remove(struct platform_device *pdev)
 {
         struct davinci_glue             *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         clk_disable(glue->clk);
diff --git a/drivers/usb/musb/musb_core.c b/drivers/usb/musb/musb_core.c
index 26f1befb4896..bb56a0e8b23b 100644
--- a/drivers/usb/musb/musb_core.c
+++ b/drivers/usb/musb/musb_core.c
@@ -99,6 +99,8 @@
 #include <linux/prefetch.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
+#include <linux/idr.h>
+#include <linux/dma-mapping.h>
 
 #include "musb_core.h"
 
@@ -114,6 +116,7 @@
 
 #define MUSB_DRIVER_NAME "musb-hdrc"
 const char musb_driver_name[] = MUSB_DRIVER_NAME;
+static DEFINE_IDA(musb_ida);
 
 MODULE_DESCRIPTION(DRIVER_INFO);
 MODULE_AUTHOR(DRIVER_AUTHOR);
@@ -130,6 +133,35 @@ static inline struct musb *dev_to_musb(struct device *dev)
 
 /*-------------------------------------------------------------------------*/
 
+int musb_get_id(struct device *dev, gfp_t gfp_mask)
+{
+        int ret;
+        int id;
+
+        ret = ida_pre_get(&musb_ida, gfp_mask);
+        if (!ret) {
+                dev_err(dev, "failed to reserve resource for id\n");
+                return -ENOMEM;
+        }
+
+        ret = ida_get_new(&musb_ida, &id);
+        if (ret < 0) {
+                dev_err(dev, "failed to allocate a new id\n");
+                return ret;
+        }
+
+        return id;
+}
+EXPORT_SYMBOL_GPL(musb_get_id);
+
+void musb_put_id(struct device *dev, int id)
+{
+
+        dev_dbg(dev, "removing id %d\n", id);
+        ida_remove(&musb_ida, id);
+}
+EXPORT_SYMBOL_GPL(musb_put_id);
+
 #ifndef CONFIG_BLACKFIN
 static int musb_ulpi_read(struct usb_phy *phy, u32 offset)
 {
@@ -234,6 +266,9 @@ void musb_write_fifo(struct musb_hw_ep *hw_ep, u16 len, const u8 *src)
         struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
 
+        if (unlikely(len == 0))
+                return;
+
         prefetch((u8 *)src);
 
         dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
@@ -276,6 +311,9 @@ void musb_read_fifo(struct musb_hw_ep *hw_ep, u16 len, u8 *dst)
         struct musb *musb = hw_ep->musb;
         void __iomem *fifo = hw_ep->fifo;
 
+        if (unlikely(len == 0))
+                return;
+
         dev_dbg(musb->controller, "%cX ep%d fifo %p count %d buf %p\n",
                         'R', hw_ep->epnum, fifo, len, dst);
 
@@ -348,7 +386,7 @@ void musb_load_testpacket(struct musb *musb)
 /*
  * Handles OTG hnp timeouts, such as b_ase0_brst
  */
-void musb_otg_timer_func(unsigned long data)
+static void musb_otg_timer_func(unsigned long data)
 {
         struct musb     *musb = (struct musb *)data;
         unsigned long   flags;
@@ -643,8 +681,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                                 break;
                 case OTG_STATE_B_PERIPHERAL:
                         musb_g_suspend(musb);
-                        musb->is_active = is_otg_enabled(musb)
-                                        && otg->gadget->b_hnp_enable;
+                        musb->is_active = otg->gadget->b_hnp_enable;
                         if (musb->is_active) {
                                 musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
                                 dev_dbg(musb->controller, "HNP: Setting timer for b_ase0_brst\n");
@@ -660,8 +697,7 @@ static irqreturn_t musb_stage0_irq(struct musb *musb, u8 int_usb,
                         break;
                 case OTG_STATE_A_HOST:
                         musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                        musb->is_active = is_otg_enabled(musb)
-                                        && otg->host->b_hnp_enable;
+                        musb->is_active = otg->host->b_hnp_enable;
                         break;
                 case OTG_STATE_B_HOST:
                         /* Transition to B_PERIPHERAL, see 6.8.2.6 p 44 */
@@ -749,7 +785,7 @@ b_host:
                 case OTG_STATE_A_SUSPEND:
                         usb_hcd_resume_root_hub(musb_to_hcd(musb));
                         musb_root_disconnect(musb);
-                        if (musb->a_wait_bcon != 0 && is_otg_enabled(musb))
+                        if (musb->a_wait_bcon != 0)
                                 musb_platform_try_idle(musb, jiffies
                                         + msecs_to_jiffies(musb->a_wait_bcon));
                         break;
@@ -787,7 +823,7 @@ b_host:
          */
         if (int_usb & MUSB_INTR_RESET) {
                 handled = IRQ_HANDLED;
-                if (is_host_capable() && (devctl & MUSB_DEVCTL_HM) != 0) {
+                if ((devctl & MUSB_DEVCTL_HM) != 0) {
                         /*
                          * Looks like non-HS BABBLE can be ignored, but
                          * HS BABBLE is an error condition. For HS the solution
@@ -801,7 +837,7 @@ b_host:
                                 ERR("Stopping host session -- babble\n");
                                 musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
                         }
-                } else if (is_peripheral_capable()) {
+                } else {
                         dev_dbg(musb->controller, "BUS RESET as %s\n",
                                 otg_state_string(musb->xceiv->state));
                         switch (musb->xceiv->state) {
@@ -925,25 +961,16 @@ void musb_start(struct musb *musb)
         devctl = musb_readb(regs, MUSB_DEVCTL);
         devctl &= ~MUSB_DEVCTL_SESSION;
 
-        if (is_otg_enabled(musb)) {
-                /* session started after:
-                 * (a) ID-grounded irq, host mode;
-                 * (b) vbus present/connect IRQ, peripheral mode;
-                 * (c) peripheral initiates, using SRP
-                 */
-                if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
-                        musb->is_active = 1;
-                else
-                        devctl |= MUSB_DEVCTL_SESSION;
-
-        } else if (is_host_enabled(musb)) {
-                /* assume ID pin is hard-wired to ground */
+        /* session started after:
+         * (a) ID-grounded irq, host mode;
+         * (b) vbus present/connect IRQ, peripheral mode;
+         * (c) peripheral initiates, using SRP
+         */
+        if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
+                musb->is_active = 1;
+        else
                 devctl |= MUSB_DEVCTL_SESSION;
 
-        } else /* peripheral is enabled */ {
-                if ((devctl & MUSB_DEVCTL_VBUS) == MUSB_DEVCTL_VBUS)
-                        musb->is_active = 1;
-        }
         musb_platform_enable(musb);
         musb_writeb(regs, MUSB_DEVCTL, devctl);
 }
@@ -1007,8 +1034,6 @@ static void musb_shutdown(struct platform_device *pdev)
         musb_generic_disable(musb);
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        if (!is_otg_enabled(musb) && is_host_enabled(musb))
-                usb_remove_hcd(musb_to_hcd(musb));
         musb_writeb(musb->mregs, MUSB_DEVCTL, 0);
         musb_platform_exit(musb);
 
@@ -1302,7 +1327,7 @@ done:
                 if (offset < 0) {
                         pr_debug("%s: mem overrun, ep %d\n",
                                         musb_driver_name, epn);
-                        return -EINVAL;
+                        return offset;
                 }
                 epn++;
                 musb->nr_endpoints = max(epn, musb->nr_endpoints);
@@ -1330,7 +1355,7 @@ static int __devinit ep_config_from_hw(struct musb *musb)
 {
         u8 epnum = 0;
         struct musb_hw_ep *hw_ep;
-        void *mbase = musb->mregs;
+        void __iomem *mbase = musb->mregs;
         int ret = 0;
 
         dev_dbg(musb->controller, "<== static silicon ep config\n");
@@ -1571,13 +1596,10 @@ irqreturn_t musb_interrupt(struct musb *musb)
                         /* musb_ep_select(musb->mregs, ep_num); */
                         /* REVISIT just retval = ep->rx_irq(...) */
                         retval = IRQ_HANDLED;
-                        if (devctl & MUSB_DEVCTL_HM) {
-                                if (is_host_capable())
-                                        musb_host_rx(musb, ep_num);
-                        } else {
-                                if (is_peripheral_capable())
-                                        musb_g_rx(musb, ep_num);
-                        }
+                        if (devctl & MUSB_DEVCTL_HM)
+                                musb_host_rx(musb, ep_num);
+                        else
+                                musb_g_rx(musb, ep_num);
                 }
 
                 reg >>= 1;
@@ -1592,13 +1614,10 @@ irqreturn_t musb_interrupt(struct musb *musb)
                         /* musb_ep_select(musb->mregs, ep_num); */
                         /* REVISIT just retval |= ep->tx_irq(...) */
                         retval = IRQ_HANDLED;
-                        if (devctl & MUSB_DEVCTL_HM) {
-                                if (is_host_capable())
-                                        musb_host_tx(musb, ep_num);
-                        } else {
-                                if (is_peripheral_capable())
-                                        musb_g_tx(musb, ep_num);
-                        }
+                        if (devctl & MUSB_DEVCTL_HM)
+                                musb_host_tx(musb, ep_num);
+                        else
+                                musb_g_tx(musb, ep_num);
                 }
                 reg >>= 1;
                 ep_num++;
@@ -1634,22 +1653,16 @@ void musb_dma_completion(struct musb *musb, u8 epnum, u8 transmit)
         } else {
                 /* endpoints 1..15 */
                 if (transmit) {
-                        if (devctl & MUSB_DEVCTL_HM) {
-                                if (is_host_capable())
-                                        musb_host_tx(musb, epnum);
-                        } else {
-                                if (is_peripheral_capable())
-                                        musb_g_tx(musb, epnum);
-                        }
+                        if (devctl & MUSB_DEVCTL_HM)
+                                musb_host_tx(musb, epnum);
+                        else
+                                musb_g_tx(musb, epnum);
                 } else {
                         /* receive */
-                        if (devctl & MUSB_DEVCTL_HM) {
-                                if (is_host_capable())
-                                        musb_host_rx(musb, epnum);
-                        } else {
-                                if (is_peripheral_capable())
-                                        musb_g_rx(musb, epnum);
-                        }
+                        if (devctl & MUSB_DEVCTL_HM)
+                                musb_host_rx(musb, epnum);
+                        else
+                                musb_g_rx(musb, epnum);
                 }
         }
 }
@@ -1785,10 +1798,9 @@ static const struct attribute_group musb_attr_group = {
 static void musb_irq_work(struct work_struct *data)
 {
         struct musb *musb = container_of(data, struct musb, irq_work);
-        static int old_state;
 
-        if (musb->xceiv->state != old_state) {
-                old_state = musb->xceiv->state;
+        if (musb->xceiv->state != musb->xceiv_old_state) {
+                musb->xceiv_old_state = musb->xceiv->state;
                 sysfs_notify(&musb->controller->kobj, NULL, "mode");
         }
 }
@@ -1862,15 +1874,15 @@ static void musb_free(struct musb *musb)
                 dma_controller_destroy(c);
         }
 
-        kfree(musb);
+        usb_put_hcd(musb_to_hcd(musb));
 }
 
 /*
  * Perform generic per-controller initialization.
  *
- * @pDevice: the controller (already clocked, etc)
- * @nIrq: irq
- * @mregs: virtual address of controller registers,
+ * @dev: the controller (already clocked, etc)
+ * @nIrq: IRQ number
+ * @ctrl: virtual address of controller registers,
  *      not yet corrected for platform-specific offsets
  */
 static int __devinit
@@ -1879,6 +1891,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         int                     status;
         struct musb             *musb;
         struct musb_hdrc_platform_data *plat = dev->platform_data;
+        struct usb_hcd          *hcd;
 
         /* The driver might handle more features than the board; OK.
          * Fail when the board needs a feature that's not enabled.
@@ -1901,7 +1914,6 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         pm_runtime_enable(musb->controller);
 
         spin_lock_init(&musb->lock);
-        musb->board_mode = plat->mode;
         musb->board_set_power = plat->set_power;
         musb->min_power = plat->min_power;
         musb->ops = plat->platform_ops;
@@ -1972,7 +1984,7 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
                 goto fail3;
         }
         musb->nIrq = nIrq;
-/* FIXME this handles wakeup irqs wrong */
+        /* FIXME this handles wakeup irqs wrong */
         if (enable_irq_wake(nIrq) == 0) {
                 musb->irq_wake = 1;
                 device_init_wakeup(dev, 1);
@@ -1981,58 +1993,25 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
         }
 
         /* host side needs more setup */
-        if (is_host_enabled(musb)) {
-                struct usb_hcd  *hcd = musb_to_hcd(musb);
-
-                otg_set_host(musb->xceiv->otg, &hcd->self);
-
-                if (is_otg_enabled(musb))
-                        hcd->self.otg_port = 1;
-                musb->xceiv->otg->host = &hcd->self;
-                hcd->power_budget = 2 * (plat->power ? : 250);
-
-                /* program PHY to use external vBus if required */
-                if (plat->extvbus) {
-                        u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
-                        busctl |= MUSB_ULPI_USE_EXTVBUS;
-                        musb_write_ulpi_buscontrol(musb->mregs, busctl);
-                }
+        hcd = musb_to_hcd(musb);
+        otg_set_host(musb->xceiv->otg, &hcd->self);
+        hcd->self.otg_port = 1;
+        musb->xceiv->otg->host = &hcd->self;
+        hcd->power_budget = 2 * (plat->power ? : 250);
+
+        /* program PHY to use external vBus if required */
+        if (plat->extvbus) {
+                u8 busctl = musb_read_ulpi_buscontrol(musb->mregs);
+                busctl |= MUSB_ULPI_USE_EXTVBUS;
+                musb_write_ulpi_buscontrol(musb->mregs, busctl);
         }
 
-        /* For the host-only role, we can activate right away.
-         * (We expect the ID pin to be forcibly grounded!!)
-         * Otherwise, wait till the gadget driver hooks up.
-         */
-        if (!is_otg_enabled(musb) && is_host_enabled(musb)) {
-                struct usb_hcd  *hcd = musb_to_hcd(musb);
-
-                MUSB_HST_MODE(musb);
-                musb->xceiv->otg->default_a = 1;
-                musb->xceiv->state = OTG_STATE_A_IDLE;
-
-                status = usb_add_hcd(musb_to_hcd(musb), 0, 0);
-
-                hcd->self.uses_pio_for_control = 1;
-                dev_dbg(musb->controller, "%s mode, status %d, devctl %02x %c\n",
-                        "HOST", status,
-                        musb_readb(musb->mregs, MUSB_DEVCTL),
-                        (musb_readb(musb->mregs, MUSB_DEVCTL)
-                                        & MUSB_DEVCTL_BDEVICE
-                                ? 'B' : 'A'));
-
-        } else /* peripheral is enabled */ {
-                MUSB_DEV_MODE(musb);
-                musb->xceiv->otg->default_a = 0;
-                musb->xceiv->state = OTG_STATE_B_IDLE;
-
-                status = musb_gadget_setup(musb);
+        MUSB_DEV_MODE(musb);
+        musb->xceiv->otg->default_a = 0;
+        musb->xceiv->state = OTG_STATE_B_IDLE;
 
-                dev_dbg(musb->controller, "%s mode, status %d, dev%02x\n",
-                        is_otg_enabled(musb) ? "OTG" : "PERIPHERAL",
-                        status,
-                        musb_readb(musb->mregs, MUSB_DEVCTL));
+        status = musb_gadget_setup(musb);
 
-        }
         if (status < 0)
                 goto fail3;
 
@@ -2048,28 +2027,13 @@ musb_init_controller(struct device *dev, int nIrq, void __iomem *ctrl)
 
         pm_runtime_put(musb->controller);
 
-        dev_info(dev, "USB %s mode controller at %p using %s, IRQ %d\n",
-                        ({char *s;
-                         switch (musb->board_mode) {
-                         case MUSB_HOST:                s = "Host"; break;
-                         case MUSB_PERIPHERAL:  s = "Peripheral"; break;
-                         default:               s = "OTG"; break;
-                         }; s; }),
-                        ctrl,
-                        (is_dma_capable() && musb->dma_controller)
-                        ? "DMA" : "PIO",
-                        musb->nIrq);
-
         return 0;
 
 fail5:
         musb_exit_debugfs(musb);
 
 fail4:
-        if (!is_otg_enabled(musb) && is_host_enabled(musb))
-                usb_remove_hcd(musb_to_hcd(musb));
-        else
-                musb_gadget_cleanup(musb);
+        musb_gadget_cleanup(musb);
 
 fail3:
         pm_runtime_put_sync(musb->controller);
@@ -2096,11 +2060,6 @@ fail0:
 /* all implementations (PCI bridge to FPGA, VLYNQ, etc) should just
  * bridge to a platform device; this driver then suffices.
  */
-
-#ifndef CONFIG_MUSB_PIO_ONLY
-static u64      *orig_dma_mask;
-#endif
-
 static int __devinit musb_probe(struct platform_device *pdev)
 {
         struct device   *dev = &pdev->dev;
@@ -2119,10 +2078,6 @@ static int __devinit musb_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
-#ifndef CONFIG_MUSB_PIO_ONLY
-        /* clobbered by use_dma=n */
-        orig_dma_mask = dev->dma_mask;
-#endif
         status = musb_init_controller(dev, irq, base);
         if (status < 0)
                 iounmap(base);
@@ -2132,7 +2087,8 @@ static int __devinit musb_probe(struct platform_device *pdev)
 
 static int __devexit musb_remove(struct platform_device *pdev)
 {
-        struct musb     *musb = dev_to_musb(&pdev->dev);
+        struct device   *dev = &pdev->dev;
+        struct musb     *musb = dev_to_musb(dev);
         void __iomem    *ctrl_base = musb->ctrl_base;
 
         /* this gets called on rmmod.
@@ -2145,9 +2101,9 @@ static int __devexit musb_remove(struct platform_device *pdev)
 
         musb_free(musb);
         iounmap(ctrl_base);
-        device_init_wakeup(&pdev->dev, 0);
+        device_init_wakeup(dev, 0);
 #ifndef CONFIG_MUSB_PIO_ONLY
-        pdev->dev.dma_mask = orig_dma_mask;
+        dma_set_mask(dev, *dev->parent->dma_mask);
 #endif
         return 0;
 }
@@ -2160,11 +2116,9 @@ static void musb_save_context(struct musb *musb)
         void __iomem *musb_base = musb->mregs;
         void __iomem *epio;
 
-        if (is_host_enabled(musb)) {
-                musb->context.frame = musb_readw(musb_base, MUSB_FRAME);
-                musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
-                musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
-        }
+        musb->context.frame = musb_readw(musb_base, MUSB_FRAME);
+        musb->context.testmode = musb_readb(musb_base, MUSB_TESTMODE);
+        musb->context.busctl = musb_read_ulpi_buscontrol(musb->mregs);
         musb->context.power = musb_readb(musb_base, MUSB_POWER);
         musb->context.intrtxe = musb_readw(musb_base, MUSB_INTRTXE);
         musb->context.intrrxe = musb_readw(musb_base, MUSB_INTRRXE);
@@ -2203,30 +2157,29 @@ static void musb_save_context(struct musb *musb)
                         musb->context.index_regs[i].rxfifosz =
                                         musb_read_rxfifosz(musb_base);
                 }
-                if (is_host_enabled(musb)) {
-                        musb->context.index_regs[i].txtype =
-                                musb_readb(epio, MUSB_TXTYPE);
-                        musb->context.index_regs[i].txinterval =
-                                musb_readb(epio, MUSB_TXINTERVAL);
-                        musb->context.index_regs[i].rxtype =
-                                musb_readb(epio, MUSB_RXTYPE);
-                        musb->context.index_regs[i].rxinterval =
-                                musb_readb(epio, MUSB_RXINTERVAL);
-
-                        musb->context.index_regs[i].txfunaddr =
-                                musb_read_txfunaddr(musb_base, i);
-                        musb->context.index_regs[i].txhubaddr =
-                                musb_read_txhubaddr(musb_base, i);
-                        musb->context.index_regs[i].txhubport =
-                                musb_read_txhubport(musb_base, i);
-
-                        musb->context.index_regs[i].rxfunaddr =
-                                musb_read_rxfunaddr(musb_base, i);
-                        musb->context.index_regs[i].rxhubaddr =
-                                musb_read_rxhubaddr(musb_base, i);
-                        musb->context.index_regs[i].rxhubport =
-                                musb_read_rxhubport(musb_base, i);
-                }
+
+                musb->context.index_regs[i].txtype =
+                        musb_readb(epio, MUSB_TXTYPE);
+                musb->context.index_regs[i].txinterval =
+                        musb_readb(epio, MUSB_TXINTERVAL);
+                musb->context.index_regs[i].rxtype =
+                        musb_readb(epio, MUSB_RXTYPE);
+                musb->context.index_regs[i].rxinterval =
+                        musb_readb(epio, MUSB_RXINTERVAL);
+
+                musb->context.index_regs[i].txfunaddr =
+                        musb_read_txfunaddr(musb_base, i);
+                musb->context.index_regs[i].txhubaddr =
+                        musb_read_txhubaddr(musb_base, i);
+                musb->context.index_regs[i].txhubport =
+                        musb_read_txhubport(musb_base, i);
+
+                musb->context.index_regs[i].rxfunaddr =
+                        musb_read_rxfunaddr(musb_base, i);
+                musb->context.index_regs[i].rxhubaddr =
+                        musb_read_rxhubaddr(musb_base, i);
+                musb->context.index_regs[i].rxhubport =
+                        musb_read_rxhubport(musb_base, i);
         }
 }
 
@@ -2237,11 +2190,9 @@ static void musb_restore_context(struct musb *musb)
         void __iomem *ep_target_regs;
         void __iomem *epio;
 
-        if (is_host_enabled(musb)) {
-                musb_writew(musb_base, MUSB_FRAME, musb->context.frame);
-                musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);
-                musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);
-        }
+        musb_writew(musb_base, MUSB_FRAME, musb->context.frame);
+        musb_writeb(musb_base, MUSB_TESTMODE, musb->context.testmode);
+        musb_write_ulpi_buscontrol(musb->mregs, musb->context.busctl);
         musb_writeb(musb_base, MUSB_POWER, musb->context.power);
         musb_writew(musb_base, MUSB_INTRTXE, musb->context.intrtxe);
         musb_writew(musb_base, MUSB_INTRRXE, musb->context.intrrxe);
@@ -2280,33 +2231,31 @@ static void musb_restore_context(struct musb *musb)
                                 musb->context.index_regs[i].rxfifoadd);
                 }
 
-                if (is_host_enabled(musb)) {
-                        musb_writeb(epio, MUSB_TXTYPE,
+                musb_writeb(epio, MUSB_TXTYPE,
                                 musb->context.index_regs[i].txtype);
-                        musb_writeb(epio, MUSB_TXINTERVAL,
+                musb_writeb(epio, MUSB_TXINTERVAL,
                                 musb->context.index_regs[i].txinterval);
-                        musb_writeb(epio, MUSB_RXTYPE,
+                musb_writeb(epio, MUSB_RXTYPE,
                                 musb->context.index_regs[i].rxtype);
-                        musb_writeb(epio, MUSB_RXINTERVAL,
+                musb_writeb(epio, MUSB_RXINTERVAL,
 
-                        musb->context.index_regs[i].rxinterval);
-                        musb_write_txfunaddr(musb_base, i,
+                                musb->context.index_regs[i].rxinterval);
+                musb_write_txfunaddr(musb_base, i,
                                 musb->context.index_regs[i].txfunaddr);
-                        musb_write_txhubaddr(musb_base, i,
+                musb_write_txhubaddr(musb_base, i,
                                 musb->context.index_regs[i].txhubaddr);
-                        musb_write_txhubport(musb_base, i,
+                musb_write_txhubport(musb_base, i,
                                 musb->context.index_regs[i].txhubport);
 
-                        ep_target_regs =
-                                musb_read_target_reg_base(i, musb_base);
+                ep_target_regs =
+                        musb_read_target_reg_base(i, musb_base);
 
-                        musb_write_rxfunaddr(ep_target_regs,
+                musb_write_rxfunaddr(ep_target_regs,
                                 musb->context.index_regs[i].rxfunaddr);
-                        musb_write_rxhubaddr(ep_target_regs,
+                musb_write_rxhubaddr(ep_target_regs,
                                 musb->context.index_regs[i].rxhubaddr);
-                        musb_write_rxhubport(ep_target_regs,
+                musb_write_rxhubport(ep_target_regs,
                                 musb->context.index_regs[i].rxhubport);
-                }
         }
         musb_writeb(musb_base, MUSB_INDEX, musb->context.index);
 }
diff --git a/drivers/usb/musb/musb_core.h b/drivers/usb/musb/musb_core.h
index 586105b55a7c..c158aacd6de8 100644
--- a/drivers/usb/musb/musb_core.h
+++ b/drivers/usb/musb/musb_core.h
@@ -71,10 +71,6 @@ struct musb_ep;
 #include <linux/usb/hcd.h>
 #include "musb_host.h"
 
-#define is_peripheral_enabled(musb)     ((musb)->board_mode != MUSB_HOST)
-#define is_host_enabled(musb)           ((musb)->board_mode != MUSB_PERIPHERAL)
-#define is_otg_enabled(musb)            ((musb)->board_mode == MUSB_OTG)
-
 /* NOTE:  otg and peripheral-only state machines start at B_IDLE.
  * OTG or host-only go to A_IDLE when ID is sensed.
  */
@@ -88,8 +84,6 @@ struct musb_ep;
 
 /****************************** PERIPHERAL ROLE *****************************/
 
-#define is_peripheral_capable() (1)
-
 extern irqreturn_t musb_g_ep0_irq(struct musb *);
 extern void musb_g_tx(struct musb *, u8);
 extern void musb_g_rx(struct musb *, u8);
@@ -101,8 +95,6 @@ extern void musb_g_disconnect(struct musb *);
 
 /****************************** HOST ROLE ***********************************/
 
-#define is_host_capable()       (1)
-
 extern irqreturn_t musb_h_ep0_irq(struct musb *);
 extern void musb_host_tx(struct musb *, u8);
 extern void musb_host_rx(struct musb *, u8);
@@ -376,7 +368,6 @@ struct musb {
         u16 epmask;
         u8 nr_endpoints;
 
-        u8 board_mode;          /* enum musb_mode */
         int                     (*board_set_power)(int state);
 
         u8                      min_power;      /* vbus for periph, in mA/2 */
@@ -446,6 +437,10 @@ struct musb {
 #ifdef MUSB_CONFIG_PROC_FS
         struct proc_dir_entry *proc_entry;
 #endif
+        int                     xceiv_old_state;
+#ifdef CONFIG_DEBUG_FS
+        struct dentry           *debugfs_root;
+#endif
 };
 
 static inline struct musb *gadget_to_musb(struct usb_gadget *g)
@@ -484,7 +479,7 @@ static inline void musb_configure_ep0(struct musb *musb)
 static inline int musb_read_fifosize(struct musb *musb,
                 struct musb_hw_ep *hw_ep, u8 epnum)
 {
-        void *mbase = musb->mregs;
+        void __iomem *mbase = musb->mregs;
         u8 reg = 0;
 
         /* read from core using indexed model */
@@ -526,6 +521,8 @@ extern const char musb_driver_name[];
 
 extern void musb_start(struct musb *musb);
 extern void musb_stop(struct musb *musb);
+extern int musb_get_id(struct device *dev, gfp_t gfp_mask);
+extern void musb_put_id(struct device *dev, int id);
 
 extern void musb_write_fifo(struct musb_hw_ep *ep, u16 len, const u8 *src);
 extern void musb_read_fifo(struct musb_hw_ep *ep, u16 len, u8 *dst);
diff --git a/drivers/usb/musb/musb_debugfs.c b/drivers/usb/musb/musb_debugfs.c
index 40a37c91cc10..1d6e8af94c06 100644
--- a/drivers/usb/musb/musb_debugfs.c
+++ b/drivers/usb/musb/musb_debugfs.c
@@ -103,8 +103,6 @@ static const struct musb_register_map musb_regmap[] = {
         {  }    /* Terminating Entry */
 };
 
-static struct dentry *musb_debugfs_root;
-
 static int musb_regdump_show(struct seq_file *s, void *unused)
 {
         struct musb             *musb = s->private;
@@ -241,7 +239,7 @@ int __devinit musb_init_debugfs(struct musb *musb)
         struct dentry           *file;
         int                     ret;
 
-        root = debugfs_create_dir("musb", NULL);
+        root = debugfs_create_dir(dev_name(musb->controller), NULL);
         if (!root) {
                 ret = -ENOMEM;
                 goto err0;
@@ -261,7 +259,7 @@ int __devinit musb_init_debugfs(struct musb *musb)
                 goto err1;
         }
 
-        musb_debugfs_root = root;
+        musb->debugfs_root = root;
 
         return 0;
 
@@ -274,5 +272,5 @@ err0:
 
 void /* __init_or_exit */ musb_exit_debugfs(struct musb *musb)
 {
-        debugfs_remove_recursive(musb_debugfs_root);
+        debugfs_remove_recursive(musb->debugfs_root);
 }
diff --git a/drivers/usb/musb/musb_dma.h b/drivers/usb/musb/musb_dma.h
index 3a97c4e2d4f5..24d39210d4ab 100644
--- a/drivers/usb/musb/musb_dma.h
+++ b/drivers/usb/musb/musb_dma.h
@@ -178,7 +178,7 @@ struct dma_controller {
 extern void musb_dma_completion(struct musb *musb, u8 epnum, u8 transmit);
 
 
-extern struct dma_controller *__init
+extern struct dma_controller *__devinit
 dma_controller_create(struct musb *, void __iomem *);
 
 extern void dma_controller_destroy(struct dma_controller *);
diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c
index 494772fc9e23..444346e1e10d 100644
--- a/drivers/usb/musb/musb_dsps.c
+++ b/drivers/usb/musb/musb_dsps.c
@@ -31,11 +31,13 @@
 
 #include <linux/init.h>
 #include <linux/io.h>
+#include <linux/of.h>
 #include <linux/err.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/pm_runtime.h>
 #include <linux/module.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include <linux/of.h>
 #include <linux/of_device.h>
@@ -45,6 +47,10 @@
 
 #include "musb_core.h"
 
+#ifdef CONFIG_OF
+static const struct of_device_id musb_dsps_of_match[];
+#endif
+
 /**
  * avoid using musb_readx()/musb_writex() as glue layer should not be
  * dependent on musb core layer symbols.
@@ -105,6 +111,8 @@ struct dsps_musb_wrapper {
         /* miscellaneous stuff */
         u32             musb_core_offset;
         u8              poll_seconds;
+        /* number of musb instances */
+        u8              instances;
 };
 
 /**
@@ -112,9 +120,10 @@ struct dsps_musb_wrapper {
  */
 struct dsps_glue {
         struct device *dev;
-        struct platform_device *musb;   /* child musb pdev */
+        struct platform_device *musb[2];        /* child musb pdev */
         const struct dsps_musb_wrapper *wrp; /* wrapper register offsets */
-        struct timer_list timer;        /* otg_workaround timer */
+        struct timer_list timer[2];     /* otg_workaround timer */
+        unsigned long last_timer[2];    /* last timer data for each instance */
 };
 
 /**
@@ -137,9 +146,8 @@ static void dsps_musb_enable(struct musb *musb)
         dsps_writel(reg_base, wrp->epintr_set, epmask);
         dsps_writel(reg_base, wrp->coreintr_set, coremask);
         /* Force the DRVVBUS IRQ so we can start polling for ID change. */
-        if (is_otg_enabled(musb))
-                dsps_writel(reg_base, wrp->coreintr_set,
-                            (1 << wrp->drvvbus) << wrp->usb_shift);
+        dsps_writel(reg_base, wrp->coreintr_set,
+                    (1 << wrp->drvvbus) << wrp->usb_shift);
 }
 
 /**
@@ -165,8 +173,8 @@ static void otg_timer(unsigned long _musb)
         struct musb *musb = (void *)_musb;
         void __iomem *mregs = musb->mregs;
         struct device *dev = musb->controller;
-        struct platform_device *pdev = to_platform_device(dev->parent);
-        struct dsps_glue *glue = platform_get_drvdata(pdev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
         const struct dsps_musb_wrapper *wrp = glue->wrp;
         u8 devctl;
         unsigned long flags;
@@ -200,12 +208,9 @@ static void otg_timer(unsigned long _musb)
                             MUSB_INTR_VBUSERROR << wrp->usb_shift);
                 break;
         case OTG_STATE_B_IDLE:
-                if (!is_peripheral_enabled(musb))
-                        break;
-
                 devctl = dsps_readb(mregs, MUSB_DEVCTL);
                 if (devctl & MUSB_DEVCTL_BDEVICE)
-                        mod_timer(&glue->timer,
+                        mod_timer(&glue->timer[pdev->id],
                                         jiffies + wrp->poll_seconds * HZ);
                 else
                         musb->xceiv->state = OTG_STATE_A_IDLE;
@@ -219,12 +224,8 @@ static void otg_timer(unsigned long _musb)
 static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
 {
         struct device *dev = musb->controller;
-        struct platform_device *pdev = to_platform_device(dev->parent);
-        struct dsps_glue *glue = platform_get_drvdata(pdev);
-        static unsigned long last_timer;
-
-        if (!is_otg_enabled(musb))
-                return;
+        struct platform_device *pdev = to_platform_device(dev);
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
 
         if (timeout == 0)
                 timeout = jiffies + msecs_to_jiffies(3);
@@ -234,22 +235,23 @@ static void dsps_musb_try_idle(struct musb *musb, unsigned long timeout)
                                 musb->xceiv->state == OTG_STATE_A_WAIT_BCON)) {
                 dev_dbg(musb->controller, "%s active, deleting timer\n",
                                 otg_state_string(musb->xceiv->state));
-                del_timer(&glue->timer);
-                last_timer = jiffies;
+                del_timer(&glue->timer[pdev->id]);
+                glue->last_timer[pdev->id] = jiffies;
                 return;
         }
 
-        if (time_after(last_timer, timeout) && timer_pending(&glue->timer)) {
+        if (time_after(glue->last_timer[pdev->id], timeout) &&
+                                timer_pending(&glue->timer[pdev->id])) {
                 dev_dbg(musb->controller,
                         "Longer idle timer already pending, ignoring...\n");
                 return;
         }
-        last_timer = timeout;
+        glue->last_timer[pdev->id] = timeout;
 
         dev_dbg(musb->controller, "%s inactive, starting idle timer for %u ms\n",
                 otg_state_string(musb->xceiv->state),
                         jiffies_to_msecs(timeout - jiffies));
-        mod_timer(&glue->timer, timeout);
+        mod_timer(&glue->timer[pdev->id], timeout);
 }
 
 static irqreturn_t dsps_interrupt(int irq, void *hci)
@@ -257,8 +259,8 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
         struct musb  *musb = hci;
         void __iomem *reg_base = musb->ctrl_base;
         struct device *dev = musb->controller;
-        struct platform_device *pdev = to_platform_device(dev->parent);
-        struct dsps_glue *glue = platform_get_drvdata(pdev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
         const struct dsps_musb_wrapper *wrp = glue->wrp;
         unsigned long flags;
         irqreturn_t ret = IRQ_NONE;
@@ -293,7 +295,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
          * value but DEVCTL.BDEVICE is invalid without DEVCTL.SESSION set.
          * Also, DRVVBUS pulses for SRP (but not at 5V) ...
          */
-        if ((usbintr & MUSB_INTR_BABBLE) && is_host_enabled(musb))
+        if (usbintr & MUSB_INTR_BABBLE)
                 pr_info("CAUTION: musb: Babble Interrupt Occured\n");
 
         if (usbintr & ((1 << wrp->drvvbus) << wrp->usb_shift)) {
@@ -302,8 +304,7 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                 u8 devctl = dsps_readb(mregs, MUSB_DEVCTL);
                 int err;
 
-                err = is_host_enabled(musb) && (musb->int_usb &
-                                                MUSB_INTR_VBUSERROR);
+                err = musb->int_usb & MUSB_INTR_VBUSERROR;
                 if (err) {
                         /*
                          * The Mentor core doesn't debounce VBUS as needed
@@ -318,15 +319,15 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                          */
                         musb->int_usb &= ~MUSB_INTR_VBUSERROR;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VFALL;
-                        mod_timer(&glue->timer,
+                        mod_timer(&glue->timer[pdev->id],
                                         jiffies + wrp->poll_seconds * HZ);
                         WARNING("VBUS error workaround (delay coming)\n");
-                } else if (is_host_enabled(musb) && drvvbus) {
+                } else if (drvvbus) {
                         musb->is_active = 1;
                         MUSB_HST_MODE(musb);
                         musb->xceiv->otg->default_a = 1;
                         musb->xceiv->state = OTG_STATE_A_WAIT_VRISE;
-                        del_timer(&glue->timer);
+                        del_timer(&glue->timer[pdev->id]);
                 } else {
                         musb->is_active = 0;
                         MUSB_DEV_MODE(musb);
@@ -352,8 +353,9 @@ static irqreturn_t dsps_interrupt(int irq, void *hci)
                 dsps_writel(reg_base, wrp->eoi, 1);
 
         /* Poll for ID change */
-        if (is_otg_enabled(musb) && musb->xceiv->state == OTG_STATE_B_IDLE)
-                mod_timer(&glue->timer, jiffies + wrp->poll_seconds * HZ);
+        if (musb->xceiv->state == OTG_STATE_B_IDLE)
+                mod_timer(&glue->timer[pdev->id],
+                         jiffies + wrp->poll_seconds * HZ);
 
         spin_unlock_irqrestore(&musb->lock, flags);
 
@@ -364,8 +366,8 @@ static int dsps_musb_init(struct musb *musb)
 {
         struct device *dev = musb->controller;
         struct musb_hdrc_platform_data *plat = dev->platform_data;
-        struct platform_device *pdev = to_platform_device(dev->parent);
-        struct dsps_glue *glue = platform_get_drvdata(pdev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
         const struct dsps_musb_wrapper *wrp = glue->wrp;
         struct omap_musb_board_data *data = plat->board_data;
         void __iomem *reg_base = musb->ctrl_base;
@@ -375,8 +377,7 @@ static int dsps_musb_init(struct musb *musb)
         /* mentor core register starts at offset of 0x400 from musb base */
         musb->mregs += wrp->musb_core_offset;
 
-        /* NOP driver needs change if supporting dual instance */
-        usb_nop_xceiv_register();
+        /* Get the NOP PHY */
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
         if (IS_ERR_OR_NULL(musb->xceiv))
                 return -ENODEV;
@@ -388,8 +389,7 @@ static int dsps_musb_init(struct musb *musb)
                 goto err0;
         }
 
-        if (is_host_enabled(musb))
-                setup_timer(&glue->timer, otg_timer, (unsigned long) musb);
+        setup_timer(&glue->timer[pdev->id], otg_timer, (unsigned long) musb);
 
         /* Reset the musb */
         dsps_writel(reg_base, wrp->control, (1 << wrp->reset));
@@ -420,11 +420,10 @@ static int dsps_musb_exit(struct musb *musb)
         struct device *dev = musb->controller;
         struct musb_hdrc_platform_data *plat = dev->platform_data;
         struct omap_musb_board_data *data = plat->board_data;
-        struct platform_device *pdev = to_platform_device(dev->parent);
-        struct dsps_glue *glue = platform_get_drvdata(pdev);
+        struct platform_device *pdev = to_platform_device(dev);
+        struct dsps_glue *glue = dev_get_drvdata(dev->parent);
 
-        if (is_host_enabled(musb))
-                del_timer_sync(&glue->timer);
+        del_timer_sync(&glue->timer[pdev->id]);
 
         /* Shutdown the on-chip PHY and its PLL. */
         if (data->set_phy_power)
@@ -454,11 +453,13 @@ static int __devinit dsps_create_musb_pdev(struct dsps_glue *glue, u8 id)
         struct device *dev = glue->dev;
         struct platform_device *pdev = to_platform_device(dev);
         struct musb_hdrc_platform_data  *pdata = dev->platform_data;
+        struct device_node *np = pdev->dev.of_node;
+        struct musb_hdrc_config *config;
         struct platform_device  *musb;
         struct resource *res;
         struct resource resources[2];
         char res_name[10];
-        int ret;
+        int ret, musbid;
 
         /* get memory resource */
         sprintf(res_name, "musb%d", id);
@@ -483,62 +484,107 @@ static int __devinit dsps_create_musb_pdev(struct dsps_glue *glue, u8 id)
         resources[1] = *res;
         resources[1].name = "mc";
 
+        /* get the musb id */
+        musbid = musb_get_id(dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err0;
+        }
         /* allocate the child platform device */
-        musb = platform_device_alloc("musb-hdrc", -1);
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(dev, "failed to allocate musb device\n");
                 ret = -ENOMEM;
-                goto err0;
+                goto err1;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = dev;
         musb->dev.dma_mask              = &musb_dmamask;
         musb->dev.coherent_dma_mask     = musb_dmamask;
 
-        glue->musb                      = musb;
-
-        pdata->platform_ops             = &dsps_ops;
+        glue->musb[id]                  = musb;
 
         ret = platform_device_add_resources(musb, resources, 2);
         if (ret) {
                 dev_err(dev, "failed to add resources\n");
-                goto err1;
+                goto err2;
         }
 
+        if (np) {
+                pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+                if (!pdata) {
+                        dev_err(&pdev->dev,
+                                "failed to allocate musb platfrom data\n");
+                        ret = -ENOMEM;
+                        goto err2;
+                }
+
+                config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
+                if (!config) {
+                        dev_err(&pdev->dev,
+                                "failed to allocate musb hdrc config\n");
+                        goto err2;
+                }
+
+                of_property_read_u32(np, "num-eps", (u32 *)&config->num_eps);
+                of_property_read_u32(np, "ram-bits", (u32 *)&config->ram_bits);
+                sprintf(res_name, "port%d-mode", id);
+                of_property_read_u32(np, res_name, (u32 *)&pdata->mode);
+                of_property_read_u32(np, "power", (u32 *)&pdata->power);
+                config->multipoint = of_property_read_bool(np, "multipoint");
+
+                pdata->config           = config;
+        }
+
+        pdata->platform_ops             = &dsps_ops;
+
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(dev, "failed to add platform_data\n");
-                goto err1;
+                goto err2;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(dev, "failed to register musb device\n");
-                goto err1;
+                goto err2;
         }
 
         return 0;
 
-err1:
+err2:
         platform_device_put(musb);
+err1:
+        musb_put_id(dev, musbid);
 err0:
         return ret;
 }
 
-static void __devexit dsps_delete_musb_pdev(struct dsps_glue *glue)
+static void dsps_delete_musb_pdev(struct dsps_glue *glue, u8 id)
 {
-        platform_device_del(glue->musb);
-        platform_device_put(glue->musb);
+        musb_put_id(glue->dev, glue->musb[id]->id);
+        platform_device_del(glue->musb[id]);
+        platform_device_put(glue->musb[id]);
 }
 
 static int __devinit dsps_probe(struct platform_device *pdev)
 {
-        const struct platform_device_id *id = platform_get_device_id(pdev);
-        const struct dsps_musb_wrapper *wrp =
-                                (struct dsps_musb_wrapper *)id->driver_data;
+        struct device_node *np = pdev->dev.of_node;
+        const struct of_device_id *match;
+        const struct dsps_musb_wrapper *wrp;
         struct dsps_glue *glue;
         struct resource *iomem;
-        int ret;
+        int ret, i;
+
+        match = of_match_node(musb_dsps_of_match, np);
+        if (!match) {
+                dev_err(&pdev->dev, "fail to get matching of_match struct\n");
+                ret = -EINVAL;
+                goto err0;
+        }
+        wrp = match->data;
 
         /* allocate glue */
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
@@ -575,11 +621,16 @@ static int __devinit dsps_probe(struct platform_device *pdev)
                 goto err2;
         }
 
-        /* create the child platform device for first instances of musb */
-        ret = dsps_create_musb_pdev(glue, 0);
-        if (ret != 0) {
-                dev_err(&pdev->dev, "failed to create child pdev\n");
-                goto err3;
+        /* create the child platform device for all instances of musb */
+        for (i = 0; i < wrp->instances ; i++) {
+                ret = dsps_create_musb_pdev(glue, i);
+                if (ret != 0) {
+                        dev_err(&pdev->dev, "failed to create child pdev\n");
+                        /* release resources of previously created instances */
+                        for (i--; i >= 0 ; i--)
+                                dsps_delete_musb_pdev(glue, i);
+                        goto err3;
+                }
         }
 
         return 0;
@@ -597,9 +648,12 @@ err0:
 static int __devexit dsps_remove(struct platform_device *pdev)
 {
         struct dsps_glue *glue = platform_get_drvdata(pdev);
+        const struct dsps_musb_wrapper *wrp = glue->wrp;
+        int i;
 
         /* delete the child platform device */
-        dsps_delete_musb_pdev(glue);
+        for (i = 0; i < wrp->instances ; i++)
+                dsps_delete_musb_pdev(glue, i);
 
         /* disable usbss clocks */
         pm_runtime_put(&pdev->dev);
@@ -665,6 +719,7 @@ static const struct dsps_musb_wrapper ti81xx_driver_data __devinitconst = {
         .rxep_bitmap            = (0xfffe << 16),
         .musb_core_offset       = 0x400,
         .poll_seconds           = 2,
+        .instances              = 2,
 };
 
 static const struct platform_device_id musb_dsps_id_table[] __devinitconst = {
@@ -676,13 +731,14 @@ static const struct platform_device_id musb_dsps_id_table[] __devinitconst = {
 };
 MODULE_DEVICE_TABLE(platform, musb_dsps_id_table);
 
+#ifdef CONFIG_OF
 static const struct of_device_id musb_dsps_of_match[] __devinitconst = {
-        { .compatible = "musb-ti81xx", },
-        { .compatible = "ti,ti81xx-musb", },
-        { .compatible = "ti,am335x-musb", },
+        { .compatible = "ti,musb-am33xx",
+                .data = (void *) &ti81xx_driver_data, },
         {  },
 };
 MODULE_DEVICE_TABLE(of, musb_dsps_of_match);
+#endif
 
 static struct platform_driver dsps_usbss_driver = {
         .probe          = dsps_probe,
@@ -690,7 +746,7 @@ static struct platform_driver dsps_usbss_driver = {
         .driver         = {
                 .name   = "musb-dsps",
                 .pm     = &dsps_pm_ops,
-                .of_match_table = musb_dsps_of_match,
+                .of_match_table = of_match_ptr(musb_dsps_of_match),
         },
         .id_table       = musb_dsps_id_table,
 };
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index f7194cf65aba..d0b87e7b4abf 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -373,7 +373,7 @@ static void txstate(struct musb *musb, struct musb_request *req)
                 request_size = min_t(size_t, request->length - request->actual,
                                         musb_ep->dma->max_len);
 
-                use_dma = (request->dma != DMA_ADDR_INVALID);
+                use_dma = (request->dma != DMA_ADDR_INVALID && request_size);
 
                 /* MUSB_TXCSR_P_ISO is still set correctly */
 
@@ -644,8 +644,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
         struct usb_request      *request = &req->request;
         struct musb_ep          *musb_ep;
         void __iomem            *epio = musb->endpoints[epnum].regs;
-        unsigned                fifo_count = 0;
-        u16                     len;
+        unsigned                len = 0;
+        u16                     fifo_count;
         u16                     csr = musb_readw(epio, MUSB_RXCSR);
         struct musb_hw_ep       *hw_ep = &musb->endpoints[epnum];
         u8                      use_mode_1;
@@ -655,7 +655,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
         else
                 musb_ep = &hw_ep->ep_out;
 
-        len = musb_ep->packet_sz;
+        fifo_count = musb_ep->packet_sz;
 
         /* Check if EP is disabled */
         if (!musb_ep->desc) {
@@ -704,15 +704,14 @@ static void rxstate(struct musb *musb, struct musb_request *req)
         }
 
         if (csr & MUSB_RXCSR_RXPKTRDY) {
-                len = musb_readw(epio, MUSB_RXCOUNT);
+                fifo_count = musb_readw(epio, MUSB_RXCOUNT);
 
                 /*
-                 * Enable Mode 1 on RX transfers only when short_not_ok flag
-                 * is set. Currently short_not_ok flag is set only from
-                 * file_storage and f_mass_storage drivers
+                 *  use mode 1 only if we expect data of at least ep packet_sz
+                 *  and have not yet received a short packet
                  */
-
-                if (request->short_not_ok && len == musb_ep->packet_sz)
+                if ((request->length - request->actual >= musb_ep->packet_sz) &&
+                        (fifo_count >= musb_ep->packet_sz))
                         use_mode_1 = 1;
                 else
                         use_mode_1 = 0;
@@ -723,31 +722,11 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                 struct dma_controller   *c;
                                 struct dma_channel      *channel;
                                 int                     use_dma = 0;
+                                int transfer_size;
 
                                 c = musb->dma_controller;
                                 channel = musb_ep->dma;
 
-        /* We use DMA Req mode 0 in rx_csr, and DMA controller operates in
-         * mode 0 only. So we do not get endpoint interrupts due to DMA
-         * completion. We only get interrupts from DMA controller.
-         *
-         * We could operate in DMA mode 1 if we knew the size of the tranfer
-         * in advance. For mass storage class, request->length = what the host
-         * sends, so that'd work.  But for pretty much everything else,
-         * request->length is routinely more than what the host sends. For
-         * most these gadgets, end of is signified either by a short packet,
-         * or filling the last byte of the buffer.  (Sending extra data in
-         * that last pckate should trigger an overflow fault.)  But in mode 1,
-         * we don't get DMA completion interrupt for short packets.
-         *
-         * Theoretically, we could enable DMAReq irq (MUSB_RXCSR_DMAMODE = 1),
-         * to get endpoint interrupt on every DMA req, but that didn't seem
-         * to work reliably.
-         *
-         * REVISIT an updated g_file_storage can set req->short_not_ok, which
-         * then becomes usable as a runtime "use mode 1" hint...
-         */
-
                                 /* Experimental: Mode1 works with mass storage use cases */
                                 if (use_mode_1) {
                                         csr |= MUSB_RXCSR_AUTOCLEAR;
@@ -764,35 +743,30 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                                 csr | MUSB_RXCSR_DMAMODE);
                                         musb_writew(epio, MUSB_RXCSR, csr);
 
+                                        transfer_size = min(request->length - request->actual,
+                                                        channel->max_len);
+                                        musb_ep->dma->desired_mode = 1;
+
                                 } else {
                                         if (!musb_ep->hb_mult &&
                                                 musb_ep->hw_ep->rx_double_buffered)
                                                 csr |= MUSB_RXCSR_AUTOCLEAR;
                                         csr |= MUSB_RXCSR_DMAENAB;
                                         musb_writew(epio, MUSB_RXCSR, csr);
-                                }
 
-                                if (request->actual < request->length) {
-                                        int transfer_size = 0;
-                                        if (use_mode_1) {
-                                                transfer_size = min(request->length - request->actual,
-                                                                channel->max_len);
-                                                musb_ep->dma->desired_mode = 1;
-                                        } else {
-                                                transfer_size = min(request->length - request->actual,
-                                                                (unsigned)len);
-                                                musb_ep->dma->desired_mode = 0;
-                                        }
-
-                                        use_dma = c->channel_program(
-                                                        channel,
-                                                        musb_ep->packet_sz,
-                                                        channel->desired_mode,
-                                                        request->dma
-                                                        + request->actual,
-                                                        transfer_size);
+                                        transfer_size = min(request->length - request->actual,
+                                                        (unsigned)fifo_count);
+                                        musb_ep->dma->desired_mode = 0;
                                 }
 
+                                use_dma = c->channel_program(
+                                                channel,
+                                                musb_ep->packet_sz,
+                                                channel->desired_mode,
+                                                request->dma
+                                                + request->actual,
+                                                transfer_size);
+
                                 if (use_dma)
                                         return;
                         }
@@ -808,8 +782,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                 channel = musb_ep->dma;
 
                                 /* In case first packet is short */
-                                if (len < musb_ep->packet_sz)
-                                        transfer_size = len;
+                                if (fifo_count < musb_ep->packet_sz)
+                                        transfer_size = fifo_count;
                                 else if (request->short_not_ok)
                                         transfer_size = min(request->length -
                                                         request->actual,
@@ -817,7 +791,7 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                                 else
                                         transfer_size = min(request->length -
                                                         request->actual,
-                                                        (unsigned)len);
+                                                        (unsigned)fifo_count);
 
                                 csr &= ~MUSB_RXCSR_DMAMODE;
                                 csr |= (MUSB_RXCSR_DMAENAB |
@@ -845,10 +819,10 @@ static void rxstate(struct musb *musb, struct musb_request *req)
                         }
 #endif  /* Mentor's DMA */
 
-                        fifo_count = request->length - request->actual;
+                        len = request->length - request->actual;
                         dev_dbg(musb->controller, "%s OUT/RX pio fifo %d/%d, maxpacket %d\n",
                                         musb_ep->end_point.name,
-                                        len, fifo_count,
+                                        fifo_count, len,
                                         musb_ep->packet_sz);
 
                         fifo_count = min_t(unsigned, len, fifo_count);
@@ -901,7 +875,8 @@ static void rxstate(struct musb *musb, struct musb_request *req)
         }
 
         /* reach the end or short packet detected */
-        if (request->actual == request->length || len < musb_ep->packet_sz)
+        if (request->actual == request->length ||
+            fifo_count < musb_ep->packet_sz)
                 musb_g_giveback(musb_ep, request, 0);
 }
 
@@ -1885,8 +1860,7 @@ int __devinit musb_gadget_setup(struct musb *musb)
         musb->g.dev.release = musb_gadget_release;
         musb->g.name = musb_driver_name;
 
-        if (is_otg_enabled(musb))
-                musb->g.is_otg = 1;
+        musb->g.is_otg = 1;
 
         musb_g_init_endpoints(musb);
 
@@ -1932,11 +1906,14 @@ static int musb_gadget_start(struct usb_gadget *g,
 {
         struct musb             *musb = gadget_to_musb(g);
         struct usb_otg          *otg = musb->xceiv->otg;
+        struct usb_hcd          *hcd = musb_to_hcd(musb);
         unsigned long           flags;
-        int                     retval = -EINVAL;
+        int                     retval = 0;
 
-        if (driver->max_speed < USB_SPEED_HIGH)
-                goto err0;
+        if (driver->max_speed < USB_SPEED_HIGH) {
+                retval = -EINVAL;
+                goto err;
+        }
 
         pm_runtime_get_sync(musb->controller);
 
@@ -1950,49 +1927,30 @@ static int musb_gadget_start(struct usb_gadget *g,
 
         otg_set_peripheral(otg, &musb->g);
         musb->xceiv->state = OTG_STATE_B_IDLE;
-
-        /*
-         * FIXME this ignores the softconnect flag.  Drivers are
-         * allowed hold the peripheral inactive until for example
-         * userspace hooks up printer hardware or DSP codecs, so
-         * hosts only see fully functional devices.
-         */
-
-        if (!is_otg_enabled(musb))
-                musb_start(musb);
-
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        if (is_otg_enabled(musb)) {
-                struct usb_hcd  *hcd = musb_to_hcd(musb);
-
-                dev_dbg(musb->controller, "OTG startup...\n");
+        /* REVISIT:  funcall to other code, which also
+         * handles power budgeting ... this way also
+         * ensures HdrcStart is indirectly called.
+         */
+        retval = usb_add_hcd(hcd, 0, 0);
+        if (retval < 0) {
+                dev_dbg(musb->controller, "add_hcd failed, %d\n", retval);
+                goto err;
+        }
 
-                /* REVISIT:  funcall to other code, which also
-                 * handles power budgeting ... this way also
-                 * ensures HdrcStart is indirectly called.
-                 */
-                retval = usb_add_hcd(musb_to_hcd(musb), 0, 0);
-                if (retval < 0) {
-                        dev_dbg(musb->controller, "add_hcd failed, %d\n", retval);
-                        goto err2;
-                }
+        if ((musb->xceiv->last_event == USB_EVENT_ID)
+                                && otg->set_vbus)
+                otg_set_vbus(otg, 1);
 
-                if ((musb->xceiv->last_event == USB_EVENT_ID)
-                                        && otg->set_vbus)
-                        otg_set_vbus(otg, 1);
+        hcd->self.uses_pio_for_control = 1;
 
-                hcd->self.uses_pio_for_control = 1;
-        }
         if (musb->xceiv->last_event == USB_EVENT_NONE)
                 pm_runtime_put(musb->controller);
 
         return 0;
 
-err2:
-        if (!is_otg_enabled(musb))
-                musb_stop(musb);
-err0:
+err:
         return retval;
 }
 
@@ -2070,16 +2028,12 @@ static int musb_gadget_stop(struct usb_gadget *g,
         musb_platform_try_idle(musb, 0);
         spin_unlock_irqrestore(&musb->lock, flags);
 
-        if (is_otg_enabled(musb)) {
-                usb_remove_hcd(musb_to_hcd(musb));
-                /* FIXME we need to be able to register another
-                 * gadget driver here and have everything work;
-                 * that currently misbehaves.
-                 */
-        }
-
-        if (!is_otg_enabled(musb))
-                musb_stop(musb);
+        usb_remove_hcd(musb_to_hcd(musb));
+        /*
+         * FIXME we need to be able to register another
+         * gadget driver here and have everything work;
+         * that currently misbehaves.
+         */
 
         pm_runtime_put(musb->controller);
 
@@ -2241,13 +2195,11 @@ __acquires(musb->lock)
         if (devctl & MUSB_DEVCTL_BDEVICE) {
                 musb->xceiv->state = OTG_STATE_B_PERIPHERAL;
                 musb->g.is_a_peripheral = 0;
-        } else if (is_otg_enabled(musb)) {
+        } else {
                 musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                 musb->g.is_a_peripheral = 1;
-        } else
-                WARN_ON(1);
+        }
 
         /* start with default limits on VBUS power draw */
-        (void) musb_gadget_vbus_draw(&musb->g,
-                        is_otg_enabled(musb) ? 8 : 100);
+        (void) musb_gadget_vbus_draw(&musb->g, 8);
 }
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 1ae378d5fc6f..3df6a76b851d 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -693,6 +693,8 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
         void __iomem            *epio = hw_ep->regs;
         struct musb_qh          *qh = musb_ep_get_qh(hw_ep, !is_out);
         u16                     packet_sz = qh->maxpacket;
+        u8                      use_dma = 1;
+        u16                     csr;
 
         dev_dbg(musb->controller, "%s hw%d urb %p spd%d dev%d ep%d%s "
                                 "h_addr%02x h_port%02x bytes %d\n",
@@ -704,9 +706,17 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
 
         musb_ep_select(mbase, epnum);
 
+        if (is_out && !len) {
+                use_dma = 0;
+                csr = musb_readw(epio, MUSB_TXCSR);
+                csr &= ~MUSB_TXCSR_DMAENAB;
+                musb_writew(epio, MUSB_TXCSR, csr);
+                hw_ep->tx_channel = NULL;
+        }
+
         /* candidate for DMA? */
         dma_controller = musb->dma_controller;
-        if (is_dma_capable() && epnum && dma_controller) {
+        if (use_dma && is_dma_capable() && epnum && dma_controller) {
                 dma_channel = is_out ? hw_ep->tx_channel : hw_ep->rx_channel;
                 if (!dma_channel) {
                         dma_channel = dma_controller->channel_alloc(
@@ -813,9 +823,28 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
                 if (load_count) {
                         /* PIO to load FIFO */
                         qh->segsize = load_count;
-                        musb_write_fifo(hw_ep, load_count, buf);
+                        if (!buf) {
+                                sg_miter_start(&qh->sg_miter, urb->sg, 1,
+                                                SG_MITER_ATOMIC
+                                                | SG_MITER_FROM_SG);
+                                if (!sg_miter_next(&qh->sg_miter)) {
+                                        dev_err(musb->controller,
+                                                        "error: sg"
+                                                        "list empty\n");
+                                        sg_miter_stop(&qh->sg_miter);
+                                        goto finish;
+                                }
+                                buf = qh->sg_miter.addr + urb->sg->offset +
+                                        urb->actual_length;
+                                load_count = min_t(u32, load_count,
+                                                qh->sg_miter.length);
+                                musb_write_fifo(hw_ep, load_count, buf);
+                                qh->sg_miter.consumed = load_count;
+                                sg_miter_stop(&qh->sg_miter);
+                        } else
+                                musb_write_fifo(hw_ep, load_count, buf);
                 }
-
+finish:
                 /* re-enable interrupt */
                 musb_writew(mbase, MUSB_INTRTXE, int_txe);
 
@@ -882,6 +911,73 @@ static void musb_ep_program(struct musb *musb, u8 epnum,
         }
 }
 
+/* Schedule next QH from musb->in_bulk/out_bulk and move the current qh to
+ * the end; avoids starvation for other endpoints.
+ */
+static void musb_bulk_nak_timeout(struct musb *musb, struct musb_hw_ep *ep,
+        int is_in)
+{
+        struct dma_channel      *dma;
+        struct urb              *urb;
+        void __iomem            *mbase = musb->mregs;
+        void __iomem            *epio = ep->regs;
+        struct musb_qh          *cur_qh, *next_qh;
+        u16                     rx_csr, tx_csr;
+
+        musb_ep_select(mbase, ep->epnum);
+        if (is_in) {
+                dma = is_dma_capable() ? ep->rx_channel : NULL;
+
+                /* clear nak timeout bit */
+                rx_csr = musb_readw(epio, MUSB_RXCSR);
+                rx_csr |= MUSB_RXCSR_H_WZC_BITS;
+                rx_csr &= ~MUSB_RXCSR_DATAERROR;
+                musb_writew(epio, MUSB_RXCSR, rx_csr);
+
+                cur_qh = first_qh(&musb->in_bulk);
+        } else {
+                dma = is_dma_capable() ? ep->tx_channel : NULL;
+
+                /* clear nak timeout bit */
+                tx_csr = musb_readw(epio, MUSB_TXCSR);
+                tx_csr |= MUSB_TXCSR_H_WZC_BITS;
+                tx_csr &= ~MUSB_TXCSR_H_NAKTIMEOUT;
+                musb_writew(epio, MUSB_TXCSR, tx_csr);
+
+                cur_qh = first_qh(&musb->out_bulk);
+        }
+        if (cur_qh) {
+                urb = next_urb(cur_qh);
+                if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
+                        dma->status = MUSB_DMA_STATUS_CORE_ABORT;
+                        musb->dma_controller->channel_abort(dma);
+                        urb->actual_length += dma->actual_len;
+                        dma->actual_len = 0L;
+                }
+                musb_save_toggle(cur_qh, is_in, urb);
+
+                if (is_in) {
+                        /* move cur_qh to end of queue */
+                        list_move_tail(&cur_qh->ring, &musb->in_bulk);
+
+                        /* get the next qh from musb->in_bulk */
+                        next_qh = first_qh(&musb->in_bulk);
+
+                        /* set rx_reinit and schedule the next qh */
+                        ep->rx_reinit = 1;
+                } else {
+                        /* move cur_qh to end of queue */
+                        list_move_tail(&cur_qh->ring, &musb->out_bulk);
+
+                        /* get the next qh from musb->out_bulk */
+                        next_qh = first_qh(&musb->out_bulk);
+
+                        /* set tx_reinit and schedule the next qh */
+                        ep->tx_reinit = 1;
+                }
+                musb_start_urb(musb, is_in, next_qh);
+        }
+}
 
 /*
  * Service the default endpoint (ep0) as host.
@@ -1116,6 +1212,7 @@ void musb_host_tx(struct musb *musb, u8 epnum)
         void __iomem            *mbase = musb->mregs;
         struct dma_channel      *dma;
         bool                    transfer_pending = false;
+        static bool use_sg;
 
         musb_ep_select(mbase, epnum);
         tx_csr = musb_readw(epio, MUSB_TXCSR);
@@ -1146,23 +1243,31 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                 status = -ETIMEDOUT;
 
         } else if (tx_csr & MUSB_TXCSR_H_NAKTIMEOUT) {
-                dev_dbg(musb->controller, "TX end=%d device not responding\n", epnum);
-
-                /* NOTE:  this code path would be a good place to PAUSE a
-                 * transfer, if there's some other (nonperiodic) tx urb
-                 * that could use this fifo.  (dma complicates it...)
-                 * That's already done for bulk RX transfers.
-                 *
-                 * if (bulk && qh->ring.next != &musb->out_bulk), then
-                 * we have a candidate... NAKing is *NOT* an error
-                 */
-                musb_ep_select(mbase, epnum);
-                musb_writew(epio, MUSB_TXCSR,
-                                MUSB_TXCSR_H_WZC_BITS
-                                | MUSB_TXCSR_TXPKTRDY);
-                return;
+                if (USB_ENDPOINT_XFER_BULK == qh->type && qh->mux == 1
+                                && !list_is_singular(&musb->out_bulk)) {
+                        dev_dbg(musb->controller,
+                                "NAK timeout on TX%d ep\n", epnum);
+                        musb_bulk_nak_timeout(musb, hw_ep, 0);
+                } else {
+                        dev_dbg(musb->controller,
+                                "TX end=%d device not responding\n", epnum);
+                        /* NOTE:  this code path would be a good place to PAUSE a
+                         * transfer, if there's some other (nonperiodic) tx urb
+                         * that could use this fifo.  (dma complicates it...)
+                         * That's already done for bulk RX transfers.
+                         *
+                         * if (bulk && qh->ring.next != &musb->out_bulk), then
+                         * we have a candidate... NAKing is *NOT* an error
+                         */
+                        musb_ep_select(mbase, epnum);
+                        musb_writew(epio, MUSB_TXCSR,
+                                        MUSB_TXCSR_H_WZC_BITS
+                                        | MUSB_TXCSR_TXPKTRDY);
+                }
+                        return;
         }
 
+done:
         if (status) {
                 if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
                         dma->status = MUSB_DMA_STATUS_CORE_ABORT;
@@ -1332,9 +1437,38 @@ void musb_host_tx(struct musb *musb, u8 epnum)
                 length = qh->maxpacket;
         /* Unmap the buffer so that CPU can use it */
         usb_hcd_unmap_urb_for_dma(musb_to_hcd(musb), urb);
-        musb_write_fifo(hw_ep, length, urb->transfer_buffer + offset);
+
+        /*
+         * We need to map sg if the transfer_buffer is
+         * NULL.
+         */
+        if (!urb->transfer_buffer)
+                use_sg = true;
+
+        if (use_sg) {
+                /* sg_miter_start is already done in musb_ep_program */
+                if (!sg_miter_next(&qh->sg_miter)) {
+                        dev_err(musb->controller, "error: sg list empty\n");
+                        sg_miter_stop(&qh->sg_miter);
+                        status = -EINVAL;
+                        goto done;
+                }
+                urb->transfer_buffer = qh->sg_miter.addr;
+                length = min_t(u32, length, qh->sg_miter.length);
+                musb_write_fifo(hw_ep, length, urb->transfer_buffer);
+                qh->sg_miter.consumed = length;
+                sg_miter_stop(&qh->sg_miter);
+        } else {
+                musb_write_fifo(hw_ep, length, urb->transfer_buffer + offset);
+        }
+
         qh->segsize = length;
 
+        if (use_sg) {
+                if (offset + length >= urb->transfer_buffer_length)
+                        use_sg = false;
+        }
+
         musb_ep_select(mbase, epnum);
         musb_writew(epio, MUSB_TXCSR,
                         MUSB_TXCSR_H_WZC_BITS | MUSB_TXCSR_TXPKTRDY);
@@ -1380,50 +1514,6 @@ void musb_host_tx(struct musb *musb, u8 epnum)
 
 #endif
 
-/* Schedule next QH from musb->in_bulk and move the current qh to
- * the end; avoids starvation for other endpoints.
- */
-static void musb_bulk_rx_nak_timeout(struct musb *musb, struct musb_hw_ep *ep)
-{
-        struct dma_channel      *dma;
-        struct urb              *urb;
-        void __iomem            *mbase = musb->mregs;
-        void __iomem            *epio = ep->regs;
-        struct musb_qh          *cur_qh, *next_qh;
-        u16                     rx_csr;
-
-        musb_ep_select(mbase, ep->epnum);
-        dma = is_dma_capable() ? ep->rx_channel : NULL;
-
-        /* clear nak timeout bit */
-        rx_csr = musb_readw(epio, MUSB_RXCSR);
-        rx_csr |= MUSB_RXCSR_H_WZC_BITS;
-        rx_csr &= ~MUSB_RXCSR_DATAERROR;
-        musb_writew(epio, MUSB_RXCSR, rx_csr);
-
-        cur_qh = first_qh(&musb->in_bulk);
-        if (cur_qh) {
-                urb = next_urb(cur_qh);
-                if (dma_channel_status(dma) == MUSB_DMA_STATUS_BUSY) {
-                        dma->status = MUSB_DMA_STATUS_CORE_ABORT;
-                        musb->dma_controller->channel_abort(dma);
-                        urb->actual_length += dma->actual_len;
-                        dma->actual_len = 0L;
-                }
-                musb_save_toggle(cur_qh, 1, urb);
-
-                /* move cur_qh to end of queue */
-                list_move_tail(&cur_qh->ring, &musb->in_bulk);
-
-                /* get the next qh from musb->in_bulk */
-                next_qh = first_qh(&musb->in_bulk);
-
-                /* set rx_reinit and schedule the next qh */
-                ep->rx_reinit = 1;
-                musb_start_urb(musb, 1, next_qh);
-        }
-}
-
 /*
  * Service an RX interrupt for the given IN endpoint; docs cover bulk, iso,
  * and high-bandwidth IN transfer cases.
@@ -1442,6 +1532,8 @@ void musb_host_rx(struct musb *musb, u8 epnum)
         bool                    done = false;
         u32                     status;
         struct dma_channel      *dma;
+        static bool use_sg;
+        unsigned int sg_flags = SG_MITER_ATOMIC | SG_MITER_TO_SG;
 
         musb_ep_select(mbase, epnum);
 
@@ -1500,7 +1592,7 @@ void musb_host_rx(struct musb *musb, u8 epnum)
                         if (usb_pipebulk(urb->pipe)
                                         && qh->mux == 1
                                         && !list_is_singular(&musb->in_bulk)) {
-                                musb_bulk_rx_nak_timeout(musb, hw_ep);
+                                musb_bulk_nak_timeout(musb, hw_ep, 1);
                                 return;
                         }
                         musb_ep_select(mbase, epnum);
@@ -1756,10 +1848,43 @@ void musb_host_rx(struct musb *musb, u8 epnum)
 #endif  /* Mentor DMA */
 
                 if (!dma) {
+                        unsigned int received_len;
+
                         /* Unmap the buffer so that CPU can use it */
                         usb_hcd_unmap_urb_for_dma(musb_to_hcd(musb), urb);
-                        done = musb_host_packet_rx(musb, urb,
-                                        epnum, iso_err);
+
+                        /*
+                         * We need to map sg if the transfer_buffer is
+                         * NULL.
+                         */
+                        if (!urb->transfer_buffer) {
+                                use_sg = true;
+                                sg_miter_start(&qh->sg_miter, urb->sg, 1,
+                                                sg_flags);
+                        }
+
+                        if (use_sg) {
+                                if (!sg_miter_next(&qh->sg_miter)) {
+                                        dev_err(musb->controller, "error: sg list empty\n");
+                                        sg_miter_stop(&qh->sg_miter);
+                                        status = -EINVAL;
+                                        done = true;
+                                        goto finish;
+                                }
+                                urb->transfer_buffer = qh->sg_miter.addr;
+                                received_len = urb->actual_length;
+                                qh->offset = 0x0;
+                                done = musb_host_packet_rx(musb, urb, epnum,
+                                                iso_err);
+                                /* Calculate the number of bytes received */
+                                received_len = urb->actual_length -
+                                        received_len;
+                                qh->sg_miter.consumed = received_len;
+                                sg_miter_stop(&qh->sg_miter);
+                        } else {
+                                done = musb_host_packet_rx(musb, urb,
+                                                epnum, iso_err);
+                        }
                         dev_dbg(musb->controller, "read %spacket\n", done ? "last " : "");
                 }
         }
@@ -1768,6 +1893,9 @@ finish:
         urb->actual_length += xfer_len;
         qh->offset += xfer_len;
         if (done) {
+                if (use_sg)
+                        use_sg = false;
+
                 if (urb->status == -EINPROGRESS)
                         urb->status = status;
                 musb_advance_schedule(musb, urb, hw_ep, USB_DIR_IN);
@@ -1863,14 +1991,14 @@ static int musb_schedule(
                 else
                         head = &musb->out_bulk;
 
-                /* Enable bulk RX NAK timeout scheme when bulk requests are
+                /* Enable bulk RX/TX NAK timeout scheme when bulk requests are
                  * multiplexed.  This scheme doen't work in high speed to full
                  * speed scenario as NAK interrupts are not coming from a
                  * full speed device connected to a high speed device.
                  * NAK timeout interval is 8 (128 uframe or 16ms) for HS and
                  * 4 (8 frame or 8ms) for FS device.
                  */
-                if (is_in && qh->dev)
+                if (qh->dev)
                         qh->intv_reg =
                                 (USB_SPEED_HIGH == qh->dev->speed) ? 8 : 4;
                 goto success;
diff --git a/drivers/usb/musb/musb_host.h b/drivers/usb/musb/musb_host.h
index 622d09fb9aba..5a9c8feec10c 100644
--- a/drivers/usb/musb/musb_host.h
+++ b/drivers/usb/musb/musb_host.h
@@ -35,6 +35,8 @@
 #ifndef _MUSB_HOST_H
 #define _MUSB_HOST_H
 
+#include <linux/scatterlist.h>
+
 static inline struct usb_hcd *musb_to_hcd(struct musb *musb)
 {
         return container_of((void *) musb, struct usb_hcd, hcd_priv);
@@ -71,6 +73,7 @@ struct musb_qh {
         u16                     maxpacket;
         u16                     frame;          /* for periodic schedule */
         unsigned                iso_idx;        /* in urb->iso_frame_desc[] */
+        struct sg_mapping_iter sg_miter;        /* for highmem in PIO mode */
 };
 
 /* map from control or bulk queue head to the first qh on that ring */
diff --git a/drivers/usb/musb/musb_virthub.c b/drivers/usb/musb/musb_virthub.c
index 22ec3e379980..f70579154ded 100644
--- a/drivers/usb/musb/musb_virthub.c
+++ b/drivers/usb/musb/musb_virthub.c
@@ -81,8 +81,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                 switch (musb->xceiv->state) {
                 case OTG_STATE_A_HOST:
                         musb->xceiv->state = OTG_STATE_A_SUSPEND;
-                        musb->is_active = is_otg_enabled(musb)
-                                        && otg->host->b_hnp_enable;
+                        musb->is_active = otg->host->b_hnp_enable;
                         if (musb->is_active)
                                 mod_timer(&musb->otg_timer, jiffies
                                         + msecs_to_jiffies(
@@ -91,8 +90,7 @@ static void musb_port_suspend(struct musb *musb, bool do_suspend)
                         break;
                 case OTG_STATE_B_HOST:
                         musb->xceiv->state = OTG_STATE_B_WAIT_ACON;
-                        musb->is_active = is_otg_enabled(musb)
-                                        && otg->host->b_hnp_enable;
+                        musb->is_active = otg->host->b_hnp_enable;
                         musb_platform_try_idle(musb, 0);
                         break;
                 default:
@@ -190,8 +188,7 @@ void musb_root_disconnect(struct musb *musb)
 
         switch (musb->xceiv->state) {
         case OTG_STATE_A_SUSPEND:
-                if (is_otg_enabled(musb)
-                                && otg->host->b_hnp_enable) {
+                if (otg->host->b_hnp_enable) {
                         musb->xceiv->state = OTG_STATE_A_PERIPHERAL;
                         musb->g.is_a_peripheral = 1;
                         break;
@@ -273,7 +270,7 @@ int musb_hub_control(
                         musb_port_suspend(musb, false);
                         break;
                 case USB_PORT_FEAT_POWER:
-                        if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
+                        if (!hcd->self.is_b_host)
                                 musb_platform_set_vbus(musb, 0);
                         break;
                 case USB_PORT_FEAT_C_CONNECTION:
@@ -369,7 +366,7 @@ int musb_hub_control(
                          * initialization logic, e.g. for OTG, or change any
                          * logic relating to VBUS power-up.
                          */
-                        if (!(is_otg_enabled(musb) && hcd->self.is_b_host))
+                        if (!hcd->self.is_b_host)
                                 musb_start(musb);
                         break;
                 case USB_PORT_FEAT_RESET:
diff --git a/drivers/usb/musb/musbhsdma.c b/drivers/usb/musb/musbhsdma.c
index c1be687e00ec..0fc6ca6bc60a 100644
--- a/drivers/usb/musb/musbhsdma.c
+++ b/drivers/usb/musb/musbhsdma.c
@@ -380,7 +380,7 @@ void dma_controller_destroy(struct dma_controller *c)
         kfree(controller);
 }
 
-struct dma_controller *__init
+struct dma_controller *__devinit
 dma_controller_create(struct musb *musb, void __iomem *base)
 {
         struct musb_dma_controller *controller;
diff --git a/drivers/usb/musb/omap2430.c b/drivers/usb/musb/omap2430.c
index 5fdb9da8dd56..a538fe17a966 100644
--- a/drivers/usb/musb/omap2430.c
+++ b/drivers/usb/musb/omap2430.c
@@ -30,10 +30,12 @@
 #include <linux/init.h>
 #include <linux/list.h>
 #include <linux/io.h>
+#include <linux/of.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/pm_runtime.h>
 #include <linux/err.h>
+#include <linux/delay.h>
 #include <linux/usb/musb-omap.h>
 
 #include "musb_core.h"
@@ -44,6 +46,7 @@ struct omap2430_glue {
         struct platform_device  *musb;
         enum omap_musb_vbus_id_status status;
         struct work_struct      omap_musb_mailbox_work;
+        u32 __iomem             *control_otghs;
 };
 #define glue_to_musb(g)         platform_get_drvdata(g->musb)
 
@@ -51,6 +54,26 @@ struct omap2430_glue		*_glue;
 
 static struct timer_list musb_idle_timer;
 
+/**
+ * omap4_usb_phy_mailbox - write to usb otg mailbox
+ * @glue: struct omap2430_glue *
+ * @val: the value to be written to the mailbox
+ *
+ * On detection of a device (ID pin is grounded), this API should be called
+ * to set AVALID, VBUSVALID and ID pin is grounded.
+ *
+ * When OMAP is connected to a host (OMAP in device mode), this API
+ * is called to set AVALID, VBUSVALID and ID pin in high impedance.
+ *
+ * XXX: This function will be removed once we have a seperate driver for
+ * control module
+ */
+static void omap4_usb_phy_mailbox(struct omap2430_glue *glue, u32 val)
+{
+        if (glue->control_otghs)
+                writel(val, glue->control_otghs);
+}
+
 static void musb_do_idle(unsigned long _musb)
 {
         struct musb     *musb = (void *)_musb;
@@ -140,7 +163,6 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
         struct usb_otg  *otg = musb->xceiv->otg;
         u8              devctl;
         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
-        int ret = 1;
         /* HDRC controls CPEN, but beware current surges during device
          * connect.  They can trigger transient overcurrent conditions
          * that must be ignored.
@@ -150,6 +172,7 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
 
         if (is_on) {
                 if (musb->xceiv->state == OTG_STATE_A_IDLE) {
+                        int loops = 100;
                         /* start the session */
                         devctl |= MUSB_DEVCTL_SESSION;
                         musb_writeb(musb->mregs, MUSB_DEVCTL, devctl);
@@ -159,17 +182,18 @@ static void omap2430_musb_set_vbus(struct musb *musb, int is_on)
                          */
                         while (musb_readb(musb->mregs, MUSB_DEVCTL) & 0x80) {
 
+                                mdelay(5);
                                 cpu_relax();
 
-                                if (time_after(jiffies, timeout)) {
+                                if (time_after(jiffies, timeout)
+                                    || loops-- <= 0) {
                                         dev_err(musb->controller,
                                         "configured as A device timeout");
-                                        ret = -EINVAL;
                                         break;
                                 }
                         }
 
-                        if (ret && otg->set_vbus)
+                        if (otg->set_vbus)
                                 otg_set_vbus(otg, 1);
                 } else {
                         musb->is_active = 1;
@@ -245,6 +269,7 @@ EXPORT_SYMBOL_GPL(omap_musb_mailbox);
 
 static void omap_musb_set_mailbox(struct omap2430_glue *glue)
 {
+        u32 val;
         struct musb *musb = glue_to_musb(glue);
         struct device *dev = musb->controller;
         struct musb_hdrc_platform_data *pdata = dev->platform_data;
@@ -258,9 +283,10 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
                 otg->default_a = true;
                 musb->xceiv->state = OTG_STATE_A_IDLE;
                 musb->xceiv->last_event = USB_EVENT_ID;
-                if (!is_otg_enabled(musb) || musb->gadget_driver) {
+                if (musb->gadget_driver) {
                         pm_runtime_get_sync(dev);
-                        usb_phy_init(musb->xceiv);
+                        val = AVALID | VBUSVALID;
+                        omap4_usb_phy_mailbox(glue, val);
                         omap2430_musb_set_vbus(musb, 1);
                 }
                 break;
@@ -273,7 +299,8 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
                 musb->xceiv->last_event = USB_EVENT_VBUS;
                 if (musb->gadget_driver)
                         pm_runtime_get_sync(dev);
-                usb_phy_init(musb->xceiv);
+                val = IDDIG | AVALID | VBUSVALID;
+                omap4_usb_phy_mailbox(glue, val);
                 break;
 
         case OMAP_MUSB_ID_FLOAT:
@@ -281,17 +308,17 @@ static void omap_musb_set_mailbox(struct omap2430_glue *glue)
                 dev_dbg(dev, "VBUS Disconnect\n");
 
                 musb->xceiv->last_event = USB_EVENT_NONE;
-                if (is_otg_enabled(musb) || is_peripheral_enabled(musb))
-                        if (musb->gadget_driver) {
-                                pm_runtime_mark_last_busy(dev);
-                                pm_runtime_put_autosuspend(dev);
-                        }
+                if (musb->gadget_driver) {
+                        pm_runtime_mark_last_busy(dev);
+                        pm_runtime_put_autosuspend(dev);
+                }
 
                 if (data->interface_type == MUSB_INTERFACE_UTMI) {
                         if (musb->xceiv->otg->set_vbus)
                                 otg_set_vbus(musb->xceiv->otg, 0);
                 }
-                usb_phy_shutdown(musb->xceiv);
+                val = SESSEND | IDDIG;
+                omap4_usb_phy_mailbox(glue, val);
                 break;
         default:
                 dev_dbg(dev, "ID float\n");
@@ -366,6 +393,7 @@ err1:
 static void omap2430_musb_enable(struct musb *musb)
 {
         u8              devctl;
+        u32             val;
         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
         struct device *dev = musb->controller;
         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
@@ -375,7 +403,8 @@ static void omap2430_musb_enable(struct musb *musb)
         switch (glue->status) {
 
         case OMAP_MUSB_ID_GROUND:
-                usb_phy_init(musb->xceiv);
+                val = AVALID | VBUSVALID;
+                omap4_usb_phy_mailbox(glue, val);
                 if (data->interface_type != MUSB_INTERFACE_UTMI)
                         break;
                 devctl = musb_readb(musb->mregs, MUSB_DEVCTL);
@@ -394,7 +423,8 @@ static void omap2430_musb_enable(struct musb *musb)
                 break;
 
         case OMAP_MUSB_VBUS_VALID:
-                usb_phy_init(musb->xceiv);
+                val = IDDIG | AVALID | VBUSVALID;
+                omap4_usb_phy_mailbox(glue, val);
                 break;
 
         default:
@@ -404,11 +434,14 @@ static void omap2430_musb_enable(struct musb *musb)
 
 static void omap2430_musb_disable(struct musb *musb)
 {
+        u32 val;
         struct device *dev = musb->controller;
         struct omap2430_glue *glue = dev_get_drvdata(dev->parent);
 
-        if (glue->status != OMAP_MUSB_UNKNOWN)
-                usb_phy_shutdown(musb->xceiv);
+        if (glue->status != OMAP_MUSB_UNKNOWN) {
+                val = SESSEND | IDDIG;
+                omap4_usb_phy_mailbox(glue, val);
+        }
 }
 
 static int omap2430_musb_exit(struct musb *musb)
@@ -438,9 +471,14 @@ static u64 omap2430_dmamask = DMA_BIT_MASK(32);
 static int __devinit omap2430_probe(struct platform_device *pdev)
 {
         struct musb_hdrc_platform_data  *pdata = pdev->dev.platform_data;
+        struct omap_musb_board_data     *data;
         struct platform_device          *musb;
         struct omap2430_glue            *glue;
+        struct device_node              *np = pdev->dev.of_node;
+        struct musb_hdrc_config         *config;
+        struct resource                 *res;
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = devm_kzalloc(&pdev->dev, sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -448,12 +486,21 @@ static int __devinit omap2430_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err0;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err0;
+                goto err1;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &omap2430_dmamask;
         musb->dev.coherent_dma_mask     = omap2430_dmamask;
@@ -462,6 +509,48 @@ static int __devinit omap2430_probe(struct platform_device *pdev)
         glue->musb                      = musb;
         glue->status                    = OMAP_MUSB_UNKNOWN;
 
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+
+        glue->control_otghs = devm_request_and_ioremap(&pdev->dev, res);
+        if (glue->control_otghs == NULL)
+                dev_dbg(&pdev->dev, "Failed to obtain control memory\n");
+
+        if (np) {
+                pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
+                if (!pdata) {
+                        dev_err(&pdev->dev,
+                                "failed to allocate musb platfrom data\n");
+                        ret = -ENOMEM;
+                        goto err1;
+                }
+
+                data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
+                if (!data) {
+                        dev_err(&pdev->dev,
+                                        "failed to allocate musb board data\n");
+                        ret = -ENOMEM;
+                        goto err1;
+                }
+
+                config = devm_kzalloc(&pdev->dev, sizeof(*config), GFP_KERNEL);
+                if (!data) {
+                        dev_err(&pdev->dev,
+                                "failed to allocate musb hdrc config\n");
+                        goto err1;
+                }
+
+                of_property_read_u32(np, "mode", (u32 *)&pdata->mode);
+                of_property_read_u32(np, "interface_type",
+                                                (u32 *)&data->interface_type);
+                of_property_read_u32(np, "num_eps", (u32 *)&config->num_eps);
+                of_property_read_u32(np, "ram_bits", (u32 *)&config->ram_bits);
+                of_property_read_u32(np, "power", (u32 *)&pdata->power);
+                config->multipoint = of_property_read_bool(np, "multipoint");
+
+                pdata->board_data       = data;
+                pdata->config           = config;
+        }
+
         pdata->platform_ops             = &omap2430_ops;
 
         platform_set_drvdata(pdev, glue);
@@ -478,13 +567,13 @@ static int __devinit omap2430_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err1;
+                goto err2;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err1;
+                goto err2;
         }
 
         pm_runtime_enable(&pdev->dev);
@@ -492,14 +581,17 @@ static int __devinit omap2430_probe(struct platform_device *pdev)
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err1;
+                goto err2;
         }
 
         return 0;
 
-err1:
+err2:
         platform_device_put(musb);
 
+err1:
+        musb_put_id(&pdev->dev, musbid);
+
 err0:
         return ret;
 }
@@ -509,8 +601,8 @@ static int __devexit omap2430_remove(struct platform_device *pdev)
         struct omap2430_glue            *glue = platform_get_drvdata(pdev);
 
         cancel_work_sync(&glue->omap_musb_mailbox_work);
-        platform_device_del(glue->musb);
-        platform_device_put(glue->musb);
+        musb_put_id(&pdev->dev, glue->musb->id);
+        platform_device_unregister(glue->musb);
 
         return 0;
 }
@@ -559,12 +651,26 @@ static struct dev_pm_ops omap2430_pm_ops = {
 #define DEV_PM_OPS      NULL
 #endif
 
+#ifdef CONFIG_OF
+static const struct of_device_id omap2430_id_table[] = {
+        {
+                .compatible = "ti,omap4-musb"
+        },
+        {
+                .compatible = "ti,omap3-musb"
+        },
+        {},
+};
+MODULE_DEVICE_TABLE(of, omap2430_id_table);
+#endif
+
 static struct platform_driver omap2430_driver = {
         .probe          = omap2430_probe,
         .remove         = __devexit_p(omap2430_remove),
         .driver         = {
                 .name   = "musb-omap2430",
                 .pm     = DEV_PM_OPS,
+                .of_match_table = of_match_ptr(omap2430_id_table),
         },
 };
 
diff --git a/drivers/usb/musb/omap2430.h b/drivers/usb/musb/omap2430.h
index 40b3c02ae9f0..b85f3973e78c 100644
--- a/drivers/usb/musb/omap2430.h
+++ b/drivers/usb/musb/omap2430.h
@@ -49,4 +49,13 @@
 #define OTG_FORCESTDBY          0x414
 #       define  ENABLEFORCE             (1 << 0)
 
+/*
+ * Control Module bit definitions
+ * XXX: Will be removed once we have a driver for control module.
+ */
+#define AVALID                          BIT(0)
+#define BVALID                          BIT(1)
+#define VBUSVALID                       BIT(2)
+#define SESSEND                         BIT(3)
+#define IDDIG                           BIT(4)
 #endif  /* __MUSB_OMAP243X_H__ */
diff --git a/drivers/usb/musb/tusb6010.c b/drivers/usb/musb/tusb6010.c
index 341625442377..dc4d75ea13ad 100644
--- a/drivers/usb/musb/tusb6010.c
+++ b/drivers/usb/musb/tusb6010.c
@@ -24,6 +24,7 @@
 #include <linux/irq.h>
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
+#include <linux/usb/nop-usb-xceiv.h>
 
 #include "musb_core.h"
 
@@ -153,7 +154,7 @@ tusb_fifo_write_unaligned(void __iomem *fifo, const u8 *buf, u16 len)
 }
 
 static inline void tusb_fifo_read_unaligned(void __iomem *fifo,
-                                                void __iomem *buf, u16 len)
+                                                void *buf, u16 len)
 {
         u32             val;
         int             i;
@@ -437,14 +438,13 @@ static void musb_do_idle(unsigned long _musb)
                 if (is_host_active(musb) && (musb->port1_status >> 16))
                         goto done;
 
-                if (is_peripheral_enabled(musb) && !musb->gadget_driver) {
+                if (!musb->gadget_driver) {
                         wakeups = 0;
                 } else {
                         wakeups = TUSB_PRCM_WHOSTDISCON
                                 | TUSB_PRCM_WBUS
                                         | TUSB_PRCM_WVBUS;
-                        if (is_otg_enabled(musb))
-                                wakeups |= TUSB_PRCM_WID;
+                        wakeups |= TUSB_PRCM_WID;
                 }
                 tusb_allow_idle(musb, wakeups);
         }
@@ -582,21 +582,12 @@ static void tusb_musb_set_vbus(struct musb *musb, int is_on)
  *
  * Note that if a mini-A cable is plugged in the ID line will stay down as
  * the weak ID pull-up is not able to pull the ID up.
- *
- * REVISIT: It would be possible to add support for changing between host
- * and peripheral modes in non-OTG configurations by reconfiguring hardware
- * and then setting musb->board_mode. For now, only support OTG mode.
  */
 static int tusb_musb_set_mode(struct musb *musb, u8 musb_mode)
 {
         void __iomem    *tbase = musb->ctrl_base;
         u32             otg_stat, phy_otg_ctrl, phy_otg_ena, dev_conf;
 
-        if (musb->board_mode != MUSB_OTG) {
-                ERR("Changing mode currently only supported in OTG mode\n");
-                return -EINVAL;
-        }
-
         otg_stat = musb_readl(tbase, TUSB_DEV_OTG_STAT);
         phy_otg_ctrl = musb_readl(tbase, TUSB_PHY_OTG_CTRL);
         phy_otg_ena = musb_readl(tbase, TUSB_PHY_OTG_CTRL_ENABLE);
@@ -652,10 +643,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         if ((int_src & TUSB_INT_SRC_ID_STATUS_CHNG)) {
                 int     default_a;
 
-                if (is_otg_enabled(musb))
-                        default_a = !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS);
-                else
-                        default_a = is_host_enabled(musb);
+                default_a = !(otg_stat & TUSB_DEV_OTG_STAT_ID_STATUS);
                 dev_dbg(musb->controller, "Default-%c\n", default_a ? 'A' : 'B');
                 otg->default_a = default_a;
                 tusb_musb_set_vbus(musb, default_a);
@@ -669,8 +657,7 @@ tusb_otg_ints(struct musb *musb, u32 int_src, void __iomem *tbase)
         if (int_src & TUSB_INT_SRC_VBUS_SENSE_CHNG) {
 
                 /* B-dev state machine:  no vbus ~= disconnect */
-                if ((is_otg_enabled(musb) && !otg->default_a)
-                                || !is_host_enabled(musb)) {
+                if (!otg->default_a) {
                         /* ? musb_root_disconnect(musb); */
                         musb->port1_status &=
                                 ~(USB_PORT_STAT_CONNECTION
@@ -1119,10 +1106,8 @@ static int tusb_musb_init(struct musb *musb)
         }
         musb->isr = tusb_musb_interrupt;
 
-        if (is_peripheral_enabled(musb)) {
-                musb->xceiv->set_power = tusb_draw_power;
-                the_musb = musb;
-        }
+        musb->xceiv->set_power = tusb_draw_power;
+        the_musb = musb;
 
         setup_timer(&musb_idle_timer, musb_do_idle, (unsigned long) musb);
 
@@ -1175,6 +1160,7 @@ static int __devinit tusb_probe(struct platform_device *pdev)
         struct tusb6010_glue            *glue;
 
         int                             ret = -ENOMEM;
+        int                             musbid;
 
         glue = kzalloc(sizeof(*glue), GFP_KERNEL);
         if (!glue) {
@@ -1182,12 +1168,21 @@ static int __devinit tusb_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = &tusb_dmamask;
         musb->dev.coherent_dma_mask     = tusb_dmamask;
@@ -1203,26 +1198,29 @@ static int __devinit tusb_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err2;
+                goto err3;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err2;
+                goto err3;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err2;
+                goto err3;
         }
 
         return 0;
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -1234,6 +1232,7 @@ static int __devexit tusb_remove(struct platform_device *pdev)
 {
         struct tusb6010_glue            *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         kfree(glue);
diff --git a/drivers/usb/musb/tusb6010_omap.c b/drivers/usb/musb/tusb6010_omap.c
index b67b4bc596c1..53e25968ed0c 100644
--- a/drivers/usb/musb/tusb6010_omap.c
+++ b/drivers/usb/musb/tusb6010_omap.c
@@ -662,7 +662,7 @@ void dma_controller_destroy(struct dma_controller *c)
         kfree(tusb_dma);
 }
 
-struct dma_controller *__init
+struct dma_controller *__devinit
 dma_controller_create(struct musb *musb, void __iomem *base)
 {
         void __iomem            *tbase = musb->ctrl_base;
diff --git a/drivers/usb/musb/ux500.c b/drivers/usb/musb/ux500.c
index a8c0fadce1b0..d62a91fedc22 100644
--- a/drivers/usb/musb/ux500.c
+++ b/drivers/usb/musb/ux500.c
@@ -74,25 +74,34 @@ static int __devinit ux500_probe(struct platform_device *pdev)
                 goto err0;
         }
 
-        musb = platform_device_alloc("musb-hdrc", -1);
+        /* get the musb id */
+        musbid = musb_get_id(&pdev->dev, GFP_KERNEL);
+        if (musbid < 0) {
+                dev_err(&pdev->dev, "failed to allocate musb id\n");
+                ret = -ENOMEM;
+                goto err1;
+        }
+
+        musb = platform_device_alloc("musb-hdrc", musbid);
         if (!musb) {
                 dev_err(&pdev->dev, "failed to allocate musb device\n");
-                goto err1;
+                goto err2;
         }
 
         clk = clk_get(&pdev->dev, "usb");
         if (IS_ERR(clk)) {
                 dev_err(&pdev->dev, "failed to get clock\n");
                 ret = PTR_ERR(clk);
-                goto err2;
+                goto err3;
         }
 
         ret = clk_enable(clk);
         if (ret) {
                 dev_err(&pdev->dev, "failed to enable clock\n");
-                goto err3;
+                goto err4;
         }
 
+        musb->id                        = musbid;
         musb->dev.parent                = &pdev->dev;
         musb->dev.dma_mask              = pdev->dev.dma_mask;
         musb->dev.coherent_dma_mask     = pdev->dev.coherent_dma_mask;
@@ -109,32 +118,35 @@ static int __devinit ux500_probe(struct platform_device *pdev)
                         pdev->num_resources);
         if (ret) {
                 dev_err(&pdev->dev, "failed to add resources\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add_data(musb, pdata, sizeof(*pdata));
         if (ret) {
                 dev_err(&pdev->dev, "failed to add platform_data\n");
-                goto err4;
+                goto err5;
         }
 
         ret = platform_device_add(musb);
         if (ret) {
                 dev_err(&pdev->dev, "failed to register musb device\n");
-                goto err4;
+                goto err5;
         }
 
         return 0;
 
-err4:
+err5:
         clk_disable(clk);
 
-err3:
+err4:
         clk_put(clk);
 
-err2:
+err3:
         platform_device_put(musb);
 
+err2:
+        musb_put_id(&pdev->dev, musbid);
+
 err1:
         kfree(glue);
 
@@ -146,6 +158,7 @@ static int __devexit ux500_remove(struct platform_device *pdev)
 {
         struct ux500_glue       *glue = platform_get_drvdata(pdev);
 
+        musb_put_id(&pdev->dev, glue->musb->id);
         platform_device_del(glue->musb);
         platform_device_put(glue->musb);
         clk_disable(glue->clk);
diff --git a/drivers/usb/musb/ux500_dma.c b/drivers/usb/musb/ux500_dma.c
index d05c7fbbb703..639d58ee24f9 100644
--- a/drivers/usb/musb/ux500_dma.c
+++ b/drivers/usb/musb/ux500_dma.c
@@ -364,7 +364,7 @@ void dma_controller_destroy(struct dma_controller *c)
         kfree(controller);
 }
 
-struct dma_controller *__init
+struct dma_controller *__devinit
 dma_controller_create(struct musb *musb, void __iomem *base)
 {
         struct ux500_dma_controller *controller;
diff --git a/drivers/usb/otg/Kconfig b/drivers/usb/otg/Kconfig
index 13fd1ddf742f..d8c8a42bff3e 100644
--- a/drivers/usb/otg/Kconfig
+++ b/drivers/usb/otg/Kconfig
@@ -68,7 +68,7 @@ config TWL4030_USB
 
 config TWL6030_USB
         tristate "TWL6030 USB Transceiver Driver"
-        depends on TWL4030_CORE
+        depends on TWL4030_CORE && OMAP_USB2
         select USB_OTG_UTILS
         help
           Enable this to support the USB OTG transceiver on TWL6030
diff --git a/drivers/usb/otg/fsl_otg.c b/drivers/usb/otg/fsl_otg.c
index 23c798cb2d7f..c19d1d7173a9 100644
--- a/drivers/usb/otg/fsl_otg.c
+++ b/drivers/usb/otg/fsl_otg.c
@@ -544,9 +544,13 @@ int fsl_otg_start_gadget(struct otg_fsm *fsm, int on)
  */
 static int fsl_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
 {
-        struct fsl_otg *otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        struct fsl_otg *otg_dev;
+
+        if (!otg)
+                return -ENODEV;
 
-        if (!otg || otg_dev != fsl_otg_dev)
+        otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        if (otg_dev != fsl_otg_dev)
                 return -ENODEV;
 
         otg->host = host;
@@ -590,12 +594,15 @@ static int fsl_otg_set_host(struct usb_otg *otg, struct usb_bus *host)
 static int fsl_otg_set_peripheral(struct usb_otg *otg,
                                         struct usb_gadget *gadget)
 {
-        struct fsl_otg *otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        struct fsl_otg *otg_dev;
 
+        if (!otg)
+                return -ENODEV;
+
+        otg_dev = container_of(otg->phy, struct fsl_otg, phy);
         VDBG("otg_dev 0x%x\n", (int)otg_dev);
         VDBG("fsl_otg_dev 0x%x\n", (int)fsl_otg_dev);
-
-        if (!otg || otg_dev != fsl_otg_dev)
+        if (otg_dev != fsl_otg_dev)
                 return -ENODEV;
 
         if (!gadget) {
@@ -660,10 +667,13 @@ static void fsl_otg_event(struct work_struct *work)
 /* B-device start SRP */
 static int fsl_otg_start_srp(struct usb_otg *otg)
 {
-        struct fsl_otg *otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        struct fsl_otg *otg_dev;
+
+        if (!otg || otg->phy->state != OTG_STATE_B_IDLE)
+                return -ENODEV;
 
-        if (!otg || otg_dev != fsl_otg_dev
-            || otg->phy->state != OTG_STATE_B_IDLE)
+        otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        if (otg_dev != fsl_otg_dev)
                 return -ENODEV;
 
         otg_dev->fsm.b_bus_req = 1;
@@ -675,9 +685,13 @@ static int fsl_otg_start_srp(struct usb_otg *otg)
 /* A_host suspend will call this function to start hnp */
 static int fsl_otg_start_hnp(struct usb_otg *otg)
 {
-        struct fsl_otg *otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        struct fsl_otg *otg_dev;
+
+        if (!otg)
+                return -ENODEV;
 
-        if (!otg || otg_dev != fsl_otg_dev)
+        otg_dev = container_of(otg->phy, struct fsl_otg, phy);
+        if (otg_dev != fsl_otg_dev)
                 return -ENODEV;
 
         DBG("start_hnp...n");
diff --git a/drivers/usb/otg/mxs-phy.c b/drivers/usb/otg/mxs-phy.c
index c1a67cb8e244..88db976647cf 100644
--- a/drivers/usb/otg/mxs-phy.c
+++ b/drivers/usb/otg/mxs-phy.c
@@ -20,6 +20,7 @@
 #include <linux/delay.h>
 #include <linux/err.h>
 #include <linux/io.h>
+#include <linux/workqueue.h>
 
 #define DRIVER_NAME "mxs_phy"
 
@@ -34,9 +35,16 @@
 #define BM_USBPHY_CTRL_ENUTMILEVEL2             BIT(14)
 #define BM_USBPHY_CTRL_ENHOSTDISCONDETECT       BIT(1)
 
+/*
+ * Amount of delay in miliseconds to safely enable ENHOSTDISCONDETECT bit
+ * so that connection and reset processing can be completed for the root hub.
+ */
+#define MXY_PHY_ENHOSTDISCONDETECT_DELAY        250
+
 struct mxs_phy {
         struct usb_phy phy;
         struct clk *clk;
+        struct delayed_work enhostdiscondetect_work;
 };
 
 #define to_mxs_phy(p) container_of((p), struct mxs_phy, phy)
@@ -62,6 +70,7 @@ static int mxs_phy_init(struct usb_phy *phy)
 
         clk_prepare_enable(mxs_phy->clk);
         mxs_phy_hw_init(mxs_phy);
+        INIT_DELAYED_WORK(&mxs_phy->enhostdiscondetect_work, NULL);
 
         return 0;
 }
@@ -76,13 +85,34 @@ static void mxs_phy_shutdown(struct usb_phy *phy)
         clk_disable_unprepare(mxs_phy->clk);
 }
 
+static void mxs_phy_enhostdiscondetect_delay(struct work_struct *ws)
+{
+        struct mxs_phy *mxs_phy = container_of(ws, struct mxs_phy,
+                                                enhostdiscondetect_work.work);
+
+        /* Enable HOSTDISCONDETECT after delay. */
+        dev_dbg(mxs_phy->phy.dev, "Setting ENHOSTDISCONDETECT\n");
+        writel_relaxed(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
+                                mxs_phy->phy.io_priv + HW_USBPHY_CTRL_SET);
+}
+
 static int mxs_phy_on_connect(struct usb_phy *phy, int port)
 {
+        struct mxs_phy *mxs_phy = to_mxs_phy(phy);
+
         dev_dbg(phy->dev, "Connect on port %d\n", port);
 
-        mxs_phy_hw_init(to_mxs_phy(phy));
-        writel_relaxed(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
-                        phy->io_priv + HW_USBPHY_CTRL_SET);
+        mxs_phy_hw_init(mxs_phy);
+
+        /*
+         * Delay enabling ENHOSTDISCONDETECT so that connection and
+         * reset processing can be completed for the root hub.
+         */
+        dev_dbg(phy->dev, "Delaying setting ENHOSTDISCONDETECT\n");
+        PREPARE_DELAYED_WORK(&mxs_phy->enhostdiscondetect_work,
+                        mxs_phy_enhostdiscondetect_delay);
+        schedule_delayed_work(&mxs_phy->enhostdiscondetect_work,
+                        msecs_to_jiffies(MXY_PHY_ENHOSTDISCONDETECT_DELAY));
 
         return 0;
 }
@@ -91,6 +121,8 @@ static int mxs_phy_on_disconnect(struct usb_phy *phy, int port)
 {
         dev_dbg(phy->dev, "Disconnect on port %d\n", port);
 
+        /* No need to delay before clearing ENHOSTDISCONDETECT. */
+        dev_dbg(phy->dev, "Clearing ENHOSTDISCONDETECT\n");
         writel_relaxed(BM_USBPHY_CTRL_ENHOSTDISCONDETECT,
                         phy->io_priv + HW_USBPHY_CTRL_CLR);
 
diff --git a/drivers/usb/otg/nop-usb-xceiv.c b/drivers/usb/otg/nop-usb-xceiv.c
index 803f958f4133..e52e35e7adaf 100644
--- a/drivers/usb/otg/nop-usb-xceiv.c
+++ b/drivers/usb/otg/nop-usb-xceiv.c
@@ -30,6 +30,7 @@
 #include <linux/platform_device.h>
 #include <linux/dma-mapping.h>
 #include <linux/usb/otg.h>
+#include <linux/usb/nop-usb-xceiv.h>
 #include <linux/slab.h>
 
 struct nop_usb_xceiv {
@@ -94,7 +95,9 @@ static int nop_set_host(struct usb_otg *otg, struct usb_bus *host)
 
 static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
 {
+        struct nop_usb_xceiv_platform_data *pdata = pdev->dev.platform_data;
         struct nop_usb_xceiv    *nop;
+        enum usb_phy_type       type = USB_PHY_TYPE_USB2;
         int err;
 
         nop = kzalloc(sizeof *nop, GFP_KERNEL);
@@ -107,6 +110,9 @@ static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        if (pdata)
+                type = pdata->type;
+
         nop->dev                = &pdev->dev;
         nop->phy.dev            = nop->dev;
         nop->phy.label          = "nop-xceiv";
@@ -117,7 +123,7 @@ static int __devinit nop_usb_xceiv_probe(struct platform_device *pdev)
         nop->phy.otg->set_host          = nop_set_host;
         nop->phy.otg->set_peripheral    = nop_set_peripheral;
 
-        err = usb_add_phy(&nop->phy, USB_PHY_TYPE_USB2);
+        err = usb_add_phy(&nop->phy, type);
         if (err) {
                 dev_err(&pdev->dev, "can't register transceiver, err: %d\n",
                         err);
diff --git a/drivers/usb/otg/otg.c b/drivers/usb/otg/otg.c
index 1bf60a22595c..a30c04115115 100644
--- a/drivers/usb/otg/otg.c
+++ b/drivers/usb/otg/otg.c
@@ -159,7 +159,7 @@ int usb_add_phy(struct usb_phy *x, enum usb_phy_type type)
         unsigned long   flags;
         struct usb_phy  *phy;
 
-        if (x && x->type != USB_PHY_TYPE_UNDEFINED) {
+        if (x->type != USB_PHY_TYPE_UNDEFINED) {
                 dev_err(x->dev, "not accepting initialized PHY %s\n", x->label);
                 return -EINVAL;
         }
diff --git a/drivers/usb/otg/twl4030-usb.c b/drivers/usb/otg/twl4030-usb.c
index 523cad5bfea9..f0d2e7530cfe 100644
--- a/drivers/usb/otg/twl4030-usb.c
+++ b/drivers/usb/otg/twl4030-usb.c
@@ -585,23 +585,28 @@ static int __devinit twl4030_usb_probe(struct platform_device *pdev)
         struct twl4030_usb      *twl;
         int                     status, err;
         struct usb_otg          *otg;
-
-        if (!pdata) {
-                dev_dbg(&pdev->dev, "platform_data not available\n");
-                return -EINVAL;
-        }
+        struct device_node      *np = pdev->dev.of_node;
 
         twl = devm_kzalloc(&pdev->dev, sizeof *twl, GFP_KERNEL);
         if (!twl)
                 return -ENOMEM;
 
+        if (np)
+                of_property_read_u32(np, "usb_mode",
+                                (enum twl4030_usb_mode *)&twl->usb_mode);
+        else if (pdata)
+                twl->usb_mode = pdata->usb_mode;
+        else {
+                dev_err(&pdev->dev, "twl4030 initialized without pdata\n");
+                return -EINVAL;
+        }
+
         otg = devm_kzalloc(&pdev->dev, sizeof *otg, GFP_KERNEL);
         if (!otg)
                 return -ENOMEM;
 
         twl->dev                = &pdev->dev;
         twl->irq                = platform_get_irq(pdev, 0);
-        twl->usb_mode           = pdata->usb_mode;
         twl->vbus_supplied      = false;
         twl->asleep             = 1;
         twl->linkstat           = OMAP_MUSB_UNKNOWN;
@@ -690,12 +695,21 @@ static int __exit twl4030_usb_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id twl4030_usb_id_table[] = {
+        { .compatible = "ti,twl4030-usb" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, twl4030_usb_id_table);
+#endif
+
 static struct platform_driver twl4030_usb_driver = {
         .probe          = twl4030_usb_probe,
         .remove         = __exit_p(twl4030_usb_remove),
         .driver         = {
                 .name   = "twl4030_usb",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(twl4030_usb_id_table),
         },
 };
 
diff --git a/drivers/usb/otg/twl6030-usb.c b/drivers/usb/otg/twl6030-usb.c
index 6907d8df7a27..fcadef7864f1 100644
--- a/drivers/usb/otg/twl6030-usb.c
+++ b/drivers/usb/otg/twl6030-usb.c
@@ -25,8 +25,9 @@
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
-#include <linux/usb/otg.h>
 #include <linux/usb/musb-omap.h>
+#include <linux/usb/phy_companion.h>
+#include <linux/usb/omap_usb.h>
 #include <linux/i2c/twl.h>
 #include <linux/regulator/consumer.h>
 #include <linux/err.h>
@@ -87,7 +88,7 @@
 #define VBUS_DET                        BIT(2)
 
 struct twl6030_usb {
-        struct usb_phy          phy;
+        struct phy_companion    comparator;
         struct device           *dev;
 
         /* for vbus reporting with irqs disabled */
@@ -104,10 +105,10 @@ struct twl6030_usb {
         u8                      asleep;
         bool                    irq_enabled;
         bool                    vbus_enable;
-        unsigned long           features;
+        const char              *regulator;
 };
 
-#define phy_to_twl(x)           container_of((x), struct twl6030_usb, phy)
+#define comparator_to_twl(x) container_of((x), struct twl6030_usb, comparator)
 
 /*-------------------------------------------------------------------------*/
 
@@ -137,50 +138,9 @@ static inline u8 twl6030_readb(struct twl6030_usb *twl, u8 module, u8 address)
         return ret;
 }
 
-static int twl6030_phy_init(struct usb_phy *x)
+static int twl6030_start_srp(struct phy_companion *comparator)
 {
-        struct twl6030_usb *twl;
-        struct device *dev;
-        struct twl4030_usb_data *pdata;
-
-        twl = phy_to_twl(x);
-        dev  = twl->dev;
-        pdata = dev->platform_data;
-
-        if (twl->linkstat == OMAP_MUSB_ID_GROUND)
-                pdata->phy_power(twl->dev, 1, 1);
-        else
-                pdata->phy_power(twl->dev, 0, 1);
-
-        return 0;
-}
-
-static void twl6030_phy_shutdown(struct usb_phy *x)
-{
-        struct twl6030_usb *twl;
-        struct device *dev;
-        struct twl4030_usb_data *pdata;
-
-        twl = phy_to_twl(x);
-        dev  = twl->dev;
-        pdata = dev->platform_data;
-        pdata->phy_power(twl->dev, 0, 0);
-}
-
-static int twl6030_phy_suspend(struct usb_phy *x, int suspend)
-{
-        struct twl6030_usb *twl = phy_to_twl(x);
-        struct device *dev = twl->dev;
-        struct twl4030_usb_data *pdata = dev->platform_data;
-
-        pdata->phy_suspend(dev, suspend);
-
-        return 0;
-}
-
-static int twl6030_start_srp(struct usb_otg *otg)
-{
-        struct twl6030_usb *twl = phy_to_twl(otg->phy);
+        struct twl6030_usb *twl = comparator_to_twl(comparator);
 
         twl6030_writeb(twl, TWL_MODULE_USB, 0x24, USB_VBUS_CTRL_SET);
         twl6030_writeb(twl, TWL_MODULE_USB, 0x84, USB_VBUS_CTRL_SET);
@@ -193,13 +153,6 @@ static int twl6030_start_srp(struct usb_otg *otg)
 
 static int twl6030_usb_ldo_init(struct twl6030_usb *twl)
 {
-        char *regulator_name;
-
-        if (twl->features & TWL6025_SUBCLASS)
-                regulator_name = "ldousb";
-        else
-                regulator_name = "vusb";
-
         /* Set to OTG_REV 1.3 and turn on the ID_WAKEUP_COMP */
         twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x1, TWL6030_BACKUP_REG);
 
@@ -209,7 +162,7 @@ static int twl6030_usb_ldo_init(struct twl6030_usb *twl)
         /* Program MISC2 register and set bit VUSB_IN_VBAT */
         twl6030_writeb(twl, TWL6030_MODULE_ID0 , 0x10, TWL6030_MISC2);
 
-        twl->usb3v3 = regulator_get(twl->dev, regulator_name);
+        twl->usb3v3 = regulator_get(twl->dev, twl->regulator);
         if (IS_ERR(twl->usb3v3))
                 return -ENODEV;
 
@@ -313,23 +266,8 @@ static irqreturn_t twl6030_usbotg_irq(int irq, void *_twl)
         return IRQ_HANDLED;
 }
 
-static int twl6030_set_peripheral(struct usb_otg *otg,
-                struct usb_gadget *gadget)
-{
-        if (!otg)
-                return -ENODEV;
-
-        otg->gadget = gadget;
-        if (!gadget)
-                otg->phy->state = OTG_STATE_UNDEFINED;
-
-        return 0;
-}
-
-static int twl6030_enable_irq(struct usb_phy *x)
+static int twl6030_enable_irq(struct twl6030_usb *twl)
 {
-        struct twl6030_usb *twl = phy_to_twl(x);
-
         twl6030_writeb(twl, TWL_MODULE_USB, 0x1, USB_ID_INT_EN_HI_SET);
         twl6030_interrupt_unmask(0x05, REG_INT_MSK_LINE_C);
         twl6030_interrupt_unmask(0x05, REG_INT_MSK_STS_C);
@@ -362,9 +300,9 @@ static void otg_set_vbus_work(struct work_struct *data)
                                                         CHARGERUSB_CTRL1);
 }
 
-static int twl6030_set_vbus(struct usb_otg *otg, bool enabled)
+static int twl6030_set_vbus(struct phy_companion *comparator, bool enabled)
 {
-        struct twl6030_usb *twl = phy_to_twl(otg->phy);
+        struct twl6030_usb *twl = comparator_to_twl(comparator);
 
         twl->vbus_enable = enabled;
         schedule_work(&twl->set_vbus_work);
@@ -372,52 +310,44 @@ static int twl6030_set_vbus(struct usb_otg *otg, bool enabled)
         return 0;
 }
 
-static int twl6030_set_host(struct usb_otg *otg, struct usb_bus *host)
-{
-        if (!otg)
-                return -ENODEV;
-
-        otg->host = host;
-        if (!host)
-                otg->phy->state = OTG_STATE_UNDEFINED;
-        return 0;
-}
-
 static int __devinit twl6030_usb_probe(struct platform_device *pdev)
 {
+        u32 ret;
         struct twl6030_usb      *twl;
         int                     status, err;
-        struct twl4030_usb_data *pdata;
-        struct usb_otg          *otg;
-        struct device *dev = &pdev->dev;
-        pdata = dev->platform_data;
+        struct device_node      *np = pdev->dev.of_node;
+        struct device           *dev = &pdev->dev;
+        struct twl4030_usb_data *pdata = dev->platform_data;
 
         twl = devm_kzalloc(dev, sizeof *twl, GFP_KERNEL);
         if (!twl)
                 return -ENOMEM;
 
-        otg = devm_kzalloc(dev, sizeof *otg, GFP_KERNEL);
-        if (!otg)
-                return -ENOMEM;
-
         twl->dev                = &pdev->dev;
         twl->irq1               = platform_get_irq(pdev, 0);
         twl->irq2               = platform_get_irq(pdev, 1);
-        twl->features           = pdata->features;
         twl->linkstat           = OMAP_MUSB_UNKNOWN;
 
-        twl->phy.dev            = twl->dev;
-        twl->phy.label          = "twl6030";
-        twl->phy.otg            = otg;
-        twl->phy.init           = twl6030_phy_init;
-        twl->phy.shutdown       = twl6030_phy_shutdown;
-        twl->phy.set_suspend    = twl6030_phy_suspend;
+        twl->comparator.set_vbus        = twl6030_set_vbus;
+        twl->comparator.start_srp       = twl6030_start_srp;
+
+        ret = omap_usb2_set_comparator(&twl->comparator);
+        if (ret == -ENODEV) {
+                dev_info(&pdev->dev, "phy not ready, deferring probe");
+                return -EPROBE_DEFER;
+        }
 
-        otg->phy                = &twl->phy;
-        otg->set_host           = twl6030_set_host;
-        otg->set_peripheral     = twl6030_set_peripheral;
-        otg->set_vbus           = twl6030_set_vbus;
-        otg->start_srp          = twl6030_start_srp;
+        if (np) {
+                twl->regulator = "usb";
+        } else if (pdata) {
+                if (pdata->features & TWL6025_SUBCLASS)
+                        twl->regulator = "ldousb";
+                else
+                        twl->regulator = "vusb";
+        } else {
+                dev_err(&pdev->dev, "twl6030 initialized without pdata\n");
+                return -EINVAL;
+        }
 
         /* init spinlock for workqueue */
         spin_lock_init(&twl->lock);
@@ -427,7 +357,6 @@ static int __devinit twl6030_usb_probe(struct platform_device *pdev)
                 dev_err(&pdev->dev, "ldo init failed\n");
                 return err;
         }
-        usb_add_phy(&twl->phy, USB_PHY_TYPE_USB2);
 
         platform_set_drvdata(pdev, twl);
         if (device_create_file(&pdev->dev, &dev_attr_vbus))
@@ -458,9 +387,7 @@ static int __devinit twl6030_usb_probe(struct platform_device *pdev)
         }
 
         twl->asleep = 0;
-        pdata->phy_init(dev);
-        twl6030_phy_suspend(&twl->phy, 0);
-        twl6030_enable_irq(&twl->phy);
+        twl6030_enable_irq(twl);
         dev_info(&pdev->dev, "Initialized TWL6030 USB module\n");
 
         return 0;
@@ -470,10 +397,6 @@ static int __exit twl6030_usb_remove(struct platform_device *pdev)
 {
         struct twl6030_usb *twl = platform_get_drvdata(pdev);
 
-        struct twl4030_usb_data *pdata;
-        struct device *dev = &pdev->dev;
-        pdata = dev->platform_data;
-
         twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
                 REG_INT_MSK_LINE_C);
         twl6030_interrupt_mask(TWL6030_USBOTG_INT_MASK,
@@ -481,19 +404,27 @@ static int __exit twl6030_usb_remove(struct platform_device *pdev)
         free_irq(twl->irq1, twl);
         free_irq(twl->irq2, twl);
         regulator_put(twl->usb3v3);
-        pdata->phy_exit(twl->dev);
         device_remove_file(twl->dev, &dev_attr_vbus);
         cancel_work_sync(&twl->set_vbus_work);
 
         return 0;
 }
 
+#ifdef CONFIG_OF
+static const struct of_device_id twl6030_usb_id_table[] = {
+        { .compatible = "ti,twl6030-usb" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, twl6030_usb_id_table);
+#endif
+
 static struct platform_driver twl6030_usb_driver = {
         .probe          = twl6030_usb_probe,
         .remove         = __exit_p(twl6030_usb_remove),
         .driver         = {
                 .name   = "twl6030_usb",
                 .owner  = THIS_MODULE,
+                .of_match_table = of_match_ptr(twl6030_usb_id_table),
         },
 };
 
diff --git a/drivers/usb/phy/Kconfig b/drivers/usb/phy/Kconfig
index e7cf84f0751a..63c339b3e676 100644
--- a/drivers/usb/phy/Kconfig
+++ b/drivers/usb/phy/Kconfig
@@ -4,6 +4,15 @@
 comment "USB Physical Layer drivers"
         depends on USB || USB_GADGET
 
+config OMAP_USB2
+        tristate "OMAP USB2 PHY Driver"
+        select USB_OTG_UTILS
+        help
+          Enable this to support the transceiver that is part of SOC. This
+          driver takes care of all the PHY functionality apart from comparator.
+          The USB OTG controller communicates with the comparator using this
+          driver.
+
 config USB_ISP1301
         tristate "NXP ISP1301 USB transceiver support"
         depends on USB || USB_GADGET
@@ -15,3 +24,11 @@ config USB_ISP1301
 
           To compile this driver as a module, choose M here: the
           module will be called isp1301.
+
+config MV_U3D_PHY
+        bool "Marvell USB 3.0 PHY controller Driver"
+        depends on USB_MV_U3D
+        select USB_OTG_UTILS
+        help
+          Enable this to support Marvell USB 3.0 phy controller for Marvell
+          SoC.
diff --git a/drivers/usb/phy/Makefile b/drivers/usb/phy/Makefile
index eca095b1a890..b069f29f1225 100644
--- a/drivers/usb/phy/Makefile
+++ b/drivers/usb/phy/Makefile
@@ -4,4 +4,7 @@
 
 ccflags-$(CONFIG_USB_DEBUG) := -DDEBUG
 
+obj-$(CONFIG_OMAP_USB2)                 += omap-usb2.o
 obj-$(CONFIG_USB_ISP1301)               += isp1301.o
+obj-$(CONFIG_MV_U3D_PHY)                += mv_u3d_phy.o
+obj-$(CONFIG_USB_EHCI_TEGRA)    += tegra_usb_phy.o
diff --git a/drivers/usb/phy/isp1301.c b/drivers/usb/phy/isp1301.c
index b19f4932a037..18dbf7e37607 100644
--- a/drivers/usb/phy/isp1301.c
+++ b/drivers/usb/phy/isp1301.c
@@ -15,12 +15,6 @@
 
 #define DRV_NAME                "isp1301"
 
-#define ISP1301_I2C_ADDR        0x2C
-
-static const unsigned short normal_i2c[] = {
-        ISP1301_I2C_ADDR, ISP1301_I2C_ADDR + 1, I2C_CLIENT_END
-};
-
 static const struct i2c_device_id isp1301_id[] = {
         { "isp1301", 0 },
         { }
diff --git a/drivers/usb/phy/mv_u3d_phy.c b/drivers/usb/phy/mv_u3d_phy.c
new file mode 100644
index 000000000000..9f1c5d3c60ec
--- /dev/null
+++ b/drivers/usb/phy/mv_u3d_phy.c
@@ -0,0 +1,345 @@
+/*
+ * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/clk.h>
+#include <linux/delay.h>
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/usb/otg.h>
+#include <linux/platform_data/mv_usb.h>
+
+#include "mv_u3d_phy.h"
+
+/*
+ * struct mv_u3d_phy - transceiver driver state
+ * @phy: transceiver structure
+ * @dev: The parent device supplied to the probe function
+ * @clk: usb phy clock
+ * @base: usb phy register memory base
+ */
+struct mv_u3d_phy {
+        struct usb_phy  phy;
+        struct mv_usb_platform_data *plat;
+        struct device   *dev;
+        struct clk      *clk;
+        void __iomem    *base;
+};
+
+static u32 mv_u3d_phy_read(void __iomem *base, u32 reg)
+{
+        void __iomem *addr, *data;
+
+        addr = base;
+        data = base + 0x4;
+
+        writel_relaxed(reg, addr);
+        return readl_relaxed(data);
+}
+
+static void mv_u3d_phy_set(void __iomem *base, u32 reg, u32 value)
+{
+        void __iomem *addr, *data;
+        u32 tmp;
+
+        addr = base;
+        data = base + 0x4;
+
+        writel_relaxed(reg, addr);
+        tmp = readl_relaxed(data);
+        tmp |= value;
+        writel_relaxed(tmp, data);
+}
+
+static void mv_u3d_phy_clear(void __iomem *base, u32 reg, u32 value)
+{
+        void __iomem *addr, *data;
+        u32 tmp;
+
+        addr = base;
+        data = base + 0x4;
+
+        writel_relaxed(reg, addr);
+        tmp = readl_relaxed(data);
+        tmp &= ~value;
+        writel_relaxed(tmp, data);
+}
+
+static void mv_u3d_phy_write(void __iomem *base, u32 reg, u32 value)
+{
+        void __iomem *addr, *data;
+
+        addr = base;
+        data = base + 0x4;
+
+        writel_relaxed(reg, addr);
+        writel_relaxed(value, data);
+}
+
+void mv_u3d_phy_shutdown(struct usb_phy *phy)
+{
+        struct mv_u3d_phy *mv_u3d_phy;
+        void __iomem *base;
+        u32 val;
+
+        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
+        base = mv_u3d_phy->base;
+
+        /* Power down Reference Analog current, bit 15
+         * Power down PLL, bit 14
+         * Power down Receiver, bit 13
+         * Power down Transmitter, bit 12
+         * of USB3_POWER_PLL_CONTROL register
+         */
+        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
+        val &= ~(USB3_POWER_PLL_CONTROL_PU);
+        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
+
+        if (mv_u3d_phy->clk)
+                clk_disable(mv_u3d_phy->clk);
+}
+
+static int mv_u3d_phy_init(struct usb_phy *phy)
+{
+        struct mv_u3d_phy *mv_u3d_phy;
+        void __iomem *base;
+        u32 val, count;
+
+        /* enable usb3 phy */
+        mv_u3d_phy = container_of(phy, struct mv_u3d_phy, phy);
+
+        if (mv_u3d_phy->clk)
+                clk_enable(mv_u3d_phy->clk);
+
+        base = mv_u3d_phy->base;
+
+        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
+        val &= ~(USB3_POWER_PLL_CONTROL_PU_MASK);
+        val |= 0xF << USB3_POWER_PLL_CONTROL_PU_SHIFT;
+        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
+        udelay(100);
+
+        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
+                        USB3_RESET_CONTROL_RESET_PIPE);
+        udelay(100);
+
+        mv_u3d_phy_write(base, USB3_RESET_CONTROL,
+                        USB3_RESET_CONTROL_RESET_PIPE
+                        | USB3_RESET_CONTROL_RESET_PHY);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_POWER_PLL_CONTROL);
+        val &= ~(USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK
+                | USB3_POWER_PLL_CONTROL_PHY_MODE_MASK);
+        val |=  (USB3_PLL_25MHZ << USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT)
+                | (0x5 << USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT);
+        mv_u3d_phy_write(base, USB3_POWER_PLL_CONTROL, val);
+        udelay(100);
+
+        mv_u3d_phy_clear(base, USB3_KVCO_CALI_CONTROL,
+                USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_SQUELCH_FFE);
+        val &= ~(USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK
+                | USB3_SQUELCH_FFE_FFE_RES_SEL_MASK
+                | USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK);
+        val |= ((0xD << USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT)
+                | (0x7 << USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT)
+                | (0x8 << USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT));
+        mv_u3d_phy_write(base, USB3_SQUELCH_FFE, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_GEN1_SET0);
+        val &= ~USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK;
+        val |= 1 << USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT;
+        mv_u3d_phy_write(base, USB3_GEN1_SET0, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_GEN2_SET0);
+        val &= ~(USB3_GEN2_SET0_G2_TX_AMP_MASK
+                | USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK
+                | USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK);
+        val |= ((0x14 << USB3_GEN2_SET0_G2_TX_AMP_SHIFT)
+                | (1 << USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT)
+                | (0xA << USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT)
+                | (1 << USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT));
+        mv_u3d_phy_write(base, USB3_GEN2_SET0, val);
+        udelay(100);
+
+        mv_u3d_phy_read(base, USB3_TX_EMPPH);
+        val &= ~(USB3_TX_EMPPH_AMP_MASK
+                | USB3_TX_EMPPH_EN_MASK
+                | USB3_TX_EMPPH_AMP_FORCE_MASK
+                | USB3_TX_EMPPH_PAR1_MASK
+                | USB3_TX_EMPPH_PAR2_MASK);
+        val |= ((0xB << USB3_TX_EMPPH_AMP_SHIFT)
+                | (1 << USB3_TX_EMPPH_EN_SHIFT)
+                | (1 << USB3_TX_EMPPH_AMP_FORCE_SHIFT)
+                | (0x1C << USB3_TX_EMPPH_PAR1_SHIFT)
+                | (1 << USB3_TX_EMPPH_PAR2_SHIFT));
+
+        mv_u3d_phy_write(base, USB3_TX_EMPPH, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_GEN2_SET1);
+        val &= ~(USB3_GEN2_SET1_G2_RX_SELMUPI_MASK
+                | USB3_GEN2_SET1_G2_RX_SELMUPF_MASK
+                | USB3_GEN2_SET1_G2_RX_SELMUFI_MASK
+                | USB3_GEN2_SET1_G2_RX_SELMUFF_MASK);
+        val |= ((1 << USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT)
+                | (1 << USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT)
+                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT)
+                | (1 << USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT));
+        mv_u3d_phy_write(base, USB3_GEN2_SET1, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_DIGITAL_LOOPBACK_EN);
+        val &= ~USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK;
+        val |= 1 << USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT;
+        mv_u3d_phy_write(base, USB3_DIGITAL_LOOPBACK_EN, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_TX_SSC);
+        val &= ~USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK;
+        val |= 0xC << USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT;
+        mv_u3d_phy_write(base, USB3_IMPEDANCE_TX_SSC, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_IMPEDANCE_CALI_CTRL);
+        val &= ~USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK;
+        val |= 0x4 << USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT;
+        mv_u3d_phy_write(base, USB3_IMPEDANCE_CALI_CTRL, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_PHY_ISOLATION_MODE);
+        val &= ~(USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK
+                | USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK
+                | USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK);
+        val |= ((1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT)
+                | (1 << USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT));
+        mv_u3d_phy_write(base, USB3_PHY_ISOLATION_MODE, val);
+        udelay(100);
+
+        val = mv_u3d_phy_read(base, USB3_TXDETRX);
+        val &= ~(USB3_TXDETRX_VTHSEL_MASK);
+        val |= 0x1 << USB3_TXDETRX_VTHSEL_SHIFT;
+        mv_u3d_phy_write(base, USB3_TXDETRX, val);
+        udelay(100);
+
+        dev_dbg(mv_u3d_phy->dev, "start calibration\n");
+
+calstart:
+        /* Perform Manual Calibration */
+        mv_u3d_phy_set(base, USB3_KVCO_CALI_CONTROL,
+                1 << USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT);
+
+        mdelay(1);
+
+        count = 0;
+        while (1) {
+                val = mv_u3d_phy_read(base, USB3_KVCO_CALI_CONTROL);
+                if (val & (1 << USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT))
+                        break;
+                else if (count > 50) {
+                        dev_dbg(mv_u3d_phy->dev, "calibration failure, retry...\n");
+                        goto calstart;
+                }
+                count++;
+                mdelay(1);
+        }
+
+        /* active PIPE interface */
+        mv_u3d_phy_write(base, USB3_PIPE_SM_CTRL,
+                1 << USB3_PIPE_SM_CTRL_PHY_INIT_DONE);
+
+        return 0;
+}
+
+static int __devinit mv_u3d_phy_probe(struct platform_device *pdev)
+{
+        struct mv_u3d_phy *mv_u3d_phy;
+        struct mv_usb_platform_data *pdata;
+        struct device *dev = &pdev->dev;
+        struct resource *res;
+        void __iomem    *phy_base;
+        int     ret;
+
+        pdata = pdev->dev.platform_data;
+        if (!pdata) {
+                dev_err(&pdev->dev, "%s: no platform data defined\n", __func__);
+                return -EINVAL;
+        }
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                dev_err(dev, "missing mem resource\n");
+                return -ENODEV;
+        }
+
+        phy_base = devm_request_and_ioremap(dev, res);
+        if (!phy_base) {
+                dev_err(dev, "%s: register mapping failed\n", __func__);
+                return -ENXIO;
+        }
+
+        mv_u3d_phy = devm_kzalloc(dev, sizeof(*mv_u3d_phy), GFP_KERNEL);
+        if (!mv_u3d_phy)
+                return -ENOMEM;
+
+        mv_u3d_phy->dev                 = &pdev->dev;
+        mv_u3d_phy->plat                = pdata;
+        mv_u3d_phy->base                = phy_base;
+        mv_u3d_phy->phy.dev             = mv_u3d_phy->dev;
+        mv_u3d_phy->phy.label           = "mv-u3d-phy";
+        mv_u3d_phy->phy.init            = mv_u3d_phy_init;
+        mv_u3d_phy->phy.shutdown        = mv_u3d_phy_shutdown;
+
+        ret = usb_add_phy(&mv_u3d_phy->phy, USB_PHY_TYPE_USB3);
+        if (ret)
+                goto err;
+
+        if (!mv_u3d_phy->clk)
+                mv_u3d_phy->clk = clk_get(mv_u3d_phy->dev, "u3dphy");
+
+        platform_set_drvdata(pdev, mv_u3d_phy);
+
+        dev_info(&pdev->dev, "Initialized Marvell USB 3.0 PHY\n");
+err:
+        return ret;
+}
+
+static int __exit mv_u3d_phy_remove(struct platform_device *pdev)
+{
+        struct mv_u3d_phy *mv_u3d_phy = platform_get_drvdata(pdev);
+
+        usb_remove_phy(&mv_u3d_phy->phy);
+
+        if (mv_u3d_phy->clk) {
+                clk_put(mv_u3d_phy->clk);
+                mv_u3d_phy->clk = NULL;
+        }
+
+        return 0;
+}
+
+static struct platform_driver mv_u3d_phy_driver = {
+        .probe          = mv_u3d_phy_probe,
+        .remove         = __devexit_p(mv_u3d_phy_remove),
+        .driver         = {
+                .name   = "mv-u3d-phy",
+                .owner  = THIS_MODULE,
+        },
+};
+
+module_platform_driver(mv_u3d_phy_driver);
+MODULE_DESCRIPTION("Marvell USB 3.0 PHY controller");
+MODULE_AUTHOR("Yu Xu <yuxu@marvell.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:mv-u3d-phy");
diff --git a/drivers/usb/phy/mv_u3d_phy.h b/drivers/usb/phy/mv_u3d_phy.h
new file mode 100644
index 000000000000..2a658cb9a527
--- /dev/null
+++ b/drivers/usb/phy/mv_u3d_phy.h
@@ -0,0 +1,105 @@
+/*
+ * Copyright (C) 2011 Marvell International Ltd. All rights reserved.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ */
+
+#ifndef __MV_U3D_PHY_H
+#define __MV_U3D_PHY_H
+
+#define USB3_POWER_PLL_CONTROL          0x1
+#define USB3_KVCO_CALI_CONTROL          0x2
+#define USB3_IMPEDANCE_CALI_CTRL        0x3
+#define USB3_IMPEDANCE_TX_SSC           0x4
+#define USB3_SQUELCH_FFE                0x6
+#define USB3_GEN1_SET0                  0xD
+#define USB3_GEN2_SET0                  0xF
+#define USB3_GEN2_SET1                  0x10
+#define USB3_DIGITAL_LOOPBACK_EN        0x23
+#define USB3_PHY_ISOLATION_MODE         0x26
+#define USB3_TXDETRX                    0x48
+#define USB3_TX_EMPPH                   0x5E
+#define USB3_RESET_CONTROL              0x90
+#define USB3_PIPE_SM_CTRL               0x91
+
+#define USB3_RESET_CONTROL_RESET_PIPE                   0x1
+#define USB3_RESET_CONTROL_RESET_PHY                    0x2
+
+#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_MASK        (0x1F << 0)
+#define USB3_POWER_PLL_CONTROL_REF_FREF_SEL_SHIFT       0
+#define USB3_PLL_25MHZ                                  0x2
+#define USB3_PLL_26MHZ                                  0x5
+#define USB3_POWER_PLL_CONTROL_PHY_MODE_MASK            (0x7 << 5)
+#define USB3_POWER_PLL_CONTROL_PHY_MODE_SHIFT           5
+#define USB3_POWER_PLL_CONTROL_PU_MASK                  (0xF << 12)
+#define USB3_POWER_PLL_CONTROL_PU_SHIFT                 12
+#define USB3_POWER_PLL_CONTROL_PU                       (0xF << 12)
+
+#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_MASK    (0x1 << 12)
+#define USB3_KVCO_CALI_CONTROL_USE_MAX_PLL_RATE_SHIFT   12
+#define USB3_KVCO_CALI_CONTROL_CAL_DONE_SHIFT           14
+#define USB3_KVCO_CALI_CONTROL_CAL_START_SHIFT          15
+
+#define USB3_SQUELCH_FFE_FFE_CAP_SEL_MASK               0xF
+#define USB3_SQUELCH_FFE_FFE_CAP_SEL_SHIFT              0
+#define USB3_SQUELCH_FFE_FFE_RES_SEL_MASK               (0x7 << 4)
+#define USB3_SQUELCH_FFE_FFE_RES_SEL_SHIFT              4
+#define USB3_SQUELCH_FFE_SQ_THRESH_IN_MASK              (0x1F << 8)
+#define USB3_SQUELCH_FFE_SQ_THRESH_IN_SHIFT             8
+
+#define USB3_GEN1_SET0_G1_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
+#define USB3_GEN1_SET0_G1_TX_EMPH_EN_SHIFT              11
+
+#define USB3_GEN2_SET0_G2_TX_AMP_MASK                   (0x1F << 1)
+#define USB3_GEN2_SET0_G2_TX_AMP_SHIFT                  1
+#define USB3_GEN2_SET0_G2_TX_AMP_ADJ_SHIFT              6
+#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_MASK              (0xF << 7)
+#define USB3_GEN2_SET0_G2_TX_EMPH_AMP_SHIFT             7
+#define USB3_GEN2_SET0_G2_TX_EMPH_EN_MASK               (0x1 << 11)
+#define USB3_GEN2_SET0_G2_TX_EMPH_EN_SHIFT              11
+#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_MASK          (0x1 << 15)
+#define USB3_GEN2_SET0_G2_TX_SLEW_CTRL_EN_SHIFT         15
+
+#define USB3_GEN2_SET1_G2_RX_SELMUPI_MASK               (0x7 << 0)
+#define USB3_GEN2_SET1_G2_RX_SELMUPI_SHIFT              0
+#define USB3_GEN2_SET1_G2_RX_SELMUPF_MASK               (0x7 << 3)
+#define USB3_GEN2_SET1_G2_RX_SELMUPF_SHIFT              3
+#define USB3_GEN2_SET1_G2_RX_SELMUFI_MASK               (0x3 << 6)
+#define USB3_GEN2_SET1_G2_RX_SELMUFI_SHIFT              6
+#define USB3_GEN2_SET1_G2_RX_SELMUFF_MASK               (0x3 << 8)
+#define USB3_GEN2_SET1_G2_RX_SELMUFF_SHIFT              8
+
+#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_MASK          (0x3 << 10)
+#define USB3_DIGITAL_LOOPBACK_EN_SEL_BITS_SHIFT         10
+
+#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_MASK       (0x7 << 12)
+#define USB3_IMPEDANCE_CALI_CTRL_IMP_CAL_THR_SHIFT      12
+
+#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_MASK              (0x3F << 0)
+#define USB3_IMPEDANCE_TX_SSC_SSC_AMP_SHIFT             0
+
+#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_MASK         0xF
+#define USB3_PHY_ISOLATION_MODE_PHY_GEN_RX_SHIFT        0
+#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_MASK         (0xF << 4)
+#define USB3_PHY_ISOLATION_MODE_PHY_GEN_TX_SHIFT        4
+#define USB3_PHY_ISOLATION_MODE_TX_DRV_IDLE_MASK        (0x1 << 8)
+
+#define USB3_TXDETRX_VTHSEL_MASK                        (0x3 << 4)
+#define USB3_TXDETRX_VTHSEL_SHIFT                       4
+
+#define USB3_TX_EMPPH_AMP_MASK                          (0xF << 0)
+#define USB3_TX_EMPPH_AMP_SHIFT                         0
+#define USB3_TX_EMPPH_EN_MASK                           (0x1 << 6)
+#define USB3_TX_EMPPH_EN_SHIFT                          6
+#define USB3_TX_EMPPH_AMP_FORCE_MASK                    (0x1 << 7)
+#define USB3_TX_EMPPH_AMP_FORCE_SHIFT                   7
+#define USB3_TX_EMPPH_PAR1_MASK                         (0x1F << 8)
+#define USB3_TX_EMPPH_PAR1_SHIFT                        8
+#define USB3_TX_EMPPH_PAR2_MASK                         (0x1 << 13)
+#define USB3_TX_EMPPH_PAR2_SHIFT                        13
+
+#define USB3_PIPE_SM_CTRL_PHY_INIT_DONE                 15
+
+#endif /* __MV_U3D_PHY_H */
diff --git a/drivers/usb/phy/omap-usb2.c b/drivers/usb/phy/omap-usb2.c
new file mode 100644
index 000000000000..15ab3d6f2e8c
--- /dev/null
+++ b/drivers/usb/phy/omap-usb2.c
@@ -0,0 +1,271 @@
+/*
+ * omap-usb2.c - USB PHY, talking to musb controller in OMAP.
+ *
+ * Copyright (C) 2012 Texas Instruments Incorporated - http://www.ti.com
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * Author: Kishon Vijay Abraham I <kishon@ti.com>
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/module.h>
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/of.h>
+#include <linux/io.h>
+#include <linux/usb/omap_usb.h>
+#include <linux/usb/phy_companion.h>
+#include <linux/clk.h>
+#include <linux/err.h>
+#include <linux/pm_runtime.h>
+#include <linux/delay.h>
+
+/**
+ * omap_usb2_set_comparator - links the comparator present in the sytem with
+ *      this phy
+ * @comparator - the companion phy(comparator) for this phy
+ *
+ * The phy companion driver should call this API passing the phy_companion
+ * filled with set_vbus and start_srp to be used by usb phy.
+ *
+ * For use by phy companion driver
+ */
+int omap_usb2_set_comparator(struct phy_companion *comparator)
+{
+        struct omap_usb *phy;
+        struct usb_phy  *x = usb_get_phy(USB_PHY_TYPE_USB2);
+
+        if (IS_ERR(x))
+                return -ENODEV;
+
+        phy = phy_to_omapusb(x);
+        phy->comparator = comparator;
+        return 0;
+}
+EXPORT_SYMBOL_GPL(omap_usb2_set_comparator);
+
+/**
+ * omap_usb_phy_power - power on/off the phy using control module reg
+ * @phy: struct omap_usb *
+ * @on: 0 or 1, based on powering on or off the PHY
+ *
+ * XXX: Remove this function once control module driver gets merged
+ */
+static void omap_usb_phy_power(struct omap_usb *phy, int on)
+{
+        u32 val;
+
+        if (on) {
+                val = readl(phy->control_dev);
+                if (val & PHY_PD) {
+                        writel(~PHY_PD, phy->control_dev);
+                        /* XXX: add proper documentation for this delay */
+                        mdelay(200);
+                }
+        } else {
+                writel(PHY_PD, phy->control_dev);
+        }
+}
+
+static int omap_usb_set_vbus(struct usb_otg *otg, bool enabled)
+{
+        struct omap_usb *phy = phy_to_omapusb(otg->phy);
+
+        if (!phy->comparator)
+                return -ENODEV;
+
+        return phy->comparator->set_vbus(phy->comparator, enabled);
+}
+
+static int omap_usb_start_srp(struct usb_otg *otg)
+{
+        struct omap_usb *phy = phy_to_omapusb(otg->phy);
+
+        if (!phy->comparator)
+                return -ENODEV;
+
+        return phy->comparator->start_srp(phy->comparator);
+}
+
+static int omap_usb_set_host(struct usb_otg *otg, struct usb_bus *host)
+{
+        struct usb_phy  *phy = otg->phy;
+
+        otg->host = host;
+        if (!host)
+                phy->state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int omap_usb_set_peripheral(struct usb_otg *otg,
+                struct usb_gadget *gadget)
+{
+        struct usb_phy  *phy = otg->phy;
+
+        otg->gadget = gadget;
+        if (!gadget)
+                phy->state = OTG_STATE_UNDEFINED;
+
+        return 0;
+}
+
+static int omap_usb2_suspend(struct usb_phy *x, int suspend)
+{
+        u32 ret;
+        struct omap_usb *phy = phy_to_omapusb(x);
+
+        if (suspend && !phy->is_suspended) {
+                omap_usb_phy_power(phy, 0);
+                pm_runtime_put_sync(phy->dev);
+                phy->is_suspended = 1;
+        } else if (!suspend && phy->is_suspended) {
+                ret = pm_runtime_get_sync(phy->dev);
+                if (ret < 0) {
+                        dev_err(phy->dev, "get_sync failed with err %d\n",
+                                                                        ret);
+                        return ret;
+                }
+                omap_usb_phy_power(phy, 1);
+                phy->is_suspended = 0;
+        }
+
+        return 0;
+}
+
+static int __devinit omap_usb2_probe(struct platform_device *pdev)
+{
+        struct omap_usb                 *phy;
+        struct usb_otg                  *otg;
+        struct resource                 *res;
+
+        phy = devm_kzalloc(&pdev->dev, sizeof(*phy), GFP_KERNEL);
+        if (!phy) {
+                dev_err(&pdev->dev, "unable to allocate memory for USB2 PHY\n");
+                return -ENOMEM;
+        }
+
+        otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL);
+        if (!otg) {
+                dev_err(&pdev->dev, "unable to allocate memory for USB OTG\n");
+                return -ENOMEM;
+        }
+
+        phy->dev                = &pdev->dev;
+
+        phy->phy.dev            = phy->dev;
+        phy->phy.label          = "omap-usb2";
+        phy->phy.set_suspend    = omap_usb2_suspend;
+        phy->phy.otg            = otg;
+
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
+
+        phy->control_dev = devm_request_and_ioremap(&pdev->dev, res);
+        if (phy->control_dev == NULL) {
+                dev_err(&pdev->dev, "Failed to obtain io memory\n");
+                return -ENXIO;
+        }
+
+        phy->is_suspended       = 1;
+        omap_usb_phy_power(phy, 0);
+
+        otg->set_host           = omap_usb_set_host;
+        otg->set_peripheral     = omap_usb_set_peripheral;
+        otg->set_vbus           = omap_usb_set_vbus;
+        otg->start_srp          = omap_usb_start_srp;
+        otg->phy                = &phy->phy;
+
+        phy->wkupclk = devm_clk_get(phy->dev, "usb_phy_cm_clk32k");
+        if (IS_ERR(phy->wkupclk)) {
+                dev_err(&pdev->dev, "unable to get usb_phy_cm_clk32k\n");
+                return PTR_ERR(phy->wkupclk);
+        }
+        clk_prepare(phy->wkupclk);
+
+        usb_add_phy(&phy->phy, USB_PHY_TYPE_USB2);
+
+        platform_set_drvdata(pdev, phy);
+
+        pm_runtime_enable(phy->dev);
+
+        return 0;
+}
+
+static int __devexit omap_usb2_remove(struct platform_device *pdev)
+{
+        struct omap_usb *phy = platform_get_drvdata(pdev);
+
+        clk_unprepare(phy->wkupclk);
+        usb_remove_phy(&phy->phy);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM_RUNTIME
+
+static int omap_usb2_runtime_suspend(struct device *dev)
+{
+        struct platform_device  *pdev = to_platform_device(dev);
+        struct omap_usb *phy = platform_get_drvdata(pdev);
+
+        clk_disable(phy->wkupclk);
+
+        return 0;
+}
+
+static int omap_usb2_runtime_resume(struct device *dev)
+{
+        u32 ret = 0;
+        struct platform_device  *pdev = to_platform_device(dev);
+        struct omap_usb *phy = platform_get_drvdata(pdev);
+
+        ret = clk_enable(phy->wkupclk);
+        if (ret < 0)
+                dev_err(phy->dev, "Failed to enable wkupclk %d\n", ret);
+
+        return ret;
+}
+
+static const struct dev_pm_ops omap_usb2_pm_ops = {
+        SET_RUNTIME_PM_OPS(omap_usb2_runtime_suspend, omap_usb2_runtime_resume,
+                NULL)
+};
+
+#define DEV_PM_OPS     (&omap_usb2_pm_ops)
+#else
+#define DEV_PM_OPS     NULL
+#endif
+
+#ifdef CONFIG_OF
+static const struct of_device_id omap_usb2_id_table[] = {
+        { .compatible = "ti,omap-usb2" },
+        {}
+};
+MODULE_DEVICE_TABLE(of, omap_usb2_id_table);
+#endif
+
+static struct platform_driver omap_usb2_driver = {
+        .probe          = omap_usb2_probe,
+        .remove         = __devexit_p(omap_usb2_remove),
+        .driver         = {
+                .name   = "omap-usb2",
+                .owner  = THIS_MODULE,
+                .pm     = DEV_PM_OPS,
+                .of_match_table = of_match_ptr(omap_usb2_id_table),
+        },
+};
+
+module_platform_driver(omap_usb2_driver);
+
+MODULE_ALIAS("platform: omap_usb2");
+MODULE_AUTHOR("Texas Instruments Inc.");
+MODULE_DESCRIPTION("OMAP USB2 phy driver");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/phy/tegra_usb_phy.c b/drivers/usb/phy/tegra_usb_phy.c
new file mode 100644
index 000000000000..4739903245e8
--- /dev/null
+++ b/drivers/usb/phy/tegra_usb_phy.c
@@ -0,0 +1,839 @@
+/*
+ * Copyright (C) 2010 Google, Inc.
+ *
+ * Author:
+ *      Erik Gilling <konkers@google.com>
+ *      Benoit Goby <benoit@android.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/resource.h>
+#include <linux/delay.h>
+#include <linux/slab.h>
+#include <linux/err.h>
+#include <linux/export.h>
+#include <linux/platform_device.h>
+#include <linux/io.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/usb/otg.h>
+#include <linux/usb/ulpi.h>
+#include <asm/mach-types.h>
+#include <mach/gpio-tegra.h>
+#include <linux/usb/tegra_usb_phy.h>
+#include <mach/iomap.h>
+
+#define ULPI_VIEWPORT           0x170
+
+#define USB_PORTSC1             0x184
+#define   USB_PORTSC1_PTS(x)    (((x) & 0x3) << 30)
+#define   USB_PORTSC1_PSPD(x)   (((x) & 0x3) << 26)
+#define   USB_PORTSC1_PHCD      (1 << 23)
+#define   USB_PORTSC1_WKOC      (1 << 22)
+#define   USB_PORTSC1_WKDS      (1 << 21)
+#define   USB_PORTSC1_WKCN      (1 << 20)
+#define   USB_PORTSC1_PTC(x)    (((x) & 0xf) << 16)
+#define   USB_PORTSC1_PP        (1 << 12)
+#define   USB_PORTSC1_SUSP      (1 << 7)
+#define   USB_PORTSC1_PE        (1 << 2)
+#define   USB_PORTSC1_CCS       (1 << 0)
+
+#define USB_SUSP_CTRL           0x400
+#define   USB_WAKE_ON_CNNT_EN_DEV       (1 << 3)
+#define   USB_WAKE_ON_DISCON_EN_DEV     (1 << 4)
+#define   USB_SUSP_CLR          (1 << 5)
+#define   USB_PHY_CLK_VALID     (1 << 7)
+#define   UTMIP_RESET                   (1 << 11)
+#define   UHSIC_RESET                   (1 << 11)
+#define   UTMIP_PHY_ENABLE              (1 << 12)
+#define   ULPI_PHY_ENABLE       (1 << 13)
+#define   USB_SUSP_SET          (1 << 14)
+#define   USB_WAKEUP_DEBOUNCE_COUNT(x)  (((x) & 0x7) << 16)
+
+#define USB1_LEGACY_CTRL        0x410
+#define   USB1_NO_LEGACY_MODE                   (1 << 0)
+#define   USB1_VBUS_SENSE_CTL_MASK              (3 << 1)
+#define   USB1_VBUS_SENSE_CTL_VBUS_WAKEUP       (0 << 1)
+#define   USB1_VBUS_SENSE_CTL_AB_SESS_VLD_OR_VBUS_WAKEUP \
+                                                (1 << 1)
+#define   USB1_VBUS_SENSE_CTL_AB_SESS_VLD       (2 << 1)
+#define   USB1_VBUS_SENSE_CTL_A_SESS_VLD        (3 << 1)
+
+#define ULPI_TIMING_CTRL_0      0x424
+#define   ULPI_OUTPUT_PINMUX_BYP        (1 << 10)
+#define   ULPI_CLKOUT_PINMUX_BYP        (1 << 11)
+
+#define ULPI_TIMING_CTRL_1      0x428
+#define   ULPI_DATA_TRIMMER_LOAD        (1 << 0)
+#define   ULPI_DATA_TRIMMER_SEL(x)      (((x) & 0x7) << 1)
+#define   ULPI_STPDIRNXT_TRIMMER_LOAD   (1 << 16)
+#define   ULPI_STPDIRNXT_TRIMMER_SEL(x) (((x) & 0x7) << 17)
+#define   ULPI_DIR_TRIMMER_LOAD         (1 << 24)
+#define   ULPI_DIR_TRIMMER_SEL(x)       (((x) & 0x7) << 25)
+
+#define UTMIP_PLL_CFG1          0x804
+#define   UTMIP_XTAL_FREQ_COUNT(x)              (((x) & 0xfff) << 0)
+#define   UTMIP_PLLU_ENABLE_DLY_COUNT(x)        (((x) & 0x1f) << 27)
+
+#define UTMIP_XCVR_CFG0         0x808
+#define   UTMIP_XCVR_SETUP(x)                   (((x) & 0xf) << 0)
+#define   UTMIP_XCVR_LSRSLEW(x)                 (((x) & 0x3) << 8)
+#define   UTMIP_XCVR_LSFSLEW(x)                 (((x) & 0x3) << 10)
+#define   UTMIP_FORCE_PD_POWERDOWN              (1 << 14)
+#define   UTMIP_FORCE_PD2_POWERDOWN             (1 << 16)
+#define   UTMIP_FORCE_PDZI_POWERDOWN            (1 << 18)
+#define   UTMIP_XCVR_HSSLEW_MSB(x)              (((x) & 0x7f) << 25)
+
+#define UTMIP_BIAS_CFG0         0x80c
+#define   UTMIP_OTGPD                   (1 << 11)
+#define   UTMIP_BIASPD                  (1 << 10)
+
+#define UTMIP_HSRX_CFG0         0x810
+#define   UTMIP_ELASTIC_LIMIT(x)        (((x) & 0x1f) << 10)
+#define   UTMIP_IDLE_WAIT(x)            (((x) & 0x1f) << 15)
+
+#define UTMIP_HSRX_CFG1         0x814
+#define   UTMIP_HS_SYNC_START_DLY(x)    (((x) & 0x1f) << 1)
+
+#define UTMIP_TX_CFG0           0x820
+#define   UTMIP_FS_PREABMLE_J           (1 << 19)
+#define   UTMIP_HS_DISCON_DISABLE       (1 << 8)
+
+#define UTMIP_MISC_CFG0         0x824
+#define   UTMIP_DPDM_OBSERVE            (1 << 26)
+#define   UTMIP_DPDM_OBSERVE_SEL(x)     (((x) & 0xf) << 27)
+#define   UTMIP_DPDM_OBSERVE_SEL_FS_J   UTMIP_DPDM_OBSERVE_SEL(0xf)
+#define   UTMIP_DPDM_OBSERVE_SEL_FS_K   UTMIP_DPDM_OBSERVE_SEL(0xe)
+#define   UTMIP_DPDM_OBSERVE_SEL_FS_SE1 UTMIP_DPDM_OBSERVE_SEL(0xd)
+#define   UTMIP_DPDM_OBSERVE_SEL_FS_SE0 UTMIP_DPDM_OBSERVE_SEL(0xc)
+#define   UTMIP_SUSPEND_EXIT_ON_EDGE    (1 << 22)
+
+#define UTMIP_MISC_CFG1         0x828
+#define   UTMIP_PLL_ACTIVE_DLY_COUNT(x) (((x) & 0x1f) << 18)
+#define   UTMIP_PLLU_STABLE_COUNT(x)    (((x) & 0xfff) << 6)
+
+#define UTMIP_DEBOUNCE_CFG0     0x82c
+#define   UTMIP_BIAS_DEBOUNCE_A(x)      (((x) & 0xffff) << 0)
+
+#define UTMIP_BAT_CHRG_CFG0     0x830
+#define   UTMIP_PD_CHRG                 (1 << 0)
+
+#define UTMIP_SPARE_CFG0        0x834
+#define   FUSE_SETUP_SEL                (1 << 3)
+
+#define UTMIP_XCVR_CFG1         0x838
+#define   UTMIP_FORCE_PDDISC_POWERDOWN  (1 << 0)
+#define   UTMIP_FORCE_PDCHRP_POWERDOWN  (1 << 2)
+#define   UTMIP_FORCE_PDDR_POWERDOWN    (1 << 4)
+#define   UTMIP_XCVR_TERM_RANGE_ADJ(x)  (((x) & 0xf) << 18)
+
+#define UTMIP_BIAS_CFG1         0x83c
+#define   UTMIP_BIAS_PDTRK_COUNT(x)     (((x) & 0x1f) << 3)
+
+static DEFINE_SPINLOCK(utmip_pad_lock);
+static int utmip_pad_count;
+
+struct tegra_xtal_freq {
+        int freq;
+        u8 enable_delay;
+        u8 stable_count;
+        u8 active_delay;
+        u8 xtal_freq_count;
+        u16 debounce;
+};
+
+static const struct tegra_xtal_freq tegra_freq_table[] = {
+        {
+                .freq = 12000000,
+                .enable_delay = 0x02,
+                .stable_count = 0x2F,
+                .active_delay = 0x04,
+                .xtal_freq_count = 0x76,
+                .debounce = 0x7530,
+        },
+        {
+                .freq = 13000000,
+                .enable_delay = 0x02,
+                .stable_count = 0x33,
+                .active_delay = 0x05,
+                .xtal_freq_count = 0x7F,
+                .debounce = 0x7EF4,
+        },
+        {
+                .freq = 19200000,
+                .enable_delay = 0x03,
+                .stable_count = 0x4B,
+                .active_delay = 0x06,
+                .xtal_freq_count = 0xBB,
+                .debounce = 0xBB80,
+        },
+        {
+                .freq = 26000000,
+                .enable_delay = 0x04,
+                .stable_count = 0x66,
+                .active_delay = 0x09,
+                .xtal_freq_count = 0xFE,
+                .debounce = 0xFDE8,
+        },
+};
+
+static struct tegra_utmip_config utmip_default[] = {
+        [0] = {
+                .hssync_start_delay = 9,
+                .idle_wait_delay = 17,
+                .elastic_limit = 16,
+                .term_range_adj = 6,
+                .xcvr_setup = 9,
+                .xcvr_lsfslew = 1,
+                .xcvr_lsrslew = 1,
+        },
+        [2] = {
+                .hssync_start_delay = 9,
+                .idle_wait_delay = 17,
+                .elastic_limit = 16,
+                .term_range_adj = 6,
+                .xcvr_setup = 9,
+                .xcvr_lsfslew = 2,
+                .xcvr_lsrslew = 2,
+        },
+};
+
+static inline bool phy_is_ulpi(struct tegra_usb_phy *phy)
+{
+        return (phy->instance == 1);
+}
+
+static int utmip_pad_open(struct tegra_usb_phy *phy)
+{
+        phy->pad_clk = clk_get_sys("utmip-pad", NULL);
+        if (IS_ERR(phy->pad_clk)) {
+                pr_err("%s: can't get utmip pad clock\n", __func__);
+                return PTR_ERR(phy->pad_clk);
+        }
+
+        if (phy->instance == 0) {
+                phy->pad_regs = phy->regs;
+        } else {
+                phy->pad_regs = ioremap(TEGRA_USB_BASE, TEGRA_USB_SIZE);
+                if (!phy->pad_regs) {
+                        pr_err("%s: can't remap usb registers\n", __func__);
+                        clk_put(phy->pad_clk);
+                        return -ENOMEM;
+                }
+        }
+        return 0;
+}
+
+static void utmip_pad_close(struct tegra_usb_phy *phy)
+{
+        if (phy->instance != 0)
+                iounmap(phy->pad_regs);
+        clk_put(phy->pad_clk);
+}
+
+static void utmip_pad_power_on(struct tegra_usb_phy *phy)
+{
+        unsigned long val, flags;
+        void __iomem *base = phy->pad_regs;
+
+        clk_prepare_enable(phy->pad_clk);
+
+        spin_lock_irqsave(&utmip_pad_lock, flags);
+
+        if (utmip_pad_count++ == 0) {
+                val = readl(base + UTMIP_BIAS_CFG0);
+                val &= ~(UTMIP_OTGPD | UTMIP_BIASPD);
+                writel(val, base + UTMIP_BIAS_CFG0);
+        }
+
+        spin_unlock_irqrestore(&utmip_pad_lock, flags);
+
+        clk_disable_unprepare(phy->pad_clk);
+}
+
+static int utmip_pad_power_off(struct tegra_usb_phy *phy)
+{
+        unsigned long val, flags;
+        void __iomem *base = phy->pad_regs;
+
+        if (!utmip_pad_count) {
+                pr_err("%s: utmip pad already powered off\n", __func__);
+                return -EINVAL;
+        }
+
+        clk_prepare_enable(phy->pad_clk);
+
+        spin_lock_irqsave(&utmip_pad_lock, flags);
+
+        if (--utmip_pad_count == 0) {
+                val = readl(base + UTMIP_BIAS_CFG0);
+                val |= UTMIP_OTGPD | UTMIP_BIASPD;
+                writel(val, base + UTMIP_BIAS_CFG0);
+        }
+
+        spin_unlock_irqrestore(&utmip_pad_lock, flags);
+
+        clk_disable_unprepare(phy->pad_clk);
+
+        return 0;
+}
+
+static int utmi_wait_register(void __iomem *reg, u32 mask, u32 result)
+{
+        unsigned long timeout = 2000;
+        do {
+                if ((readl(reg) & mask) == result)
+                        return 0;
+                udelay(1);
+                timeout--;
+        } while (timeout);
+        return -1;
+}
+
+static void utmi_phy_clk_disable(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        if (phy->instance == 0) {
+                val = readl(base + USB_SUSP_CTRL);
+                val |= USB_SUSP_SET;
+                writel(val, base + USB_SUSP_CTRL);
+
+                udelay(10);
+
+                val = readl(base + USB_SUSP_CTRL);
+                val &= ~USB_SUSP_SET;
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        if (phy->instance == 2) {
+                val = readl(base + USB_PORTSC1);
+                val |= USB_PORTSC1_PHCD;
+                writel(val, base + USB_PORTSC1);
+        }
+
+        if (utmi_wait_register(base + USB_SUSP_CTRL, USB_PHY_CLK_VALID, 0) < 0)
+                pr_err("%s: timeout waiting for phy to stabilize\n", __func__);
+}
+
+static void utmi_phy_clk_enable(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        if (phy->instance == 0) {
+                val = readl(base + USB_SUSP_CTRL);
+                val |= USB_SUSP_CLR;
+                writel(val, base + USB_SUSP_CTRL);
+
+                udelay(10);
+
+                val = readl(base + USB_SUSP_CTRL);
+                val &= ~USB_SUSP_CLR;
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        if (phy->instance == 2) {
+                val = readl(base + USB_PORTSC1);
+                val &= ~USB_PORTSC1_PHCD;
+                writel(val, base + USB_PORTSC1);
+        }
+
+        if (utmi_wait_register(base + USB_SUSP_CTRL, USB_PHY_CLK_VALID,
+                                                     USB_PHY_CLK_VALID))
+                pr_err("%s: timeout waiting for phy to stabilize\n", __func__);
+}
+
+static int utmi_phy_power_on(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+        struct tegra_utmip_config *config = phy->config;
+
+        val = readl(base + USB_SUSP_CTRL);
+        val |= UTMIP_RESET;
+        writel(val, base + USB_SUSP_CTRL);
+
+        if (phy->instance == 0) {
+                val = readl(base + USB1_LEGACY_CTRL);
+                val |= USB1_NO_LEGACY_MODE;
+                writel(val, base + USB1_LEGACY_CTRL);
+        }
+
+        val = readl(base + UTMIP_TX_CFG0);
+        val &= ~UTMIP_FS_PREABMLE_J;
+        writel(val, base + UTMIP_TX_CFG0);
+
+        val = readl(base + UTMIP_HSRX_CFG0);
+        val &= ~(UTMIP_IDLE_WAIT(~0) | UTMIP_ELASTIC_LIMIT(~0));
+        val |= UTMIP_IDLE_WAIT(config->idle_wait_delay);
+        val |= UTMIP_ELASTIC_LIMIT(config->elastic_limit);
+        writel(val, base + UTMIP_HSRX_CFG0);
+
+        val = readl(base + UTMIP_HSRX_CFG1);
+        val &= ~UTMIP_HS_SYNC_START_DLY(~0);
+        val |= UTMIP_HS_SYNC_START_DLY(config->hssync_start_delay);
+        writel(val, base + UTMIP_HSRX_CFG1);
+
+        val = readl(base + UTMIP_DEBOUNCE_CFG0);
+        val &= ~UTMIP_BIAS_DEBOUNCE_A(~0);
+        val |= UTMIP_BIAS_DEBOUNCE_A(phy->freq->debounce);
+        writel(val, base + UTMIP_DEBOUNCE_CFG0);
+
+        val = readl(base + UTMIP_MISC_CFG0);
+        val &= ~UTMIP_SUSPEND_EXIT_ON_EDGE;
+        writel(val, base + UTMIP_MISC_CFG0);
+
+        val = readl(base + UTMIP_MISC_CFG1);
+        val &= ~(UTMIP_PLL_ACTIVE_DLY_COUNT(~0) | UTMIP_PLLU_STABLE_COUNT(~0));
+        val |= UTMIP_PLL_ACTIVE_DLY_COUNT(phy->freq->active_delay) |
+                UTMIP_PLLU_STABLE_COUNT(phy->freq->stable_count);
+        writel(val, base + UTMIP_MISC_CFG1);
+
+        val = readl(base + UTMIP_PLL_CFG1);
+        val &= ~(UTMIP_XTAL_FREQ_COUNT(~0) | UTMIP_PLLU_ENABLE_DLY_COUNT(~0));
+        val |= UTMIP_XTAL_FREQ_COUNT(phy->freq->xtal_freq_count) |
+                UTMIP_PLLU_ENABLE_DLY_COUNT(phy->freq->enable_delay);
+        writel(val, base + UTMIP_PLL_CFG1);
+
+        if (phy->mode == TEGRA_USB_PHY_MODE_DEVICE) {
+                val = readl(base + USB_SUSP_CTRL);
+                val &= ~(USB_WAKE_ON_CNNT_EN_DEV | USB_WAKE_ON_DISCON_EN_DEV);
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        utmip_pad_power_on(phy);
+
+        val = readl(base + UTMIP_XCVR_CFG0);
+        val &= ~(UTMIP_FORCE_PD_POWERDOWN | UTMIP_FORCE_PD2_POWERDOWN |
+                 UTMIP_FORCE_PDZI_POWERDOWN | UTMIP_XCVR_SETUP(~0) |
+                 UTMIP_XCVR_LSFSLEW(~0) | UTMIP_XCVR_LSRSLEW(~0) |
+                 UTMIP_XCVR_HSSLEW_MSB(~0));
+        val |= UTMIP_XCVR_SETUP(config->xcvr_setup);
+        val |= UTMIP_XCVR_LSFSLEW(config->xcvr_lsfslew);
+        val |= UTMIP_XCVR_LSRSLEW(config->xcvr_lsrslew);
+        writel(val, base + UTMIP_XCVR_CFG0);
+
+        val = readl(base + UTMIP_XCVR_CFG1);
+        val &= ~(UTMIP_FORCE_PDDISC_POWERDOWN | UTMIP_FORCE_PDCHRP_POWERDOWN |
+                 UTMIP_FORCE_PDDR_POWERDOWN | UTMIP_XCVR_TERM_RANGE_ADJ(~0));
+        val |= UTMIP_XCVR_TERM_RANGE_ADJ(config->term_range_adj);
+        writel(val, base + UTMIP_XCVR_CFG1);
+
+        val = readl(base + UTMIP_BAT_CHRG_CFG0);
+        val &= ~UTMIP_PD_CHRG;
+        writel(val, base + UTMIP_BAT_CHRG_CFG0);
+
+        val = readl(base + UTMIP_BIAS_CFG1);
+        val &= ~UTMIP_BIAS_PDTRK_COUNT(~0);
+        val |= UTMIP_BIAS_PDTRK_COUNT(0x5);
+        writel(val, base + UTMIP_BIAS_CFG1);
+
+        if (phy->instance == 0) {
+                val = readl(base + UTMIP_SPARE_CFG0);
+                if (phy->mode == TEGRA_USB_PHY_MODE_DEVICE)
+                        val &= ~FUSE_SETUP_SEL;
+                else
+                        val |= FUSE_SETUP_SEL;
+                writel(val, base + UTMIP_SPARE_CFG0);
+        }
+
+        if (phy->instance == 2) {
+                val = readl(base + USB_SUSP_CTRL);
+                val |= UTMIP_PHY_ENABLE;
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        val = readl(base + USB_SUSP_CTRL);
+        val &= ~UTMIP_RESET;
+        writel(val, base + USB_SUSP_CTRL);
+
+        if (phy->instance == 0) {
+                val = readl(base + USB1_LEGACY_CTRL);
+                val &= ~USB1_VBUS_SENSE_CTL_MASK;
+                val |= USB1_VBUS_SENSE_CTL_A_SESS_VLD;
+                writel(val, base + USB1_LEGACY_CTRL);
+
+                val = readl(base + USB_SUSP_CTRL);
+                val &= ~USB_SUSP_SET;
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        utmi_phy_clk_enable(phy);
+
+        if (phy->instance == 2) {
+                val = readl(base + USB_PORTSC1);
+                val &= ~USB_PORTSC1_PTS(~0);
+                writel(val, base + USB_PORTSC1);
+        }
+
+        return 0;
+}
+
+static int utmi_phy_power_off(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        utmi_phy_clk_disable(phy);
+
+        if (phy->mode == TEGRA_USB_PHY_MODE_DEVICE) {
+                val = readl(base + USB_SUSP_CTRL);
+                val &= ~USB_WAKEUP_DEBOUNCE_COUNT(~0);
+                val |= USB_WAKE_ON_CNNT_EN_DEV | USB_WAKEUP_DEBOUNCE_COUNT(5);
+                writel(val, base + USB_SUSP_CTRL);
+        }
+
+        val = readl(base + USB_SUSP_CTRL);
+        val |= UTMIP_RESET;
+        writel(val, base + USB_SUSP_CTRL);
+
+        val = readl(base + UTMIP_BAT_CHRG_CFG0);
+        val |= UTMIP_PD_CHRG;
+        writel(val, base + UTMIP_BAT_CHRG_CFG0);
+
+        val = readl(base + UTMIP_XCVR_CFG0);
+        val |= UTMIP_FORCE_PD_POWERDOWN | UTMIP_FORCE_PD2_POWERDOWN |
+               UTMIP_FORCE_PDZI_POWERDOWN;
+        writel(val, base + UTMIP_XCVR_CFG0);
+
+        val = readl(base + UTMIP_XCVR_CFG1);
+        val |= UTMIP_FORCE_PDDISC_POWERDOWN | UTMIP_FORCE_PDCHRP_POWERDOWN |
+               UTMIP_FORCE_PDDR_POWERDOWN;
+        writel(val, base + UTMIP_XCVR_CFG1);
+
+        return utmip_pad_power_off(phy);
+}
+
+static void utmi_phy_preresume(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        val = readl(base + UTMIP_TX_CFG0);
+        val |= UTMIP_HS_DISCON_DISABLE;
+        writel(val, base + UTMIP_TX_CFG0);
+}
+
+static void utmi_phy_postresume(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        val = readl(base + UTMIP_TX_CFG0);
+        val &= ~UTMIP_HS_DISCON_DISABLE;
+        writel(val, base + UTMIP_TX_CFG0);
+}
+
+static void utmi_phy_restore_start(struct tegra_usb_phy *phy,
+                                   enum tegra_usb_phy_port_speed port_speed)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        val = readl(base + UTMIP_MISC_CFG0);
+        val &= ~UTMIP_DPDM_OBSERVE_SEL(~0);
+        if (port_speed == TEGRA_USB_PHY_PORT_SPEED_LOW)
+                val |= UTMIP_DPDM_OBSERVE_SEL_FS_K;
+        else
+                val |= UTMIP_DPDM_OBSERVE_SEL_FS_J;
+        writel(val, base + UTMIP_MISC_CFG0);
+        udelay(1);
+
+        val = readl(base + UTMIP_MISC_CFG0);
+        val |= UTMIP_DPDM_OBSERVE;
+        writel(val, base + UTMIP_MISC_CFG0);
+        udelay(10);
+}
+
+static void utmi_phy_restore_end(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+
+        val = readl(base + UTMIP_MISC_CFG0);
+        val &= ~UTMIP_DPDM_OBSERVE;
+        writel(val, base + UTMIP_MISC_CFG0);
+        udelay(10);
+}
+
+static int ulpi_phy_power_on(struct tegra_usb_phy *phy)
+{
+        int ret;
+        unsigned long val;
+        void __iomem *base = phy->regs;
+        struct tegra_ulpi_config *config = phy->config;
+
+        gpio_direction_output(config->reset_gpio, 0);
+        msleep(5);
+        gpio_direction_output(config->reset_gpio, 1);
+
+        clk_prepare_enable(phy->clk);
+        msleep(1);
+
+        val = readl(base + USB_SUSP_CTRL);
+        val |= UHSIC_RESET;
+        writel(val, base + USB_SUSP_CTRL);
+
+        val = readl(base + ULPI_TIMING_CTRL_0);
+        val |= ULPI_OUTPUT_PINMUX_BYP | ULPI_CLKOUT_PINMUX_BYP;
+        writel(val, base + ULPI_TIMING_CTRL_0);
+
+        val = readl(base + USB_SUSP_CTRL);
+        val |= ULPI_PHY_ENABLE;
+        writel(val, base + USB_SUSP_CTRL);
+
+        val = 0;
+        writel(val, base + ULPI_TIMING_CTRL_1);
+
+        val |= ULPI_DATA_TRIMMER_SEL(4);
+        val |= ULPI_STPDIRNXT_TRIMMER_SEL(4);
+        val |= ULPI_DIR_TRIMMER_SEL(4);
+        writel(val, base + ULPI_TIMING_CTRL_1);
+        udelay(10);
+
+        val |= ULPI_DATA_TRIMMER_LOAD;
+        val |= ULPI_STPDIRNXT_TRIMMER_LOAD;
+        val |= ULPI_DIR_TRIMMER_LOAD;
+        writel(val, base + ULPI_TIMING_CTRL_1);
+
+        /* Fix VbusInvalid due to floating VBUS */
+        ret = usb_phy_io_write(phy->ulpi, 0x40, 0x08);
+        if (ret) {
+                pr_err("%s: ulpi write failed\n", __func__);
+                return ret;
+        }
+
+        ret = usb_phy_io_write(phy->ulpi, 0x80, 0x0B);
+        if (ret) {
+                pr_err("%s: ulpi write failed\n", __func__);
+                return ret;
+        }
+
+        val = readl(base + USB_PORTSC1);
+        val |= USB_PORTSC1_WKOC | USB_PORTSC1_WKDS | USB_PORTSC1_WKCN;
+        writel(val, base + USB_PORTSC1);
+
+        val = readl(base + USB_SUSP_CTRL);
+        val |= USB_SUSP_CLR;
+        writel(val, base + USB_SUSP_CTRL);
+        udelay(100);
+
+        val = readl(base + USB_SUSP_CTRL);
+        val &= ~USB_SUSP_CLR;
+        writel(val, base + USB_SUSP_CTRL);
+
+        return 0;
+}
+
+static int ulpi_phy_power_off(struct tegra_usb_phy *phy)
+{
+        unsigned long val;
+        void __iomem *base = phy->regs;
+        struct tegra_ulpi_config *config = phy->config;
+
+        /* Clear WKCN/WKDS/WKOC wake-on events that can cause the USB
+         * Controller to immediately bring the ULPI PHY out of low power
+         */
+        val = readl(base + USB_PORTSC1);
+        val &= ~(USB_PORTSC1_WKOC | USB_PORTSC1_WKDS | USB_PORTSC1_WKCN);
+        writel(val, base + USB_PORTSC1);
+
+        clk_disable(phy->clk);
+        return gpio_direction_output(config->reset_gpio, 0);
+}
+
+static int      tegra_phy_init(struct usb_phy *x)
+{
+        struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
+        struct tegra_ulpi_config *ulpi_config;
+        int err;
+
+        if (phy_is_ulpi(phy)) {
+                ulpi_config = phy->config;
+                phy->clk = clk_get_sys(NULL, ulpi_config->clk);
+                if (IS_ERR(phy->clk)) {
+                        pr_err("%s: can't get ulpi clock\n", __func__);
+                        err = -ENXIO;
+                        goto err1;
+                }
+                if (!gpio_is_valid(ulpi_config->reset_gpio))
+                        ulpi_config->reset_gpio =
+                                of_get_named_gpio(phy->dev->of_node,
+                                                  "nvidia,phy-reset-gpio", 0);
+                if (!gpio_is_valid(ulpi_config->reset_gpio)) {
+                        pr_err("%s: invalid reset gpio: %d\n", __func__,
+                               ulpi_config->reset_gpio);
+                        err = -EINVAL;
+                        goto err1;
+                }
+                gpio_request(ulpi_config->reset_gpio, "ulpi_phy_reset_b");
+                gpio_direction_output(ulpi_config->reset_gpio, 0);
+                phy->ulpi = otg_ulpi_create(&ulpi_viewport_access_ops, 0);
+                phy->ulpi->io_priv = phy->regs + ULPI_VIEWPORT;
+        } else {
+                err = utmip_pad_open(phy);
+                if (err < 0)
+                        goto err1;
+        }
+        return 0;
+err1:
+        clk_disable_unprepare(phy->pll_u);
+        clk_put(phy->pll_u);
+        return err;
+}
+
+static void tegra_usb_phy_close(struct usb_phy *x)
+{
+        struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
+
+        if (phy_is_ulpi(phy))
+                clk_put(phy->clk);
+        else
+                utmip_pad_close(phy);
+        clk_disable_unprepare(phy->pll_u);
+        clk_put(phy->pll_u);
+        kfree(phy);
+}
+
+static int tegra_usb_phy_power_on(struct tegra_usb_phy *phy)
+{
+        if (phy_is_ulpi(phy))
+                return ulpi_phy_power_on(phy);
+        else
+                return utmi_phy_power_on(phy);
+}
+
+static int tegra_usb_phy_power_off(struct tegra_usb_phy *phy)
+{
+        if (phy_is_ulpi(phy))
+                return ulpi_phy_power_off(phy);
+        else
+                return utmi_phy_power_off(phy);
+}
+
+static int      tegra_usb_phy_suspend(struct usb_phy *x, int suspend)
+{
+        struct tegra_usb_phy *phy = container_of(x, struct tegra_usb_phy, u_phy);
+        if (suspend)
+                return tegra_usb_phy_power_off(phy);
+        else
+                return tegra_usb_phy_power_on(phy);
+}
+
+struct tegra_usb_phy *tegra_usb_phy_open(struct device *dev, int instance,
+        void __iomem *regs, void *config, enum tegra_usb_phy_mode phy_mode)
+{
+        struct tegra_usb_phy *phy;
+        unsigned long parent_rate;
+        int i;
+        int err;
+
+        phy = kmalloc(sizeof(struct tegra_usb_phy), GFP_KERNEL);
+        if (!phy)
+                return ERR_PTR(-ENOMEM);
+
+        phy->instance = instance;
+        phy->regs = regs;
+        phy->config = config;
+        phy->mode = phy_mode;
+        phy->dev = dev;
+
+        if (!phy->config) {
+                if (phy_is_ulpi(phy)) {
+                        pr_err("%s: ulpi phy configuration missing", __func__);
+                        err = -EINVAL;
+                        goto err0;
+                } else {
+                        phy->config = &utmip_default[instance];
+                }
+        }
+
+        phy->pll_u = clk_get_sys(NULL, "pll_u");
+        if (IS_ERR(phy->pll_u)) {
+                pr_err("Can't get pll_u clock\n");
+                err = PTR_ERR(phy->pll_u);
+                goto err0;
+        }
+        clk_prepare_enable(phy->pll_u);
+
+        parent_rate = clk_get_rate(clk_get_parent(phy->pll_u));
+        for (i = 0; i < ARRAY_SIZE(tegra_freq_table); i++) {
+                if (tegra_freq_table[i].freq == parent_rate) {
+                        phy->freq = &tegra_freq_table[i];
+                        break;
+                }
+        }
+        if (!phy->freq) {
+                pr_err("invalid pll_u parent rate %ld\n", parent_rate);
+                err = -EINVAL;
+                goto err1;
+        }
+
+        phy->u_phy.init = tegra_phy_init;
+        phy->u_phy.shutdown = tegra_usb_phy_close;
+        phy->u_phy.set_suspend = tegra_usb_phy_suspend;
+
+        return phy;
+
+err1:
+        clk_disable_unprepare(phy->pll_u);
+        clk_put(phy->pll_u);
+err0:
+        kfree(phy);
+        return ERR_PTR(err);
+}
+EXPORT_SYMBOL_GPL(tegra_usb_phy_open);
+
+void tegra_usb_phy_preresume(struct tegra_usb_phy *phy)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_preresume(phy);
+}
+EXPORT_SYMBOL_GPL(tegra_usb_phy_preresume);
+
+void tegra_usb_phy_postresume(struct tegra_usb_phy *phy)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_postresume(phy);
+}
+EXPORT_SYMBOL_GPL(tegra_usb_phy_postresume);
+
+void tegra_ehci_phy_restore_start(struct tegra_usb_phy *phy,
+                                 enum tegra_usb_phy_port_speed port_speed)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_restore_start(phy, port_speed);
+}
+EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_start);
+
+void tegra_ehci_phy_restore_end(struct tegra_usb_phy *phy)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_restore_end(phy);
+}
+EXPORT_SYMBOL_GPL(tegra_ehci_phy_restore_end);
+
+void tegra_usb_phy_clk_disable(struct tegra_usb_phy *phy)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_clk_disable(phy);
+}
+EXPORT_SYMBOL_GPL(tegra_usb_phy_clk_disable);
+
+void tegra_usb_phy_clk_enable(struct tegra_usb_phy *phy)
+{
+        if (!phy_is_ulpi(phy))
+                utmi_phy_clk_enable(phy);
+}
+EXPORT_SYMBOL_GPL(tegra_usb_phy_clk_enable);
diff --git a/drivers/usb/renesas_usbhs/common.c b/drivers/usb/renesas_usbhs/common.c
index 681da06170c2..072edc1cc55f 100644
--- a/drivers/usb/renesas_usbhs/common.c
+++ b/drivers/usb/renesas_usbhs/common.c
@@ -432,17 +432,16 @@ static int usbhs_probe(struct platform_device *pdev)
         }
 
         /* usb private data */
-        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
+        priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
         if (!priv) {
                 dev_err(&pdev->dev, "Could not allocate priv\n");
                 return -ENOMEM;
         }
 
-        priv->base = ioremap_nocache(res->start, resource_size(res));
+        priv->base = devm_request_and_ioremap(&pdev->dev, res);
         if (!priv->base) {
                 dev_err(&pdev->dev, "ioremap error.\n");
-                ret = -ENOMEM;
-                goto probe_end_kfree;
+                return -ENOMEM;
         }
 
         /*
@@ -485,7 +484,7 @@ static int usbhs_probe(struct platform_device *pdev)
         /* call pipe and module init */
         ret = usbhs_pipe_probe(priv);
         if (ret < 0)
-                goto probe_end_iounmap;
+                return ret;
 
         ret = usbhs_fifo_probe(priv);
         if (ret < 0)
@@ -546,10 +545,6 @@ probe_end_fifo_exit:
         usbhs_fifo_remove(priv);
 probe_end_pipe_exit:
         usbhs_pipe_remove(priv);
-probe_end_iounmap:
-        iounmap(priv->base);
-probe_end_kfree:
-        kfree(priv);
 
         dev_info(&pdev->dev, "probe failed\n");
 
@@ -576,8 +571,6 @@ static int __devexit usbhs_remove(struct platform_device *pdev)
         usbhs_mod_remove(priv);
         usbhs_fifo_remove(priv);
         usbhs_pipe_remove(priv);
-        iounmap(priv->base);
-        kfree(priv);
 
         return 0;
 }
diff --git a/drivers/usb/renesas_usbhs/mod.c b/drivers/usb/renesas_usbhs/mod.c
index 82a628f96c03..35c5208f3249 100644
--- a/drivers/usb/renesas_usbhs/mod.c
+++ b/drivers/usb/renesas_usbhs/mod.c
@@ -209,14 +209,18 @@ int usbhs_status_get_ctrl_stage(struct usbhs_irq_state *irq_state)
         return (int)irq_state->intsts0 & CTSQ_MASK;
 }
 
-static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
-                                      struct usbhs_irq_state *state)
+static int usbhs_status_get_each_irq(struct usbhs_priv *priv,
+                                     struct usbhs_irq_state *state)
 {
         struct usbhs_mod *mod = usbhs_mod_get_current(priv);
+        u16 intenb0, intenb1;
 
         state->intsts0 = usbhs_read(priv, INTSTS0);
         state->intsts1 = usbhs_read(priv, INTSTS1);
 
+        intenb0 = usbhs_read(priv, INTENB0);
+        intenb1 = usbhs_read(priv, INTENB1);
+
         /* mask */
         if (mod) {
                 state->brdysts = usbhs_read(priv, BRDYSTS);
@@ -226,6 +230,20 @@ static void usbhs_status_get_each_irq(struct usbhs_priv *priv,
                 state->bempsts &= mod->irq_bempsts;
                 state->brdysts &= mod->irq_brdysts;
         }
+
+        /*
+         * Check whether the irq enable registers and the irq status are set
+         * when IRQF_SHARED is set.
+         */
+        if (priv->irqflags & IRQF_SHARED) {
+                if (!(intenb0 & state->intsts0) &&
+                    !(intenb1 & state->intsts1) &&
+                    !(state->bempsts) &&
+                    !(state->brdysts))
+                        return -EIO;
+        }
+
+        return 0;
 }
 
 /*
@@ -238,7 +256,8 @@ static irqreturn_t usbhs_interrupt(int irq, void *data)
         struct usbhs_priv *priv = data;
         struct usbhs_irq_state irq_state;
 
-        usbhs_status_get_each_irq(priv, &irq_state);
+        if (usbhs_status_get_each_irq(priv, &irq_state) < 0)
+                return IRQ_NONE;
 
         /*
          * clear interrupt
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index 325d2910f9f9..76f462241738 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -42,11 +42,6 @@ config USB_SERIAL_CONSOLE
 
           If unsure, say N.
 
-config USB_EZUSB
-        bool "Functions for loading firmware on EZUSB chips"
-        help
-            Say Y here if you need EZUSB device support.
-
 config USB_SERIAL_GENERIC
         bool "USB Generic Serial Driver"
         help
@@ -94,7 +89,7 @@ config USB_SERIAL_CH341
 
 config USB_SERIAL_WHITEHEAT
         tristate "USB ConnectTech WhiteHEAT Serial Driver"
-        select USB_EZUSB
+        select USB_EZUSB_FX2
         help
           Say Y here if you want to use a ConnectTech WhiteHEAT 4 port
           USB to serial converter device.
@@ -281,7 +276,7 @@ config USB_SERIAL_IUU
 
 config USB_SERIAL_KEYSPAN_PDA
         tristate "USB Keyspan PDA Single Port Serial Driver"
-        select USB_EZUSB
+        select USB_EZUSB_FX2
         help
           Say Y here if you want to use a Keyspan PDA single port USB to
           serial converter device.  This driver makes use of firmware
@@ -292,7 +287,7 @@ config USB_SERIAL_KEYSPAN_PDA
 
 config USB_SERIAL_KEYSPAN
         tristate "USB Keyspan USA-xxx Serial Driver"
-        select USB_EZUSB
+        select USB_EZUSB_FX2
         ---help---
           Say Y here if you want to use Keyspan USB to serial converter
           devices.  This driver makes use of Keyspan's official firmware
@@ -596,7 +591,7 @@ config USB_SERIAL_CYBERJACK
 
 config USB_SERIAL_XIRCOM
         tristate "USB Xircom / Entregra Single Port Serial Driver"
-        select USB_EZUSB
+        select USB_EZUSB_FX2
         help
           Say Y here if you want to use a Xircom or Entregra single port USB to
           serial converter device.  This driver makes use of firmware
@@ -660,6 +655,14 @@ config USB_SERIAL_ZIO
           To compile this driver as a module, choose M here: the
           module will be called zio.
 
+config USB_SERIAL_ZTE
+        tristate "ZTE USB serial driver"
+        help
+          Say Y here if you want to use a ZTE USB to serial device.
+
+          To compile this driver as a module, choose M here: the
+          module will be called zte.
+
 config USB_SERIAL_SSU100
         tristate "USB Quatech SSU-100 Single Port Serial Driver"
         help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 1dc483a8bfc7..3b3e7308d476 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -9,7 +9,6 @@ obj-$(CONFIG_USB_SERIAL)			+= usbserial.o
 usbserial-y := usb-serial.o generic.o bus.o
 
 usbserial-$(CONFIG_USB_SERIAL_CONSOLE)  += console.o
-usbserial-$(CONFIG_USB_EZUSB)           += ezusb.o
 
 obj-$(CONFIG_USB_SERIAL_AIRCABLE)               += aircable.o
 obj-$(CONFIG_USB_SERIAL_ARK3116)                += ark3116.o
@@ -63,3 +62,4 @@ obj-$(CONFIG_USB_SERIAL_WHITEHEAT)		+= whiteheat.o
 obj-$(CONFIG_USB_SERIAL_XIRCOM)                 += keyspan_pda.o
 obj-$(CONFIG_USB_SERIAL_VIVOPAY_SERIAL)         += vivopay-serial.o
 obj-$(CONFIG_USB_SERIAL_ZIO)                    += zio.o
+obj-$(CONFIG_USB_SERIAL_ZTE)                    += zte_ev.o
diff --git a/drivers/usb/serial/aircable.c b/drivers/usb/serial/aircable.c
index d634e6635632..54e1bb6372e7 100644
--- a/drivers/usb/serial/aircable.c
+++ b/drivers/usb/serial/aircable.c
@@ -52,8 +52,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static bool debug;
-
 /* Vendor and Product ID */
 #define AIRCABLE_VID            0x16CA
 #define AIRCABLE_USB_PID        0x1502
@@ -196,6 +194,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ark3116.c b/drivers/usb/serial/ark3116.c
index 3b98fb733362..cf2522c397d3 100644
--- a/drivers/usb/serial/ark3116.c
+++ b/drivers/usb/serial/ark3116.c
@@ -37,7 +37,6 @@
 #include <linux/mutex.h>
 #include <linux/spinlock.h>
 
-static bool debug;
 /*
  * Version information
  */
@@ -650,8 +649,7 @@ static void ark3116_read_int_callback(struct urb *urb)
                 /*
                  * Not sure what this data meant...
                  */
-                usb_serial_debug_data(debug, &port->dev,
-                                      __func__,
+                usb_serial_debug_data(&port->dev, __func__,
                                       urb->actual_length,
                                       urb->transfer_buffer);
                 break;
@@ -750,9 +748,6 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable debug");
-
 /*
  * The following describes what I learned from studying the old
  * ark3116.c driver, disassembling the windows driver, and some lucky
diff --git a/drivers/usb/serial/belkin_sa.c b/drivers/usb/serial/belkin_sa.c
index a46df73ee96e..99449424193f 100644
--- a/drivers/usb/serial/belkin_sa.c
+++ b/drivers/usb/serial/belkin_sa.c
@@ -37,8 +37,6 @@
 #include <linux/usb/serial.h>
 #include "belkin_sa.h"
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -206,8 +204,7 @@ static void belkin_sa_read_int_callback(struct urb *urb)
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                        urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         /* Handle known interrupt data */
         /* ignore data[0] and data[1] */
@@ -515,6 +512,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ch341.c b/drivers/usb/serial/ch341.c
index cabd1b15ddce..e9c7046ae355 100644
--- a/drivers/usb/serial/ch341.c
+++ b/drivers/usb/serial/ch341.c
@@ -70,8 +70,6 @@
 #define CH341_NBREAK_BITS_REG2 0x40
 
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x4348, 0x5523) },
         { USB_DEVICE(0x1a86, 0x7523) },
@@ -93,8 +91,9 @@ static int ch341_control_out(struct usb_device *dev, u8 request,
                              u16 value, u16 index)
 {
         int r;
-        dbg("ch341_control_out(%02x,%02x,%04x,%04x)", USB_DIR_OUT|0x40,
-                (int)request, (int)value, (int)index);
+
+        dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n",
+                USB_DIR_OUT|0x40, (int)request, (int)value, (int)index);
 
         r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request,
                             USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
@@ -108,8 +107,10 @@ static int ch341_control_in(struct usb_device *dev,
                             char *buf, unsigned bufsize)
 {
         int r;
-        dbg("ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)", USB_DIR_IN|0x40,
-                (int)request, (int)value, (int)index, buf, (int)bufsize);
+
+        dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n",
+                USB_DIR_IN|0x40, (int)request, (int)value, (int)index, buf,
+                (int)bufsize);
 
         r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request,
                             USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
@@ -320,7 +321,7 @@ static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port)
         if (r)
                 goto out;
 
-        dbg("%s - submitting interrupt urb", __func__);
+        dev_dbg(&port->dev, "%s - submitting interrupt urb", __func__);
         r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
         if (r) {
                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
@@ -390,19 +391,19 @@ static void ch341_break_ctl(struct tty_struct *tty, int break_state)
                                 __func__, r);
                 goto out;
         }
-        dbg("%s - initial ch341 break register contents - reg1: %x, reg2: %x",
-                        __func__, break_reg[0], break_reg[1]);
+        dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n",
+                __func__, break_reg[0], break_reg[1]);
         if (break_state != 0) {
-                dbg("%s - Enter break state requested", __func__);
+                dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__);
                 break_reg[0] &= ~CH341_NBREAK_BITS_REG1;
                 break_reg[1] &= ~CH341_NBREAK_BITS_REG2;
         } else {
-                dbg("%s - Leave break state requested", __func__);
+                dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__);
                 break_reg[0] |= CH341_NBREAK_BITS_REG1;
                 break_reg[1] |= CH341_NBREAK_BITS_REG2;
         }
-        dbg("%s - New ch341 break register contents - reg1: %x, reg2: %x",
-                        __func__, break_reg[0], break_reg[1]);
+        dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n",
+                __func__, break_reg[0], break_reg[1]);
         reg_contents = get_unaligned_le16(break_reg);
         r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG,
                         ch341_break_reg, reg_contents);
@@ -451,16 +452,16 @@ static void ch341_read_int_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                    urb->status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, urb->status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                    urb->status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, urb->status);
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
+        usb_serial_debug_data(&port->dev, __func__,
                               urb->actual_length, urb->transfer_buffer);
 
         if (actual_length >= 4) {
@@ -536,15 +537,16 @@ static int ch341_ioctl(struct tty_struct *tty,
                         unsigned int cmd, unsigned long arg)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s (%d) cmd = 0x%04x", __func__, port->number, cmd);
+
+        dev_dbg(&port->dev, "%s (%d) cmd = 0x%04x\n", __func__, port->number, cmd);
 
         switch (cmd) {
         case TIOCMIWAIT:
-                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+                dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__,  port->number);
                 return wait_modem_info(port, arg);
 
         default:
-                dbg("%s not supported = 0x%04x", __func__, cmd);
+                dev_dbg(&port->dev, "%s not supported = 0x%04x\n", __func__, cmd);
                 break;
         }
 
@@ -572,7 +574,7 @@ static int ch341_tiocmget(struct tty_struct *tty)
                   | ((status & CH341_BIT_RI)    ? TIOCM_RI  : 0)
                   | ((status & CH341_BIT_DCD)   ? TIOCM_CD  : 0);
 
-        dbg("%s - result = %x", __func__, result);
+        dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
 
         return result;
 }
@@ -617,6 +619,3 @@ static struct usb_serial_driver * const serial_drivers[] = {
 module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/console.c b/drivers/usb/serial/console.c
index 9a564286bfd7..5f3bcd31e204 100644
--- a/drivers/usb/serial/console.c
+++ b/drivers/usb/serial/console.c
@@ -11,6 +11,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/slab.h>
@@ -20,8 +22,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static int debug;
-
 struct usbcons_info {
         int                     magic;
         int                     break_flag;
@@ -68,8 +68,6 @@ static int usb_console_setup(struct console *co, char *options)
         struct tty_struct *tty = NULL;
         struct ktermios dummy;
 
-        dbg("%s", __func__);
-
         if (options) {
                 baud = simple_strtoul(options, NULL, 10);
                 s = options;
@@ -113,8 +111,7 @@ static int usb_console_setup(struct console *co, char *options)
         serial = usb_serial_get_by_index(co->index);
         if (serial == NULL) {
                 /* no device is connected yet, sorry :( */
-                printk(KERN_ERR "No USB device connected to ttyUSB%i\n",
-                       co->index);
+                pr_err("No USB device connected to ttyUSB%i\n", co->index);
                 return -ENODEV;
         }
 
@@ -213,10 +210,10 @@ static void usb_console_write(struct console *co,
         if (count == 0)
                 return;
 
-        dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
+        pr_debug("%s - port %d, %d byte(s)\n", __func__, port->number, count);
 
         if (!port->port.console) {
-                dbg("%s - port not opened", __func__);
+                pr_debug("%s - port not opened\n", __func__);
                 return;
         }
 
@@ -237,7 +234,7 @@ static void usb_console_write(struct console *co,
                         retval = serial->type->write(NULL, port, buf, i);
                 else
                         retval = usb_serial_generic_write(NULL, port, buf, i);
-                dbg("%s - return value : %d", __func__, retval);
+                pr_debug("%s - return value : %d\n", __func__, retval);
                 if (lf) {
                         /* append CR after LF */
                         unsigned char cr = 13;
@@ -247,7 +244,7 @@ static void usb_console_write(struct console *co,
                         else
                                 retval = usb_serial_generic_write(NULL,
                                                                 port, &cr, 1);
-                        dbg("%s - return value : %d", __func__, retval);
+                        pr_debug("%s - return value : %d\n", __func__, retval);
                 }
                 buf += i;
                 count -= i;
@@ -284,10 +281,8 @@ void usb_serial_console_disconnect(struct usb_serial *serial)
         }
 }
 
-void usb_serial_console_init(int serial_debug, int minor)
+void usb_serial_console_init(int minor)
 {
-        debug = serial_debug;
-
         if (minor == 0) {
                 /*
                  * Call register_console() if this is the first device plugged
@@ -302,7 +297,7 @@ void usb_serial_console_init(int serial_debug, int minor)
                  * register_console). console_write() is called immediately
                  * from register_console iff CON_PRINTBUFFER is set in flags.
                  */
-                dbg("registering the USB serial console.");
+                pr_debug("registering the USB serial console.\n");
                 register_console(&usbcons);
         }
 }
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index ba5e07e188a0..28af5acc3360 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -52,8 +52,6 @@ static int cp210x_startup(struct usb_serial *);
 static void cp210x_release(struct usb_serial *);
 static void cp210x_dtr_rts(struct usb_serial_port *p, int on);
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
         { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
@@ -304,9 +302,8 @@ static int cp210x_get_config(struct usb_serial_port *port, u8 request,
         kfree(buf);
 
         if (result != size) {
-                dbg("%s - Unable to send config request, "
-                                "request=0x%x size=%d result=%d",
-                                __func__, request, size, result);
+                dev_dbg(&port->dev, "%s - Unable to send config request, request=0x%x size=%d result=%d\n",
+                        __func__, request, size, result);
                 if (result > 0)
                         result = -EPROTO;
 
@@ -361,9 +358,8 @@ static int cp210x_set_config(struct usb_serial_port *port, u8 request,
         kfree(buf);
 
         if ((size > 2 && result != size) || result < 0) {
-                dbg("%s - Unable to send request, "
-                                "request=0x%x size=%d result=%d",
-                                __func__, request, size, result);
+                dev_dbg(&port->dev, "%s - Unable to send request, request=0x%x size=%d result=%d\n",
+                        __func__, request, size, result);
                 if (result > 0)
                         result = -EPROTO;
 
@@ -487,13 +483,14 @@ static void cp210x_get_termios(struct tty_struct *tty,
 static void cp210x_get_termios_port(struct usb_serial_port *port,
         unsigned int *cflagp, unsigned int *baudp)
 {
+        struct device *dev = &port->dev;
         unsigned int cflag, modem_ctl[4];
         unsigned int baud;
         unsigned int bits;
 
         cp210x_get_config(port, CP210X_GET_BAUDRATE, &baud, 4);
 
-        dbg("%s - baud rate = %d", __func__, baud);
+        dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud);
         *baudp = baud;
 
         cflag = *cflagp;
@@ -502,31 +499,30 @@ static void cp210x_get_termios_port(struct usb_serial_port *port,
         cflag &= ~CSIZE;
         switch (bits & BITS_DATA_MASK) {
         case BITS_DATA_5:
-                dbg("%s - data bits = 5", __func__);
+                dev_dbg(dev, "%s - data bits = 5\n", __func__);
                 cflag |= CS5;
                 break;
         case BITS_DATA_6:
-                dbg("%s - data bits = 6", __func__);
+                dev_dbg(dev, "%s - data bits = 6\n", __func__);
                 cflag |= CS6;
                 break;
         case BITS_DATA_7:
-                dbg("%s - data bits = 7", __func__);
+                dev_dbg(dev, "%s - data bits = 7\n", __func__);
                 cflag |= CS7;
                 break;
         case BITS_DATA_8:
-                dbg("%s - data bits = 8", __func__);
+                dev_dbg(dev, "%s - data bits = 8\n", __func__);
                 cflag |= CS8;
                 break;
         case BITS_DATA_9:
-                dbg("%s - data bits = 9 (not supported, using 8 data bits)",
-                                                                __func__);
+                dev_dbg(dev, "%s - data bits = 9 (not supported, using 8 data bits)\n", __func__);
                 cflag |= CS8;
                 bits &= ~BITS_DATA_MASK;
                 bits |= BITS_DATA_8;
                 cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         default:
-                dbg("%s - Unknown number of data bits, using 8", __func__);
+                dev_dbg(dev, "%s - Unknown number of data bits, using 8\n", __func__);
                 cflag |= CS8;
                 bits &= ~BITS_DATA_MASK;
                 bits |= BITS_DATA_8;
@@ -536,29 +532,29 @@ static void cp210x_get_termios_port(struct usb_serial_port *port,
 
         switch (bits & BITS_PARITY_MASK) {
         case BITS_PARITY_NONE:
-                dbg("%s - parity = NONE", __func__);
+                dev_dbg(dev, "%s - parity = NONE\n", __func__);
                 cflag &= ~PARENB;
                 break;
         case BITS_PARITY_ODD:
-                dbg("%s - parity = ODD", __func__);
+                dev_dbg(dev, "%s - parity = ODD\n", __func__);
                 cflag |= (PARENB|PARODD);
                 break;
         case BITS_PARITY_EVEN:
-                dbg("%s - parity = EVEN", __func__);
+                dev_dbg(dev, "%s - parity = EVEN\n", __func__);
                 cflag &= ~PARODD;
                 cflag |= PARENB;
                 break;
         case BITS_PARITY_MARK:
-                dbg("%s - parity = MARK", __func__);
+                dev_dbg(dev, "%s - parity = MARK\n", __func__);
                 cflag |= (PARENB|PARODD|CMSPAR);
                 break;
         case BITS_PARITY_SPACE:
-                dbg("%s - parity = SPACE", __func__);
+                dev_dbg(dev, "%s - parity = SPACE\n", __func__);
                 cflag &= ~PARODD;
                 cflag |= (PARENB|CMSPAR);
                 break;
         default:
-                dbg("%s - Unknown parity mode, disabling parity", __func__);
+                dev_dbg(dev, "%s - Unknown parity mode, disabling parity\n", __func__);
                 cflag &= ~PARENB;
                 bits &= ~BITS_PARITY_MASK;
                 cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
@@ -568,21 +564,19 @@ static void cp210x_get_termios_port(struct usb_serial_port *port,
         cflag &= ~CSTOPB;
         switch (bits & BITS_STOP_MASK) {
         case BITS_STOP_1:
-                dbg("%s - stop bits = 1", __func__);
+                dev_dbg(dev, "%s - stop bits = 1\n", __func__);
                 break;
         case BITS_STOP_1_5:
-                dbg("%s - stop bits = 1.5 (not supported, using 1 stop bit)",
-                                                                __func__);
+                dev_dbg(dev, "%s - stop bits = 1.5 (not supported, using 1 stop bit)\n", __func__);
                 bits &= ~BITS_STOP_MASK;
                 cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
         case BITS_STOP_2:
-                dbg("%s - stop bits = 2", __func__);
+                dev_dbg(dev, "%s - stop bits = 2\n", __func__);
                 cflag |= CSTOPB;
                 break;
         default:
-                dbg("%s - Unknown number of stop bits, using 1 stop bit",
-                                                                __func__);
+                dev_dbg(dev, "%s - Unknown number of stop bits, using 1 stop bit\n", __func__);
                 bits &= ~BITS_STOP_MASK;
                 cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2);
                 break;
@@ -590,10 +584,10 @@ static void cp210x_get_termios_port(struct usb_serial_port *port,
 
         cp210x_get_config(port, CP210X_GET_FLOW, modem_ctl, 16);
         if (modem_ctl[0] & 0x0008) {
-                dbg("%s - flow control = CRTSCTS", __func__);
+                dev_dbg(dev, "%s - flow control = CRTSCTS\n", __func__);
                 cflag |= CRTSCTS;
         } else {
-                dbg("%s - flow control = NONE", __func__);
+                dev_dbg(dev, "%s - flow control = NONE\n", __func__);
                 cflag &= ~CRTSCTS;
         }
 
@@ -640,7 +634,7 @@ static void cp210x_change_speed(struct tty_struct *tty,
          */
         baud = cp210x_quantise_baudrate(baud);
 
-        dbg("%s - setting baud rate to %u", __func__, baud);
+        dev_dbg(&port->dev, "%s - setting baud rate to %u\n", __func__, baud);
         if (cp210x_set_config(port, CP210X_SET_BAUDRATE, &baud,
                                                         sizeof(baud))) {
                 dev_warn(&port->dev, "failed to set baud rate to %u\n", baud);
@@ -656,11 +650,12 @@ static void cp210x_change_speed(struct tty_struct *tty,
 static void cp210x_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
+        struct device *dev = &port->dev;
         unsigned int cflag, old_cflag;
         unsigned int bits;
         unsigned int modem_ctl[4];
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(dev, "%s - port %d\n", __func__, port->number);
 
         if (!tty)
                 return;
@@ -678,34 +673,31 @@ static void cp210x_set_termios(struct tty_struct *tty,
                 switch (cflag & CSIZE) {
                 case CS5:
                         bits |= BITS_DATA_5;
-                        dbg("%s - data bits = 5", __func__);
+                        dev_dbg(dev, "%s - data bits = 5\n", __func__);
                         break;
                 case CS6:
                         bits |= BITS_DATA_6;
-                        dbg("%s - data bits = 6", __func__);
+                        dev_dbg(dev, "%s - data bits = 6\n", __func__);
                         break;
                 case CS7:
                         bits |= BITS_DATA_7;
-                        dbg("%s - data bits = 7", __func__);
+                        dev_dbg(dev, "%s - data bits = 7\n", __func__);
                         break;
                 case CS8:
                         bits |= BITS_DATA_8;
-                        dbg("%s - data bits = 8", __func__);
+                        dev_dbg(dev, "%s - data bits = 8\n", __func__);
                         break;
                 /*case CS9:
                         bits |= BITS_DATA_9;
-                        dbg("%s - data bits = 9", __func__);
+                        dev_dbg(dev, "%s - data bits = 9\n", __func__);
                         break;*/
                 default:
-                        dbg("cp210x driver does not "
-                                        "support the number of bits requested,"
-                                        " using 8 bit mode");
+                        dev_dbg(dev, "cp210x driver does not support the number of bits requested, using 8 bit mode\n");
                                 bits |= BITS_DATA_8;
                                 break;
                 }
                 if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
-                        dbg("Number of data bits requested "
-                                        "not supported by device");
+                        dev_dbg(dev, "Number of data bits requested not supported by device\n");
         }
 
         if ((cflag     & (PARENB|PARODD|CMSPAR)) !=
@@ -714,25 +706,25 @@ static void cp210x_set_termios(struct tty_struct *tty,
                 bits &= ~BITS_PARITY_MASK;
                 if (cflag & PARENB) {
                         if (cflag & CMSPAR) {
-                            if (cflag & PARODD) {
-                                    bits |= BITS_PARITY_MARK;
-                                    dbg("%s - parity = MARK", __func__);
-                            } else {
-                                    bits |= BITS_PARITY_SPACE;
-                                    dbg("%s - parity = SPACE", __func__);
-                            }
+                                if (cflag & PARODD) {
+                                        bits |= BITS_PARITY_MARK;
+                                        dev_dbg(dev, "%s - parity = MARK\n", __func__);
+                                } else {
+                                        bits |= BITS_PARITY_SPACE;
+                                        dev_dbg(dev, "%s - parity = SPACE\n", __func__);
+                                }
                         } else {
-                            if (cflag & PARODD) {
-                                    bits |= BITS_PARITY_ODD;
-                                    dbg("%s - parity = ODD", __func__);
-                            } else {
-                                    bits |= BITS_PARITY_EVEN;
-                                    dbg("%s - parity = EVEN", __func__);
-                            }
+                                if (cflag & PARODD) {
+                                        bits |= BITS_PARITY_ODD;
+                                        dev_dbg(dev, "%s - parity = ODD\n", __func__);
+                                } else {
+                                        bits |= BITS_PARITY_EVEN;
+                                        dev_dbg(dev, "%s - parity = EVEN\n", __func__);
+                                }
                         }
                 }
                 if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
-                        dbg("Parity mode not supported by device");
+                        dev_dbg(dev, "Parity mode not supported by device\n");
         }
 
         if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
@@ -740,37 +732,36 @@ static void cp210x_set_termios(struct tty_struct *tty,
                 bits &= ~BITS_STOP_MASK;
                 if (cflag & CSTOPB) {
                         bits |= BITS_STOP_2;
-                        dbg("%s - stop bits = 2", __func__);
+                        dev_dbg(dev, "%s - stop bits = 2\n", __func__);
                 } else {
                         bits |= BITS_STOP_1;
-                        dbg("%s - stop bits = 1", __func__);
+                        dev_dbg(dev, "%s - stop bits = 1\n", __func__);
                 }
                 if (cp210x_set_config(port, CP210X_SET_LINE_CTL, &bits, 2))
-                        dbg("Number of stop bits requested "
-                                        "not supported by device");
+                        dev_dbg(dev, "Number of stop bits requested not supported by device\n");
         }
 
         if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
                 cp210x_get_config(port, CP210X_GET_FLOW, modem_ctl, 16);
-                dbg("%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
-                                __func__, modem_ctl[0], modem_ctl[1],
-                                modem_ctl[2], modem_ctl[3]);
+                dev_dbg(dev, "%s - read modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x\n",
+                        __func__, modem_ctl[0], modem_ctl[1],
+                        modem_ctl[2], modem_ctl[3]);
 
                 if (cflag & CRTSCTS) {
                         modem_ctl[0] &= ~0x7B;
                         modem_ctl[0] |= 0x09;
                         modem_ctl[1] = 0x80;
-                        dbg("%s - flow control = CRTSCTS", __func__);
+                        dev_dbg(dev, "%s - flow control = CRTSCTS\n", __func__);
                 } else {
                         modem_ctl[0] &= ~0x7B;
                         modem_ctl[0] |= 0x01;
                         modem_ctl[1] |= 0x40;
-                        dbg("%s - flow control = NONE", __func__);
+                        dev_dbg(dev, "%s - flow control = NONE\n", __func__);
                 }
 
-                dbg("%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x",
-                                __func__, modem_ctl[0], modem_ctl[1],
-                                modem_ctl[2], modem_ctl[3]);
+                dev_dbg(dev, "%s - write modem controls = 0x%.4x 0x%.4x 0x%.4x 0x%.4x\n",
+                        __func__, modem_ctl[0], modem_ctl[1],
+                        modem_ctl[2], modem_ctl[3]);
                 cp210x_set_config(port, CP210X_SET_FLOW, modem_ctl, 16);
         }
 
@@ -805,7 +796,7 @@ static int cp210x_tiocmset_port(struct usb_serial_port *port,
                 control |= CONTROL_WRITE_DTR;
         }
 
-        dbg("%s - control = 0x%.4x", __func__, control);
+        dev_dbg(&port->dev, "%s - control = 0x%.4x\n", __func__, control);
 
         return cp210x_set_config(port, CP210X_SET_MHS, &control, 2);
 }
@@ -833,7 +824,7 @@ static int cp210x_tiocmget (struct tty_struct *tty)
                 |((control & CONTROL_RING)? TIOCM_RI  : 0)
                 |((control & CONTROL_DCD) ? TIOCM_CD  : 0);
 
-        dbg("%s - control = 0x%.2x", __func__, control);
+        dev_dbg(&port->dev, "%s - control = 0x%.2x\n", __func__, control);
 
         return result;
 }
@@ -847,8 +838,8 @@ static void cp210x_break_ctl (struct tty_struct *tty, int break_state)
                 state = BREAK_OFF;
         else
                 state = BREAK_ON;
-        dbg("%s - turning break %s", __func__,
-                        state == BREAK_OFF ? "off" : "on");
+        dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
+                state == BREAK_OFF ? "off" : "on");
         cp210x_set_config(port, CP210X_SET_BREAK, &state, 2);
 }
 
@@ -865,7 +856,6 @@ static int cp210x_startup(struct usb_serial *serial)
                 if (!port_priv)
                         return -ENOMEM;
 
-                memset(port_priv, 0x00, sizeof(*port_priv));
                 port_priv->bInterfaceNumber =
                     serial->interface->cur_altsetting->desc.bInterfaceNumber;
 
@@ -892,6 +882,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable verbose debugging messages");
diff --git a/drivers/usb/serial/cyberjack.c b/drivers/usb/serial/cyberjack.c
index 3aa0b530f68e..2a7aecc72237 100644
--- a/drivers/usb/serial/cyberjack.c
+++ b/drivers/usb/serial/cyberjack.c
@@ -43,8 +43,6 @@
 
 #define CYBERJACK_LOCAL_BUF_SIZE 32
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -136,7 +134,8 @@ static int cyberjack_startup(struct usb_serial *serial)
                 if (result)
                         dev_err(&serial->dev->dev,
                                 "usb_submit_urb(read int) failed\n");
-                dbg("%s - usb_submit_urb(int urb)", __func__);
+                dev_dbg(&serial->dev->dev, "%s - usb_submit_urb(int urb)\n",
+                        __func__);
         }
 
         return 0;
@@ -167,7 +166,7 @@ static int  cyberjack_open(struct tty_struct *tty,
         unsigned long flags;
         int result = 0;
 
-        dbg("%s - usb_clear_halt", __func__);
+        dev_dbg(&port->dev, "%s - usb_clear_halt\n", __func__);
         usb_clear_halt(port->serial->dev, port->write_urb->pipe);
 
         priv = usb_get_serial_port_data(port);
@@ -192,18 +191,19 @@ static void cyberjack_close(struct usb_serial_port *port)
 static int cyberjack_write(struct tty_struct *tty,
         struct usb_serial_port *port, const unsigned char *buf, int count)
 {
+        struct device *dev = &port->dev;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         int result;
         int wrexpected;
 
         if (count == 0) {
-                dbg("%s - write request of 0 bytes", __func__);
+                dev_dbg(dev, "%s - write request of 0 bytes\n", __func__);
                 return 0;
         }
 
         if (!test_and_clear_bit(0, &port->write_urbs_free)) {
-                dbg("%s - already writing", __func__);
+                dev_dbg(dev, "%s - already writing\n", __func__);
                 return 0;
         }
 
@@ -220,13 +220,12 @@ static int cyberjack_write(struct tty_struct *tty,
         /* Copy data */
         memcpy(priv->wrbuf + priv->wrfilled, buf, count);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                priv->wrbuf + priv->wrfilled);
+        usb_serial_debug_data(dev, __func__, count, priv->wrbuf + priv->wrfilled);
         priv->wrfilled += count;
 
         if (priv->wrfilled >= 3) {
                 wrexpected = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
-                dbg("%s - expected data: %d", __func__, wrexpected);
+                dev_dbg(dev, "%s - expected data: %d\n", __func__, wrexpected);
         } else
                 wrexpected = sizeof(priv->wrbuf);
 
@@ -234,7 +233,7 @@ static int cyberjack_write(struct tty_struct *tty,
                 /* We have enough data to begin transmission */
                 int length;
 
-                dbg("%s - transmitting data (frame 1)", __func__);
+                dev_dbg(dev, "%s - transmitting data (frame 1)\n", __func__);
                 length = (wrexpected > port->bulk_out_size) ?
                                         port->bulk_out_size : wrexpected;
 
@@ -258,11 +257,11 @@ static int cyberjack_write(struct tty_struct *tty,
                         return 0;
                 }
 
-                dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
-                dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
+                dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent);
+                dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled);
 
                 if (priv->wrsent >= priv->wrfilled) {
-                        dbg("%s - buffer cleaned", __func__);
+                        dev_dbg(dev, "%s - buffer cleaned\n", __func__);
                         memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
                         priv->wrfilled = 0;
                         priv->wrsent = 0;
@@ -284,6 +283,7 @@ static void cyberjack_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
         int result;
@@ -292,8 +292,7 @@ static void cyberjack_read_int_callback(struct urb *urb)
         if (status)
                 return;
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                                urb->actual_length, data);
+        usb_serial_debug_data(dev, __func__, urb->actual_length, data);
 
         /* React only to interrupts signaling a bulk_in transfer */
         if (urb->actual_length == 4 && data[0] == 0x01) {
@@ -307,7 +306,7 @@ static void cyberjack_read_int_callback(struct urb *urb)
                 old_rdtodo = priv->rdtodo;
 
                 if (old_rdtodo + size < old_rdtodo) {
-                        dbg("To many bulk_in urbs to do.");
+                        dev_dbg(dev, "To many bulk_in urbs to do.\n");
                         spin_unlock(&priv->lock);
                         goto resubmit;
                 }
@@ -315,17 +314,16 @@ static void cyberjack_read_int_callback(struct urb *urb)
                 /* "+=" is probably more fault tollerant than "=" */
                 priv->rdtodo += size;
 
-                dbg("%s - rdtodo: %d", __func__, priv->rdtodo);
+                dev_dbg(dev, "%s - rdtodo: %d\n", __func__, priv->rdtodo);
 
                 spin_unlock(&priv->lock);
 
                 if (!old_rdtodo) {
                         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                         if (result)
-                                dev_err(&port->dev, "%s - failed resubmitting "
-                                        "read urb, error %d\n",
+                                dev_err(dev, "%s - failed resubmitting read urb, error %d\n",
                                         __func__, result);
-                        dbg("%s - usb_submit_urb(read urb)", __func__);
+                        dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__);
                 }
         }
 
@@ -333,30 +331,30 @@ resubmit:
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
         if (result)
                 dev_err(&port->dev, "usb_submit_urb(read int) failed\n");
-        dbg("%s - usb_submit_urb(int urb)", __func__);
+        dev_dbg(dev, "%s - usb_submit_urb(int urb)\n", __func__);
 }
 
 static void cyberjack_read_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         short todo;
         int result;
         int status = urb->status;
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                                urb->actual_length, data);
+        usb_serial_debug_data(dev, __func__, urb->actual_length, data);
         if (status) {
-                dbg("%s - nonzero read bulk status received: %d",
-                    __func__, status);
+                dev_dbg(dev, "%s - nonzero read bulk status received: %d\n",
+                        __func__, status);
                 return;
         }
 
         tty = tty_port_tty_get(&port->port);
         if (!tty) {
-                dbg("%s - ignoring since device not open", __func__);
+                dev_dbg(dev, "%s - ignoring since device not open\n", __func__);
                 return;
         }
         if (urb->actual_length) {
@@ -376,15 +374,15 @@ static void cyberjack_read_bulk_callback(struct urb *urb)
 
         spin_unlock(&priv->lock);
 
-        dbg("%s - rdtodo: %d", __func__, todo);
+        dev_dbg(dev, "%s - rdtodo: %d\n", __func__, todo);
 
         /* Continue to read if we have still urbs to do. */
         if (todo /* || (urb->actual_length==port->bulk_in_endpointAddress)*/) {
                 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                 if (result)
-                        dev_err(&port->dev, "%s - failed resubmitting read "
-                                "urb, error %d\n", __func__, result);
-                dbg("%s - usb_submit_urb(read urb)", __func__);
+                        dev_err(dev, "%s - failed resubmitting read urb, error %d\n",
+                                __func__, result);
+                dev_dbg(dev, "%s - usb_submit_urb(read urb)\n", __func__);
         }
 }
 
@@ -392,12 +390,13 @@ static void cyberjack_write_bulk_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cyberjack_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         int status = urb->status;
 
         set_bit(0, &port->write_urbs_free);
         if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(dev, "%s - nonzero write bulk status received: %d\n",
+                        __func__, status);
                 return;
         }
 
@@ -407,7 +406,7 @@ static void cyberjack_write_bulk_callback(struct urb *urb)
         if (priv->wrfilled) {
                 int length, blksize, result;
 
-                dbg("%s - transmitting data (frame n)", __func__);
+                dev_dbg(dev, "%s - transmitting data (frame n)\n", __func__);
 
                 length = ((priv->wrfilled - priv->wrsent) > port->bulk_out_size) ?
                         port->bulk_out_size : (priv->wrfilled - priv->wrsent);
@@ -422,8 +421,7 @@ static void cyberjack_write_bulk_callback(struct urb *urb)
                 /* send the data out the bulk port */
                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
                 if (result) {
-                        dev_err(&port->dev,
-                                "%s - failed submitting write urb, error %d\n",
+                        dev_err(dev, "%s - failed submitting write urb, error %d\n",
                                 __func__, result);
                         /* Throw away data. No better idea what to do with it. */
                         priv->wrfilled = 0;
@@ -431,14 +429,14 @@ static void cyberjack_write_bulk_callback(struct urb *urb)
                         goto exit;
                 }
 
-                dbg("%s - priv->wrsent=%d", __func__, priv->wrsent);
-                dbg("%s - priv->wrfilled=%d", __func__, priv->wrfilled);
+                dev_dbg(dev, "%s - priv->wrsent=%d\n", __func__, priv->wrsent);
+                dev_dbg(dev, "%s - priv->wrfilled=%d\n", __func__, priv->wrfilled);
 
                 blksize = ((int)priv->wrbuf[2]<<8)+priv->wrbuf[1]+3;
 
                 if (priv->wrsent >= priv->wrfilled ||
                                         priv->wrsent >= blksize) {
-                        dbg("%s - buffer cleaned", __func__);
+                        dev_dbg(dev, "%s - buffer cleaned\n", __func__);
                         memset(priv->wrbuf, 0, sizeof(priv->wrbuf));
                         priv->wrfilled = 0;
                         priv->wrsent = 0;
@@ -456,6 +454,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index be34f153e566..1befce21e173 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -46,7 +46,6 @@
 #include "cypress_m8.h"
 
 
-static bool debug;
 static bool stats;
 static int interval;
 static bool unstable_bauds;
@@ -263,8 +262,9 @@ static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
                  * safest speed for a part like that.
                  */
                 if (new_rate > 4800) {
-                        dbg("%s - failed setting baud rate, device incapable "
-                            "speed %d", __func__, new_rate);
+                        dev_dbg(&port->dev,
+                                "%s - failed setting baud rate, device incapable speed %d\n",
+                                __func__, new_rate);
                         return -1;
                 }
         }
@@ -274,8 +274,9 @@ static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
                         /* 300 and 600 baud rates are supported under
                          * the generic firmware, but are not used with
                          * NMEA and SiRF protocols */
-                        dbg("%s - failed setting baud rate, unsupported speed "
-                            "of %d on Earthmate GPS", __func__, new_rate);
+                        dev_dbg(&port->dev,
+                                "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS",
+                                __func__, new_rate);
                         return -1;
                 }
                 break;
@@ -294,6 +295,7 @@ static int cypress_serial_control(struct tty_struct *tty,
 {
         int new_baudrate = 0, retval = 0, tries = 0;
         struct cypress_private *priv;
+        struct device *dev = &port->dev;
         u8 *feature_buffer;
         const unsigned int feature_len = 5;
         unsigned long flags;
@@ -312,16 +314,16 @@ static int cypress_serial_control(struct tty_struct *tty,
                 /* 0 means 'Hang up' so doesn't change the true bit rate */
                 new_baudrate = priv->baud_rate;
                 if (baud_rate && baud_rate != priv->baud_rate) {
-                        dbg("%s - baud rate is changing", __func__);
+                        dev_dbg(dev, "%s - baud rate is changing\n", __func__);
                         retval = analyze_baud_rate(port, baud_rate);
                         if (retval >= 0) {
                                 new_baudrate = retval;
-                                dbg("%s - New baud rate set to %d",
-                                    __func__, new_baudrate);
+                                dev_dbg(dev, "%s - New baud rate set to %d\n",
+                                        __func__, new_baudrate);
                         }
                 }
-                dbg("%s - baud rate is being sent as %d",
-                                        __func__, new_baudrate);
+                dev_dbg(dev, "%s - baud rate is being sent as %d\n", __func__,
+                        new_baudrate);
 
                 /* fill the feature_buffer with new configuration */
                 put_unaligned_le32(new_baudrate, feature_buffer);
@@ -333,9 +335,8 @@ static int cypress_serial_control(struct tty_struct *tty,
                 /* 1 bit gap */
                 feature_buffer[4] |= (reset << 7);   /* assign reset at end of byte, 1 bit space */
 
-                dbg("%s - device is being sent this feature report:",
-                                                                __func__);
-                dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__,
+                dev_dbg(dev, "%s - device is being sent this feature report:\n", __func__);
+                dev_dbg(dev, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__,
                         feature_buffer[0], feature_buffer[1],
                         feature_buffer[2], feature_buffer[3],
                         feature_buffer[4]);
@@ -355,8 +356,8 @@ static int cypress_serial_control(struct tty_struct *tty,
                          retval != -ENODEV);
 
                 if (retval != feature_len) {
-                        dev_err(&port->dev, "%s - failed sending serial "
-                                "line settings - %d\n", __func__, retval);
+                        dev_err(dev, "%s - failed sending serial line settings - %d\n",
+                                __func__, retval);
                         cypress_set_dead(port);
                 } else {
                         spin_lock_irqsave(&priv->lock, flags);
@@ -377,7 +378,7 @@ static int cypress_serial_control(struct tty_struct *tty,
                         retval = -ENOTTY;
                         goto out;
                 }
-                dbg("%s - retreiving serial line settings", __func__);
+                dev_dbg(dev, "%s - retreiving serial line settings\n", __func__);
                 do {
                         retval = usb_control_msg(port->serial->dev,
                                         usb_rcvctrlpipe(port->serial->dev, 0),
@@ -392,8 +393,8 @@ static int cypress_serial_control(struct tty_struct *tty,
                                                 && retval != -ENODEV);
 
                 if (retval != feature_len) {
-                        dev_err(&port->dev, "%s - failed to retrieve serial "
-                                "line settings - %d\n", __func__, retval);
+                        dev_err(dev, "%s - failed to retrieve serial line settings - %d\n",
+                                __func__, retval);
                         cypress_set_dead(port);
                         goto out;
                 } else {
@@ -474,14 +475,14 @@ static int generic_startup(struct usb_serial *serial)
         if (interval > 0) {
                 priv->write_urb_interval = interval;
                 priv->read_urb_interval = interval;
-                dbg("%s - port %d read & write intervals forced to %d",
-                    __func__, port->number, interval);
+                dev_dbg(&port->dev, "%s - read & write intervals forced to %d\n",
+                        __func__, interval);
         } else {
                 priv->write_urb_interval = port->interrupt_out_urb->interval;
                 priv->read_urb_interval = port->interrupt_in_urb->interval;
-                dbg("%s - port %d intervals: read=%d write=%d",
-                    __func__, port->number,
-                    priv->read_urb_interval, priv->write_urb_interval);
+                dev_dbg(&port->dev, "%s - intervals: read=%d write=%d\n",
+                        __func__, priv->read_urb_interval,
+                        priv->write_urb_interval);
         }
         usb_set_serial_port_data(port, priv);
 
@@ -495,8 +496,7 @@ static int cypress_earthmate_startup(struct usb_serial *serial)
         struct usb_serial_port *port = serial->port[0];
 
         if (generic_startup(serial)) {
-                dbg("%s - Failed setting up port %d", __func__,
-                                port->number);
+                dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__);
                 return 1;
         }
 
@@ -511,8 +511,9 @@ static int cypress_earthmate_startup(struct usb_serial *serial)
                    handle GET_CONFIG requests; everything they've
                    produced since that time crashes if this command is
                    attempted :-( */
-                dbg("%s - Marking this device as unsafe for GET_CONFIG "
-                    "commands", __func__);
+                dev_dbg(&port->dev,
+                        "%s - Marking this device as unsafe for GET_CONFIG commands\n",
+                        __func__);
                 priv->get_cfg_unsafe = !0;
         }
 
@@ -523,14 +524,14 @@ static int cypress_earthmate_startup(struct usb_serial *serial)
 static int cypress_hidcom_startup(struct usb_serial *serial)
 {
         struct cypress_private *priv;
+        struct usb_serial_port *port = serial->port[0];
 
         if (generic_startup(serial)) {
-                dbg("%s - Failed setting up port %d", __func__,
-                                serial->port[0]->number);
+                dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__);
                 return 1;
         }
 
-        priv = usb_get_serial_port_data(serial->port[0]);
+        priv = usb_get_serial_port_data(port);
         priv->chiptype = CT_CYPHIDCOM;
 
         return 0;
@@ -540,14 +541,14 @@ static int cypress_hidcom_startup(struct usb_serial *serial)
 static int cypress_ca42v2_startup(struct usb_serial *serial)
 {
         struct cypress_private *priv;
+        struct usb_serial_port *port = serial->port[0];
 
         if (generic_startup(serial)) {
-                dbg("%s - Failed setting up port %d", __func__,
-                                serial->port[0]->number);
+                dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__);
                 return 1;
         }
 
-        priv = usb_get_serial_port_data(serial->port[0]);
+        priv = usb_get_serial_port_data(port);
         priv->chiptype = CT_CA42V2;
 
         return 0;
@@ -649,7 +650,7 @@ static void cypress_close(struct usb_serial_port *port)
         kfifo_reset_out(&priv->write_fifo);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s - stopping urbs", __func__);
+        dev_dbg(&port->dev, "%s - stopping urbs\n", __func__);
         usb_kill_urb(port->interrupt_in_urb);
         usb_kill_urb(port->interrupt_out_urb);
 
@@ -665,7 +666,7 @@ static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
 
-        dbg("%s - port %d, %d bytes", __func__, port->number, count);
+        dev_dbg(&port->dev, "%s - port %d, %d bytes\n", __func__, port->number, count);
 
         /* line control commands, which need to be executed immediately,
            are not put into the buffer for obvious reasons.
@@ -691,17 +692,18 @@ static void cypress_send(struct usb_serial_port *port)
 {
         int count = 0, result, offset, actual_size;
         struct cypress_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         unsigned long flags;
 
         if (!priv->comm_is_ok)
                 return;
 
-        dbg("%s - interrupt out size is %d", __func__,
-                                                port->interrupt_out_size);
+        dev_dbg(dev, "%s - interrupt out size is %d\n", __func__,
+                port->interrupt_out_size);
 
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->write_urb_in_use) {
-                dbg("%s - can't write, urb in use", __func__);
+                dev_dbg(dev, "%s - can't write, urb in use\n", __func__);
                 spin_unlock_irqrestore(&priv->lock, flags);
                 return;
         }
@@ -731,7 +733,7 @@ static void cypress_send(struct usb_serial_port *port)
 
         if (priv->cmd_ctrl) {
                 priv->cmd_count++;
-                dbg("%s - line control command being issued", __func__);
+                dev_dbg(dev, "%s - line control command being issued\n", __func__);
                 spin_unlock_irqrestore(&priv->lock, flags);
                 goto send;
         } else
@@ -753,7 +755,7 @@ static void cypress_send(struct usb_serial_port *port)
                 port->interrupt_out_buffer[0] |= count;
         }
 
-        dbg("%s - count is %d", __func__, count);
+        dev_dbg(dev, "%s - count is %d\n", __func__, count);
 
 send:
         spin_lock_irqsave(&priv->lock, flags);
@@ -766,9 +768,8 @@ send:
                 actual_size = count +
                               (priv->pkt_fmt == packet_format_1 ? 2 : 1);
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                port->interrupt_out_size,
-                port->interrupt_out_urb->transfer_buffer);
+        usb_serial_debug_data(dev, __func__, port->interrupt_out_size,
+                              port->interrupt_out_urb->transfer_buffer);
 
         usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev,
                 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),
@@ -807,7 +808,7 @@ static int cypress_write_room(struct tty_struct *tty)
         room = kfifo_avail(&priv->write_fifo);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
         return room;
 }
 
@@ -832,7 +833,7 @@ static int cypress_tiocmget(struct tty_struct *tty)
                 | ((status & UART_RI)         ? TIOCM_RI  : 0)
                 | ((status & UART_CD)         ? TIOCM_CD  : 0);
 
-        dbg("%s - result = %x", __func__, result);
+        dev_dbg(&port->dev, "%s - result = %x\n", __func__, result);
 
         return result;
 }
@@ -867,7 +868,7 @@ static int cypress_ioctl(struct tty_struct *tty,
         struct usb_serial_port *port = tty->driver_data;
         struct cypress_private *priv = usb_get_serial_port_data(port);
 
-        dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd);
 
         switch (cmd) {
         /* This code comes from drivers/char/serial.c and ftdi_sio.c */
@@ -902,7 +903,7 @@ static int cypress_ioctl(struct tty_struct *tty,
         default:
                 break;
         }
-        dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
+        dev_dbg(&port->dev, "%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h\n", __func__, cmd);
         return -ENOIOCTLCMD;
 } /* cypress_ioctl */
 
@@ -911,6 +912,7 @@ static void cypress_set_termios(struct tty_struct *tty,
         struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct cypress_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         int data_bits, stop_bits, parity_type, parity_enable;
         unsigned cflag, iflag;
         unsigned long flags;
@@ -984,23 +986,21 @@ static void cypress_set_termios(struct tty_struct *tty,
                 data_bits = 3;
                 break;
         default:
-                dev_err(&port->dev, "%s - CSIZE was set, but not CS5-CS8\n",
-                        __func__);
+                dev_err(dev, "%s - CSIZE was set, but not CS5-CS8\n", __func__);
                 data_bits = 3;
         }
         spin_lock_irqsave(&priv->lock, flags);
         oldlines = priv->line_control;
         if ((cflag & CBAUD) == B0) {
                 /* drop dtr and rts */
-                dbg("%s - dropping the lines, baud rate 0bps", __func__);
+                dev_dbg(dev, "%s - dropping the lines, baud rate 0bps\n", __func__);
                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
         } else
                 priv->line_control = (CONTROL_DTR | CONTROL_RTS);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
-                        "%d data_bits (+5)", __func__, stop_bits,
-                        parity_enable, parity_type, data_bits);
+        dev_dbg(dev, "%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)\n",
+                __func__, stop_bits, parity_enable, parity_type, data_bits);
 
         cypress_serial_control(tty, port, tty_get_baud_rate(tty),
                         data_bits, stop_bits,
@@ -1017,8 +1017,7 @@ static void cypress_set_termios(struct tty_struct *tty,
 
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->chiptype == CT_EARTHMATE && priv->baud_rate == 4800) {
-                dbg("Using custom termios settings for a baud rate of "
-                                "4800bps.");
+                dev_dbg(dev, "Using custom termios settings for a baud rate of 4800bps.\n");
                 /* define custom termios settings for NMEA protocol */
 
                 tty->termios.c_iflag /* input modes - */
@@ -1067,7 +1066,7 @@ static int cypress_chars_in_buffer(struct tty_struct *tty)
         chars = kfifo_len(&priv->write_fifo);
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s - returns %d", __func__, chars);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
         return chars;
 }
 
@@ -1112,6 +1111,7 @@ static void cypress_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cypress_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &urb->dev->dev;
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         unsigned long flags;
@@ -1135,16 +1135,15 @@ static void cypress_read_int_callback(struct urb *urb)
                 /* FALLS THROUGH */
         default:
                 /* something ugly is going on... */
-                dev_err(&urb->dev->dev,
-                        "%s - unexpected nonzero read status received: %d\n",
-                                                        __func__, status);
+                dev_err(dev, "%s - unexpected nonzero read status received: %d\n",
+                        __func__, status);
                 cypress_set_dead(port);
                 return;
         }
 
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->rx_flags & THROTTLED) {
-                dbg("%s - now throttling", __func__);
+                dev_dbg(dev, "%s - now throttling\n", __func__);
                 priv->rx_flags |= ACTUALLY_THROTTLED;
                 spin_unlock_irqrestore(&priv->lock, flags);
                 return;
@@ -1153,7 +1152,7 @@ static void cypress_read_int_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&port->port);
         if (!tty) {
-                dbg("%s - bad tty pointer - exiting", __func__);
+                dev_dbg(dev, "%s - bad tty pointer - exiting\n", __func__);
                 return;
         }
 
@@ -1180,13 +1179,13 @@ static void cypress_read_int_callback(struct urb *urb)
         }
         spin_unlock_irqrestore(&priv->lock, flags);
         if (result < bytes) {
-                dbg("%s - wrong packet size - received %d bytes but packet "
-                    "said %d bytes", __func__, result, bytes);
+                dev_dbg(dev,
+                        "%s - wrong packet size - received %d bytes but packet said %d bytes\n",
+                        __func__, result, bytes);
                 goto continue_read;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                                urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         spin_lock_irqsave(&priv->lock, flags);
         /* check to see if status has changed */
@@ -1202,7 +1201,7 @@ static void cypress_read_int_callback(struct urb *urb)
          * though */
         if (tty && !(tty->termios.c_cflag & CLOCAL) &&
                         !(priv->current_status & UART_CD)) {
-                dbg("%s - calling hangup", __func__);
+                dev_dbg(dev, "%s - calling hangup\n", __func__);
                 tty_hangup(tty);
                 goto continue_read;
         }
@@ -1215,7 +1214,7 @@ static void cypress_read_int_callback(struct urb *urb)
         if (priv->current_status & CYP_ERROR) {
                 spin_unlock_irqrestore(&priv->lock, flags);
                 tty_flag = TTY_PARITY;
-                dbg("%s - Parity Error detected", __func__);
+                dev_dbg(dev, "%s - Parity Error detected\n", __func__);
         } else
                 spin_unlock_irqrestore(&priv->lock, flags);
 
@@ -1246,9 +1245,8 @@ continue_read:
                                 priv->read_urb_interval);
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
                 if (result && result != -EPERM) {
-                        dev_err(&urb->dev->dev, "%s - failed resubmitting "
-                                        "read urb, error %d\n", __func__,
-                                        result);
+                        dev_err(dev, "%s - failed resubmitting read urb, error %d\n",
+                                __func__, result);
                         cypress_set_dead(port);
                 }
         }
@@ -1259,6 +1257,7 @@ static void cypress_write_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct cypress_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &urb->dev->dev;
         int result;
         int status = urb->status;
 
@@ -1270,8 +1269,8 @@ static void cypress_write_int_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                                                __func__, status);
+                dev_dbg(dev, "%s - urb shutting down with status: %d\n",
+                        __func__, status);
                 priv->write_urb_in_use = 0;
                 return;
         case -EPIPE: /* no break needed; clear halt and resubmit */
@@ -1279,21 +1278,19 @@ static void cypress_write_int_callback(struct urb *urb)
                         break;
                 usb_clear_halt(port->serial->dev, 0x02);
                 /* error in the urb, so we have to resubmit it */
-                dbg("%s - nonzero write bulk status received: %d",
+                dev_dbg(dev, "%s - nonzero write bulk status received: %d\n",
                         __func__, status);
                 port->interrupt_out_urb->transfer_buffer_length = 1;
                 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC);
                 if (!result)
                         return;
-                dev_err(&urb->dev->dev,
-                        "%s - failed resubmitting write urb, error %d\n",
-                                                        __func__, result);
+                dev_err(dev, "%s - failed resubmitting write urb, error %d\n",
+                        __func__, result);
                 cypress_set_dead(port);
                 break;
         default:
-                dev_err(&urb->dev->dev,
-                         "%s - unexpected nonzero write status received: %d\n",
-                                                        __func__, status);
+                dev_err(dev, "%s - unexpected nonzero write status received: %d\n",
+                        __func__, status);
                 cypress_set_dead(port);
                 break;
         }
@@ -1310,8 +1307,6 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
 module_param(stats, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(stats, "Enable statistics or not");
 module_param(interval, int, S_IRUGO | S_IWUSR);
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index afd9d2ec577b..c86f68c6b078 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -249,10 +249,6 @@ static int digi_read_inb_callback(struct urb *urb);
 static int digi_read_oob_callback(struct urb *urb);
 
 
-/* Statics */
-
-static bool debug;
-
 static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_2_ID) },
         { USB_DEVICE(DIGI_VENDOR_ID, DIGI_4_ID) },
@@ -404,14 +400,15 @@ static void digi_wakeup_write(struct usb_serial_port *port)
 static int digi_write_oob_command(struct usb_serial_port *port,
         unsigned char *buf, int count, int interruptible)
 {
-
         int ret = 0;
         int len;
         struct usb_serial_port *oob_port = (struct usb_serial_port *)((struct digi_serial *)(usb_get_serial_data(port->serial)))->ds_oob_port;
         struct digi_port *oob_priv = usb_get_serial_port_data(oob_port);
         unsigned long flags = 0;
 
-        dbg("digi_write_oob_command: TOP: port=%d, count=%d", oob_priv->dp_port_num, count);
+        dev_dbg(&port->dev,
+                "digi_write_oob_command: TOP: port=%d, count=%d\n",
+                oob_priv->dp_port_num, count);
 
         spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
         while (count > 0) {
@@ -467,7 +464,7 @@ static int digi_write_inb_command(struct usb_serial_port *port,
         unsigned char *data = port->write_urb->transfer_buffer;
         unsigned long flags = 0;
 
-        dbg("digi_write_inb_command: TOP: port=%d, count=%d",
+        dev_dbg(&port->dev, "digi_write_inb_command: TOP: port=%d, count=%d\n",
                 priv->dp_port_num, count);
 
         if (timeout)
@@ -549,7 +546,8 @@ static int digi_set_modem_signals(struct usb_serial_port *port,
         unsigned long flags = 0;
 
 
-        dbg("digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x",
+        dev_dbg(&port->dev,
+                "digi_set_modem_signals: TOP: port=%d, modem_signals=0x%x\n",
                 port_priv->dp_port_num, modem_signals);
 
         spin_lock_irqsave(&oob_priv->dp_port_lock, flags);
@@ -687,6 +685,7 @@ static void digi_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct digi_port *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         unsigned int iflag = tty->termios.c_iflag;
         unsigned int cflag = tty->termios.c_cflag;
         unsigned int old_iflag = old_termios->c_iflag;
@@ -697,7 +696,9 @@ static void digi_set_termios(struct tty_struct *tty,
         int i = 0;
         speed_t baud;
 
-        dbg("digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x", priv->dp_port_num, iflag, old_iflag, cflag, old_cflag);
+        dev_dbg(dev,
+                "digi_set_termios: TOP: port=%d, iflag=0x%x, old_iflag=0x%x, cflag=0x%x, old_cflag=0x%x\n",
+                priv->dp_port_num, iflag, old_iflag, cflag, old_cflag);
 
         /* set baud rate */
         baud = tty_get_baud_rate(tty);
@@ -773,7 +774,8 @@ static void digi_set_termios(struct tty_struct *tty,
                 case CS7: arg = DIGI_WORD_SIZE_7; break;
                 case CS8: arg = DIGI_WORD_SIZE_8; break;
                 default:
-                        dbg("digi_set_termios: can't handle word size %d",
+                        dev_dbg(dev,
+                                "digi_set_termios: can't handle word size %d\n",
                                 (cflag&CSIZE));
                         break;
                 }
@@ -866,7 +868,7 @@ static void digi_set_termios(struct tty_struct *tty,
         }
         ret = digi_write_oob_command(port, buf, i, 1);
         if (ret != 0)
-                dbg("digi_set_termios: write oob failed, ret=%d", ret);
+                dev_dbg(dev, "digi_set_termios: write oob failed, ret=%d\n", ret);
         tty_encode_baud_rate(tty, baud, baud);
 }
 
@@ -922,7 +924,8 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
         unsigned char *data = port->write_urb->transfer_buffer;
         unsigned long flags = 0;
 
-        dbg("digi_write: TOP: port=%d, count=%d, in_interrupt=%ld",
+        dev_dbg(&port->dev,
+                "digi_write: TOP: port=%d, count=%d, in_interrupt=%ld\n",
                 priv->dp_port_num, count, in_interrupt());
 
         /* copy user data (which can sleep) before getting spin lock */
@@ -981,7 +984,7 @@ static int digi_write(struct tty_struct *tty, struct usb_serial_port *port,
                 dev_err_console(port,
                         "%s: usb_submit_urb failed, ret=%d, port=%d\n",
                         __func__, ret, priv->dp_port_num);
-        dbg("digi_write: returning %d", ret);
+        dev_dbg(&port->dev, "digi_write: returning %d\n", ret);
         return ret;
 
 }
@@ -1012,7 +1015,7 @@ static void digi_write_bulk_callback(struct urb *urb)
 
         /* handle oob callback */
         if (priv->dp_port_num == serial_priv->ds_oob_port_num) {
-                dbg("digi_write_bulk_callback: oob callback");
+                dev_dbg(&port->dev, "digi_write_bulk_callback: oob callback\n");
                 spin_lock(&priv->dp_port_lock);
                 priv->dp_write_urb_in_use = 0;
                 wake_up_interruptible(&port->write_wait);
@@ -1066,7 +1069,7 @@ static int digi_write_room(struct tty_struct *tty)
                 room = port->bulk_out_size - 2 - priv->dp_out_buf_len;
 
         spin_unlock_irqrestore(&priv->dp_port_lock, flags);
-        dbg("digi_write_room: port=%d, room=%d", priv->dp_port_num, room);
+        dev_dbg(&port->dev, "digi_write_room: port=%d, room=%d\n", priv->dp_port_num, room);
         return room;
 
 }
@@ -1077,12 +1080,12 @@ static int digi_chars_in_buffer(struct tty_struct *tty)
         struct digi_port *priv = usb_get_serial_port_data(port);
 
         if (priv->dp_write_urb_in_use) {
-                dbg("digi_chars_in_buffer: port=%d, chars=%d",
+                dev_dbg(&port->dev, "digi_chars_in_buffer: port=%d, chars=%d\n",
                         priv->dp_port_num, port->bulk_out_size - 2);
                 /* return(port->bulk_out_size - 2); */
                 return 256;
         } else {
-                dbg("digi_chars_in_buffer: port=%d, chars=%d",
+                dev_dbg(&port->dev, "digi_chars_in_buffer: port=%d, chars=%d\n",
                         priv->dp_port_num, priv->dp_out_buf_len);
                 return priv->dp_out_buf_len;
         }
@@ -1120,7 +1123,7 @@ static int digi_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         ret = digi_write_oob_command(port, buf, 8, 1);
         if (ret != 0)
-                dbg("digi_open: write oob failed, ret=%d", ret);
+                dev_dbg(&port->dev, "digi_open: write oob failed, ret=%d\n", ret);
 
         /* set termios settings */
         if (tty) {
@@ -1180,7 +1183,7 @@ static void digi_close(struct usb_serial_port *port)
 
                 ret = digi_write_oob_command(port, buf, 20, 0);
                 if (ret != 0)
-                        dbg("digi_close: write oob failed, ret=%d", ret);
+                        dev_dbg(&port->dev, "digi_close: write oob failed, ret=%d\n", ret);
 
                 /* wait for final commands on oob port to complete */
                 prepare_to_wait(&priv->dp_flush_wait, &wait,
@@ -1448,9 +1451,9 @@ static int digi_read_inb_callback(struct urb *urb)
         tty_kref_put(tty);
 
         if (opcode == DIGI_CMD_RECEIVE_DISABLE)
-                dbg("%s: got RECEIVE_DISABLE", __func__);
+                dev_dbg(&port->dev, "%s: got RECEIVE_DISABLE\n", __func__);
         else if (opcode != DIGI_CMD_RECEIVE_DATA)
-                dbg("%s: unknown opcode: %d", __func__, opcode);
+                dev_dbg(&port->dev, "%s: unknown opcode: %d\n", __func__, opcode);
 
         return throttled ? 1 : 0;
 
@@ -1484,7 +1487,7 @@ static int digi_read_oob_callback(struct urb *urb)
                 status = ((unsigned char *)urb->transfer_buffer)[i++];
                 val = ((unsigned char *)urb->transfer_buffer)[i++];
 
-                dbg("digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d",
+                dev_dbg(&port->dev, "digi_read_oob_callback: opcode=%d, line=%d, status=%d, val=%d\n",
                         opcode, line, status, val);
 
                 if (status != 0 || line >= serial->type->num_ports)
@@ -1552,6 +1555,3 @@ module_usb_serial_driver(serial_drivers, id_table_combined);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/empeg.c b/drivers/usb/serial/empeg.c
index 34e86383090a..43ede4a1e12c 100644
--- a/drivers/usb/serial/empeg.c
+++ b/drivers/usb/serial/empeg.c
@@ -28,8 +28,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -134,6 +132,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ezusb.c b/drivers/usb/serial/ezusb.c
deleted file mode 100644
index 800e8eb60003..000000000000
--- a/drivers/usb/serial/ezusb.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * EZ-USB specific functions used by some of the USB to Serial drivers.
- *
- * Copyright (C) 1999 - 2002 Greg Kroah-Hartman (greg@kroah.com)
- *
- *      This program is free software; you can redistribute it and/or
- *      modify it under the terms of the GNU General Public License version
- *      2 as published by the Free Software Foundation.
- */
-
-#include <linux/kernel.h>
-#include <linux/errno.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/tty.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include <linux/usb/serial.h>
-
-/* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */
-#define CPUCS_REG    0x7F92
-
-int ezusb_writememory(struct usb_serial *serial, int address,
-                                unsigned char *data, int length, __u8 request)
-{
-        int result;
-        unsigned char *transfer_buffer;
-
-        if (!serial->dev) {
-                printk(KERN_ERR "ezusb: %s - no physical device present, "
-                       "failing.\n", __func__);
-                return -ENODEV;
-        }
-
-        transfer_buffer = kmemdup(data, length, GFP_KERNEL);
-        if (!transfer_buffer) {
-                dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
-                                                        __func__, length);
-                return -ENOMEM;
-        }
-        result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
-                     request, 0x40, address, 0, transfer_buffer, length, 3000);
-        kfree(transfer_buffer);
-        return result;
-}
-EXPORT_SYMBOL_GPL(ezusb_writememory);
-
-int ezusb_set_reset(struct usb_serial *serial, unsigned char reset_bit)
-{
-        int response;
-
-        response = ezusb_writememory(serial, CPUCS_REG, &reset_bit, 1, 0xa0);
-        if (response < 0)
-                dev_err(&serial->dev->dev, "%s- %d failed\n",
-                                                __func__, reset_bit);
-        return response;
-}
-EXPORT_SYMBOL_GPL(ezusb_set_reset);
-
diff --git a/drivers/usb/serial/f81232.c b/drivers/usb/serial/f81232.c
index 79451ee12ca0..244477107e2f 100644
--- a/drivers/usb/serial/f81232.c
+++ b/drivers/usb/serial/f81232.c
@@ -25,8 +25,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1934, 0x0706) },
         { }                                     /* Terminating entry */
@@ -85,7 +83,7 @@ static void f81232_read_int_callback(struct urb *urb)
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
+        usb_serial_debug_data(&port->dev, __func__,
                               urb->actual_length, urb->transfer_buffer);
 
         f81232_update_line_status(port, data, actual_length);
@@ -389,7 +387,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_DESCRIPTION("Fintek F81232 USB to serial adaptor driver");
 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org");
 MODULE_LICENSE("GPL v2");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 0c8d1c226273..be845873e23d 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -48,14 +48,9 @@
 #include "ftdi_sio.h"
 #include "ftdi_sio_ids.h"
 
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v1.6.0"
 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr, Johan Hovold <jhovold@gmail.com>"
 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 
-static bool debug;
 static __u16 vendor = FTDI_VID;
 static __u16 product;
 
@@ -584,6 +579,8 @@ static struct usb_device_id id_table_combined [] = {
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
         { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
+        { USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID),
+                .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
         /*
          * ELV devices:
          */
@@ -1063,11 +1060,12 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                                         unsigned int clear)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         unsigned urb_value;
         int rv;
 
         if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
-                dbg("%s - DTR|RTS not being set|cleared", __func__);
+                dev_dbg(dev, "%s - DTR|RTS not being set|cleared\n", __func__);
                 return 0;       /* no change */
         }
 
@@ -1088,18 +1086,14 @@ static int update_mctrl(struct usb_serial_port *port, unsigned int set,
                                urb_value, priv->interface,
                                NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
-                dbg("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
-                                __func__,
-                                (set & TIOCM_DTR) ? "HIGH" :
-                                (clear & TIOCM_DTR) ? "LOW" : "unchanged",
-                                (set & TIOCM_RTS) ? "HIGH" :
-                                (clear & TIOCM_RTS) ? "LOW" : "unchanged");
+                dev_dbg(dev, "%s Error from MODEM_CTRL urb: DTR %s, RTS %s\n",
+                        __func__,
+                        (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
+                        (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
         } else {
-                dbg("%s - DTR %s, RTS %s", __func__,
-                                (set & TIOCM_DTR) ? "HIGH" :
-                                (clear & TIOCM_DTR) ? "LOW" : "unchanged",
-                                (set & TIOCM_RTS) ? "HIGH" :
-                                (clear & TIOCM_RTS) ? "LOW" : "unchanged");
+                dev_dbg(dev, "%s - DTR %s, RTS %s\n", __func__,
+                        (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
+                        (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
                 /* FIXME: locking on last_dtr_rts */
                 priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
         }
@@ -1111,6 +1105,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                                                 struct usb_serial_port *port)
 {
         struct ftdi_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         __u32 div_value = 0;
         int div_okay = 1;
         int baud;
@@ -1146,7 +1141,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
               alt_speed hack */
 
         baud = tty_get_baud_rate(tty);
-        dbg("%s - tty_get_baud_rate reports speed %d", __func__, baud);
+        dev_dbg(dev, "%s - tty_get_baud_rate reports speed %d\n", __func__, baud);
 
         /* 2. Observe async-compatible custom_divisor hack, update baudrate
            if needed */
@@ -1155,8 +1150,8 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
             ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
              (priv->custom_divisor)) {
                 baud = priv->baud_base / priv->custom_divisor;
-                dbg("%s - custom divisor %d sets baud rate to %d",
-                                __func__, priv->custom_divisor, baud);
+                dev_dbg(dev, "%s - custom divisor %d sets baud rate to %d\n",
+                        __func__, priv->custom_divisor, baud);
         }
 
         /* 3. Convert baudrate to device-specific divisor */
@@ -1178,8 +1173,8 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                 case 115200: div_value = ftdi_sio_b115200; break;
                 } /* baud */
                 if (div_value == 0) {
-                        dbg("%s - Baudrate (%d) requested is not supported",
-                                                        __func__,  baud);
+                        dev_dbg(dev, "%s - Baudrate (%d) requested is not supported\n",
+                                __func__,  baud);
                         div_value = ftdi_sio_b9600;
                         baud = 9600;
                         div_okay = 0;
@@ -1189,7 +1184,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                 if (baud <= 3000000) {
                         div_value = ftdi_232am_baud_to_divisor(baud);
                 } else {
-                        dbg("%s - Baud rate too high!", __func__);
+                        dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
                         baud = 9600;
                         div_value = ftdi_232am_baud_to_divisor(9600);
                         div_okay = 0;
@@ -1212,7 +1207,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                         }
                         div_value = ftdi_232bm_baud_to_divisor(baud);
                 } else {
-                        dbg("%s - Baud rate too high!", __func__);
+                        dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
                         div_value = ftdi_232bm_baud_to_divisor(9600);
                         div_okay = 0;
                         baud = 9600;
@@ -1226,7 +1221,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
                 } else if (baud < 1200) {
                         div_value = ftdi_232bm_baud_to_divisor(baud);
                 } else {
-                        dbg("%s - Baud rate too high!", __func__);
+                        dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
                         div_value = ftdi_232bm_baud_to_divisor(9600);
                         div_okay = 0;
                         baud = 9600;
@@ -1235,7 +1230,7 @@ static __u32 get_ftdi_divisor(struct tty_struct *tty,
         } /* priv->chip_type */
 
         if (div_okay) {
-                dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
+                dev_dbg(dev, "%s - Baud rate set to %d (divisor 0x%lX) on chip %s\n",
                         __func__, baud, (unsigned long)div_value,
                         ftdi_chip_name[priv->chip_type]);
         }
@@ -1281,7 +1276,7 @@ static int write_latency_timer(struct usb_serial_port *port)
         if (priv->flags & ASYNC_LOW_LATENCY)
                 l = 1;
 
-        dbg("%s: setting latency timer = %i", __func__, l);
+        dev_dbg(&port->dev, "%s: setting latency timer = %i\n", __func__, l);
 
         rv = usb_control_msg(udev,
                              usb_sndctrlpipe(udev, 0),
@@ -1436,8 +1431,8 @@ static void ftdi_determine_type(struct usb_serial_port *port)
 
         version = le16_to_cpu(udev->descriptor.bcdDevice);
         interfaces = udev->actconfig->desc.bNumInterfaces;
-        dbg("%s: bcdDevice = 0x%x, bNumInterfaces = %u", __func__,
-                        version, interfaces);
+        dev_dbg(&port->dev, "%s: bcdDevice = 0x%x, bNumInterfaces = %u\n", __func__,
+                version, interfaces);
         if (interfaces > 1) {
                 int inter;
 
@@ -1467,8 +1462,9 @@ static void ftdi_determine_type(struct usb_serial_port *port)
                 /* BM-type devices have a bug where bcdDevice gets set
                  * to 0x200 when iSerialNumber is 0.  */
                 if (version < 0x500) {
-                        dbg("%s: something fishy - bcdDevice too low for multi-interface device",
-                                        __func__);
+                        dev_dbg(&port->dev,
+                                "%s: something fishy - bcdDevice too low for multi-interface device\n",
+                                __func__);
                 }
         } else if (version < 0x200) {
                 /* Old device.  Assume it's the original SIO. */
@@ -1582,7 +1578,7 @@ static ssize_t store_event_char(struct device *dev,
         int v = simple_strtoul(valbuf, NULL, 10);
         int rv;
 
-        dbg("%s: setting event char = %i", __func__, v);
+        dev_dbg(&port->dev, "%s: setting event char = %i\n", __func__, v);
 
         rv = usb_control_msg(udev,
                              usb_sndctrlpipe(udev, 0),
@@ -1591,7 +1587,7 @@ static ssize_t store_event_char(struct device *dev,
                              v, priv->interface,
                              NULL, 0, WDR_TIMEOUT);
         if (rv < 0) {
-                dbg("Unable to write event character: %i", rv);
+                dev_dbg(&port->dev, "Unable to write event character: %i\n", rv);
                 return -EIO;
         }
 
@@ -1610,7 +1606,7 @@ static int create_sysfs_attrs(struct usb_serial_port *port)
         /* XXX I've no idea if the original SIO supports the event_char
          * sysfs parameter, so I'm playing it safe.  */
         if (priv->chip_type != SIO) {
-                dbg("sysfs attributes for %s", ftdi_chip_name[priv->chip_type]);
+                dev_dbg(&port->dev, "sysfs attributes for %s\n", ftdi_chip_name[priv->chip_type]);
                 retval = device_create_file(&port->dev, &dev_attr_event_char);
                 if ((!retval) &&
                     (priv->chip_type == FT232BM ||
@@ -1750,8 +1746,8 @@ static int ftdi_NDI_device_setup(struct usb_serial *serial)
         if (latency > 99)
                 latency = 99;
 
-        dbg("%s setting NDI device latency to %d", __func__, latency);
-        dev_info(&udev->dev, "NDI device with a latency value of %d", latency);
+        dev_dbg(&udev->dev, "%s setting NDI device latency to %d\n", __func__, latency);
+        dev_info(&udev->dev, "NDI device with a latency value of %d\n", latency);
 
         /* FIXME: errors are not returned */
         usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
@@ -1969,7 +1965,7 @@ static int ftdi_process_packet(struct tty_struct *tty,
         char *ch;
 
         if (len < 2) {
-                dbg("malformed packet");
+                dev_dbg(&port->dev, "malformed packet\n");
                 return 0;
         }
 
@@ -2084,12 +2080,12 @@ static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
                         FTDI_SIO_SET_DATA_REQUEST_TYPE,
                         urb_value , priv->interface,
                         NULL, 0, WDR_TIMEOUT) < 0) {
-                dev_err(&port->dev, "%s FAILED to enable/disable break state "
-                        "(state was %d)\n", __func__, break_state);
+                dev_err(&port->dev, "%s FAILED to enable/disable break state (state was %d)\n",
+                        __func__, break_state);
         }
 
-        dbg("%s break state is %d - urb is %d", __func__,
-                                                break_state, urb_value);
+        dev_dbg(&port->dev, "%s break state is %d - urb is %d\n", __func__,
+                break_state, urb_value);
 
 }
 
@@ -2101,6 +2097,7 @@ static void ftdi_set_termios(struct tty_struct *tty,
                 struct usb_serial_port *port, struct ktermios *old_termios)
 {
         struct usb_device *dev = port->serial->dev;
+        struct device *ddev = &port->dev;
         struct ftdi_private *priv = usb_get_serial_port_data(port);
         struct ktermios *termios = &tty->termios;
         unsigned int cflag = termios->c_cflag;
@@ -2114,20 +2111,20 @@ static void ftdi_set_termios(struct tty_struct *tty,
         /* Force baud rate if this device requires it, unless it is set to
            B0. */
         if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
-                dbg("%s: forcing baud rate for this device", __func__);
+                dev_dbg(ddev, "%s: forcing baud rate for this device\n", __func__);
                 tty_encode_baud_rate(tty, priv->force_baud,
                                         priv->force_baud);
         }
 
         /* Force RTS-CTS if this device requires it. */
         if (priv->force_rtscts) {
-                dbg("%s: forcing rtscts for this device", __func__);
+                dev_dbg(ddev, "%s: forcing rtscts for this device\n", __func__);
                 termios->c_cflag |= CRTSCTS;
         }
 
         cflag = termios->c_cflag;
 
-        if (old_termios == 0)
+        if (!old_termios)
                 goto no_skip;
 
         if (old_termios->c_cflag == termios->c_cflag
@@ -2163,10 +2160,16 @@ no_skip:
         }
         if (cflag & CSIZE) {
                 switch (cflag & CSIZE) {
-                case CS7: urb_value |= 7; dbg("Setting CS7"); break;
-                case CS8: urb_value |= 8; dbg("Setting CS8"); break;
+                case CS7:
+                        urb_value |= 7;
+                        dev_dbg(ddev, "Setting CS7\n");
+                        break;
+                case CS8:
+                        urb_value |= 8;
+                        dev_dbg(ddev, "Setting CS8\n");
+                        break;
                 default:
-                        dev_err(&port->dev, "CSIZE was set but not CS7-CS8\n");
+                        dev_err(ddev, "CSIZE was set but not CS7-CS8\n");
                 }
         }
 
@@ -2179,8 +2182,8 @@ no_skip:
                             FTDI_SIO_SET_DATA_REQUEST_TYPE,
                             urb_value , priv->interface,
                             NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
-                dev_err(&port->dev, "%s FAILED to set "
-                        "databits/stopbits/parity\n", __func__);
+                dev_err(ddev, "%s FAILED to set databits/stopbits/parity\n",
+                        __func__);
         }
 
         /* Now do the baudrate */
@@ -2192,8 +2195,7 @@ no_data_parity_stop_changes:
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0, priv->interface,
                                     NULL, 0, WDR_TIMEOUT) < 0) {
-                        dev_err(&port->dev,
-                                "%s error from disable flowcontrol urb\n",
+                        dev_err(ddev, "%s error from disable flowcontrol urb\n",
                                 __func__);
                 }
                 /* Drop RTS and DTR */
@@ -2202,8 +2204,7 @@ no_data_parity_stop_changes:
                 /* set the baudrate determined before */
                 mutex_lock(&priv->cfg_lock);
                 if (change_speed(tty, port))
-                        dev_err(&port->dev, "%s urb failed to set baudrate\n",
-                                __func__);
+                        dev_err(ddev, "%s urb failed to set baudrate\n", __func__);
                 mutex_unlock(&priv->cfg_lock);
                 /* Ensure RTS and DTR are raised when baudrate changed from 0 */
                 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0)
@@ -2214,17 +2215,15 @@ no_data_parity_stop_changes:
         /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
 no_c_cflag_changes:
         if (cflag & CRTSCTS) {
-                dbg("%s Setting to CRTSCTS flow control", __func__);
+                dev_dbg(ddev, "%s Setting to CRTSCTS flow control\n", __func__);
                 if (usb_control_msg(dev,
                                     usb_sndctrlpipe(dev, 0),
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                     0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
                                     NULL, 0, WDR_TIMEOUT) < 0) {
-                        dev_err(&port->dev,
-                                "urb failed to set to rts/cts flow control\n");
+                        dev_err(ddev, "urb failed to set to rts/cts flow control\n");
                 }
-
         } else {
                 /*
                  * Xon/Xoff code
@@ -2234,8 +2233,8 @@ no_c_cflag_changes:
                  * code is executed.
                  */
                 if (iflag & IXOFF) {
-                        dbg("%s  request to enable xonxoff iflag=%04x",
-                                                        __func__, iflag);
+                        dev_dbg(ddev, "%s  request to enable xonxoff iflag=%04x\n",
+                                __func__, iflag);
                         /* Try to enable the XON/XOFF on the ftdi_sio
                          * Set the vstart and vstop -- could have been done up
                          * above where a lot of other dereferencing is done but
@@ -2260,18 +2259,16 @@ no_c_cflag_changes:
                         /* else clause to only run if cflag ! CRTSCTS and iflag
                          * ! XOFF. CHECKME Assuming XON/XOFF handled by tty
                          * stack - not by device */
-                        dbg("%s Turning off hardware flow control", __func__);
+                        dev_dbg(ddev, "%s Turning off hardware flow control\n", __func__);
                         if (usb_control_msg(dev,
                                             usb_sndctrlpipe(dev, 0),
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
                                             0, priv->interface,
                                             NULL, 0, WDR_TIMEOUT) < 0) {
-                                dev_err(&port->dev,
-                                        "urb failed to clear flow control\n");
+                                dev_err(ddev, "urb failed to clear flow control\n");
                         }
                 }
-
         }
 }
 
@@ -2365,7 +2362,7 @@ static int ftdi_ioctl(struct tty_struct *tty,
         struct async_icount cnow;
         struct async_icount cprev;
 
-        dbg("%s cmd 0x%04x", __func__, cmd);
+        dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
 
         /* Based on code from acm.c and others */
         switch (cmd) {
@@ -2413,14 +2410,13 @@ static int ftdi_ioctl(struct tty_struct *tty,
         /* This is not necessarily an error - turns out the higher layers
          * will do some ioctls themselves (see comment above)
          */
-        dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __func__, cmd);
+        dev_dbg(&port->dev, "%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h\n",
+                __func__, cmd);
         return -ENOIOCTLCMD;
 }
 
 static int __init ftdi_init(void)
 {
-        int retval;
-
         if (vendor > 0 && product > 0) {
                 /* Add user specified VID/PID to reserved element of table. */
                 int i;
@@ -2430,11 +2426,7 @@ static int __init ftdi_init(void)
                 id_table_combined[i].idVendor = vendor;
                 id_table_combined[i].idProduct = product;
         }
-        retval = usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table_combined);
-        if (retval == 0)
-                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-                               DRIVER_DESC "\n");
-        return retval;
+        return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table_combined);
 }
 
 static void __exit ftdi_exit(void)
@@ -2450,8 +2442,6 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
 module_param(vendor, ushort, 0);
 MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
                 __MODULE_STRING(FTDI_VID)")");
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index 41fe5826100c..57c12ef6625e 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -517,6 +517,11 @@
  */
 #define FTDI_TAVIR_STK500_PID   0xFA33  /* STK500 AVR programmer */
 
+/*
+ * TIAO product ids (FTDI_VID)
+ * http://www.tiaowiki.com/w/Main_Page
+ */
+#define FTDI_TIAO_UMPA_PID      0x8a98  /* TIAO/DIYGADGET USB Multi-Protocol Adapter */
 
 
 /********************************/
diff --git a/drivers/usb/serial/funsoft.c b/drivers/usb/serial/funsoft.c
index 235707961ca3..9362f8fd2385 100644
--- a/drivers/usb/serial/funsoft.c
+++ b/drivers/usb/serial/funsoft.c
@@ -16,8 +16,6 @@
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x1404, 0xcddc) },
         { },
@@ -40,6 +38,3 @@ static struct usb_serial_driver * const serial_drivers[] = {
 module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/garmin_gps.c b/drivers/usb/serial/garmin_gps.c
index 346c15a51066..3ee92648c02d 100644
--- a/drivers/usb/serial/garmin_gps.c
+++ b/drivers/usb/serial/garmin_gps.c
@@ -41,9 +41,6 @@
 /* the mode to be set when the port ist opened */
 static int initial_mode = 1;
 
-/* debug flag */
-static bool debug;
-
 #define GARMIN_VENDOR_ID             0x091E
 
 /*
@@ -258,10 +255,7 @@ static void send_to_tty(struct usb_serial_port *port,
         struct tty_struct *tty = tty_port_tty_get(&port->port);
 
         if (tty && actual_length) {
-
-                usb_serial_debug_data(debug, &port->dev,
-                                        __func__, actual_length, data);
-
+                usb_serial_debug_data(&port->dev, __func__, actual_length, data);
                 tty_insert_flip_string(tty, data, actual_length);
                 tty_flip_buffer_push(tty);
         }
@@ -303,8 +297,9 @@ static int pkt_add(struct garmin_data *garmin_data_p,
                 state = garmin_data_p->state;
                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
-                dbg("%s - added: pkt: %d - %d bytes",
-                        __func__, pkt->seq, data_length);
+                dev_dbg(&garmin_data_p->port->dev,
+                        "%s - added: pkt: %d - %d bytes\n", __func__,
+                        pkt->seq, data_length);
 
                 /* in serial mode, if someone is waiting for data from
                    the device, convert and send the next packet to tty. */
@@ -359,7 +354,8 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
         __u8 *ptr = pkt;
         unsigned  l = 0;
 
-        dbg("%s - pkt-id: 0x%X.", __func__, 0xFF & pkt_id);
+        dev_dbg(&garmin_data_p->port->dev, "%s - pkt-id: 0x%X.\n", __func__,
+                0xFF & pkt_id);
 
         *ptr++ = DLE;
         *ptr++ = ACK;
@@ -399,20 +395,20 @@ static int gsp_send_ack(struct garmin_data *garmin_data_p, __u8 pkt_id)
  */
 static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 {
+        struct device *dev = &garmin_data_p->port->dev;
         unsigned long flags;
         const __u8 *recpkt = garmin_data_p->inbuffer+GSP_INITIAL_OFFSET;
         __le32 *usbdata = (__le32 *) garmin_data_p->inbuffer;
-
         int cksum = 0;
         int n = 0;
         int pktid = recpkt[0];
         int size = recpkt[1];
 
-        usb_serial_debug_data(debug, &garmin_data_p->port->dev,
-                               __func__, count-GSP_INITIAL_OFFSET, recpkt);
+        usb_serial_debug_data(&garmin_data_p->port->dev, __func__,
+                              count-GSP_INITIAL_OFFSET, recpkt);
 
         if (size != (count-GSP_INITIAL_OFFSET-3)) {
-                dbg("%s - invalid size, expected %d bytes, got %d",
+                dev_dbg(dev, "%s - invalid size, expected %d bytes, got %d\n",
                         __func__, size, (count-GSP_INITIAL_OFFSET-3));
                 return -EINVPKT;
         }
@@ -422,8 +418,8 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 
         /* sanity check, remove after test ... */
         if ((__u8 *)&(usbdata[3]) != recpkt) {
-                dbg("%s - ptr mismatch %p - %p",
-                        __func__, &(usbdata[4]), recpkt);
+                dev_dbg(dev, "%s - ptr mismatch %p - %p\n", __func__,
+                        &(usbdata[4]), recpkt);
                 return -EINVPKT;
         }
 
@@ -433,7 +429,7 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
         }
 
         if ((0xff & (cksum + *recpkt)) != 0) {
-                dbg("%s - invalid checksum, expected %02x, got %02x",
+                dev_dbg(dev, "%s - invalid checksum, expected %02x, got %02x\n",
                         __func__, 0xff & -cksum, 0xff & *recpkt);
                 return -EINVPKT;
         }
@@ -480,6 +476,7 @@ static int gsp_rec_packet(struct garmin_data *garmin_data_p, int count)
 static int gsp_receive(struct garmin_data *garmin_data_p,
                        const unsigned char *buf, int count)
 {
+        struct device *dev = &garmin_data_p->port->dev;
         unsigned long flags;
         int offs = 0;
         int ack_or_nak_seen = 0;
@@ -500,7 +497,7 @@ static int gsp_receive(struct garmin_data *garmin_data_p,
         skip = garmin_data_p->flags & FLAGS_GSP_SKIP;
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
-        /* dbg("%s - dle=%d skip=%d size=%d count=%d",
+        /* dev_dbg(dev, "%s - dle=%d skip=%d size=%d count=%d\n",
                 __func__, dleSeen, skip, size, count); */
 
         if (size == 0)
@@ -530,12 +527,12 @@ static int gsp_receive(struct garmin_data *garmin_data_p,
 
                                 if (data == ACK) {
                                         ack_or_nak_seen = ACK;
-                                        dbg("ACK packet complete.");
+                                        dev_dbg(dev, "ACK packet complete.\n");
                                 } else if (data == NAK) {
                                         ack_or_nak_seen = NAK;
-                                        dbg("NAK packet complete.");
+                                        dev_dbg(dev, "NAK packet complete.\n");
                                 } else {
-                                        dbg("packet complete - id=0x%X.",
+                                        dev_dbg(dev, "packet complete - id=0x%X.\n",
                                                 0xFF & data);
                                         gsp_rec_packet(garmin_data_p, size);
                                 }
@@ -557,7 +554,7 @@ static int gsp_receive(struct garmin_data *garmin_data_p,
                 }
 
                 if (size >= GPS_IN_BUFSIZ) {
-                        dbg("%s - packet too large.", __func__);
+                        dev_dbg(dev, "%s - packet too large.\n", __func__);
                         skip = 1;
                         size = GSP_INITIAL_OFFSET;
                         dleSeen = 0;
@@ -602,6 +599,7 @@ static int gsp_receive(struct garmin_data *garmin_data_p,
 static int gsp_send(struct garmin_data *garmin_data_p,
                     const unsigned char *buf, int count)
 {
+        struct device *dev = &garmin_data_p->port->dev;
         const unsigned char *src;
         unsigned char *dst;
         int pktid = 0;
@@ -610,12 +608,12 @@ static int gsp_send(struct garmin_data *garmin_data_p,
         int i = 0;
         int k;
 
-        dbg("%s - state %d - %d bytes.", __func__,
-                                        garmin_data_p->state, count);
+        dev_dbg(dev, "%s - state %d - %d bytes.\n", __func__,
+                garmin_data_p->state, count);
 
         k = garmin_data_p->outsize;
         if ((k+count) > GPS_OUT_BUFSIZ) {
-                dbg("packet too large");
+                dev_dbg(dev, "packet too large\n");
                 garmin_data_p->outsize = 0;
                 return -4;
         }
@@ -634,28 +632,28 @@ static int gsp_send(struct garmin_data *garmin_data_p,
                 return 0;
         }
 
-        dbg("%s - %d bytes in buffer, %d bytes in pkt.", __func__, k, i);
+        dev_dbg(dev, "%s - %d bytes in buffer, %d bytes in pkt.\n", __func__, k, i);
 
         /* garmin_data_p->outbuffer now contains a complete packet */
 
-        usb_serial_debug_data(debug, &garmin_data_p->port->dev,
-                                __func__, k, garmin_data_p->outbuffer);
+        usb_serial_debug_data(&garmin_data_p->port->dev, __func__, k,
+                              garmin_data_p->outbuffer);
 
         garmin_data_p->outsize = 0;
 
         if (GARMIN_LAYERID_APPL != getLayerId(garmin_data_p->outbuffer)) {
-                dbg("not an application packet (%d)",
+                dev_dbg(dev, "not an application packet (%d)\n",
                                 getLayerId(garmin_data_p->outbuffer));
                 return -1;
         }
 
         if (pktid > 255) {
-                dbg("packet-id %d too large", pktid);
+                dev_dbg(dev, "packet-id %d too large\n", pktid);
                 return -2;
         }
 
         if (datalen > 255) {
-                dbg("packet-size %d too large", datalen);
+                dev_dbg(dev, "packet-size %d too large\n", datalen);
                 return -3;
         }
 
@@ -722,7 +720,7 @@ static int gsp_next_packet(struct garmin_data *garmin_data_p)
         struct garmin_packet *pkt = NULL;
 
         while ((pkt = pkt_pop(garmin_data_p)) != NULL) {
-                dbg("%s - next pkt: %d", __func__, pkt->seq);
+                dev_dbg(&garmin_data_p->port->dev, "%s - next pkt: %d\n", __func__, pkt->seq);
                 result = gsp_send(garmin_data_p, pkt->data, pkt->size);
                 if (result > 0) {
                         kfree(pkt);
@@ -768,7 +766,9 @@ static int nat_receive(struct garmin_data *garmin_data_p,
                 if (len >= GPS_IN_BUFSIZ) {
                         /* seems to be an invalid packet, ignore rest
                            of input */
-                        dbg("%s - packet size too large: %d", __func__, len);
+                        dev_dbg(&garmin_data_p->port->dev,
+                                "%s - packet size too large: %d\n",
+                                __func__, len);
                         garmin_data_p->insize = 0;
                         count = 0;
                         result = -EINVPKT;
@@ -849,10 +849,10 @@ static int process_resetdev_request(struct usb_serial_port *port)
         spin_unlock_irqrestore(&garmin_data_p->lock, flags);
 
         usb_kill_urb(port->interrupt_in_urb);
-        dbg("%s - usb_reset_device", __func__);
+        dev_dbg(&port->dev, "%s - usb_reset_device\n", __func__);
         status = usb_reset_device(port->serial->dev);
         if (status)
-                dbg("%s - usb_reset_device failed: %d",
+                dev_dbg(&port->dev, "%s - usb_reset_device failed: %d\n",
                         __func__, status);
         return status;
 }
@@ -889,7 +889,7 @@ static int garmin_init_session(struct usb_serial_port *port)
         if (status == 0) {
                 usb_kill_urb(port->interrupt_in_urb);
 
-                dbg("%s - adding interrupt input", __func__);
+                dev_dbg(&serial->dev->dev, "%s - adding interrupt input\n", __func__);
                 status = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
                 if (status)
                         dev_err(&serial->dev->dev,
@@ -902,7 +902,7 @@ static int garmin_init_session(struct usb_serial_port *port)
          * gpsbabel/jeeps/gpslibusb.c gusb_reset_toggles()
          */
         if (status == 0) {
-                dbg("%s - starting session ...", __func__);
+                dev_dbg(&serial->dev->dev, "%s - starting session ...\n", __func__);
                 garmin_data_p->state = STATE_ACTIVE;
 
                 for (i = 0; i < 3; i++) {
@@ -952,8 +952,8 @@ static void garmin_close(struct usb_serial_port *port)
         struct usb_serial *serial = port->serial;
         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
 
-        dbg("%s - port %d - mode=%d state=%d flags=0x%X", __func__,
-                port->number, garmin_data_p->mode,
+        dev_dbg(&port->dev, "%s - port %d - mode=%d state=%d flags=0x%X\n",
+                __func__, port->number, garmin_data_p->mode,
                 garmin_data_p->state, garmin_data_p->flags);
 
         if (!serial)
@@ -1032,7 +1032,7 @@ static int garmin_write_bulk(struct usb_serial_port *port,
 
         memcpy(buffer, buf, count);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
+        usb_serial_debug_data(&port->dev, __func__, count, buffer);
 
         usb_fill_bulk_urb(urb, serial->dev,
                                 usb_sndbulkpipe(serial->dev,
@@ -1073,11 +1073,12 @@ static int garmin_write_bulk(struct usb_serial_port *port,
 static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
                                          const unsigned char *buf, int count)
 {
+        struct device *dev = &port->dev;
         int pktid, pktsiz, len;
         struct garmin_data *garmin_data_p = usb_get_serial_port_data(port);
         __le32 *privpkt = (__le32 *)garmin_data_p->privpkt;
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count, buf);
+        usb_serial_debug_data(dev, __func__, count, buf);
 
         if (garmin_data_p->state == STATE_RESET)
                 return -EIO;
@@ -1097,27 +1098,18 @@ static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
                     && GARMIN_LAYERID_PRIVATE ==
                                 getLayerId(garmin_data_p->privpkt)) {
 
-                        dbg("%s - processing private request %d",
+                        dev_dbg(dev, "%s - processing private request %d\n",
                                 __func__, pktid);
 
                         /* drop all unfinished transfers */
                         garmin_clear(garmin_data_p);
 
                         switch (pktid) {
-
-                        case PRIV_PKTID_SET_DEBUG:
-                                if (pktsiz != 4)
-                                        return -EINVPKT;
-                                debug = __le32_to_cpu(privpkt[3]);
-                                dbg("%s - debug level set to 0x%X",
-                                        __func__, debug);
-                                break;
-
                         case PRIV_PKTID_SET_MODE:
                                 if (pktsiz != 4)
                                         return -EINVPKT;
                                 garmin_data_p->mode = __le32_to_cpu(privpkt[3]);
-                                dbg("%s - mode set to %d",
+                                dev_dbg(dev, "%s - mode set to %d\n",
                                         __func__, garmin_data_p->mode);
                                 break;
 
@@ -1133,7 +1125,7 @@ static int garmin_write(struct tty_struct *tty, struct usb_serial_port *port,
                                 if (pktsiz != 4)
                                         return -EINVPKT;
                                 initial_mode = __le32_to_cpu(privpkt[3]);
-                                dbg("%s - initial_mode set to %d",
+                                dev_dbg(dev, "%s - initial_mode set to %d\n",
                                         __func__,
                                         garmin_data_p->mode);
                                 break;
@@ -1169,7 +1161,7 @@ static void garmin_read_process(struct garmin_data *garmin_data_p,
 
         if (garmin_data_p->flags & FLAGS_DROP_DATA) {
                 /* abort-transfer cmd is actice */
-                dbg("%s - pkt dropped", __func__);
+                dev_dbg(&garmin_data_p->port->dev, "%s - pkt dropped\n", __func__);
         } else if (garmin_data_p->state != STATE_DISCONNECTED &&
                 garmin_data_p->state != STATE_RESET) {
 
@@ -1178,7 +1170,7 @@ static void garmin_read_process(struct garmin_data *garmin_data_p,
                    send it directly to the tty port */
                 if (garmin_data_p->flags & FLAGS_QUEUING) {
                         pkt_add(garmin_data_p, data, data_length);
-                } else if (bulk_data || 
+                } else if (bulk_data ||
                            getLayerId(data) == GARMIN_LAYERID_APPL) {
 
                         spin_lock_irqsave(&garmin_data_p->lock, flags);
@@ -1208,18 +1200,17 @@ static void garmin_read_bulk_callback(struct urb *urb)
         int retval;
 
         if (!serial) {
-                dbg("%s - bad serial pointer, exiting", __func__);
+                dev_dbg(&urb->dev->dev, "%s - bad serial pointer, exiting\n", __func__);
                 return;
         }
 
         if (status) {
-                dbg("%s - nonzero read bulk status received: %d",
+                dev_dbg(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n",
                         __func__, status);
                 return;
         }
 
-        usb_serial_debug_data(debug, &port->dev,
-                                __func__, urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         garmin_read_process(garmin_data_p, data, urb->actual_length, 1);
 
@@ -1239,11 +1230,11 @@ static void garmin_read_bulk_callback(struct urb *urb)
                         retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                         if (retval)
                                 dev_err(&port->dev,
-                                        "%s - failed resubmitting read urb, "
-                                        "error %d\n", __func__, retval);
+                                        "%s - failed resubmitting read urb, error %d\n",
+                                        __func__, retval);
                 }
         } else {
-                dbg("%s - end of bulk data", __func__);
+                dev_dbg(&port->dev, "%s - end of bulk data\n", __func__);
                 spin_lock_irqsave(&garmin_data_p->lock, flags);
                 garmin_data_p->flags &= ~FLAGS_BULK_IN_ACTIVE;
                 spin_unlock_irqrestore(&garmin_data_p->lock, flags);
@@ -1268,23 +1259,23 @@ static void garmin_read_int_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
                         __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d",
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
                         __func__, status);
                 return;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                urb->actual_length, urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length,
+                              urb->transfer_buffer);
 
         if (urb->actual_length == sizeof(GARMIN_BULK_IN_AVAIL_REPLY) &&
             0 == memcmp(data, GARMIN_BULK_IN_AVAIL_REPLY,
                                 sizeof(GARMIN_BULK_IN_AVAIL_REPLY))) {
 
-                dbg("%s - bulk data available.", __func__);
+                dev_dbg(&port->dev, "%s - bulk data available.\n", __func__);
 
                 if (0 == (garmin_data_p->flags & FLAGS_BULK_IN_ACTIVE)) {
 
@@ -1319,7 +1310,7 @@ static void garmin_read_int_callback(struct urb *urb)
                 garmin_data_p->serial_num = __le32_to_cpup(
                                         (__le32 *)(data+GARMIN_PKTHDR_LENGTH));
 
-                dbg("%s - start-of-session reply seen - serial %u.",
+                dev_dbg(&port->dev, "%s - start-of-session reply seen - serial %u.\n",
                         __func__, garmin_data_p->serial_num);
         }
 
@@ -1495,7 +1486,5 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, S_IWUSR | S_IRUGO);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
 module_param(initial_mode, int, S_IRUGO);
 MODULE_PARM_DESC(initial_mode, "Initial mode");
diff --git a/drivers/usb/serial/generic.c b/drivers/usb/serial/generic.c
index 9b026bf7afef..296612153ea2 100644
--- a/drivers/usb/serial/generic.c
+++ b/drivers/usb/serial/generic.c
@@ -24,8 +24,6 @@
 #include <linux/kfifo.h>
 #include <linux/serial.h>
 
-static int debug;
-
 #ifdef CONFIG_USB_SERIAL_GENERIC
 
 static __u16 vendor  = 0x05f9;
@@ -60,11 +58,10 @@ static struct usb_serial_driver * const serial_drivers[] = {
 
 #endif
 
-int usb_serial_generic_register(int _debug)
+int usb_serial_generic_register(void)
 {
         int retval = 0;
 
-        debug = _debug;
 #ifdef CONFIG_USB_SERIAL_GENERIC
         generic_device_ids[0].idVendor = vendor;
         generic_device_ids[0].idProduct = product;
@@ -171,8 +168,7 @@ retry:
                                                 urb->transfer_buffer,
                                                 port->bulk_out_size);
         urb->transfer_buffer_length = count;
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                                urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, count, urb->transfer_buffer);
         spin_lock_irqsave(&port->lock, flags);
         port->tx_bytes += count;
         spin_unlock_irqrestore(&port->lock, flags);
@@ -365,8 +361,7 @@ void usb_serial_generic_read_bulk_callback(struct urb *urb)
                 return;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                                urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
         port->serial->type->process_read_urb(urb);
 
         /* Throttle the device if requested by tty */
diff --git a/drivers/usb/serial/io_edgeport.c b/drivers/usb/serial/io_edgeport.c
index f435575c4e6e..8e6faaf3580c 100644
--- a/drivers/usb/serial/io_edgeport.c
+++ b/drivers/usb/serial/io_edgeport.c
@@ -190,9 +190,6 @@ static const struct divisor_table_entry divisor_table[] = {
         {   230400,     1},
 };
 
-/* local variables */
-static bool debug;
-
 /* Number of outstanding Command Write Urbs */
 static atomic_t CmdUrbs = ATOMIC_INIT(0);
 
@@ -244,7 +241,7 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
                                 __u8 lsr, __u8 data);
 static int  send_iosp_ext_cmd(struct edgeport_port *edge_port, __u8 command,
                                 __u8 param);
-static int  calc_baud_rate_divisor(int baud_rate, int *divisor);
+static int  calc_baud_rate_divisor(struct device *dev, int baud_rate, int *divisor);
 static int  send_cmd_write_baud_rate(struct edgeport_port *edge_port,
                                 int baudRate);
 static void change_port_settings(struct tty_struct *tty,
@@ -286,6 +283,7 @@ static void unicode_to_ascii(char *string, int buflen,
  ************************************************************************/
 static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
         __u32 BootCurVer;
         __u32 BootNewVer;
         __u8 BootMajorVersion;
@@ -311,7 +309,7 @@ static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
         response = request_ihex_firmware(&fw, fw_name,
                                          &edge_serial->serial->dev->dev);
         if (response) {
-                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
+                dev_err(dev, "Failed to load image \"%s\" err %d\n",
                        fw_name, response);
                 return;
         }
@@ -330,20 +328,20 @@ static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
                      (BootMinorVersion << 16) +
                       BootBuildNumber;
 
-        dbg("Current Boot Image version %d.%d.%d",
+        dev_dbg(dev, "Current Boot Image version %d.%d.%d\n",
             edge_serial->boot_descriptor.MajorVersion,
             edge_serial->boot_descriptor.MinorVersion,
             le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
 
 
         if (BootNewVer > BootCurVer) {
-                dbg("**Update Boot Image from %d.%d.%d to %d.%d.%d",
+                dev_dbg(dev, "**Update Boot Image from %d.%d.%d to %d.%d.%d\n",
                     edge_serial->boot_descriptor.MajorVersion,
                     edge_serial->boot_descriptor.MinorVersion,
                     le16_to_cpu(edge_serial->boot_descriptor.BuildNumber),
                     BootMajorVersion, BootMinorVersion, BootBuildNumber);
 
-                dbg("Downloading new Boot Image");
+                dev_dbg(dev, "Downloading new Boot Image\n");
 
                 for (rec = ihex_next_binrec(rec); rec;
                      rec = ihex_next_binrec(rec)) {
@@ -362,7 +360,7 @@ static void update_edgeport_E2PROM(struct edgeport_serial *edge_serial)
                         }
                 }
         } else {
-                dbg("Boot Image -- already up to date");
+                dev_dbg(dev, "Boot Image -- already up to date\n");
         }
         release_firmware(fw);
 }
@@ -379,7 +377,7 @@ static int get_string_desc(struct usb_device *dev, int Id,
         struct usb_string_descriptor StringDesc;
         struct usb_string_descriptor *pStringDesc;
 
-        dbg("%s - USB String ID = %d", __func__, Id);
+        dev_dbg(&dev->dev, "%s - USB String ID = %d\n", __func__, Id);
 
         if (!usb_get_descriptor(dev, USB_DT_STRING, Id, &StringDesc,
                                                 sizeof(StringDesc)))
@@ -400,34 +398,39 @@ static int get_string_desc(struct usb_device *dev, int Id,
 }
 #endif
 
-static void dump_product_info(struct edgeport_product_info *product_info)
+static void dump_product_info(struct edgeport_serial *edge_serial,
+                              struct edgeport_product_info *product_info)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
+
         /* Dump Product Info structure */
-        dbg("**Product Information:");
-        dbg("  ProductId             %x", product_info->ProductId);
-        dbg("  NumPorts              %d", product_info->NumPorts);
-        dbg("  ProdInfoVer           %d", product_info->ProdInfoVer);
-        dbg("  IsServer              %d", product_info->IsServer);
-        dbg("  IsRS232               %d", product_info->IsRS232);
-        dbg("  IsRS422               %d", product_info->IsRS422);
-        dbg("  IsRS485               %d", product_info->IsRS485);
-        dbg("  RomSize               %d", product_info->RomSize);
-        dbg("  RamSize               %d", product_info->RamSize);
-        dbg("  CpuRev                %x", product_info->CpuRev);
-        dbg("  BoardRev              %x", product_info->BoardRev);
-        dbg("  BootMajorVersion      %d.%d.%d", product_info->BootMajorVersion,
-            product_info->BootMinorVersion,
-            le16_to_cpu(product_info->BootBuildNumber));
-        dbg("  FirmwareMajorVersion  %d.%d.%d",
-                        product_info->FirmwareMajorVersion,
-                        product_info->FirmwareMinorVersion,
-                        le16_to_cpu(product_info->FirmwareBuildNumber));
-        dbg("  ManufactureDescDate   %d/%d/%d",
-                        product_info->ManufactureDescDate[0],
-                        product_info->ManufactureDescDate[1],
-                        product_info->ManufactureDescDate[2]+1900);
-        dbg("  iDownloadFile         0x%x", product_info->iDownloadFile);
-        dbg("  EpicVer               %d", product_info->EpicVer);
+        dev_dbg(dev, "**Product Information:\n");
+        dev_dbg(dev, "  ProductId             %x\n", product_info->ProductId);
+        dev_dbg(dev, "  NumPorts              %d\n", product_info->NumPorts);
+        dev_dbg(dev, "  ProdInfoVer           %d\n", product_info->ProdInfoVer);
+        dev_dbg(dev, "  IsServer              %d\n", product_info->IsServer);
+        dev_dbg(dev, "  IsRS232               %d\n", product_info->IsRS232);
+        dev_dbg(dev, "  IsRS422               %d\n", product_info->IsRS422);
+        dev_dbg(dev, "  IsRS485               %d\n", product_info->IsRS485);
+        dev_dbg(dev, "  RomSize               %d\n", product_info->RomSize);
+        dev_dbg(dev, "  RamSize               %d\n", product_info->RamSize);
+        dev_dbg(dev, "  CpuRev                %x\n", product_info->CpuRev);
+        dev_dbg(dev, "  BoardRev              %x\n", product_info->BoardRev);
+        dev_dbg(dev, "  BootMajorVersion      %d.%d.%d\n",
+                product_info->BootMajorVersion,
+                product_info->BootMinorVersion,
+                le16_to_cpu(product_info->BootBuildNumber));
+        dev_dbg(dev, "  FirmwareMajorVersion  %d.%d.%d\n",
+                product_info->FirmwareMajorVersion,
+                product_info->FirmwareMinorVersion,
+                le16_to_cpu(product_info->FirmwareBuildNumber));
+        dev_dbg(dev, "  ManufactureDescDate   %d/%d/%d\n",
+                product_info->ManufactureDescDate[0],
+                product_info->ManufactureDescDate[1],
+                product_info->ManufactureDescDate[2]+1900);
+        dev_dbg(dev, "  iDownloadFile         0x%x\n",
+                product_info->iDownloadFile);
+        dev_dbg(dev, "  EpicVer               %d\n", product_info->EpicVer);
 }
 
 static void get_product_info(struct edgeport_serial *edge_serial)
@@ -462,7 +465,7 @@ static void get_product_info(struct edgeport_serial *edge_serial)
                 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_80251;
         else
                 product_info->iDownloadFile = EDGE_DOWNLOAD_FILE_I930;
- 
+
         /* Determine Product type and set appropriate flags */
         switch (DEVICE_ID_FROM_USB_PRODUCT_ID(product_info->ProductId)) {
         case ION_DEVICE_ID_EDGEPORT_COMPATIBLE:
@@ -490,7 +493,7 @@ static void get_product_info(struct edgeport_serial *edge_serial)
                 break;
         }
 
-        dump_product_info(product_info);
+        dump_product_info(edge_serial, product_info);
 }
 
 static int get_epic_descriptor(struct edgeport_serial *ep)
@@ -500,6 +503,7 @@ static int get_epic_descriptor(struct edgeport_serial *ep)
         struct edgeport_product_info *product_info = &ep->product_info;
         struct edge_compatibility_descriptor *epic = &ep->epic_descriptor;
         struct edge_compatibility_bits *bits;
+        struct device *dev = &serial->dev->dev;
 
         ep->is_epic = 0;
         result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
@@ -509,8 +513,6 @@ static int get_epic_descriptor(struct edgeport_serial *ep)
                                  sizeof(struct edge_compatibility_descriptor),
                                  300);
 
-        dbg("%s result = %d", __func__, result);
-
         if (result > 0) {
                 ep->is_epic = 1;
                 memset(product_info, 0, sizeof(struct edgeport_product_info));
@@ -524,23 +526,23 @@ static int get_epic_descriptor(struct edgeport_serial *ep)
                 product_info->EpicVer = epic->EpicVer;
                 product_info->Epic = epic->Supports;
                 product_info->ProductId = ION_DEVICE_ID_EDGEPORT_COMPATIBLE;
-                dump_product_info(product_info);
+                dump_product_info(ep, product_info);
 
                 bits = &ep->epic_descriptor.Supports;
-                dbg("**EPIC descriptor:");
-                dbg("  VendEnableSuspend: %s", bits->VendEnableSuspend  ? "TRUE": "FALSE");
-                dbg("  IOSPOpen         : %s", bits->IOSPOpen           ? "TRUE": "FALSE");
-                dbg("  IOSPClose        : %s", bits->IOSPClose          ? "TRUE": "FALSE");
-                dbg("  IOSPChase        : %s", bits->IOSPChase          ? "TRUE": "FALSE");
-                dbg("  IOSPSetRxFlow    : %s", bits->IOSPSetRxFlow      ? "TRUE": "FALSE");
-                dbg("  IOSPSetTxFlow    : %s", bits->IOSPSetTxFlow      ? "TRUE": "FALSE");
-                dbg("  IOSPSetXChar     : %s", bits->IOSPSetXChar       ? "TRUE": "FALSE");
-                dbg("  IOSPRxCheck      : %s", bits->IOSPRxCheck        ? "TRUE": "FALSE");
-                dbg("  IOSPSetClrBreak  : %s", bits->IOSPSetClrBreak    ? "TRUE": "FALSE");
-                dbg("  IOSPWriteMCR     : %s", bits->IOSPWriteMCR       ? "TRUE": "FALSE");
-                dbg("  IOSPWriteLCR     : %s", bits->IOSPWriteLCR       ? "TRUE": "FALSE");
-                dbg("  IOSPSetBaudRate  : %s", bits->IOSPSetBaudRate    ? "TRUE": "FALSE");
-                dbg("  TrueEdgeport     : %s", bits->TrueEdgeport       ? "TRUE": "FALSE");
+                dev_dbg(dev, "**EPIC descriptor:\n");
+                dev_dbg(dev, "  VendEnableSuspend: %s\n", bits->VendEnableSuspend ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPOpen         : %s\n", bits->IOSPOpen        ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPClose        : %s\n", bits->IOSPClose       ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPChase        : %s\n", bits->IOSPChase       ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPSetRxFlow    : %s\n", bits->IOSPSetRxFlow   ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPSetTxFlow    : %s\n", bits->IOSPSetTxFlow   ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPSetXChar     : %s\n", bits->IOSPSetXChar    ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPRxCheck      : %s\n", bits->IOSPRxCheck     ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPSetClrBreak  : %s\n", bits->IOSPSetClrBreak ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPWriteMCR     : %s\n", bits->IOSPWriteMCR    ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPWriteLCR     : %s\n", bits->IOSPWriteLCR    ? "TRUE": "FALSE");
+                dev_dbg(dev, "  IOSPSetBaudRate  : %s\n", bits->IOSPSetBaudRate ? "TRUE": "FALSE");
+                dev_dbg(dev, "  TrueEdgeport     : %s\n", bits->TrueEdgeport    ? "TRUE": "FALSE");
         }
 
         return result;
@@ -561,7 +563,8 @@ static int get_epic_descriptor(struct edgeport_serial *ep)
  *****************************************************************************/
 static void edge_interrupt_callback(struct urb *urb)
 {
-        struct edgeport_serial  *edge_serial = urb->context;
+        struct edgeport_serial *edge_serial = urb->context;
+        struct device *dev;
         struct edgeport_port *edge_port;
         struct usb_serial_port *port;
         struct tty_struct *tty;
@@ -574,8 +577,6 @@ static void edge_interrupt_callback(struct urb *urb)
         int result;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         switch (status) {
         case 0:
                 /* success */
@@ -584,36 +585,42 @@ static void edge_interrupt_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                                                __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
                 goto exit;
         }
 
+        dev = &edge_serial->serial->dev->dev;
+
         /* process this interrupt-read even if there are no ports open */
         if (length) {
-                usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
-                                                __func__, length, data);
+                usb_serial_debug_data(dev, __func__, length, data);
 
                 if (length > 1) {
                         bytes_avail = data[0] | (data[1] << 8);
                         if (bytes_avail) {
                                 spin_lock(&edge_serial->es_lock);
                                 edge_serial->rxBytesAvail += bytes_avail;
-                                dbg("%s - bytes_avail=%d, rxBytesAvail=%d, read_in_progress=%d", __func__, bytes_avail, edge_serial->rxBytesAvail, edge_serial->read_in_progress);
+                                dev_dbg(dev,
+                                        "%s - bytes_avail=%d, rxBytesAvail=%d, read_in_progress=%d\n",
+                                        __func__, bytes_avail,
+                                        edge_serial->rxBytesAvail,
+                                        edge_serial->read_in_progress);
 
                                 if (edge_serial->rxBytesAvail > 0 &&
                                     !edge_serial->read_in_progress) {
-                                        dbg("%s - posting a read", __func__);
+                                        dev_dbg(dev, "%s - posting a read\n", __func__);
                                         edge_serial->read_in_progress = true;
 
                                         /* we have pending bytes on the
                                            bulk in pipe, send a request */
                                         result = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
                                         if (result) {
-                                                dev_err(&edge_serial->serial->dev->dev, "%s - usb_submit_urb(read bulk) failed with result = %d\n", __func__, result);
+                                                dev_err(dev,
+                                                        "%s - usb_submit_urb(read bulk) failed with result = %d\n",
+                                                        __func__, result);
                                                 edge_serial->read_in_progress = false;
                                         }
                                 }
@@ -633,9 +640,9 @@ static void edge_interrupt_callback(struct urb *urb)
                                         spin_lock(&edge_port->ep_lock);
                                         edge_port->txCredits += txCredits;
                                         spin_unlock(&edge_port->ep_lock);
-                                        dbg("%s - txcredits for port%d = %d",
-                                                        __func__, portNumber,
-                                                        edge_port->txCredits);
+                                        dev_dbg(dev, "%s - txcredits for port%d = %d\n",
+                                                __func__, portNumber,
+                                                edge_port->txCredits);
 
                                         /* tell the tty driver that something
                                            has changed */
@@ -673,49 +680,48 @@ exit:
 static void edge_bulk_in_callback(struct urb *urb)
 {
         struct edgeport_serial  *edge_serial = urb->context;
+        struct device *dev;
         unsigned char           *data = urb->transfer_buffer;
         int                     retval;
         __u16                   raw_data_length;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         if (status) {
-                dbg("%s - nonzero read bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n",
+                        __func__, status);
                 edge_serial->read_in_progress = false;
                 return;
         }
 
         if (urb->actual_length == 0) {
-                dbg("%s - read bulk callback with no data", __func__);
+                dev_dbg(&urb->dev->dev, "%s - read bulk callback with no data\n", __func__);
                 edge_serial->read_in_progress = false;
                 return;
         }
 
+        dev = &edge_serial->serial->dev->dev;
         raw_data_length = urb->actual_length;
 
-        usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
-                                        __func__, raw_data_length, data);
+        usb_serial_debug_data(dev, __func__, raw_data_length, data);
 
         spin_lock(&edge_serial->es_lock);
 
         /* decrement our rxBytes available by the number that we just got */
         edge_serial->rxBytesAvail -= raw_data_length;
 
-        dbg("%s - Received = %d, rxBytesAvail %d", __func__,
-                                raw_data_length, edge_serial->rxBytesAvail);
+        dev_dbg(dev, "%s - Received = %d, rxBytesAvail %d\n", __func__,
+                raw_data_length, edge_serial->rxBytesAvail);
 
         process_rcvd_data(edge_serial, data, urb->actual_length);
 
         /* check to see if there's any more data for us to read */
         if (edge_serial->rxBytesAvail > 0) {
-                dbg("%s - posting a read", __func__);
+                dev_dbg(dev, "%s - posting a read\n", __func__);
                 retval = usb_submit_urb(edge_serial->read_urb, GFP_ATOMIC);
                 if (retval) {
-                        dev_err(&urb->dev->dev,
-                                "%s - usb_submit_urb(read bulk) failed, "
-                                "retval = %d\n", __func__, retval);
+                        dev_err(dev,
+                                "%s - usb_submit_urb(read bulk) failed, retval = %d\n",
+                                __func__, retval);
                         edge_serial->read_in_progress = false;
                 }
         } else {
@@ -737,11 +743,10 @@ static void edge_bulk_out_data_callback(struct urb *urb)
         struct tty_struct *tty;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&urb->dev->dev,
+                        "%s - nonzero write bulk status received: %d\n",
+                        __func__, status);
         }
 
         tty = tty_port_tty_get(&edge_port->port->port);
@@ -773,11 +778,9 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
         struct tty_struct *tty;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         atomic_dec(&CmdUrbs);
-        dbg("%s - FREE URB %p (outstanding %d)", __func__,
-                                        urb, atomic_read(&CmdUrbs));
+        dev_dbg(&urb->dev->dev, "%s - FREE URB %p (outstanding %d)\n",
+                __func__, urb, atomic_read(&CmdUrbs));
 
 
         /* clean up the transfer buffer */
@@ -787,8 +790,9 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
         usb_free_urb(urb);
 
         if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                                                        __func__, status);
+                dev_dbg(&urb->dev->dev,
+                        "%s - nonzero write bulk status received: %d\n",
+                        __func__, status);
                 return;
         }
 
@@ -819,12 +823,11 @@ static void edge_bulk_out_cmd_callback(struct urb *urb)
 static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         struct usb_serial *serial;
         struct edgeport_serial *edge_serial;
         int response;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return -ENODEV;
 
@@ -875,9 +878,8 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
                 response = usb_submit_urb(edge_serial->interrupt_read_urb,
                                                                 GFP_KERNEL);
                 if (response) {
-                        dev_err(&port->dev,
-                                "%s - Error %d submitting control urb\n",
-                                                        __func__, response);
+                        dev_err(dev, "%s - Error %d submitting control urb\n",
+                                __func__, response);
                 }
         }
 
@@ -902,8 +904,7 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         response = send_iosp_ext_cmd(edge_port, IOSP_CMD_OPEN_PORT, 0);
 
         if (response < 0) {
-                dev_err(&port->dev, "%s - error sending open port command\n",
-                                                                __func__);
+                dev_err(dev, "%s - error sending open port command\n", __func__);
                 edge_port->openPending = false;
                 return -ENODEV;
         }
@@ -914,7 +915,7 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         if (!edge_port->open) {
                 /* open timed out */
-                dbg("%s - open timedout", __func__);
+                dev_dbg(dev, "%s - open timedout\n", __func__);
                 edge_port->openPending = false;
                 return -ENODEV;
         }
@@ -927,7 +928,7 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         edge_port->txfifo.fifo  = kmalloc(edge_port->maxTxCredits, GFP_KERNEL);
 
         if (!edge_port->txfifo.fifo) {
-                dbg("%s - no memory", __func__);
+                dev_dbg(dev, "%s - no memory\n", __func__);
                 edge_close(port);
                 return -ENOMEM;
         }
@@ -937,15 +938,13 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         edge_port->write_in_progress = false;
 
         if (!edge_port->write_urb) {
-                dbg("%s - no memory", __func__);
+                dev_dbg(dev, "%s - no memory\n", __func__);
                 edge_close(port);
                 return -ENOMEM;
         }
 
-        dbg("%s(%d) - Initialize TX fifo to %d bytes",
-                        __func__, port->number, edge_port->maxTxCredits);
-
-        dbg("%s exited", __func__);
+        dev_dbg(dev, "%s(%d) - Initialize TX fifo to %d bytes\n",
+                __func__, port->number, edge_port->maxTxCredits);
 
         return 0;
 }
@@ -963,6 +962,7 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
  ************************************************************************/
 static void block_until_chase_response(struct edgeport_port *edge_port)
 {
+        struct device *dev = &edge_port->port->dev;
         DEFINE_WAIT(wait);
         __u16 lastCredits;
         int timeout = 1*HZ;
@@ -974,11 +974,11 @@ static void block_until_chase_response(struct edgeport_port *edge_port)
 
                 /* Did we get our Chase response */
                 if (!edge_port->chaseResponsePending) {
-                        dbg("%s - Got Chase Response", __func__);
+                        dev_dbg(dev, "%s - Got Chase Response\n", __func__);
 
                         /* did we get all of our credit back? */
                         if (edge_port->txCredits == edge_port->maxTxCredits) {
-                                dbg("%s - Got all credits", __func__);
+                                dev_dbg(dev, "%s - Got all credits\n", __func__);
                                 return;
                         }
                 }
@@ -994,12 +994,12 @@ static void block_until_chase_response(struct edgeport_port *edge_port)
                         loop--;
                         if (loop == 0) {
                                 edge_port->chaseResponsePending = false;
-                                dbg("%s - Chase TIMEOUT", __func__);
+                                dev_dbg(dev, "%s - Chase TIMEOUT\n", __func__);
                                 return;
                         }
                 } else {
                         /* Reset timeout value back to 10 seconds */
-                        dbg("%s - Last %d, Current %d", __func__,
+                        dev_dbg(dev, "%s - Last %d, Current %d\n", __func__,
                                         lastCredits, edge_port->txCredits);
                         loop = 10;
                 }
@@ -1019,6 +1019,7 @@ static void block_until_chase_response(struct edgeport_port *edge_port)
  ************************************************************************/
 static void block_until_tx_empty(struct edgeport_port *edge_port)
 {
+        struct device *dev = &edge_port->port->dev;
         DEFINE_WAIT(wait);
         struct TxFifo *fifo = &edge_port->txfifo;
         __u32 lastCount;
@@ -1031,7 +1032,7 @@ static void block_until_tx_empty(struct edgeport_port *edge_port)
 
                 /* Is the Edgeport Buffer empty? */
                 if (lastCount == 0) {
-                        dbg("%s - TX Buffer Empty", __func__);
+                        dev_dbg(dev, "%s - TX Buffer Empty\n", __func__);
                         return;
                 }
 
@@ -1041,13 +1042,13 @@ static void block_until_tx_empty(struct edgeport_port *edge_port)
                 schedule_timeout(timeout);
                 finish_wait(&edge_port->wait_chase, &wait);
 
-                dbg("%s wait", __func__);
+                dev_dbg(dev, "%s wait\n", __func__);
 
                 if (lastCount == fifo->count) {
                         /* No activity.. count down. */
                         loop--;
                         if (loop == 0) {
-                                dbg("%s - TIMEOUT", __func__);
+                                dev_dbg(dev, "%s - TIMEOUT\n", __func__);
                                 return;
                         }
                 } else {
@@ -1068,8 +1069,6 @@ static void edge_close(struct usb_serial_port *port)
         struct edgeport_port *edge_port;
         int status;
 
-        dbg("%s - port %d", __func__, port->number);
-
         edge_serial = usb_get_serial_data(port->serial);
         edge_port = usb_get_serial_port_data(port);
         if (edge_serial == NULL || edge_port == NULL)
@@ -1086,7 +1085,7 @@ static void edge_close(struct usb_serial_port *port)
                 /* flush and chase */
                 edge_port->chaseResponsePending = true;
 
-                dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
+                dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CHASE_PORT\n", __func__);
                 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
                 if (status == 0)
                         /* block until chase finished */
@@ -1099,7 +1098,7 @@ static void edge_close(struct usb_serial_port *port)
             ((edge_serial->is_epic) &&
              (edge_serial->epic_descriptor.Supports.IOSPClose))) {
                /* close the port */
-                dbg("%s - Sending IOSP_CMD_CLOSE_PORT", __func__);
+                dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CLOSE_PORT\n", __func__);
                 send_iosp_ext_cmd(edge_port, IOSP_CMD_CLOSE_PORT, 0);
         }
 
@@ -1119,8 +1118,6 @@ static void edge_close(struct usb_serial_port *port)
         }
         kfree(edge_port->txfifo.fifo);
         edge_port->txfifo.fifo = NULL;
-
-        dbg("%s exited", __func__);
 }
 
 /*****************************************************************************
@@ -1141,8 +1138,6 @@ static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
         int secondhalf;
         unsigned long flags;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return -ENODEV;
 
@@ -1155,14 +1150,14 @@ static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
         copySize = min((unsigned int)count,
                                 (edge_port->txCredits - fifo->count));
 
-        dbg("%s(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes",
-                        __func__, port->number, count,
+        dev_dbg(&port->dev, "%s(%d) of %d byte(s) Fifo room  %d -- will copy %d bytes\n",
+                __func__, port->number, count,
                         edge_port->txCredits - fifo->count, copySize);
 
         /* catch writes of 0 bytes which the tty driver likes to give us,
            and when txCredits is empty */
         if (copySize == 0) {
-                dbg("%s - copySize = Zero", __func__);
+                dev_dbg(&port->dev, "%s - copySize = Zero\n", __func__);
                 goto finish_write;
         }
 
@@ -1175,13 +1170,12 @@ static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
          */
         bytesleft = fifo->size - fifo->head;
         firsthalf = min(bytesleft, copySize);
-        dbg("%s - copy %d bytes of %d into fifo ", __func__,
-                                        firsthalf, bytesleft);
+        dev_dbg(&port->dev, "%s - copy %d bytes of %d into fifo \n", __func__,
+                firsthalf, bytesleft);
 
         /* now copy our data */
         memcpy(&fifo->fifo[fifo->head], data, firsthalf);
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                        firsthalf, &fifo->fifo[fifo->head]);
+        usb_serial_debug_data(&port->dev, __func__, firsthalf, &fifo->fifo[fifo->head]);
 
         /* update the index and size */
         fifo->head  += firsthalf;
@@ -1194,10 +1188,9 @@ static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
         secondhalf = copySize-firsthalf;
 
         if (secondhalf) {
-                dbg("%s - copy rest of data %d", __func__, secondhalf);
+                dev_dbg(&port->dev, "%s - copy rest of data %d\n", __func__, secondhalf);
                 memcpy(&fifo->fifo[fifo->head], &data[firsthalf], secondhalf);
-                usb_serial_debug_data(debug, &port->dev, __func__,
-                                        secondhalf, &fifo->fifo[fifo->head]);
+                usb_serial_debug_data(&port->dev, __func__, secondhalf, &fifo->fifo[fifo->head]);
                 /* update the index and size */
                 fifo->count += secondhalf;
                 fifo->head  += secondhalf;
@@ -1212,8 +1205,8 @@ finish_write:
         send_more_port_data((struct edgeport_serial *)
                         usb_get_serial_data(port->serial), edge_port);
 
-        dbg("%s wrote %d byte(s) TxCredits %d, Fifo %d", __func__,
-                                copySize, edge_port->txCredits, fifo->count);
+        dev_dbg(&port->dev, "%s wrote %d byte(s) TxCredits %d, Fifo %d\n",
+                __func__, copySize, edge_port->txCredits, fifo->count);
 
         return copySize;
 }
@@ -1236,6 +1229,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
                                         struct edgeport_port *edge_port)
 {
         struct TxFifo   *fifo = &edge_port->txfifo;
+        struct device   *dev = &edge_port->port->dev;
         struct urb      *urb;
         unsigned char   *buffer;
         int             status;
@@ -1245,16 +1239,14 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
         int             secondhalf;
         unsigned long   flags;
 
-        dbg("%s(%d)", __func__, edge_port->port->number);
-
         spin_lock_irqsave(&edge_port->ep_lock, flags);
 
         if (edge_port->write_in_progress ||
             !edge_port->open             ||
             (fifo->count == 0)) {
-                dbg("%s(%d) EXIT - fifo %d, PendingWrite = %d",
-                                __func__, edge_port->port->number,
-                                fifo->count, edge_port->write_in_progress);
+                dev_dbg(dev, "%s(%d) EXIT - fifo %d, PendingWrite = %d\n",
+                        __func__, edge_port->port->number,
+                        fifo->count, edge_port->write_in_progress);
                 goto exit_send;
         }
 
@@ -1266,7 +1258,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
          * it's better to wait for more credits so we can do a larger write.
          */
         if (edge_port->txCredits < EDGE_FW_GET_TX_CREDITS_SEND_THRESHOLD(edge_port->maxTxCredits, EDGE_FW_BULK_MAX_PACKET_SIZE)) {
-                dbg("%s(%d) Not enough credit - fifo %d TxCredit %d",
+                dev_dbg(dev, "%s(%d) Not enough credit - fifo %d TxCredit %d\n",
                         __func__, edge_port->port->number, fifo->count,
                         edge_port->txCredits);
                 goto exit_send;
@@ -1315,8 +1307,7 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
         }
 
         if (count)
-                usb_serial_debug_data(debug, &edge_port->port->dev,
-                                                __func__, count, &buffer[2]);
+                usb_serial_debug_data(&edge_port->port->dev, __func__, count, &buffer[2]);
 
         /* fill up the urb with all of our data and submit it */
         usb_fill_bulk_urb(urb, edge_serial->serial->dev,
@@ -1341,8 +1332,8 @@ static void send_more_port_data(struct edgeport_serial *edge_serial,
                 edge_port->txCredits += count;
                 edge_port->icount.tx -= count;
         }
-        dbg("%s wrote %d byte(s) TxCredit %d, Fifo %d",
-                        __func__, count, edge_port->txCredits, fifo->count);
+        dev_dbg(dev, "%s wrote %d byte(s) TxCredit %d, Fifo %d\n",
+                __func__, count, edge_port->txCredits, fifo->count);
 
 exit_send:
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
@@ -1363,17 +1354,13 @@ static int edge_write_room(struct tty_struct *tty)
         int room;
         unsigned long flags;
 
-        dbg("%s", __func__);
-
         if (edge_port == NULL)
                 return 0;
         if (edge_port->closePending)
                 return 0;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (!edge_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return 0;
         }
 
@@ -1382,7 +1369,7 @@ static int edge_write_room(struct tty_struct *tty)
         room = edge_port->txCredits - edge_port->txfifo.count;
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
         return room;
 }
 
@@ -1403,15 +1390,13 @@ static int edge_chars_in_buffer(struct tty_struct *tty)
         int num_chars;
         unsigned long flags;
 
-        dbg("%s", __func__);
-
         if (edge_port == NULL)
                 return 0;
         if (edge_port->closePending)
                 return 0;
 
         if (!edge_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return 0;
         }
 
@@ -1420,8 +1405,8 @@ static int edge_chars_in_buffer(struct tty_struct *tty)
                                                 edge_port->txfifo.count;
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
         if (num_chars) {
-                dbg("%s(port %d) - returns %d", __func__,
-                                                port->number, num_chars);
+                dev_dbg(&port->dev, "%s(port %d) - returns %d\n", __func__,
+                        port->number, num_chars);
         }
 
         return num_chars;
@@ -1439,13 +1424,11 @@ static void edge_throttle(struct tty_struct *tty)
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return;
 
         if (!edge_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -1479,13 +1462,11 @@ static void edge_unthrottle(struct tty_struct *tty)
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return;
 
         if (!edge_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -1517,18 +1498,14 @@ static void edge_set_termios(struct tty_struct *tty,
         unsigned int cflag;
 
         cflag = tty->termios.c_cflag;
-        dbg("%s - clfag %08x iflag %08x", __func__,
-            tty->termios.c_cflag, tty->termios.c_iflag);
-        dbg("%s - old clfag %08x old iflag %08x", __func__,
-            old_termios->c_cflag, old_termios->c_iflag);
-
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__, tty->termios.c_cflag, tty->termios.c_iflag);
+        dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__, old_termios->c_cflag, old_termios->c_iflag);
 
         if (edge_port == NULL)
                 return;
 
         if (!edge_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -1556,7 +1533,7 @@ static int get_lsr_info(struct edgeport_port *edge_port,
         spin_lock_irqsave(&edge_port->ep_lock, flags);
         if (edge_port->maxTxCredits == edge_port->txCredits &&
             edge_port->txfifo.count == 0) {
-                dbg("%s -- Empty", __func__);
+                dev_dbg(&edge_port->port->dev, "%s -- Empty\n", __func__);
                 result = TIOCSER_TEMT;
         }
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
@@ -1573,8 +1550,6 @@ static int edge_tiocmset(struct tty_struct *tty,
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int mcr;
 
-        dbg("%s - port %d", __func__, port->number);
-
         mcr = edge_port->shadowMCR;
         if (set & TIOCM_RTS)
                 mcr |= MCR_RTS;
@@ -1605,8 +1580,6 @@ static int edge_tiocmget(struct tty_struct *tty)
         unsigned int msr;
         unsigned int mcr;
 
-        dbg("%s - port %d", __func__, port->number);
-
         msr = edge_port->shadowMSR;
         mcr = edge_port->shadowMCR;
         result = ((mcr & MCR_DTR)       ? TIOCM_DTR: 0)   /* 0x002 */
@@ -1616,9 +1589,6 @@ static int edge_tiocmget(struct tty_struct *tty)
                   | ((msr & EDGEPORT_MSR_RI)    ? TIOCM_RI:  0)   /* 0x080 */
                   | ((msr & EDGEPORT_MSR_DSR)   ? TIOCM_DSR: 0);  /* 0x100 */
 
-
-        dbg("%s -- %x", __func__, result);
-
         return result;
 }
 
@@ -1642,8 +1612,8 @@ static int edge_get_icount(struct tty_struct *tty,
         icount->brk = cnow.brk;
         icount->buf_overrun = cnow.buf_overrun;
 
-        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
-                        __func__,  port->number, icount->rx, icount->tx);
+        dev_dbg(&port->dev, "%s (%d) TIOCGICOUNT RX=%d, TX=%d\n", __func__,
+                port->number, icount->rx, icount->tx);
         return 0;
 }
 
@@ -1686,19 +1656,19 @@ static int edge_ioctl(struct tty_struct *tty,
         struct async_icount cnow;
         struct async_icount cprev;
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd);
 
         switch (cmd) {
         case TIOCSERGETLSR:
-                dbg("%s (%d) TIOCSERGETLSR", __func__,  port->number);
+                dev_dbg(&port->dev, "%s (%d) TIOCSERGETLSR\n", __func__,  port->number);
                 return get_lsr_info(edge_port, (unsigned int __user *) arg);
 
         case TIOCGSERIAL:
-                dbg("%s (%d) TIOCGSERIAL", __func__,  port->number);
+                dev_dbg(&port->dev, "%s (%d) TIOCGSERIAL\n", __func__,  port->number);
                 return get_serial_info(edge_port, (struct serial_struct __user *) arg);
 
         case TIOCMIWAIT:
-                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+                dev_dbg(&port->dev, "%s (%d) TIOCMIWAIT\n", __func__,  port->number);
                 cprev = edge_port->icount;
                 while (1) {
                         prepare_to_wait(&edge_port->delta_msr_wait,
@@ -1745,7 +1715,7 @@ static void edge_break(struct tty_struct *tty, int break_state)
                 /* flush and chase */
                 edge_port->chaseResponsePending = true;
 
-                dbg("%s - Sending IOSP_CMD_CHASE_PORT", __func__);
+                dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CHASE_PORT\n", __func__);
                 status = send_iosp_ext_cmd(edge_port, IOSP_CMD_CHASE_PORT, 0);
                 if (status == 0) {
                         /* block until chase finished */
@@ -1759,16 +1729,16 @@ static void edge_break(struct tty_struct *tty, int break_state)
             ((edge_serial->is_epic) &&
              (edge_serial->epic_descriptor.Supports.IOSPSetClrBreak))) {
                 if (break_state == -1) {
-                        dbg("%s - Sending IOSP_CMD_SET_BREAK", __func__);
+                        dev_dbg(&port->dev, "%s - Sending IOSP_CMD_SET_BREAK\n", __func__);
                         status = send_iosp_ext_cmd(edge_port,
                                                 IOSP_CMD_SET_BREAK, 0);
                 } else {
-                        dbg("%s - Sending IOSP_CMD_CLEAR_BREAK", __func__);
+                        dev_dbg(&port->dev, "%s - Sending IOSP_CMD_CLEAR_BREAK\n", __func__);
                         status = send_iosp_ext_cmd(edge_port,
                                                 IOSP_CMD_CLEAR_BREAK, 0);
                 }
                 if (status)
-                        dbg("%s - error sending break set/clear command.",
+                        dev_dbg(&port->dev, "%s - error sending break set/clear command.\n",
                                 __func__);
         }
 }
@@ -1781,20 +1751,19 @@ static void edge_break(struct tty_struct *tty, int break_state)
 static void process_rcvd_data(struct edgeport_serial *edge_serial,
                                 unsigned char *buffer, __u16 bufferLength)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
         struct usb_serial_port *port;
         struct edgeport_port *edge_port;
         struct tty_struct *tty;
         __u16 lastBufferLength;
         __u16 rxLen;
 
-        dbg("%s", __func__);
-
         lastBufferLength = bufferLength + 1;
 
         while (bufferLength > 0) {
                 /* failsafe incase we get a message that we don't understand */
                 if (lastBufferLength == bufferLength) {
-                        dbg("%s - stuck in loop, exiting it.", __func__);
+                        dev_dbg(dev, "%s - stuck in loop, exiting it.\n", __func__);
                         break;
                 }
                 lastBufferLength = bufferLength;
@@ -1815,8 +1784,8 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
                         ++buffer;
                         --bufferLength;
 
-                        dbg("%s - Hdr1=%02X Hdr2=%02X", __func__,
-                            edge_serial->rxHeader1, edge_serial->rxHeader2);
+                        dev_dbg(dev, "%s - Hdr1=%02X Hdr2=%02X\n", __func__,
+                                edge_serial->rxHeader1, edge_serial->rxHeader2);
                         /* Process depending on whether this header is
                          * data or status */
 
@@ -1855,10 +1824,10 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
                                     IOSP_GET_HDR_DATA_LEN(
                                                 edge_serial->rxHeader1,
                                                 edge_serial->rxHeader2);
-                                dbg("%s - Data for Port %u Len %u",
-                                                __func__,
-                                                edge_serial->rxPort,
-                                                edge_serial->rxBytesRemaining);
+                                dev_dbg(dev, "%s - Data for Port %u Len %u\n",
+                                        __func__,
+                                        edge_serial->rxPort,
+                                        edge_serial->rxBytesRemaining);
 
                                 /* ASSERT(DevExt->RxPort < DevExt->NumPorts);
                                  * ASSERT(DevExt->RxBytesRemaining <
@@ -1896,7 +1865,7 @@ static void process_rcvd_data(struct edgeport_serial *edge_serial,
                                         tty = tty_port_tty_get(
                                                 &edge_port->port->port);
                                         if (tty) {
-                                                dbg("%s - Sending %d bytes to TTY for port %d",
+                                                dev_dbg(dev, "%s - Sending %d bytes to TTY for port %d\n",
                                                         __func__, rxLen, edge_serial->rxPort);
                                                 edge_tty_recv(&edge_serial->serial->dev->dev, tty, buffer, rxLen);
                                                 tty_kref_put(tty);
@@ -1935,6 +1904,7 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
         struct usb_serial_port *port;
         struct edgeport_port *edge_port;
         struct tty_struct *tty;
+        struct device *dev;
         __u8 code = edge_serial->rxStatusCode;
 
         /* switch the port pointer to the one being currently talked about */
@@ -1946,16 +1916,15 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                                         __func__, edge_serial->rxPort);
                 return;
         }
-
-        dbg("%s - port %d", __func__, edge_serial->rxPort);
+        dev = &port->dev;
 
         if (code == IOSP_EXT_STATUS) {
                 switch (byte2) {
                 case IOSP_EXT_STATUS_CHASE_RSP:
                         /* we want to do EXT status regardless of port
                          * open/closed */
-                        dbg("%s - Port %u EXT CHASE_RSP Data = %02x",
-                                        __func__, edge_serial->rxPort, byte3);
+                        dev_dbg(dev, "%s - Port %u EXT CHASE_RSP Data = %02x\n",
+                                __func__, edge_serial->rxPort, byte3);
                         /* Currently, the only EXT_STATUS is Chase, so process
                          * here instead of one more call to one more subroutine
                          * If/when more EXT_STATUS, there'll be more work to do
@@ -1970,7 +1939,8 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                         return;
 
                 case IOSP_EXT_STATUS_RX_CHECK_RSP:
-                        dbg("%s ========== Port %u CHECK_RSP Sequence = %02x =============", __func__, edge_serial->rxPort, byte3);
+                        dev_dbg(dev, "%s ========== Port %u CHECK_RSP Sequence = %02x =============\n",
+                                __func__, edge_serial->rxPort, byte3);
                         /* Port->RxCheckRsp = true; */
                         return;
                 }
@@ -1979,7 +1949,8 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
         if (code == IOSP_STATUS_OPEN_RSP) {
                 edge_port->txCredits = GET_TX_BUFFER_SIZE(byte3);
                 edge_port->maxTxCredits = edge_port->txCredits;
-                dbg("%s - Port %u Open Response Initial MSR = %02x TxBufferSize = %d", __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
+                dev_dbg(dev, "%s - Port %u Open Response Initial MSR = %02x TxBufferSize = %d\n",
+                        __func__, edge_serial->rxPort, byte2, edge_port->txCredits);
                 handle_new_msr(edge_port, byte2);
 
                 /* send the current line settings to the port so we are
@@ -2008,27 +1979,27 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
         switch (code) {
         /* Not currently sent by Edgeport */
         case IOSP_STATUS_LSR:
-                dbg("%s - Port %u LSR Status = %02x",
-                                        __func__, edge_serial->rxPort, byte2);
+                dev_dbg(dev, "%s - Port %u LSR Status = %02x\n",
+                        __func__, edge_serial->rxPort, byte2);
                 handle_new_lsr(edge_port, false, byte2, 0);
                 break;
 
         case IOSP_STATUS_LSR_DATA:
-                dbg("%s - Port %u LSR Status = %02x, Data = %02x",
-                                __func__, edge_serial->rxPort, byte2, byte3);
+                dev_dbg(dev, "%s - Port %u LSR Status = %02x, Data = %02x\n",
+                        __func__, edge_serial->rxPort, byte2, byte3);
                 /* byte2 is LSR Register */
                 /* byte3 is broken data byte */
                 handle_new_lsr(edge_port, true, byte2, byte3);
                 break;
         /*
          *      case IOSP_EXT_4_STATUS:
-         *              dbg("%s - Port %u LSR Status = %02x Data = %02x",
+         *              dev_dbg(dev, "%s - Port %u LSR Status = %02x Data = %02x\n",
          *                      __func__, edge_serial->rxPort, byte2, byte3);
          *              break;
          */
         case IOSP_STATUS_MSR:
-                dbg("%s - Port %u MSR Status = %02x",
-                                        __func__, edge_serial->rxPort, byte2);
+                dev_dbg(dev, "%s - Port %u MSR Status = %02x\n",
+                        __func__, edge_serial->rxPort, byte2);
                 /*
                  * Process this new modem status and generate appropriate
                  * events, etc, based on the new status. This routine
@@ -2038,7 +2009,7 @@ static void process_rcvd_status(struct edgeport_serial *edge_serial,
                 break;
 
         default:
-                dbg("%s - Unrecognized IOSP status code %u", __func__, code);
+                dev_dbg(dev, "%s - Unrecognized IOSP status code %u\n", __func__, code);
                 break;
         }
 }
@@ -2073,8 +2044,6 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 newMsr)
 {
         struct  async_icount *icount;
 
-        dbg("%s %02x", __func__, newMsr);
-
         if (newMsr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
                         EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
                 icount = &edge_port->icount;
@@ -2107,8 +2076,6 @@ static void handle_new_lsr(struct edgeport_port *edge_port, __u8 lsrData,
                 (LSR_OVER_ERR | LSR_PAR_ERR | LSR_FRM_ERR | LSR_BREAK));
         struct async_icount *icount;
 
-        dbg("%s - %02x", __func__, newLsr);
-
         edge_port->shadowLSR = lsr;
 
         if (newLsr & LSR_BREAK) {
@@ -2156,7 +2123,7 @@ static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
         __u16 current_length;
         unsigned char *transfer_buffer;
 
-        dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
+        dev_dbg(&serial->dev->dev, "%s - %x, %x, %d\n", __func__, extAddr, addr, length);
 
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
         if (!transfer_buffer) {
@@ -2173,8 +2140,7 @@ static int sram_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
                 else
                         current_length = length;
 
-/*              dbg("%s - writing %x, %x, %d", __func__,
-                                        extAddr, addr, current_length); */
+/*              dev_dbg(&serial->dev->dev, "%s - writing %x, %x, %d\n", __func__, extAddr, addr, current_length); */
                 memcpy(transfer_buffer, data, current_length);
                 result = usb_control_msg(serial->dev,
                                         usb_sndctrlpipe(serial->dev, 0),
@@ -2207,8 +2173,6 @@ static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
         __u16 current_length;
         unsigned char *transfer_buffer;
 
-/*      dbg("%s - %x, %x, %d", __func__, extAddr, addr, length); */
-
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
         if (!transfer_buffer) {
                 dev_err(&serial->dev->dev, "%s - kmalloc(%d) failed.\n",
@@ -2223,8 +2187,6 @@ static int rom_write(struct usb_serial *serial, __u16 extAddr, __u16 addr,
                         current_length = 64;
                 else
                         current_length = length;
-/*              dbg("%s - writing %x, %x, %d", __func__,
-                                        extAddr, addr, current_length); */
                 memcpy(transfer_buffer, data, current_length);
                 result = usb_control_msg(serial->dev,
                                         usb_sndctrlpipe(serial->dev, 0),
@@ -2257,8 +2219,6 @@ static int rom_read(struct usb_serial *serial, __u16 extAddr,
         __u16 current_length;
         unsigned char *transfer_buffer;
 
-        dbg("%s - %x, %x, %d", __func__, extAddr, addr, length);
-
         transfer_buffer =  kmalloc(64, GFP_KERNEL);
         if (!transfer_buffer) {
                 dev_err(&serial->dev->dev,
@@ -2273,8 +2233,6 @@ static int rom_read(struct usb_serial *serial, __u16 extAddr,
                         current_length = 64;
                 else
                         current_length = length;
-/*              dbg("%s - %x, %x, %d", __func__,
-                                extAddr, addr, current_length); */
                 result = usb_control_msg(serial->dev,
                                         usb_rcvctrlpipe(serial->dev, 0),
                                         USB_REQUEST_ION_READ_ROM,
@@ -2305,8 +2263,6 @@ static int send_iosp_ext_cmd(struct edgeport_port *edge_port,
         int             length = 0;
         int             status = 0;
 
-        dbg("%s - %d, %d", __func__, command, param);
-
         buffer = kmalloc(10, GFP_ATOMIC);
         if (!buffer) {
                 dev_err(&edge_port->port->dev,
@@ -2339,11 +2295,11 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
 {
         struct edgeport_serial *edge_serial =
                                 usb_get_serial_data(edge_port->port->serial);
+        struct device *dev = &edge_port->port->dev;
         int status = 0;
         struct urb *urb;
 
-        usb_serial_debug_data(debug, &edge_port->port->dev,
-                                                __func__, length, buffer);
+        usb_serial_debug_data(dev, __func__, length, buffer);
 
         /* Allocate our next urb */
         urb = usb_alloc_urb(0, GFP_ATOMIC);
@@ -2351,8 +2307,8 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
                 return -ENOMEM;
 
         atomic_inc(&CmdUrbs);
-        dbg("%s - ALLOCATE URB %p (outstanding %d)",
-                                __func__, urb, atomic_read(&CmdUrbs));
+        dev_dbg(dev, "%s - ALLOCATE URB %p (outstanding %d)\n",
+                __func__, urb, atomic_read(&CmdUrbs));
 
         usb_fill_bulk_urb(urb, edge_serial->serial->dev,
                         usb_sndbulkpipe(edge_serial->serial->dev,
@@ -2364,9 +2320,8 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
 
         if (status) {
                 /* something went wrong */
-                dev_err(&edge_port->port->dev,
-                    "%s - usb_submit_urb(write command) failed, status = %d\n",
-                                                        __func__, status);
+                dev_err(dev, "%s - usb_submit_urb(write command) failed, status = %d\n",
+                        __func__, status);
                 usb_kill_urb(urb);
                 usb_free_urb(urb);
                 atomic_dec(&CmdUrbs);
@@ -2378,7 +2333,7 @@ static int write_cmd_usb(struct edgeport_port *edge_port,
 
         if (edge_port->commandPending) {
                 /* command timed out */
-                dbg("%s - command timed out", __func__);
+                dev_dbg(dev, "%s - command timed out\n", __func__);
                 status = -EINVAL;
         }
 #endif
@@ -2396,6 +2351,7 @@ static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
 {
         struct edgeport_serial *edge_serial =
                                 usb_get_serial_data(edge_port->port->serial);
+        struct device *dev = &edge_port->port->dev;
         unsigned char *cmdBuffer;
         unsigned char *currCmd;
         int cmdLen = 0;
@@ -2406,26 +2362,24 @@ static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
 
         if (edge_serial->is_epic &&
             !edge_serial->epic_descriptor.Supports.IOSPSetBaudRate) {
-                dbg("SendCmdWriteBaudRate - NOT Setting baud rate for port = %d, baud = %d",
-                    edge_port->port->number, baudRate);
+                dev_dbg(dev, "SendCmdWriteBaudRate - NOT Setting baud rate for port = %d, baud = %d\n",
+                        edge_port->port->number, baudRate);
                 return 0;
         }
 
-        dbg("%s - port = %d, baud = %d", __func__,
-                                        edge_port->port->number, baudRate);
+        dev_dbg(dev, "%s - port = %d, baud = %d\n", __func__,
+                edge_port->port->number, baudRate);
 
-        status = calc_baud_rate_divisor(baudRate, &divisor);
+        status = calc_baud_rate_divisor(dev, baudRate, &divisor);
         if (status) {
-                dev_err(&edge_port->port->dev, "%s - bad baud rate\n",
-                                                                __func__);
+                dev_err(dev, "%s - bad baud rate\n", __func__);
                 return status;
         }
 
         /* Alloc memory for the string of commands. */
         cmdBuffer =  kmalloc(0x100, GFP_ATOMIC);
         if (!cmdBuffer) {
-                dev_err(&edge_port->port->dev,
-                        "%s - kmalloc(%d) failed.\n", __func__, 0x100);
+                dev_err(dev, "%s - kmalloc(%d) failed.\n", __func__, 0x100);
                 return -ENOMEM;
         }
         currCmd = cmdBuffer;
@@ -2456,14 +2410,11 @@ static int send_cmd_write_baud_rate(struct edgeport_port *edge_port,
  *      this function calculates the proper baud rate divisor for the specified
  *      baud rate.
  *****************************************************************************/
-static int calc_baud_rate_divisor(int baudrate, int *divisor)
+static int calc_baud_rate_divisor(struct device *dev, int baudrate, int *divisor)
 {
         int i;
         __u16 custom;
 
-
-        dbg("%s - %d", __func__, baudrate);
-
         for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
                 if (divisor_table[i].BaudRate == baudrate) {
                         *divisor = divisor_table[i].Divisor;
@@ -2480,7 +2431,7 @@ static int calc_baud_rate_divisor(int baudrate, int *divisor)
 
                 *divisor = custom;
 
-                dbg("%s - Baud %d = %d", __func__, baudrate, custom);
+                dev_dbg(dev, "%s - Baud %d = %d\n", __func__, baudrate, custom);
                 return 0;
         }
 
@@ -2497,25 +2448,26 @@ static int send_cmd_write_uart_register(struct edgeport_port *edge_port,
 {
         struct edgeport_serial *edge_serial =
                                 usb_get_serial_data(edge_port->port->serial);
+        struct device *dev = &edge_port->port->dev;
         unsigned char *cmdBuffer;
         unsigned char *currCmd;
         unsigned long cmdLen = 0;
         int status;
 
-        dbg("%s - write to %s register 0x%02x",
-                        (regNum == MCR) ? "MCR" : "LCR", __func__, regValue);
+        dev_dbg(dev, "%s - write to %s register 0x%02x\n",
+                (regNum == MCR) ? "MCR" : "LCR", __func__, regValue);
 
         if (edge_serial->is_epic &&
             !edge_serial->epic_descriptor.Supports.IOSPWriteMCR &&
             regNum == MCR) {
-                dbg("SendCmdWriteUartReg - Not writing to MCR Register");
+                dev_dbg(dev, "SendCmdWriteUartReg - Not writing to MCR Register\n");
                 return 0;
         }
 
         if (edge_serial->is_epic &&
             !edge_serial->epic_descriptor.Supports.IOSPWriteLCR &&
             regNum == LCR) {
-                dbg("SendCmdWriteUartReg - Not writing to LCR Register");
+                dev_dbg(dev, "SendCmdWriteUartReg - Not writing to LCR Register\n");
                 return 0;
         }
 
@@ -2550,6 +2502,7 @@ static int send_cmd_write_uart_register(struct edgeport_port *edge_port,
 static void change_port_settings(struct tty_struct *tty,
         struct edgeport_port *edge_port, struct ktermios *old_termios)
 {
+        struct device *dev = &edge_port->port->dev;
         struct edgeport_serial *edge_serial =
                         usb_get_serial_data(edge_port->port->serial);
         int baud;
@@ -2562,11 +2515,11 @@ static void change_port_settings(struct tty_struct *tty,
         __u8 txFlow;
         int status;
 
-        dbg("%s - port %d", __func__, edge_port->port->number);
+        dev_dbg(dev, "%s - port %d\n", __func__, edge_port->port->number);
 
         if (!edge_port->open &&
             !edge_port->openPending) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -2575,20 +2528,20 @@ static void change_port_settings(struct tty_struct *tty,
         switch (cflag & CSIZE) {
         case CS5:
                 lData = LCR_BITS_5; mask = 0x1f;
-                dbg("%s - data bits = 5", __func__);
+                dev_dbg(dev, "%s - data bits = 5\n", __func__);
                 break;
         case CS6:
                 lData = LCR_BITS_6; mask = 0x3f;
-                dbg("%s - data bits = 6", __func__);
+                dev_dbg(dev, "%s - data bits = 6\n", __func__);
                 break;
         case CS7:
                 lData = LCR_BITS_7; mask = 0x7f;
-                dbg("%s - data bits = 7", __func__);
+                dev_dbg(dev, "%s - data bits = 7\n", __func__);
                 break;
         default:
         case CS8:
                 lData = LCR_BITS_8;
-                dbg("%s - data bits = 8", __func__);
+                dev_dbg(dev, "%s - data bits = 8\n", __func__);
                 break;
         }
 
@@ -2597,28 +2550,28 @@ static void change_port_settings(struct tty_struct *tty,
                 if (cflag & CMSPAR) {
                         if (cflag & PARODD) {
                                 lParity = LCR_PAR_MARK;
-                                dbg("%s - parity = mark", __func__);
+                                dev_dbg(dev, "%s - parity = mark\n", __func__);
                         } else {
                                 lParity = LCR_PAR_SPACE;
-                                dbg("%s - parity = space", __func__);
+                                dev_dbg(dev, "%s - parity = space\n", __func__);
                         }
                 } else if (cflag & PARODD) {
                         lParity = LCR_PAR_ODD;
-                        dbg("%s - parity = odd", __func__);
+                        dev_dbg(dev, "%s - parity = odd\n", __func__);
                 } else {
                         lParity = LCR_PAR_EVEN;
-                        dbg("%s - parity = even", __func__);
+                        dev_dbg(dev, "%s - parity = even\n", __func__);
                 }
         } else {
-                dbg("%s - parity = none", __func__);
+                dev_dbg(dev, "%s - parity = none\n", __func__);
         }
 
         if (cflag & CSTOPB) {
                 lStop = LCR_STOP_2;
-                dbg("%s - stop bits = 2", __func__);
+                dev_dbg(dev, "%s - stop bits = 2\n", __func__);
         } else {
                 lStop = LCR_STOP_1;
-                dbg("%s - stop bits = 1", __func__);
+                dev_dbg(dev, "%s - stop bits = 1\n", __func__);
         }
 
         /* figure out the flow control settings */
@@ -2626,9 +2579,9 @@ static void change_port_settings(struct tty_struct *tty,
         if (cflag & CRTSCTS) {
                 rxFlow |= IOSP_RX_FLOW_RTS;
                 txFlow |= IOSP_TX_FLOW_CTS;
-                dbg("%s - RTS/CTS is enabled", __func__);
+                dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
         } else {
-                dbg("%s - RTS/CTS is disabled", __func__);
+                dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
         }
 
         /* if we are implementing XON/XOFF, set the start and stop character
@@ -2649,19 +2602,19 @@ static void change_port_settings(struct tty_struct *tty,
                 /* if we are implementing INBOUND XON/XOFF */
                 if (I_IXOFF(tty)) {
                         rxFlow |= IOSP_RX_FLOW_XON_XOFF;
-                        dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                                        __func__, start_char, stop_char);
+                        dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
+                                __func__, start_char, stop_char);
                 } else {
-                        dbg("%s - INBOUND XON/XOFF is disabled", __func__);
+                        dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);
                 }
 
                 /* if we are implementing OUTBOUND XON/XOFF */
                 if (I_IXON(tty)) {
                         txFlow |= IOSP_TX_FLOW_XON_XOFF;
-                        dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                                        __func__, start_char, stop_char);
+                        dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
+                                __func__, start_char, stop_char);
                 } else {
-                        dbg("%s - OUTBOUND XON/XOFF is disabled", __func__);
+                        dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);
                 }
         }
 
@@ -2704,7 +2657,7 @@ static void change_port_settings(struct tty_struct *tty,
                 baud = 9600;
         }
 
-        dbg("%s - baud rate = %d", __func__, baud);
+        dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud);
         status = send_cmd_write_baud_rate(edge_port, baud);
         if (status == -1) {
                 /* Speed change was not possible - put back the old speed */
@@ -2746,9 +2699,10 @@ static void unicode_to_ascii(char *string, int buflen,
  ****************************************************************************/
 static void get_manufacturing_desc(struct edgeport_serial *edge_serial)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
         int response;
 
-        dbg("getting manufacturer descriptor");
+        dev_dbg(dev, "getting manufacturer descriptor\n");
 
         response = rom_read(edge_serial->serial,
                                 (EDGE_MANUF_DESC_ADDR & 0xffff0000) >> 16,
@@ -2757,42 +2711,41 @@ static void get_manufacturing_desc(struct edgeport_serial *edge_serial)
                                 (__u8 *)(&edge_serial->manuf_descriptor));
 
         if (response < 1)
-                dev_err(&edge_serial->serial->dev->dev,
-                        "error in getting manufacturer descriptor\n");
+                dev_err(dev, "error in getting manufacturer descriptor\n");
         else {
                 char string[30];
-                dbg("**Manufacturer Descriptor");
-                dbg("  RomSize:        %dK",
+                dev_dbg(dev, "**Manufacturer Descriptor\n");
+                dev_dbg(dev, "  RomSize:        %dK\n",
                         edge_serial->manuf_descriptor.RomSize);
-                dbg("  RamSize:        %dK",
+                dev_dbg(dev, "  RamSize:        %dK\n",
                         edge_serial->manuf_descriptor.RamSize);
-                dbg("  CpuRev:         %d",
+                dev_dbg(dev, "  CpuRev:         %d\n",
                         edge_serial->manuf_descriptor.CpuRev);
-                dbg("  BoardRev:       %d",
+                dev_dbg(dev, "  BoardRev:       %d\n",
                         edge_serial->manuf_descriptor.BoardRev);
-                dbg("  NumPorts:       %d",
+                dev_dbg(dev, "  NumPorts:       %d\n",
                         edge_serial->manuf_descriptor.NumPorts);
-                dbg("  DescDate:       %d/%d/%d",
+                dev_dbg(dev, "  DescDate:       %d/%d/%d\n",
                         edge_serial->manuf_descriptor.DescDate[0],
                         edge_serial->manuf_descriptor.DescDate[1],
                         edge_serial->manuf_descriptor.DescDate[2]+1900);
                 unicode_to_ascii(string, sizeof(string),
                         edge_serial->manuf_descriptor.SerialNumber,
                         edge_serial->manuf_descriptor.SerNumLength/2);
-                dbg("  SerialNumber: %s", string);
+                dev_dbg(dev, "  SerialNumber: %s\n", string);
                 unicode_to_ascii(string, sizeof(string),
                         edge_serial->manuf_descriptor.AssemblyNumber,
                         edge_serial->manuf_descriptor.AssemblyNumLength/2);
-                dbg("  AssemblyNumber: %s", string);
+                dev_dbg(dev, "  AssemblyNumber: %s\n", string);
                 unicode_to_ascii(string, sizeof(string),
                     edge_serial->manuf_descriptor.OemAssyNumber,
                     edge_serial->manuf_descriptor.OemAssyNumLength/2);
-                dbg("  OemAssyNumber:  %s", string);
-                dbg("  UartType:       %d",
+                dev_dbg(dev, "  OemAssyNumber:  %s\n", string);
+                dev_dbg(dev, "  UartType:       %d\n",
                         edge_serial->manuf_descriptor.UartType);
-                dbg("  IonPid:         %d",
+                dev_dbg(dev, "  IonPid:         %d\n",
                         edge_serial->manuf_descriptor.IonPid);
-                dbg("  IonConfig:      %d",
+                dev_dbg(dev, "  IonConfig:      %d\n",
                         edge_serial->manuf_descriptor.IonConfig);
         }
 }
@@ -2805,9 +2758,10 @@ static void get_manufacturing_desc(struct edgeport_serial *edge_serial)
  ****************************************************************************/
 static void get_boot_desc(struct edgeport_serial *edge_serial)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
         int response;
 
-        dbg("getting boot descriptor");
+        dev_dbg(dev, "getting boot descriptor\n");
 
         response = rom_read(edge_serial->serial,
                                 (EDGE_BOOT_DESC_ADDR & 0xffff0000) >> 16,
@@ -2816,23 +2770,22 @@ static void get_boot_desc(struct edgeport_serial *edge_serial)
                                 (__u8 *)(&edge_serial->boot_descriptor));
 
         if (response < 1)
-                dev_err(&edge_serial->serial->dev->dev,
-                                "error in getting boot descriptor\n");
+                dev_err(dev, "error in getting boot descriptor\n");
         else {
-                dbg("**Boot Descriptor:");
-                dbg("  BootCodeLength: %d",
-                    le16_to_cpu(edge_serial->boot_descriptor.BootCodeLength));
-                dbg("  MajorVersion:   %d",
+                dev_dbg(dev, "**Boot Descriptor:\n");
+                dev_dbg(dev, "  BootCodeLength: %d\n",
+                        le16_to_cpu(edge_serial->boot_descriptor.BootCodeLength));
+                dev_dbg(dev, "  MajorVersion:   %d\n",
                         edge_serial->boot_descriptor.MajorVersion);
-                dbg("  MinorVersion:   %d",
+                dev_dbg(dev, "  MinorVersion:   %d\n",
                         edge_serial->boot_descriptor.MinorVersion);
-                dbg("  BuildNumber:    %d",
+                dev_dbg(dev, "  BuildNumber:    %d\n",
                         le16_to_cpu(edge_serial->boot_descriptor.BuildNumber));
-                dbg("  Capabilities:   0x%x",
+                dev_dbg(dev, "  Capabilities:   0x%x\n",
                       le16_to_cpu(edge_serial->boot_descriptor.Capabilities));
-                dbg("  UConfig0:       %d",
+                dev_dbg(dev, "  UConfig0:       %d\n",
                         edge_serial->boot_descriptor.UConfig0);
-                dbg("  UConfig1:       %d",
+                dev_dbg(dev, "  UConfig1:       %d\n",
                         edge_serial->boot_descriptor.UConfig1);
         }
 }
@@ -2844,6 +2797,7 @@ static void get_boot_desc(struct edgeport_serial *edge_serial)
  ****************************************************************************/
 static void load_application_firmware(struct edgeport_serial *edge_serial)
 {
+        struct device *dev = &edge_serial->serial->dev->dev;
         const struct ihex_binrec *rec;
         const struct firmware *fw;
         const char *fw_name;
@@ -2864,7 +2818,7 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
                         break;
 
                 case EDGE_DOWNLOAD_FILE_NONE:
-                        dbg("No download file specified, skipping download");
+                        dev_dbg(dev, "No download file specified, skipping download\n");
                         return;
 
                 default:
@@ -2874,7 +2828,7 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
         response = request_ihex_firmware(&fw, fw_name,
                                     &edge_serial->serial->dev->dev);
         if (response) {
-                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
+                dev_err(dev, "Failed to load image \"%s\" err %d\n",
                        fw_name, response);
                 return;
         }
@@ -2882,7 +2836,7 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
         rec = (const struct ihex_binrec *)fw->data;
         build = (rec->data[2] << 8) | rec->data[3];
 
-        dbg("%s %d.%d.%d", fw_info, rec->data[0], rec->data[1], build);
+        dev_dbg(dev, "%s %d.%d.%d\n", fw_info, rec->data[0], rec->data[1], build);
 
         edge_serial->product_info.FirmwareMajorVersion = rec->data[0];
         edge_serial->product_info.FirmwareMinorVersion = rec->data[1];
@@ -2905,10 +2859,10 @@ static void load_application_firmware(struct edgeport_serial *edge_serial)
                 }
         }
 
-        dbg("sending exec_dl_code");
-        response = usb_control_msg (edge_serial->serial->dev, 
-                                    usb_sndctrlpipe(edge_serial->serial->dev, 0), 
-                                    USB_REQUEST_ION_EXEC_DL_CODE, 
+        dev_dbg(dev, "sending exec_dl_code\n");
+        response = usb_control_msg (edge_serial->serial->dev,
+                                    usb_sndctrlpipe(edge_serial->serial->dev, 0),
+                                    USB_REQUEST_ION_EXEC_DL_CODE,
                                     0x40, 0x4000, 0x0001, NULL, 0, 3000);
 
         release_firmware(fw);
@@ -2923,6 +2877,7 @@ static int edge_startup(struct usb_serial *serial)
         struct edgeport_serial *edge_serial;
         struct edgeport_port *edge_port;
         struct usb_device *dev;
+        struct device *ddev = &serial->dev->dev;
         int i, j;
         int response;
         bool interrupt_in_found;
@@ -2974,32 +2929,31 @@ static int edge_startup(struct usb_serial *serial)
         /* serial->num_ports = serial->product_info.NumPorts; */
         if ((!edge_serial->is_epic) &&
             (edge_serial->product_info.NumPorts != serial->num_ports)) {
-                dev_warn(&serial->dev->dev, "Device Reported %d serial ports "
-                         "vs. core thinking we have %d ports, email "
-                         "greg@kroah.com this information.\n",
+                dev_warn(ddev,
+                        "Device Reported %d serial ports vs. core thinking we have %d ports, email greg@kroah.com this information.\n",
                          edge_serial->product_info.NumPorts,
                          serial->num_ports);
         }
 
-        dbg("%s - time 1 %ld", __func__, jiffies);
+        dev_dbg(ddev, "%s - time 1 %ld\n", __func__, jiffies);
 
         /* If not an EPiC device */
         if (!edge_serial->is_epic) {
                 /* now load the application firmware into this device */
                 load_application_firmware(edge_serial);
 
-                dbg("%s - time 2 %ld", __func__, jiffies);
+                dev_dbg(ddev, "%s - time 2 %ld\n", __func__, jiffies);
 
                 /* Check current Edgeport EEPROM and update if necessary */
                 update_edgeport_E2PROM(edge_serial);
 
-                dbg("%s - time 3 %ld", __func__, jiffies);
+                dev_dbg(ddev, "%s - time 3 %ld\n", __func__, jiffies);
 
                 /* set the configuration to use #1 */
-/*              dbg("set_configuration 1"); */
+/*              dev_dbg(ddev, "set_configuration 1\n"); */
 /*              usb_set_configuration (dev, 1); */
         }
-        dbg("  FirmwareMajorVersion  %d.%d.%d",
+        dev_dbg(ddev, "  FirmwareMajorVersion  %d.%d.%d\n",
             edge_serial->product_info.FirmwareMajorVersion,
             edge_serial->product_info.FirmwareMinorVersion,
             le16_to_cpu(edge_serial->product_info.FirmwareBuildNumber));
@@ -3011,8 +2965,7 @@ static int edge_startup(struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; ++i) {
                 edge_port = kzalloc(sizeof(struct edgeport_port), GFP_KERNEL);
                 if (edge_port == NULL) {
-                        dev_err(&serial->dev->dev, "%s - Out of memory\n",
-                                                                   __func__);
+                        dev_err(ddev, "%s - Out of memory\n", __func__);
                         for (j = 0; j < i; ++j) {
                                 kfree(usb_get_serial_port_data(serial->port[j]));
                                 usb_set_serial_port_data(serial->port[j],
@@ -3044,19 +2997,19 @@ static int edge_startup(struct usb_serial *serial)
                         if (!interrupt_in_found &&
                             (usb_endpoint_is_int_in(endpoint))) {
                                 /* we found a interrupt in endpoint */
-                                dbg("found interrupt in");
+                                dev_dbg(ddev, "found interrupt in\n");
 
                                 /* not set up yet, so do it now */
                                 edge_serial->interrupt_read_urb =
                                                 usb_alloc_urb(0, GFP_KERNEL);
                                 if (!edge_serial->interrupt_read_urb) {
-                                        dev_err(&dev->dev, "out of memory\n");
+                                        dev_err(ddev, "out of memory\n");
                                         return -ENOMEM;
                                 }
                                 edge_serial->interrupt_in_buffer =
                                         kmalloc(buffer_size, GFP_KERNEL);
                                 if (!edge_serial->interrupt_in_buffer) {
-                                        dev_err(&dev->dev, "out of memory\n");
+                                        dev_err(ddev, "out of memory\n");
                                         usb_free_urb(edge_serial->interrupt_read_urb);
                                         return -ENOMEM;
                                 }
@@ -3081,13 +3034,13 @@ static int edge_startup(struct usb_serial *serial)
                         if (!bulk_in_found &&
                                 (usb_endpoint_is_bulk_in(endpoint))) {
                                 /* we found a bulk in endpoint */
-                                dbg("found bulk in");
+                                dev_dbg(ddev, "found bulk in\n");
 
                                 /* not set up yet, so do it now */
                                 edge_serial->read_urb =
                                                 usb_alloc_urb(0, GFP_KERNEL);
                                 if (!edge_serial->read_urb) {
-                                        dev_err(&dev->dev, "out of memory\n");
+                                        dev_err(ddev, "out of memory\n");
                                         return -ENOMEM;
                                 }
                                 edge_serial->bulk_in_buffer =
@@ -3114,7 +3067,7 @@ static int edge_startup(struct usb_serial *serial)
                         if (!bulk_out_found &&
                             (usb_endpoint_is_bulk_out(endpoint))) {
                                 /* we found a bulk out endpoint */
-                                dbg("found bulk out");
+                                dev_dbg(ddev, "found bulk out\n");
                                 edge_serial->bulk_out_endpoint =
                                                 endpoint->bEndpointAddress;
                                 bulk_out_found = true;
@@ -3122,8 +3075,7 @@ static int edge_startup(struct usb_serial *serial)
                 }
 
                 if (!interrupt_in_found || !bulk_in_found || !bulk_out_found) {
-                        dev_err(&dev->dev, "Error - the proper endpoints "
-                                "were not found!\n");
+                        dev_err(ddev, "Error - the proper endpoints were not found!\n");
                         return -ENODEV;
                 }
 
@@ -3132,8 +3084,7 @@ static int edge_startup(struct usb_serial *serial)
                 response = usb_submit_urb(edge_serial->interrupt_read_urb,
                                                                 GFP_KERNEL);
                 if (response)
-                        dev_err(&dev->dev,
-                                "%s - Error %d submitting control urb\n",
+                        dev_err(ddev, "%s - Error %d submitting control urb\n",
                                 __func__, response);
         }
         return response;
@@ -3148,8 +3099,6 @@ static void edge_disconnect(struct usb_serial *serial)
 {
         struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
 
-        dbg("%s", __func__);
-
         /* stop reads and writes on all ports */
         /* free up our endpoint stuff */
         if (edge_serial->is_epic) {
@@ -3173,8 +3122,6 @@ static void edge_release(struct usb_serial *serial)
         struct edgeport_serial *edge_serial = usb_get_serial_data(serial);
         int i;
 
-        dbg("%s", __func__);
-
         for (i = 0; i < serial->num_ports; ++i)
                 kfree(usb_get_serial_port_data(serial->port[i]));
 
@@ -3190,6 +3137,3 @@ MODULE_FIRMWARE("edgeport/boot.fw");
 MODULE_FIRMWARE("edgeport/boot2.fw");
 MODULE_FIRMWARE("edgeport/down.fw");
 MODULE_FIRMWARE("edgeport/down2.fw");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/io_ti.c b/drivers/usb/serial/io_ti.c
index 765978ae752e..a2209cd45093 100644
--- a/drivers/usb/serial/io_ti.c
+++ b/drivers/usb/serial/io_ti.c
@@ -201,8 +201,6 @@ static unsigned char OperationalMajorVersion;
 static unsigned char OperationalMinorVersion;
 static unsigned short OperationalBuildNumber;
 
-static bool debug;
-
 static int closing_wait = EDGE_CLOSING_WAIT;
 static bool ignore_cpu_rev;
 static int default_uart_mode;           /* RS232 */
@@ -233,8 +231,8 @@ static int ti_vread_sync(struct usb_device *dev, __u8 request,
         if (status < 0)
                 return status;
         if (status != size) {
-                dbg("%s - wanted to write %d, but only wrote %d",
-                                             __func__, size, status);
+                dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
+                        __func__, size, status);
                 return -ECOMM;
         }
         return 0;
@@ -251,8 +249,8 @@ static int ti_vsend_sync(struct usb_device *dev, __u8 request,
         if (status < 0)
                 return status;
         if (status != size) {
-                dbg("%s - wanted to write %d, but only wrote %d",
-                     __func__, size, status);
+                dev_dbg(&dev->dev, "%s - wanted to write %d, but only wrote %d\n",
+                        __func__, size, status);
                 return -ECOMM;
         }
         return 0;
@@ -270,7 +268,7 @@ static int purge_port(struct usb_serial_port *port, __u16 mask)
 {
         int port_number = port->number - port->serial->minor;
 
-        dbg("%s - port %d, mask %x", __func__, port_number, mask);
+        dev_dbg(&port->dev, "%s - port %d, mask %x\n", __func__, port_number, mask);
 
         return send_cmd(port->serial->dev,
                                         UMPC_PURGE_PORT,
@@ -295,7 +293,7 @@ static int read_download_mem(struct usb_device *dev, int start_address,
         __u8 read_length;
         __be16 be_start_address;
 
-        dbg("%s - @ %x for %d", __func__, start_address, length);
+        dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, length);
 
         /* Read in blocks of 64 bytes
          * (TI firmware can't handle more than 64 byte reads)
@@ -307,8 +305,7 @@ static int read_download_mem(struct usb_device *dev, int start_address,
                         read_length = (__u8)length;
 
                 if (read_length > 1) {
-                        dbg("%s - @ %x for %d", __func__,
-                             start_address, read_length);
+                        dev_dbg(&dev->dev, "%s - @ %x for %d\n", __func__, start_address, read_length);
                 }
                 be_start_address = cpu_to_be16(start_address);
                 status = ti_vread_sync(dev, UMPC_MEMORY_READ,
@@ -317,13 +314,12 @@ static int read_download_mem(struct usb_device *dev, int start_address,
                                         buffer, read_length);
 
                 if (status) {
-                        dbg("%s - ERROR %x", __func__, status);
+                        dev_dbg(&dev->dev, "%s - ERROR %x\n", __func__, status);
                         return status;
                 }
 
                 if (read_length > 1)
-                        usb_serial_debug_data(debug, &dev->dev, __func__,
-                                              read_length, buffer);
+                        usb_serial_debug_data(&dev->dev, __func__, read_length, buffer);
 
                 /* Update pointers/length */
                 start_address += read_length;
@@ -353,15 +349,14 @@ static int read_boot_mem(struct edgeport_serial *serial,
                                 UMPC_MEMORY_READ, serial->TI_I2C_Type,
                                 (__u16)(start_address+i), &buffer[i], 0x01);
                 if (status) {
-                        dbg("%s - ERROR %x", __func__, status);
+                        dev_dbg(&serial->serial->dev->dev, "%s - ERROR %x\n", __func__, status);
                         return status;
                 }
         }
 
-        dbg("%s - start_address = %x, length = %d",
-                                        __func__, start_address, length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev,
-                                        __func__, length, buffer);
+        dev_dbg(&serial->serial->dev->dev, "%s - start_address = %x, length = %d\n",
+                __func__, start_address, length);
+        usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
 
         serial->TiReadI2C = 1;
 
@@ -398,10 +393,8 @@ static int write_boot_mem(struct edgeport_serial *serial,
                         return status;
         }
 
-        dbg("%s - start_sddr = %x, length = %d",
-                                        __func__, start_address, length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev,
-                                        __func__, length, buffer);
+        dev_dbg(&serial->serial->dev->dev, "%s - start_sddr = %x, length = %d\n", __func__, start_address, length);
+        usb_serial_debug_data(&serial->serial->dev->dev, __func__, length, buffer);
 
         return status;
 }
@@ -411,6 +404,7 @@ static int write_boot_mem(struct edgeport_serial *serial,
 static int write_i2c_mem(struct edgeport_serial *serial,
                 int start_address, int length, __u8 address_type, __u8 *buffer)
 {
+        struct device *dev = &serial->serial->dev->dev;
         int status = 0;
         int write_length;
         __be16 be_start_address;
@@ -424,10 +418,9 @@ static int write_i2c_mem(struct edgeport_serial *serial,
         if (write_length > length)
                 write_length = length;
 
-        dbg("%s - BytesInFirstPage Addr = %x, length = %d",
-                                        __func__, start_address, write_length);
-        usb_serial_debug_data(debug, &serial->serial->dev->dev,
-                                                __func__, write_length, buffer);
+        dev_dbg(dev, "%s - BytesInFirstPage Addr = %x, length = %d\n",
+                __func__, start_address, write_length);
+        usb_serial_debug_data(dev, __func__, write_length, buffer);
 
         /* Write first page */
         be_start_address = cpu_to_be16(start_address);
@@ -436,7 +429,7 @@ static int write_i2c_mem(struct edgeport_serial *serial,
                                 (__force __u16)be_start_address,
                                 buffer, write_length);
         if (status) {
-                dbg("%s - ERROR %d", __func__, status);
+                dev_dbg(dev, "%s - ERROR %d\n", __func__, status);
                 return status;
         }
 
@@ -452,10 +445,9 @@ static int write_i2c_mem(struct edgeport_serial *serial,
                 else
                         write_length = length;
 
-                dbg("%s - Page Write Addr = %x, length = %d",
-                                        __func__, start_address, write_length);
-                usb_serial_debug_data(debug, &serial->serial->dev->dev,
-                                        __func__, write_length, buffer);
+                dev_dbg(dev, "%s - Page Write Addr = %x, length = %d\n",
+                        __func__, start_address, write_length);
+                usb_serial_debug_data(dev, __func__, write_length, buffer);
 
                 /* Write next page */
                 be_start_address = cpu_to_be16(start_address);
@@ -464,8 +456,7 @@ static int write_i2c_mem(struct edgeport_serial *serial,
                                 (__force __u16)be_start_address,
                                 buffer, write_length);
                 if (status) {
-                        dev_err(&serial->serial->dev->dev, "%s - ERROR %d\n",
-                                        __func__, status);
+                        dev_err(dev, "%s - ERROR %d\n", __func__, status);
                         return status;
                 }
 
@@ -508,7 +499,7 @@ static int tx_active(struct edgeport_port *port)
         if (status)
                 goto exit_is_tx_active;
 
-        dbg("%s - XByteCount    0x%X", __func__, oedb->XByteCount);
+        dev_dbg(&port->port->dev, "%s - XByteCount    0x%X\n", __func__, oedb->XByteCount);
 
         /* and the LSR */
         status = read_ram(port->port->serial->dev,
@@ -516,7 +507,7 @@ static int tx_active(struct edgeport_port *port)
 
         if (status)
                 goto exit_is_tx_active;
-        dbg("%s - LSR = 0x%X", __func__, *lsr);
+        dev_dbg(&port->port->dev, "%s - LSR = 0x%X\n", __func__, *lsr);
 
         /* If either buffer has data or we are transmitting then return TRUE */
         if ((oedb->XByteCount & 0x80) != 0)
@@ -527,7 +518,7 @@ static int tx_active(struct edgeport_port *port)
 
         /* We return Not Active if we get any kind of error */
 exit_is_tx_active:
-        dbg("%s - return %d", __func__, bytes_left);
+        dev_dbg(&port->port->dev, "%s - return %d\n", __func__, bytes_left);
 
         kfree(lsr);
         kfree(oedb);
@@ -599,14 +590,13 @@ static int choose_config(struct usb_device *dev)
          * configuration # 1, which is Config Descriptor 0.
          */
 
-        dbg("%s - Number of Interfaces = %d",
-                                __func__, dev->config->desc.bNumInterfaces);
-        dbg("%s - MAX Power            = %d",
-                                __func__, dev->config->desc.bMaxPower * 2);
+        dev_dbg(&dev->dev, "%s - Number of Interfaces = %d\n",
+                __func__, dev->config->desc.bNumInterfaces);
+        dev_dbg(&dev->dev, "%s - MAX Power            = %d\n",
+                __func__, dev->config->desc.bMaxPower * 2);
 
         if (dev->config->desc.bNumInterfaces != 1) {
-                dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n",
-                                                                __func__);
+                dev_err(&dev->dev, "%s - bNumInterfaces is not 1, ERROR!\n", __func__);
                 return -ENODEV;
         }
 
@@ -684,7 +674,7 @@ static int valid_csum(struct ti_i2c_desc *rom_desc, __u8 *buffer)
                 cs = (__u8)(cs + buffer[i]);
 
         if (cs != rom_desc->CheckSum) {
-                dbg("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
+                pr_debug("%s - Mismatch %x - %x", __func__, rom_desc->CheckSum, cs);
                 return -EINVAL;
         }
         return 0;
@@ -736,11 +726,11 @@ static int check_i2c_image(struct edgeport_serial *serial)
                 if ((start_address + sizeof(struct ti_i2c_desc) +
                                         rom_desc->Size) > TI_MAX_I2C_SIZE) {
                         status = -ENODEV;
-                        dbg("%s - structure too big, erroring out.", __func__);
+                        dev_dbg(dev, "%s - structure too big, erroring out.\n", __func__);
                         break;
                 }
 
-                dbg("%s Type = 0x%x", __func__, rom_desc->Type);
+                dev_dbg(dev, "%s Type = 0x%x\n", __func__, rom_desc->Type);
 
                 /* Skip type 2 record */
                 ttype = rom_desc->Type & 0x0f;
@@ -779,18 +769,18 @@ static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
         int start_address;
         struct ti_i2c_desc *rom_desc;
         struct edge_ti_manuf_descriptor *desc;
+        struct device *dev = &serial->serial->dev->dev;
 
         rom_desc = kmalloc(sizeof(*rom_desc), GFP_KERNEL);
         if (!rom_desc) {
-                dev_err(&serial->serial->dev->dev, "%s - out of memory\n",
-                                                                __func__);
+                dev_err(dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
         start_address = get_descriptor_addr(serial, I2C_DESC_TYPE_ION,
                                                                 rom_desc);
 
         if (!start_address) {
-                dbg("%s - Edge Descriptor not found in I2C", __func__);
+                dev_dbg(dev, "%s - Edge Descriptor not found in I2C\n", __func__);
                 status = -ENODEV;
                 goto exit;
         }
@@ -804,12 +794,12 @@ static int get_manuf_info(struct edgeport_serial *serial, __u8 *buffer)
         status = valid_csum(rom_desc, buffer);
 
         desc = (struct edge_ti_manuf_descriptor *)buffer;
-        dbg("%s - IonConfig      0x%x", __func__, desc->IonConfig);
-        dbg("%s - Version          %d", __func__, desc->Version);
-        dbg("%s - Cpu/Board      0x%x", __func__, desc->CpuRev_BoardRev);
-        dbg("%s - NumPorts         %d", __func__, desc->NumPorts);
-        dbg("%s - NumVirtualPorts  %d", __func__, desc->NumVirtualPorts);
-        dbg("%s - TotalPorts       %d", __func__, desc->TotalPorts);
+        dev_dbg(dev, "%s - IonConfig      0x%x\n", __func__, desc->IonConfig);
+        dev_dbg(dev, "%s - Version          %d\n", __func__, desc->Version);
+        dev_dbg(dev, "%s - Cpu/Board      0x%x\n", __func__, desc->CpuRev_BoardRev);
+        dev_dbg(dev, "%s - NumPorts         %d\n", __func__, desc->NumPorts);
+        dev_dbg(dev, "%s - NumVirtualPorts  %d\n", __func__, desc->NumVirtualPorts);
+        dev_dbg(dev, "%s - TotalPorts       %d\n", __func__, desc->TotalPorts);
 
 exit:
         kfree(rom_desc);
@@ -855,8 +845,8 @@ static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
 
         err = request_firmware(&fw, fw_name, dev);
         if (err) {
-                printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
-                       fw_name, err);
+                dev_err(dev, "Failed to load image \"%s\" err %d\n",
+                        fw_name, err);
                 kfree(buffer);
                 return err;
         }
@@ -903,13 +893,13 @@ static int build_i2c_fw_hdr(__u8 *header, struct device *dev)
 /* Try to figure out what type of I2c we have */
 static int i2c_type_bootmode(struct edgeport_serial *serial)
 {
+        struct device *dev = &serial->serial->dev->dev;
         int status;
         u8 *data;
 
         data = kmalloc(1, GFP_KERNEL);
         if (!data) {
-                dev_err(&serial->serial->dev->dev,
-                                "%s - out of memory\n", __func__);
+                dev_err(dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
 
@@ -917,11 +907,11 @@ static int i2c_type_bootmode(struct edgeport_serial *serial)
         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
                                 DTK_ADDR_SPACE_I2C_TYPE_II, 0, data, 0x01);
         if (status)
-                dbg("%s - read 2 status error = %d", __func__, status);
+                dev_dbg(dev, "%s - read 2 status error = %d\n", __func__, status);
         else
-                dbg("%s - read 2 data = 0x%x", __func__, *data);
+                dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
         if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
-                dbg("%s - ROM_TYPE_II", __func__);
+                dev_dbg(dev, "%s - ROM_TYPE_II\n", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
                 goto out;
         }
@@ -930,16 +920,16 @@ static int i2c_type_bootmode(struct edgeport_serial *serial)
         status = ti_vread_sync(serial->serial->dev, UMPC_MEMORY_READ,
                                 DTK_ADDR_SPACE_I2C_TYPE_III, 0, data, 0x01);
         if (status)
-                dbg("%s - read 3 status error = %d", __func__, status);
+                dev_dbg(dev, "%s - read 3 status error = %d\n", __func__, status);
         else
-                dbg("%s - read 2 data = 0x%x", __func__, *data);
+                dev_dbg(dev, "%s - read 2 data = 0x%x\n", __func__, *data);
         if ((!status) && (*data == UMP5152 || *data == UMP3410)) {
-                dbg("%s - ROM_TYPE_III", __func__);
+                dev_dbg(dev, "%s - ROM_TYPE_III\n", __func__);
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_III;
                 goto out;
         }
 
-        dbg("%s - Unknown", __func__);
+        dev_dbg(dev, "%s - Unknown\n", __func__);
         serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
         status = -ENODEV;
 out:
@@ -1050,11 +1040,11 @@ static int download_fw(struct edgeport_serial *serial)
         if (serial->product_info.TiMode == TI_MODE_DOWNLOAD) {
                 struct ti_i2c_desc *rom_desc;
 
-                dbg("%s - RUNNING IN DOWNLOAD MODE", __func__);
+                dev_dbg(dev, "%s - RUNNING IN DOWNLOAD MODE\n", __func__);
 
                 status = check_i2c_image(serial);
                 if (status) {
-                        dbg("%s - DOWNLOAD MODE -- BAD I2C", __func__);
+                        dev_dbg(dev, "%s - DOWNLOAD MODE -- BAD I2C\n", __func__);
                         return status;
                 }
 
@@ -1074,7 +1064,7 @@ static int download_fw(struct edgeport_serial *serial)
 
                 /* Check version number of ION descriptor */
                 if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
-                        dbg("%s - Wrong CPU Rev %d (Must be 2)",
+                        dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
                                 __func__, ti_cpu_rev(ti_manuf_desc));
                         kfree(ti_manuf_desc);
                         return -EINVAL;
@@ -1094,8 +1084,7 @@ static int download_fw(struct edgeport_serial *serial)
                         struct ti_i2c_firmware_rec *firmware_version;
                         u8 *record;
 
-                        dbg("%s - Found Type FIRMWARE (Type 2) record",
-                                                                __func__);
+                        dev_dbg(dev, "%s - Found Type FIRMWARE (Type 2) record\n", __func__);
 
                         firmware_version = kmalloc(sizeof(*firmware_version),
                                                                 GFP_KERNEL);
@@ -1127,22 +1116,21 @@ static int download_fw(struct edgeport_serial *serial)
                         download_new_ver = (OperationalMajorVersion << 8) +
                                            (OperationalMinorVersion);
 
-                        dbg("%s - >> FW Versions Device %d.%d  Driver %d.%d",
-                            __func__,
-                            firmware_version->Ver_Major,
-                            firmware_version->Ver_Minor,
-                            OperationalMajorVersion,
-                            OperationalMinorVersion);
+                        dev_dbg(dev, "%s - >> FW Versions Device %d.%d  Driver %d.%d\n",
+                                __func__, firmware_version->Ver_Major,
+                                firmware_version->Ver_Minor,
+                                OperationalMajorVersion,
+                                OperationalMinorVersion);
 
                         /* Check if we have an old version in the I2C and
                            update if necessary */
                         if (download_cur_ver < download_new_ver) {
-                                dbg("%s - Update I2C dld from %d.%d to %d.%d",
-                                    __func__,
-                                    firmware_version->Ver_Major,
-                                    firmware_version->Ver_Minor,
-                                    OperationalMajorVersion,
-                                    OperationalMinorVersion);
+                                dev_dbg(dev, "%s - Update I2C dld from %d.%d to %d.%d\n",
+                                        __func__,
+                                        firmware_version->Ver_Major,
+                                        firmware_version->Ver_Minor,
+                                        OperationalMajorVersion,
+                                        OperationalMinorVersion);
 
                                 record = kmalloc(1, GFP_KERNEL);
                                 if (!record) {
@@ -1196,9 +1184,7 @@ static int download_fw(struct edgeport_serial *serial)
                                 }
 
                                 if (*record != I2C_DESC_TYPE_FIRMWARE_BLANK) {
-                                        dev_err(dev,
-                                                "%s - error resetting device\n",
-                                                __func__);
+                                        dev_err(dev, "%s - error resetting device\n", __func__);
                                         kfree(record);
                                         kfree(firmware_version);
                                         kfree(rom_desc);
@@ -1206,15 +1192,14 @@ static int download_fw(struct edgeport_serial *serial)
                                         return -ENODEV;
                                 }
 
-                                dbg("%s - HARDWARE RESET", __func__);
+                                dev_dbg(dev, "%s - HARDWARE RESET\n", __func__);
 
                                 /* Reset UMP -- Back to BOOT MODE */
                                 status = ti_vsend_sync(serial->serial->dev,
                                                 UMPC_HARDWARE_RESET,
                                                 0, 0, NULL, 0);
 
-                                dbg("%s - HARDWARE RESET return %d",
-                                                __func__, status);
+                                dev_dbg(dev, "%s - HARDWARE RESET return %d\n", __func__, status);
 
                                 /* return an error on purpose. */
                                 kfree(record);
@@ -1249,8 +1234,7 @@ static int download_fw(struct edgeport_serial *serial)
                                 return -ENOMEM;
                         }
 
-                        dbg("%s - Found Type BLANK FIRMWARE (Type F2) record",
-                                                                __func__);
+                        dev_dbg(dev, "%s - Found Type BLANK FIRMWARE (Type F2) record\n", __func__);
 
                         /*
                          * In order to update the I2C firmware we must change
@@ -1292,7 +1276,7 @@ static int download_fw(struct edgeport_serial *serial)
                                                         HEADER_SIZE, vheader);
 
                         if (status) {
-                                dbg("%s - can't read header back", __func__);
+                                dev_dbg(dev, "%s - can't read header back\n", __func__);
                                 kfree(vheader);
                                 kfree(header);
                                 kfree(rom_desc);
@@ -1300,8 +1284,7 @@ static int download_fw(struct edgeport_serial *serial)
                                 return status;
                         }
                         if (memcmp(vheader, header, HEADER_SIZE)) {
-                                dbg("%s - write download record failed",
-                                        __func__);
+                                dev_dbg(dev, "%s - write download record failed\n", __func__);
                                 kfree(vheader);
                                 kfree(header);
                                 kfree(rom_desc);
@@ -1312,13 +1295,13 @@ static int download_fw(struct edgeport_serial *serial)
                         kfree(vheader);
                         kfree(header);
 
-                        dbg("%s - Start firmware update", __func__);
+                        dev_dbg(dev, "%s - Start firmware update\n", __func__);
 
                         /* Tell firmware to copy download image into I2C */
                         status = ti_vsend_sync(serial->serial->dev,
                                         UMPC_COPY_DNLD_TO_I2C, 0, 0, NULL, 0);
 
-                        dbg("%s - Update complete 0x%x", __func__, status);
+                        dev_dbg(dev, "%s - Update complete 0x%x\n", __func__, status);
                         if (status) {
                                 dev_err(dev,
                                         "%s - UMPC_COPY_DNLD_TO_I2C failed\n",
@@ -1338,7 +1321,7 @@ static int download_fw(struct edgeport_serial *serial)
         /********************************************************************/
         /* Boot Mode */
         /********************************************************************/
-        dbg("%s - RUNNING IN BOOT MODE", __func__);
+        dev_dbg(dev, "%s - RUNNING IN BOOT MODE\n", __func__);
 
         /* Configure the TI device so we can use the BULK pipes for download */
         status = config_boot_dev(serial->serial->dev);
@@ -1347,8 +1330,8 @@ static int download_fw(struct edgeport_serial *serial)
 
         if (le16_to_cpu(serial->serial->dev->descriptor.idVendor)
                                                         != USB_VENDOR_ID_ION) {
-                dbg("%s - VID = 0x%x", __func__,
-                     le16_to_cpu(serial->serial->dev->descriptor.idVendor));
+                dev_dbg(dev, "%s - VID = 0x%x\n", __func__,
+                        le16_to_cpu(serial->serial->dev->descriptor.idVendor));
                 serial->TI_I2C_Type = DTK_ADDR_SPACE_I2C_TYPE_II;
                 goto stayinbootmode;
         }
@@ -1385,8 +1368,8 @@ static int download_fw(struct edgeport_serial *serial)
 
                 /* Check for version 2 */
                 if (!ignore_cpu_rev && ti_cpu_rev(ti_manuf_desc) < 2) {
-                        dbg("%s - Wrong CPU Rev %d (Must be 2)",
-                                        __func__, ti_cpu_rev(ti_manuf_desc));
+                        dev_dbg(dev, "%s - Wrong CPU Rev %d (Must be 2)\n",
+                                __func__, ti_cpu_rev(ti_manuf_desc));
                         kfree(ti_manuf_desc);
                         goto stayinbootmode;
                 }
@@ -1421,8 +1404,8 @@ static int download_fw(struct edgeport_serial *serial)
 
                 err = request_firmware(&fw, fw_name, dev);
                 if (err) {
-                        printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
-                               fw_name, err);
+                        dev_err(dev, "Failed to load image \"%s\" err %d\n",
+                                fw_name, err);
                         kfree(buffer);
                         return err;
                 }
@@ -1442,23 +1425,20 @@ static int download_fw(struct edgeport_serial *serial)
                 header->CheckSum = cs;
 
                 /* Download the operational code  */
-                dbg("%s - Downloading operational code image (TI UMP)",
-                                                                __func__);
+                dev_dbg(dev, "%s - Downloading operational code image (TI UMP)\n", __func__);
                 status = download_code(serial, buffer, buffer_size);
 
                 kfree(buffer);
 
                 if (status) {
-                        dbg("%s - Error downloading operational code image",
-                                                                __func__);
+                        dev_dbg(dev, "%s - Error downloading operational code image\n", __func__);
                         return status;
                 }
 
                 /* Device will reboot */
                 serial->product_info.TiMode = TI_MODE_TRANSITIONING;
 
-                dbg("%s - Download successful -- Device rebooting...",
-                                                                __func__);
+                dev_dbg(dev, "%s - Download successful -- Device rebooting...\n", __func__);
 
                 /* return an error on purpose */
                 return -ENODEV;
@@ -1466,7 +1446,7 @@ static int download_fw(struct edgeport_serial *serial)
 
 stayinbootmode:
         /* Eprom is invalid or blank stay in boot mode */
-        dbg("%s - STAYING IN BOOT MODE", __func__);
+        dev_dbg(dev, "%s - STAYING IN BOOT MODE\n", __func__);
         serial->product_info.TiMode = TI_MODE_BOOT;
 
         return 0;
@@ -1487,7 +1467,7 @@ static int restore_mcr(struct edgeport_port *port, __u8 mcr)
 {
         int status = 0;
 
-        dbg("%s - %x", __func__, mcr);
+        dev_dbg(&port->port->dev, "%s - %x\n", __func__, mcr);
 
         status = ti_do_config(port, UMPC_SET_CLR_DTR, mcr & MCR_DTR);
         if (status)
@@ -1524,7 +1504,7 @@ static void handle_new_msr(struct edgeport_port *edge_port, __u8 msr)
         struct async_icount *icount;
         struct tty_struct *tty;
 
-        dbg("%s - %02x", __func__, msr);
+        dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, msr);
 
         if (msr & (EDGEPORT_MSR_DELTA_CTS | EDGEPORT_MSR_DELTA_DSR |
                         EDGEPORT_MSR_DELTA_RI | EDGEPORT_MSR_DELTA_CD)) {
@@ -1566,7 +1546,7 @@ static void handle_new_lsr(struct edgeport_port *edge_port, int lsr_data,
                                                 LSR_FRM_ERR | LSR_BREAK));
         struct tty_struct *tty;
 
-        dbg("%s - %02x", __func__, new_lsr);
+        dev_dbg(&edge_port->port->dev, "%s - %02x\n", __func__, new_lsr);
 
         edge_port->shadow_lsr = lsr;
 
@@ -1604,6 +1584,7 @@ static void edge_interrupt_callback(struct urb *urb)
         struct edgeport_serial *edge_serial = urb->context;
         struct usb_serial_port *port;
         struct edgeport_port *edge_port;
+        struct device *dev;
         unsigned char *data = urb->transfer_buffer;
         int length = urb->actual_length;
         int port_number;
@@ -1613,8 +1594,6 @@ static void edge_interrupt_callback(struct urb *urb)
         __u8 msr;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         switch (status) {
         case 0:
                 /* success */
@@ -1623,7 +1602,7 @@ static void edge_interrupt_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
                     __func__, status);
                 return;
         default:
@@ -1633,27 +1612,26 @@ static void edge_interrupt_callback(struct urb *urb)
         }
 
         if (!length) {
-                dbg("%s - no data in urb", __func__);
+                dev_dbg(&urb->dev->dev, "%s - no data in urb\n", __func__);
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &edge_serial->serial->dev->dev,
-                                                __func__, length, data);
+        dev = &edge_serial->serial->dev->dev;
+        usb_serial_debug_data(dev, __func__, length, data);
 
         if (length != 2) {
-                dbg("%s - expecting packet of size 2, got %d",
-                                                        __func__, length);
+                dev_dbg(dev, "%s - expecting packet of size 2, got %d\n", __func__, length);
                 goto exit;
         }
 
         port_number = TIUMP_GET_PORT_FROM_CODE(data[0]);
         function    = TIUMP_GET_FUNC_FROM_CODE(data[0]);
-        dbg("%s - port_number %d, function %d, info 0x%x",
-             __func__, port_number, function, data[1]);
+        dev_dbg(dev, "%s - port_number %d, function %d, info 0x%x\n", __func__,
+                port_number, function, data[1]);
         port = edge_serial->serial->port[port_number];
         edge_port = usb_get_serial_port_data(port);
         if (!edge_port) {
-                dbg("%s - edge_port not found", __func__);
+                dev_dbg(dev, "%s - edge_port not found\n", __func__);
                 return;
         }
         switch (function) {
@@ -1662,13 +1640,13 @@ static void edge_interrupt_callback(struct urb *urb)
                 if (lsr & UMP_UART_LSR_DATA_MASK) {
                         /* Save the LSR event for bulk read
                            completion routine */
-                        dbg("%s - LSR Event Port %u LSR Status = %02x",
-                             __func__, port_number, lsr);
+                        dev_dbg(dev, "%s - LSR Event Port %u LSR Status = %02x\n",
+                                __func__, port_number, lsr);
                         edge_port->lsr_event = 1;
                         edge_port->lsr_mask = lsr;
                 } else {
-                        dbg("%s - ===== Port %d LSR Status = %02x ======",
-                             __func__, port_number, lsr);
+                        dev_dbg(dev, "%s - ===== Port %d LSR Status = %02x ======\n",
+                                __func__, port_number, lsr);
                         handle_new_lsr(edge_port, 0, lsr, 0);
                 }
                 break;
@@ -1676,8 +1654,8 @@ static void edge_interrupt_callback(struct urb *urb)
         case TIUMP_INTERRUPT_CODE_MSR:  /* MSR */
                 /* Copy MSR from UMP */
                 msr = data[1];
-                dbg("%s - ===== Port %u MSR Status = %02x ======",
-                     __func__, port_number, msr);
+                dev_dbg(dev, "%s - ===== Port %u MSR Status = %02x ======\n",
+                        __func__, port_number, msr);
                 handle_new_msr(edge_port, msr);
                 break;
 
@@ -1700,14 +1678,13 @@ exit:
 static void edge_bulk_in_callback(struct urb *urb)
 {
         struct edgeport_port *edge_port = urb->context;
+        struct device *dev = &edge_port->port->dev;
         unsigned char *data = urb->transfer_buffer;
         struct tty_struct *tty;
         int retval = 0;
         int port_number;
         int status = urb->status;
 
-        dbg("%s", __func__);
-
         switch (status) {
         case 0:
                 /* success */
@@ -1716,13 +1693,10 @@ static void edge_bulk_in_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dev_err(&urb->dev->dev,
-                        "%s - nonzero read bulk status received: %d\n",
-                             __func__, status);
+                dev_err(&urb->dev->dev, "%s - nonzero read bulk status received: %d\n", __func__, status);
         }
 
         if (status == -EPIPE)
@@ -1737,8 +1711,8 @@ static void edge_bulk_in_callback(struct urb *urb)
 
         if (edge_port->lsr_event) {
                 edge_port->lsr_event = 0;
-                dbg("%s ===== Port %u LSR Status = %02x, Data = %02x ======",
-                     __func__, port_number, edge_port->lsr_mask, *data);
+                dev_dbg(dev, "%s ===== Port %u LSR Status = %02x, Data = %02x ======\n",
+                        __func__, port_number, edge_port->lsr_mask, *data);
                 handle_new_lsr(edge_port, 1, edge_port->lsr_mask, *data);
                 /* Adjust buffer length/pointer */
                 --urb->actual_length;
@@ -1747,14 +1721,12 @@ static void edge_bulk_in_callback(struct urb *urb)
 
         tty = tty_port_tty_get(&edge_port->port->port);
         if (tty && urb->actual_length) {
-                usb_serial_debug_data(debug, &edge_port->port->dev,
-                                        __func__, urb->actual_length, data);
+                usb_serial_debug_data(dev, __func__, urb->actual_length, data);
                 if (edge_port->close_pending)
-                        dbg("%s - close pending, dropping data on the floor",
+                        dev_dbg(dev, "%s - close pending, dropping data on the floor\n",
                                                                 __func__);
                 else
-                        edge_tty_recv(&edge_port->port->dev, tty, data,
-                                                        urb->actual_length);
+                        edge_tty_recv(dev, tty, data, urb->actual_length);
                 edge_port->icount.rx += urb->actual_length;
         }
         tty_kref_put(tty);
@@ -1769,9 +1741,7 @@ exit:
 
         spin_unlock(&edge_port->ep_lock);
         if (retval)
-                dev_err(&urb->dev->dev,
-                        "%s - usb_submit_urb failed with result %d\n",
-                         __func__, retval);
+                dev_err(dev, "%s - usb_submit_urb failed with result %d\n", __func__, retval);
 }
 
 static void edge_tty_recv(struct device *dev, struct tty_struct *tty,
@@ -1793,8 +1763,6 @@ static void edge_bulk_out_callback(struct urb *urb)
         int status = urb->status;
         struct tty_struct *tty;
 
-        dbg("%s - port %d", __func__, port->number);
-
         edge_port->ep_write_urb_in_use = 0;
 
         switch (status) {
@@ -1805,7 +1773,7 @@ static void edge_bulk_out_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
                     __func__, status);
                 return;
         default:
@@ -1830,8 +1798,6 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
         u16 open_settings;
         u8 transaction_timeout;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return -ENODEV;
 
@@ -1850,9 +1816,8 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
                 return -ENODEV;
         }
 
-        dbg("%s - port_number = %d, uart_base = %04x, dma_address = %04x",
-                                __func__, port_number, edge_port->uart_base,
-                                edge_port->dma_address);
+        dev_dbg(&port->dev, "%s - port_number = %d, uart_base = %04x, dma_address = %04x\n",
+                __func__, port_number, edge_port->uart_base, edge_port->dma_address);
 
         dev = port->serial->dev;
 
@@ -1885,7 +1850,7 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
                              UMP_PIPE_TRANS_TIMEOUT_ENA |
                              (transaction_timeout << 2));
 
-        dbg("%s - Sending UMPC_OPEN_PORT", __func__);
+        dev_dbg(&port->dev, "%s - Sending UMPC_OPEN_PORT\n", __func__);
 
         /* Tell TI to open and start the port */
         status = send_cmd(dev, UMPC_OPEN_PORT,
@@ -1924,11 +1889,11 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
                 return status;
         }
 
-        dbg("ShadowMSR 0x%X", edge_port->shadow_msr);
+        dev_dbg(&port->dev, "ShadowMSR 0x%X\n", edge_port->shadow_msr);
 
         /* Set Initial MCR */
         edge_port->shadow_mcr = MCR_RTS | MCR_DTR;
-        dbg("ShadowMCR 0x%X", edge_port->shadow_mcr);
+        dev_dbg(&port->dev, "ShadowMCR 0x%X\n", edge_port->shadow_mcr);
 
         edge_serial = edge_port->edge_serial;
         if (mutex_lock_interruptible(&edge_serial->es_lock))
@@ -1980,8 +1945,6 @@ static int edge_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         ++edge_serial->num_ports_open;
 
-        dbg("%s - exited", __func__);
-
         goto release_es_lock;
 
 unlink_int_urb:
@@ -1999,8 +1962,6 @@ static void edge_close(struct usb_serial_port *port)
         struct usb_serial *serial = port->serial;
         int port_number;
 
-        dbg("%s - port %d", __func__, port->number);
-
         edge_serial = usb_get_serial_data(port->serial);
         edge_port = usb_get_serial_port_data(port);
         if (edge_serial == NULL || edge_port == NULL)
@@ -2019,7 +1980,7 @@ static void edge_close(struct usb_serial_port *port)
 
         /* assuming we can still talk to the device,
          * send a close port command to it */
-        dbg("%s - send umpc_close_port", __func__);
+        dev_dbg(&port->dev, "%s - send umpc_close_port\n", __func__);
         port_number = port->number - port->serial->minor;
 
         mutex_lock(&serial->disc_mutex);
@@ -2042,8 +2003,6 @@ static void edge_close(struct usb_serial_port *port)
         }
         mutex_unlock(&edge_serial->es_lock);
         edge_port->close_pending = 0;
-
-        dbg("%s - exited", __func__);
 }
 
 static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
@@ -2051,10 +2010,8 @@ static int edge_write(struct tty_struct *tty, struct usb_serial_port *port,
 {
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (count == 0) {
-                dbg("%s - write request of 0 bytes", __func__);
+                dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
                 return 0;
         }
 
@@ -2077,9 +2034,6 @@ static void edge_send(struct tty_struct *tty)
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned long flags;
 
-
-        dbg("%s - port %d", __func__, port->number);
-
         spin_lock_irqsave(&edge_port->ep_lock, flags);
 
         if (edge_port->ep_write_urb_in_use) {
@@ -2100,8 +2054,7 @@ static void edge_send(struct tty_struct *tty)
 
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                port->write_urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, count, port->write_urb->transfer_buffer);
 
         /* set up our urb */
         port->write_urb->transfer_buffer_length = count;
@@ -2130,8 +2083,6 @@ static int edge_write_room(struct tty_struct *tty)
         int room = 0;
         unsigned long flags;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return 0;
         if (edge_port->close_pending == 1)
@@ -2141,7 +2092,7 @@ static int edge_write_room(struct tty_struct *tty)
         room = kfifo_avail(&edge_port->write_fifo);
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
         return room;
 }
 
@@ -2152,8 +2103,6 @@ static int edge_chars_in_buffer(struct tty_struct *tty)
         int chars = 0;
         unsigned long flags;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return 0;
         if (edge_port->close_pending == 1)
@@ -2163,7 +2112,7 @@ static int edge_chars_in_buffer(struct tty_struct *tty)
         chars = kfifo_len(&edge_port->write_fifo);
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
-        dbg("%s - returns %d", __func__, chars);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
         return chars;
 }
 
@@ -2173,8 +2122,6 @@ static void edge_throttle(struct tty_struct *tty)
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return;
 
@@ -2200,8 +2147,6 @@ static void edge_unthrottle(struct tty_struct *tty)
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         int status;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (edge_port == NULL)
                 return;
 
@@ -2261,6 +2206,7 @@ static int restart_read(struct edgeport_port *edge_port)
 static void change_port_settings(struct tty_struct *tty,
                 struct edgeport_port *edge_port, struct ktermios *old_termios)
 {
+        struct device *dev = &edge_port->port->dev;
         struct ump_uart_config *config;
         int baud;
         unsigned cflag;
@@ -2268,13 +2214,12 @@ static void change_port_settings(struct tty_struct *tty,
         int port_number = edge_port->port->number -
                                         edge_port->port->serial->minor;
 
-        dbg("%s - port %d", __func__, edge_port->port->number);
+        dev_dbg(dev, "%s - port %d\n", __func__, edge_port->port->number);
 
         config = kmalloc (sizeof (*config), GFP_KERNEL);
         if (!config) {
                 tty->termios = *old_termios;
-                dev_err(&edge_port->port->dev, "%s - out of memory\n",
-                                                                __func__);
+                dev_err(dev, "%s - out of memory\n", __func__);
                 return;
         }
 
@@ -2290,20 +2235,20 @@ static void change_port_settings(struct tty_struct *tty,
         switch (cflag & CSIZE) {
         case CS5:
                     config->bDataBits = UMP_UART_CHAR5BITS;
-                    dbg("%s - data bits = 5", __func__);
+                    dev_dbg(dev, "%s - data bits = 5\n", __func__);
                     break;
         case CS6:
                     config->bDataBits = UMP_UART_CHAR6BITS;
-                    dbg("%s - data bits = 6", __func__);
+                    dev_dbg(dev, "%s - data bits = 6\n", __func__);
                     break;
         case CS7:
                     config->bDataBits = UMP_UART_CHAR7BITS;
-                    dbg("%s - data bits = 7", __func__);
+                    dev_dbg(dev, "%s - data bits = 7\n", __func__);
                     break;
         default:
         case CS8:
                     config->bDataBits = UMP_UART_CHAR8BITS;
-                    dbg("%s - data bits = 8", __func__);
+                    dev_dbg(dev, "%s - data bits = 8\n", __func__);
                             break;
         }
 
@@ -2311,32 +2256,32 @@ static void change_port_settings(struct tty_struct *tty,
                 if (cflag & PARODD) {
                         config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
                         config->bParity = UMP_UART_ODDPARITY;
-                        dbg("%s - parity = odd", __func__);
+                        dev_dbg(dev, "%s - parity = odd\n", __func__);
                 } else {
                         config->wFlags |= UMP_MASK_UART_FLAGS_PARITY;
                         config->bParity = UMP_UART_EVENPARITY;
-                        dbg("%s - parity = even", __func__);
+                        dev_dbg(dev, "%s - parity = even\n", __func__);
                 }
         } else {
                 config->bParity = UMP_UART_NOPARITY;
-                dbg("%s - parity = none", __func__);
+                dev_dbg(dev, "%s - parity = none\n", __func__);
         }
 
         if (cflag & CSTOPB) {
                 config->bStopBits = UMP_UART_STOPBIT2;
-                dbg("%s - stop bits = 2", __func__);
+                dev_dbg(dev, "%s - stop bits = 2\n", __func__);
         } else {
                 config->bStopBits = UMP_UART_STOPBIT1;
-                dbg("%s - stop bits = 1", __func__);
+                dev_dbg(dev, "%s - stop bits = 1\n", __func__);
         }
 
         /* figure out the flow control settings */
         if (cflag & CRTSCTS) {
                 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X_CTS_FLOW;
                 config->wFlags |= UMP_MASK_UART_FLAGS_RTS_FLOW;
-                dbg("%s - RTS/CTS is enabled", __func__);
+                dev_dbg(dev, "%s - RTS/CTS is enabled\n", __func__);
         } else {
-                dbg("%s - RTS/CTS is disabled", __func__);
+                dev_dbg(dev, "%s - RTS/CTS is disabled\n", __func__);
                 tty->hw_stopped = 0;
                 restart_read(edge_port);
         }
@@ -2349,18 +2294,18 @@ static void change_port_settings(struct tty_struct *tty,
         /* if we are implementing INBOUND XON/XOFF */
         if (I_IXOFF(tty)) {
                 config->wFlags |= UMP_MASK_UART_FLAGS_IN_X;
-                dbg("%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                     __func__, config->cXon, config->cXoff);
+                dev_dbg(dev, "%s - INBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
+                        __func__, config->cXon, config->cXoff);
         } else
-                dbg("%s - INBOUND XON/XOFF is disabled", __func__);
+                dev_dbg(dev, "%s - INBOUND XON/XOFF is disabled\n", __func__);
 
         /* if we are implementing OUTBOUND XON/XOFF */
         if (I_IXON(tty)) {
                 config->wFlags |= UMP_MASK_UART_FLAGS_OUT_X;
-                dbg("%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x",
-                     __func__, config->cXon, config->cXoff);
+                dev_dbg(dev, "%s - OUTBOUND XON/XOFF is enabled, XON = %2x, XOFF = %2x\n",
+                        __func__, config->cXon, config->cXoff);
         } else
-                dbg("%s - OUTBOUND XON/XOFF is disabled", __func__);
+                dev_dbg(dev, "%s - OUTBOUND XON/XOFF is disabled\n", __func__);
 
         tty->termios.c_cflag &= ~CMSPAR;
 
@@ -2377,17 +2322,16 @@ static void change_port_settings(struct tty_struct *tty,
 
         /* FIXME: Recompute actual baud from divisor here */
 
-        dbg("%s - baud rate = %d, wBaudRate = %d", __func__, baud,
-                                                        config->wBaudRate);
+        dev_dbg(dev, "%s - baud rate = %d, wBaudRate = %d\n", __func__, baud, config->wBaudRate);
 
-        dbg("wBaudRate:   %d", (int)(461550L / config->wBaudRate));
-        dbg("wFlags:    0x%x", config->wFlags);
-        dbg("bDataBits:   %d", config->bDataBits);
-        dbg("bParity:     %d", config->bParity);
-        dbg("bStopBits:   %d", config->bStopBits);
-        dbg("cXon:        %d", config->cXon);
-        dbg("cXoff:       %d", config->cXoff);
-        dbg("bUartMode:   %d", config->bUartMode);
+        dev_dbg(dev, "wBaudRate:   %d\n", (int)(461550L / config->wBaudRate));
+        dev_dbg(dev, "wFlags:    0x%x\n", config->wFlags);
+        dev_dbg(dev, "bDataBits:   %d\n", config->bDataBits);
+        dev_dbg(dev, "bParity:     %d\n", config->bParity);
+        dev_dbg(dev, "bStopBits:   %d\n", config->bStopBits);
+        dev_dbg(dev, "cXon:        %d\n", config->cXon);
+        dev_dbg(dev, "cXoff:       %d\n", config->cXoff);
+        dev_dbg(dev, "bUartMode:   %d\n", config->bUartMode);
 
         /* move the word values into big endian mode */
         cpu_to_be16s(&config->wFlags);
@@ -2397,8 +2341,8 @@ static void change_port_settings(struct tty_struct *tty,
                                 (__u8)(UMPM_UART1_PORT + port_number),
                                 0, (__u8 *)config, sizeof(*config));
         if (status)
-                dbg("%s - error %d when trying to write config to device",
-                     __func__, status);
+                dev_dbg(dev, "%s - error %d when trying to write config to device\n",
+                        __func__, status);
         kfree(config);
 }
 
@@ -2410,11 +2354,11 @@ static void edge_set_termios(struct tty_struct *tty,
 
         cflag = tty->termios.c_cflag;
 
-        dbg("%s - clfag %08x iflag %08x", __func__,
-            tty->termios.c_cflag, tty->termios.c_iflag);
-        dbg("%s - old clfag %08x old iflag %08x", __func__,
-            old_termios->c_cflag, old_termios->c_iflag);
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
+                tty->termios.c_cflag, tty->termios.c_iflag);
+        dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
+                old_termios->c_cflag, old_termios->c_iflag);
+        dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
 
         if (edge_port == NULL)
                 return;
@@ -2430,8 +2374,6 @@ static int edge_tiocmset(struct tty_struct *tty,
         unsigned int mcr;
         unsigned long flags;
 
-        dbg("%s - port %d", __func__, port->number);
-
         spin_lock_irqsave(&edge_port->ep_lock, flags);
         mcr = edge_port->shadow_mcr;
         if (set & TIOCM_RTS)
@@ -2464,8 +2406,6 @@ static int edge_tiocmget(struct tty_struct *tty)
         unsigned int mcr;
         unsigned long flags;
 
-        dbg("%s - port %d", __func__, port->number);
-
         spin_lock_irqsave(&edge_port->ep_lock, flags);
 
         msr = edge_port->shadow_msr;
@@ -2478,7 +2418,7 @@ static int edge_tiocmget(struct tty_struct *tty)
                   | ((msr & EDGEPORT_MSR_DSR)   ? TIOCM_DSR: 0);  /* 0x100 */
 
 
-        dbg("%s -- %x", __func__, result);
+        dev_dbg(&port->dev, "%s -- %x\n", __func__, result);
         spin_unlock_irqrestore(&edge_port->ep_lock, flags);
 
         return result;
@@ -2538,15 +2478,15 @@ static int edge_ioctl(struct tty_struct *tty,
         struct async_icount cnow;
         struct async_icount cprev;
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd);
 
         switch (cmd) {
         case TIOCGSERIAL:
-                dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
+                dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);
                 return get_serial_info(edge_port,
                                 (struct serial_struct __user *) arg);
         case TIOCMIWAIT:
-                dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
+                dev_dbg(&port->dev, "%s - TIOCMIWAIT\n", __func__);
                 cprev = edge_port->icount;
                 while (1) {
                         interruptible_sleep_on(&edge_port->delta_msr_wait);
@@ -2578,8 +2518,6 @@ static void edge_break(struct tty_struct *tty, int break_state)
         int status;
         int bv = 0;     /* Off */
 
-        dbg("%s - state = %d", __func__, break_state);
-
         /* chase the port close */
         chase_port(edge_port, 0, 0);
 
@@ -2587,8 +2525,8 @@ static void edge_break(struct tty_struct *tty, int break_state)
                 bv = 1; /* On */
         status = ti_do_config(edge_port, UMPC_SET_CLR_BREAK, bv);
         if (status)
-                dbg("%s - error %d sending break set/clear command.",
-                     __func__, status);
+                dev_dbg(&port->dev, "%s - error %d sending break set/clear command.\n",
+                        __func__, status);
 }
 
 static int edge_startup(struct usb_serial *serial)
@@ -2655,7 +2593,6 @@ cleanup:
 
 static void edge_disconnect(struct usb_serial *serial)
 {
-        dbg("%s", __func__);
 }
 
 static void edge_release(struct usb_serial *serial)
@@ -2663,8 +2600,6 @@ static void edge_release(struct usb_serial *serial)
         int i;
         struct edgeport_port *edge_port;
 
-        dbg("%s", __func__);
-
         for (i = 0; i < serial->num_ports; ++i) {
                 edge_port = usb_get_serial_port_data(serial->port[i]);
                 kfifo_free(&edge_port->write_fifo);
@@ -2692,7 +2627,7 @@ static ssize_t store_uart_mode(struct device *dev,
         struct edgeport_port *edge_port = usb_get_serial_port_data(port);
         unsigned int v = simple_strtoul(valbuf, NULL, 0);
 
-        dbg("%s: setting uart_mode = %d", __func__, v);
+        dev_dbg(dev, "%s: setting uart_mode = %d\n", __func__, v);
 
         if (v < 256)
                 edge_port->bUartMode = v;
@@ -2789,9 +2724,6 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 MODULE_FIRMWARE("edgeport/down3.bin");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(closing_wait, "Maximum wait for data to drain, in .01 secs");
 
diff --git a/drivers/usb/serial/ipaq.c b/drivers/usb/serial/ipaq.c
index c85a7eb87d4e..1068bf22e27e 100644
--- a/drivers/usb/serial/ipaq.c
+++ b/drivers/usb/serial/ipaq.c
@@ -33,7 +33,6 @@
 #define DRIVER_AUTHOR "Ganesh Varadarajan <ganesh@veritas.com>"
 #define DRIVER_DESC "USB PocketPC PDA driver"
 
-static bool debug;
 static int connect_retries = KP_RETRIES;
 static int initial_wait;
 
@@ -616,9 +615,6 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
 module_param(connect_retries, int, S_IRUGO|S_IWUSR);
 MODULE_PARM_DESC(connect_retries,
                 "Maximum number of connect retries (one second each)");
diff --git a/drivers/usb/serial/ipw.c b/drivers/usb/serial/ipw.c
index 2cb30c535839..20a132ec39e2 100644
--- a/drivers/usb/serial/ipw.c
+++ b/drivers/usb/serial/ipw.c
@@ -138,11 +138,10 @@ static const struct usb_device_id id_table[] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static bool debug;
-
 static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
-        struct usb_device *dev = port->serial->dev;
+        struct usb_device *udev = port->serial->dev;
+        struct device *dev = &port->dev;
         u8 buf_flow_static[16] = IPW_BYTES_FLOWINIT;
         u8 *buf_flow_init;
         int result;
@@ -154,8 +153,8 @@ static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
         /* --1: Tell the modem to initialize (we think) From sniffs this is
          *      always the first thing that gets sent to the modem during
          *      opening of the device */
-        dbg("%s: Sending SIO_INIT (we guess)", __func__);
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        dev_dbg(dev, "%s: Sending SIO_INIT (we guess)\n", __func__);
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_INIT,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                          0,
@@ -164,22 +163,19 @@ static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
                          0,
                          100000);
         if (result < 0)
-                dev_err(&port->dev,
-                        "Init of modem failed (error = %d)\n", result);
+                dev_err(dev, "Init of modem failed (error = %d)\n", result);
 
         /* reset the bulk pipes */
-        usb_clear_halt(dev,
-                        usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress));
-        usb_clear_halt(dev,
-                        usb_sndbulkpipe(dev, port->bulk_out_endpointAddress));
+        usb_clear_halt(udev, usb_rcvbulkpipe(udev, port->bulk_in_endpointAddress));
+        usb_clear_halt(udev, usb_sndbulkpipe(udev, port->bulk_out_endpointAddress));
 
         /*--2: Start reading from the device */
-        dbg("%s: setting up bulk read callback", __func__);
+        dev_dbg(dev, "%s: setting up bulk read callback\n", __func__);
         usb_wwan_open(tty, port);
 
         /*--3: Tell the modem to open the floodgates on the rx bulk channel */
-        dbg("%s:asking modem for RxRead (RXBULK_ON)", __func__);
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        dev_dbg(dev, "%s:asking modem for RxRead (RXBULK_ON)\n", __func__);
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_RXCTL,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                          IPW_RXBULK_ON,
@@ -188,12 +184,11 @@ static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
                          0,
                          100000);
         if (result < 0)
-                dev_err(&port->dev,
-                        "Enabling bulk RxRead failed (error = %d)\n", result);
+                dev_err(dev, "Enabling bulk RxRead failed (error = %d)\n", result);
 
         /*--4: setup the initial flowcontrol */
-        dbg("%s:setting init flowcontrol (%s)", __func__, buf_flow_init);
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        dev_dbg(dev, "%s:setting init flowcontrol (%s)\n", __func__, buf_flow_init);
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_HANDFLOW,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                          0,
@@ -202,8 +197,7 @@ static int ipw_open(struct tty_struct *tty, struct usb_serial_port *port)
                          0x10,
                          200000);
         if (result < 0)
-                dev_err(&port->dev,
-                        "initial flowcontrol failed (error = %d)\n", result);
+                dev_err(dev, "initial flowcontrol failed (error = %d)\n", result);
 
         kfree(buf_flow_init);
         return 0;
@@ -233,12 +227,13 @@ static void ipw_release(struct usb_serial *serial)
 
 static void ipw_dtr_rts(struct usb_serial_port *port, int on)
 {
-        struct usb_device *dev = port->serial->dev;
+        struct usb_device *udev = port->serial->dev;
+        struct device *dev = &port->dev;
         int result;
 
-        dbg("%s: on = %d", __func__, on);
+        dev_dbg(dev, "%s: on = %d\n", __func__, on);
 
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_SET_PIN,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                          on ? IPW_PIN_SETDTR : IPW_PIN_CLRDTR,
@@ -247,10 +242,9 @@ static void ipw_dtr_rts(struct usb_serial_port *port, int on)
                          0,
                          200000);
         if (result < 0)
-                dev_err(&port->dev, "setting dtr failed (error = %d)\n",
-                                                                result);
+                dev_err(dev, "setting dtr failed (error = %d)\n", result);
 
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_SET_PIN, USB_TYPE_VENDOR |
                                         USB_RECIP_INTERFACE | USB_DIR_OUT,
                          on ? IPW_PIN_SETRTS : IPW_PIN_CLRRTS,
@@ -259,18 +253,18 @@ static void ipw_dtr_rts(struct usb_serial_port *port, int on)
                          0,
                          200000);
         if (result < 0)
-                dev_err(&port->dev, "setting rts failed (error = %d)\n",
-                                                                result);
+                dev_err(dev, "setting rts failed (error = %d)\n", result);
 }
 
 static void ipw_close(struct usb_serial_port *port)
 {
-        struct usb_device *dev = port->serial->dev;
+        struct usb_device *udev = port->serial->dev;
+        struct device *dev = &port->dev;
         int result;
 
         /*--3: purge */
-        dbg("%s:sending purge", __func__);
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        dev_dbg(dev, "%s:sending purge\n", __func__);
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_PURGE, USB_TYPE_VENDOR |
                                         USB_RECIP_INTERFACE | USB_DIR_OUT,
                          0x03,
@@ -279,12 +273,12 @@ static void ipw_close(struct usb_serial_port *port)
                          0,
                          200000);
         if (result < 0)
-                dev_err(&port->dev, "purge failed (error = %d)\n", result);
+                dev_err(dev, "purge failed (error = %d)\n", result);
 
 
         /* send RXBULK_off (tell modem to stop transmitting bulk data on
            rx chan) */
-        result = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
                          IPW_SIO_RXCTL,
                          USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                          IPW_RXBULK_OFF,
@@ -294,8 +288,7 @@ static void ipw_close(struct usb_serial_port *port)
                          100000);
 
         if (result < 0)
-                dev_err(&port->dev,
-                        "Disabling bulk RxRead failed (error = %d)\n", result);
+                dev_err(dev, "Disabling bulk RxRead failed (error = %d)\n", result);
 
         usb_wwan_close(port);
 }
@@ -328,6 +321,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ir-usb.c b/drivers/usb/serial/ir-usb.c
index 5a96692b12a2..e24e2d4f4c1b 100644
--- a/drivers/usb/serial/ir-usb.c
+++ b/drivers/usb/serial/ir-usb.c
@@ -38,15 +38,9 @@
 #include <linux/usb/serial.h>
 #include <linux/usb/irda.h>
 
-/*
- * Version Information
- */
-#define DRIVER_VERSION "v0.5"
 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Johan Hovold <jhovold@gmail.com>"
 #define DRIVER_DESC "USB IR Dongle driver"
 
-static bool debug;
-
 /* if overridden by the user, then use their value for the size of the read and
  * write urbs */
 static int buffer_size;
@@ -430,18 +424,12 @@ err_buf:
 
 static int __init ir_init(void)
 {
-        int retval;
-
         if (buffer_size) {
                 ir_device.bulk_in_size = buffer_size;
                 ir_device.bulk_out_size = buffer_size;
         }
 
-        retval = usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ir_id_table);
-        if (retval == 0)
-                printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-                               DRIVER_DESC "\n");
-        return retval;
+        return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ir_id_table);
 }
 
 static void __exit ir_exit(void)
@@ -457,8 +445,6 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
 module_param(xbof, int, 0);
 MODULE_PARM_DESC(xbof, "Force specific number of XBOFs");
 module_param(buffer_size, int, 0);
diff --git a/drivers/usb/serial/iuu_phoenix.c b/drivers/usb/serial/iuu_phoenix.c
index bf3864045c18..01da3ea36e89 100644
--- a/drivers/usb/serial/iuu_phoenix.c
+++ b/drivers/usb/serial/iuu_phoenix.c
@@ -32,13 +32,6 @@
 #include "iuu_phoenix.h"
 #include <linux/random.h>
 
-
-#ifdef CONFIG_USB_SERIAL_DEBUG
-static bool debug = 1;
-#else
-static bool debug;
-#endif
-
 /*
  * Version Information
  */
@@ -72,7 +65,6 @@ struct iuu_private {
         u8 *writebuf;           /* buffer for writing to device */
         int writelen;           /* num of byte to write to device */
         u8 *buf;                /* used for initialize speed */
-        u8 *dbgbuf;             /* debug buffer */
         u8 len;
         int vcc;                /* vcc (either 3 or 5 V) */
         u32 baud;
@@ -84,32 +76,31 @@ struct iuu_private {
 static void iuu_free_buf(struct iuu_private *priv)
 {
         kfree(priv->buf);
-        kfree(priv->dbgbuf);
         kfree(priv->writebuf);
 }
 
-static int iuu_alloc_buf(struct iuu_private *priv)
+static int iuu_alloc_buf(struct usb_serial *serial, struct iuu_private *priv)
 {
         priv->buf = kzalloc(256, GFP_KERNEL);
-        priv->dbgbuf = kzalloc(256, GFP_KERNEL);
         priv->writebuf = kzalloc(256, GFP_KERNEL);
-        if (!priv->buf || !priv->dbgbuf || !priv->writebuf) {
+        if (!priv->buf || !priv->writebuf) {
                 iuu_free_buf(priv);
-                dbg("%s problem allocation buffer", __func__);
+                dev_dbg(&serial->dev->dev, "%s problem allocation buffer\n", __func__);
                 return -ENOMEM;
         }
-        dbg("%s - Privates buffers allocation success", __func__);
+        dev_dbg(&serial->dev->dev, "%s - Privates buffers allocation success\n", __func__);
         return 0;
 }
 
 static int iuu_startup(struct usb_serial *serial)
 {
         struct iuu_private *priv;
+
         priv = kzalloc(sizeof(struct iuu_private), GFP_KERNEL);
-        dbg("%s- priv allocation success", __func__);
+        dev_dbg(&serial->dev->dev, "%s- priv allocation success\n", __func__);
         if (!priv)
                 return -ENOMEM;
-        if (iuu_alloc_buf(priv)) {
+        if (iuu_alloc_buf(serial, priv)) {
                 kfree(priv);
                 return -ENOMEM;
         }
@@ -130,13 +121,13 @@ static void iuu_release(struct usb_serial *serial)
 
         if (priv) {
                 iuu_free_buf(priv);
-                dbg("%s - I will free all", __func__);
+                dev_dbg(&port->dev, "%s - I will free all\n", __func__);
                 usb_set_serial_port_data(port, NULL);
 
-                dbg("%s - priv is not anymore in port structure", __func__);
+                dev_dbg(&port->dev, "%s - priv is not anymore in port structure\n", __func__);
                 kfree(priv);
 
-                dbg("%s priv is now kfree", __func__);
+                dev_dbg(&port->dev, "%s priv is now kfree\n", __func__);
         }
 }
 
@@ -148,13 +139,13 @@ static int iuu_tiocmset(struct tty_struct *tty,
         unsigned long flags;
 
         /* FIXME: locking on tiomstatus */
-        dbg("%s (%d) msg : SET = 0x%04x, CLEAR = 0x%04x ", __func__,
-            port->number, set, clear);
+        dev_dbg(&port->dev, "%s msg : SET = 0x%04x, CLEAR = 0x%04x\n",
+                __func__, set, clear);
 
         spin_lock_irqsave(&priv->lock, flags);
 
         if ((set & TIOCM_RTS) && !(priv->tiostatus == TIOCM_RTS)) {
-                dbg("%s TIOCMSET RESET called !!!", __func__);
+                dev_dbg(&port->dev, "%s TIOCMSET RESET called !!!\n", __func__);
                 priv->reset = 1;
         }
         if (set & TIOCM_RTS)
@@ -190,7 +181,7 @@ static void iuu_rxcmd(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                dbg("%s - status = %d", __func__, status);
+                dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
                 /* error stop all */
                 return;
         }
@@ -244,13 +235,13 @@ static void iuu_update_status_callback(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                dbg("%s - status = %d", __func__, status);
+                dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
                 /* error stop all */
                 return;
         }
 
         st = urb->transfer_buffer;
-        dbg("%s - enter", __func__);
+        dev_dbg(&port->dev, "%s - enter\n", __func__);
         if (urb->actual_length == 1) {
                 switch (st[0]) {
                 case 0x1:
@@ -272,7 +263,7 @@ static void iuu_status_callback(struct urb *urb)
         int result;
         int status = urb->status;
 
-        dbg("%s - status = %d", __func__, status);
+        dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
         usb_fill_bulk_urb(port->read_urb, port->serial->dev,
                           usb_rcvbulkpipe(port->serial->dev,
                                           port->bulk_in_endpointAddress),
@@ -311,9 +302,9 @@ static int bulk_immediate(struct usb_serial_port *port, u8 *buf, u8 count)
                          count, &actual, HZ * 1);
 
         if (status != IUU_OPERATION_OK)
-                dbg("%s - error = %2x", __func__, status);
+                dev_dbg(&port->dev, "%s - error = %2x\n", __func__, status);
         else
-                dbg("%s - write OK !", __func__);
+                dev_dbg(&port->dev, "%s - write OK !\n", __func__);
         return status;
 }
 
@@ -331,9 +322,9 @@ static int read_immediate(struct usb_serial_port *port, u8 *buf, u8 count)
                          count, &actual, HZ * 1);
 
         if (status != IUU_OPERATION_OK)
-                dbg("%s - error = %2x", __func__, status);
+                dev_dbg(&port->dev, "%s - error = %2x\n", __func__, status);
         else
-                dbg("%s - read OK !", __func__);
+                dev_dbg(&port->dev, "%s - read OK !\n", __func__);
         return status;
 }
 
@@ -357,9 +348,9 @@ static int iuu_led(struct usb_serial_port *port, unsigned int R,
         status = bulk_immediate(port, buf, 8);
         kfree(buf);
         if (status != IUU_OPERATION_OK)
-                dbg("%s - led error status = %2x", __func__, status);
+                dev_dbg(&port->dev, "%s - led error status = %2x\n", __func__, status);
         else
-                dbg("%s - led OK !", __func__);
+                dev_dbg(&port->dev, "%s - led OK !\n", __func__);
         return IUU_OPERATION_OK;
 }
 
@@ -445,7 +436,7 @@ static int iuu_clk(struct usb_serial_port *port, int dwFrq)
 
                 status = bulk_immediate(port, (u8 *) priv->buf, Count);
                 if (status != 0) {
-                        dbg("%s - write error ", __func__);
+                        dev_dbg(&port->dev, "%s - write error\n", __func__);
                         return status;
                 }
         } else if (frq == 3579000) {
@@ -554,12 +545,13 @@ static int iuu_clk(struct usb_serial_port *port, int dwFrq)
 
         status = bulk_immediate(port, (u8 *) priv->buf, Count);
         if (status != IUU_OPERATION_OK)
-                dbg("%s - write error ", __func__);
+                dev_dbg(&port->dev, "%s - write error\n", __func__);
         return status;
 }
 
 static int iuu_uart_flush(struct usb_serial_port *port)
 {
+        struct device *dev = &port->dev;
         int i;
         int status;
         u8 rxcmd = IUU_UART_RX;
@@ -571,27 +563,26 @@ static int iuu_uart_flush(struct usb_serial_port *port)
         for (i = 0; i < 2; i++) {
                 status = bulk_immediate(port, &rxcmd, 1);
                 if (status != IUU_OPERATION_OK) {
-                        dbg("%s - uart_flush_write error", __func__);
+                        dev_dbg(dev, "%s - uart_flush_write error\n", __func__);
                         return status;
                 }
 
                 status = read_immediate(port, &priv->len, 1);
                 if (status != IUU_OPERATION_OK) {
-                        dbg("%s - uart_flush_read error", __func__);
+                        dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
                         return status;
                 }
 
                 if (priv->len > 0) {
-                        dbg("%s - uart_flush datalen is : %i ", __func__,
-                            priv->len);
+                        dev_dbg(dev, "%s - uart_flush datalen is : %i\n", __func__, priv->len);
                         status = read_immediate(port, priv->buf, priv->len);
                         if (status != IUU_OPERATION_OK) {
-                                dbg("%s - uart_flush_read error", __func__);
+                                dev_dbg(dev, "%s - uart_flush_read error\n", __func__);
                                 return status;
                         }
                 }
         }
-        dbg("%s - uart_flush_read OK!", __func__);
+        dev_dbg(dev, "%s - uart_flush_read OK!\n", __func__);
         iuu_led(port, 0, 0xF000, 0, 0xFF);
         return status;
 }
@@ -610,10 +601,10 @@ static void read_buf_callback(struct urb *urb)
                 return;
         }
 
-        dbg("%s - %i chars to write", __func__, urb->actual_length);
+        dev_dbg(&port->dev, "%s - %i chars to write\n", __func__, urb->actual_length);
         tty = tty_port_tty_get(&port->port);
         if (data == NULL)
-                dbg("%s - data is NULL !!!", __func__);
+                dev_dbg(&port->dev, "%s - data is NULL !!!\n", __func__);
         if (tty && urb->actual_length && data) {
                 tty_insert_flip_string(tty, data, urb->actual_length);
                 tty_flip_buffer_push(tty);
@@ -627,7 +618,6 @@ static int iuu_bulk_write(struct usb_serial_port *port)
         struct iuu_private *priv = usb_get_serial_port_data(port);
         unsigned long flags;
         int result;
-        int i;
         int buf_len;
         char *buf_ptr = port->write_urb->transfer_buffer;
 
@@ -640,14 +630,8 @@ static int iuu_bulk_write(struct usb_serial_port *port)
         buf_len = priv->writelen;
         priv->writelen = 0;
         spin_unlock_irqrestore(&priv->lock, flags);
-        if (debug == 1) {
-                for (i = 0; i < buf_len; i++)
-                        sprintf(priv->dbgbuf + i*2 ,
-                                "%02X", priv->writebuf[i]);
-                priv->dbgbuf[buf_len+i*2] = 0;
-                dbg("%s - writing %i chars : %s", __func__,
-                    buf_len, priv->dbgbuf);
-        }
+        dev_dbg(&port->dev, "%s - writing %i chars : %*ph\n", __func__,
+                buf_len, buf_len, buf_ptr);
         usb_fill_bulk_urb(port->write_urb, port->serial->dev,
                           usb_sndbulkpipe(port->serial->dev,
                                           port->bulk_out_endpointAddress),
@@ -683,18 +667,18 @@ static void iuu_uart_read_callback(struct urb *urb)
         priv->poll++;
 
         if (status) {
-                dbg("%s - status = %d", __func__, status);
+                dev_dbg(&port->dev, "%s - status = %d\n", __func__, status);
                 /* error stop all */
                 return;
         }
         if (data == NULL)
-                dbg("%s - data is NULL !!!", __func__);
+                dev_dbg(&port->dev, "%s - data is NULL !!!\n", __func__);
 
         if (urb->actual_length == 1  && data != NULL)
                 len = (int) data[0];
 
         if (urb->actual_length > 1) {
-                dbg("%s - urb->actual_length = %i", __func__,
+                dev_dbg(&port->dev, "%s - urb->actual_length = %i\n", __func__,
                     urb->actual_length);
                 error = 1;
                 return;
@@ -702,7 +686,7 @@ static void iuu_uart_read_callback(struct urb *urb)
         /* if len > 0 call readbuf */
 
         if (len > 0 && error == 0) {
-                dbg("%s - call read buf - len to read is %i ",
+                dev_dbg(&port->dev, "%s - call read buf - len to read is %i\n",
                         __func__, len);
                 status = iuu_read_buf(port, len);
                 return;
@@ -729,7 +713,7 @@ static void iuu_uart_read_callback(struct urb *urb)
         }
         spin_unlock_irqrestore(&priv->lock, flags);
         /* if nothing to write call again rxcmd */
-        dbg("%s - rxcmd recall", __func__);
+        dev_dbg(&port->dev, "%s - rxcmd recall\n", __func__);
         iuu_led_activity_off(urb);
 }
 
@@ -769,7 +753,7 @@ static void read_rxcmd_callback(struct urb *urb)
                           port->read_urb->transfer_buffer, 256,
                           iuu_uart_read_callback, port);
         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
-        dbg("%s - submit result = %d", __func__, result);
+        dev_dbg(&port->dev, "%s - submit result = %d\n", __func__, result);
 }
 
 static int iuu_uart_on(struct usb_serial_port *port)
@@ -789,13 +773,13 @@ static int iuu_uart_on(struct usb_serial_port *port)
 
         status = bulk_immediate(port, buf, 4);
         if (status != IUU_OPERATION_OK) {
-                dbg("%s - uart_on error", __func__);
+                dev_dbg(&port->dev, "%s - uart_on error\n", __func__);
                 goto uart_enable_failed;
         }
         /*  iuu_reset() the card after iuu_uart_on() */
         status = iuu_uart_flush(port);
         if (status != IUU_OPERATION_OK)
-                dbg("%s - uart_flush error", __func__);
+                dev_dbg(&port->dev, "%s - uart_flush error\n", __func__);
 uart_enable_failed:
         kfree(buf);
         return status;
@@ -813,7 +797,7 @@ static int iuu_uart_off(struct usb_serial_port *port)
 
         status = bulk_immediate(port, buf, 1);
         if (status != IUU_OPERATION_OK)
-                dbg("%s - uart_off error", __func__);
+                dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
 
         kfree(buf);
         return status;
@@ -830,7 +814,7 @@ static int iuu_uart_baud(struct usb_serial_port *port, u32 baud_base,
         u8 T1reload = 0;
         unsigned int T1FrekvensHZ = 0;
 
-        dbg("%s - enter baud_base=%d", __func__, baud_base);
+        dev_dbg(&port->dev, "%s - enter baud_base=%d\n", __func__, baud_base);
         dataout = kmalloc(sizeof(u8) * 5, GFP_KERNEL);
 
         if (!dataout)
@@ -911,7 +895,7 @@ static int iuu_uart_baud(struct usb_serial_port *port, u32 baud_base,
 
         status = bulk_immediate(port, dataout, DataCount);
         if (status != IUU_OPERATION_OK)
-                dbg("%s - uart_off error", __func__);
+                dev_dbg(&port->dev, "%s - uart_off error\n", __func__);
         kfree(dataout);
         return status;
 }
@@ -932,7 +916,7 @@ static void iuu_set_termios(struct tty_struct *tty,
         /* Just use the ospeed. ispeed should be the same. */
         baud = tty->termios.c_ospeed;
 
-        dbg("%s - enter c_ospeed or baud=%d", __func__, baud);
+        dev_dbg(&port->dev, "%s - enter c_ospeed or baud=%d\n", __func__, baud);
 
         /* compute the parity parameter */
         parity = 0;
@@ -983,7 +967,7 @@ static void iuu_close(struct usb_serial_port *port)
         if (serial->dev) {
                 /* free writebuf */
                 /* shutdown our urbs */
-                dbg("%s - shutting down urbs", __func__);
+                dev_dbg(&port->dev, "%s - shutting down urbs\n", __func__);
                 usb_kill_urb(port->write_urb);
                 usb_kill_urb(port->read_urb);
                 usb_kill_urb(port->interrupt_in_urb);
@@ -1006,6 +990,7 @@ static void iuu_init_termios(struct tty_struct *tty)
 static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
         struct usb_serial *serial = port->serial;
+        struct device *dev = &port->dev;
         u8 *buf;
         int result;
         int baud;
@@ -1017,7 +1002,7 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
         /* Re-encode speed */
         tty_encode_baud_rate(tty, baud, baud);
 
-        dbg("%s -  port %d, baud %d", __func__, port->number, baud);
+        dev_dbg(dev, "%s - baud %d\n", __func__, baud);
         usb_clear_halt(serial->dev, port->write_urb->pipe);
         usb_clear_halt(serial->dev, port->read_urb->pipe);
 
@@ -1032,14 +1017,14 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
         result = usb_control_msg(port->serial->dev,     \
                                 usb_rcvctrlpipe(port->serial->dev, 0),  \
                                 b, a, c, d, buf, 1, 1000); \
-        dbg("0x%x:0x%x:0x%x:0x%x  %d - %x", a, b, c, d, result, \
+        dev_dbg(dev, "0x%x:0x%x:0x%x:0x%x  %d - %x\n", a, b, c, d, result, \
                                 buf[0]); } while (0);
 
 #define SOUP(a, b, c, d)  do { \
         result = usb_control_msg(port->serial->dev,     \
                                 usb_sndctrlpipe(port->serial->dev, 0),  \
                                 b, a, c, d, NULL, 0, 1000); \
-        dbg("0x%x:0x%x:0x%x:0x%x  %d", a, b, c, d, result); } while (0)
+        dev_dbg(dev, "0x%x:0x%x:0x%x:0x%x  %d\n", a, b, c, d, result); } while (0)
 
         /*  This is not UART related but IUU USB driver related or something */
         /*  like that. Basically no IUU will accept any commands from the USB */
@@ -1119,7 +1104,7 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         iuu_uart_flush(port);
 
-        dbg("%s - initialization done", __func__);
+        dev_dbg(dev, "%s - initialization done\n", __func__);
 
         memset(port->write_urb->transfer_buffer, IUU_UART_RX, 1);
         usb_fill_bulk_urb(port->write_urb, port->serial->dev,
@@ -1129,11 +1114,10 @@ static int iuu_open(struct tty_struct *tty, struct usb_serial_port *port)
                           read_rxcmd_callback, port);
         result = usb_submit_urb(port->write_urb, GFP_KERNEL);
         if (result) {
-                dev_err(&port->dev, "%s - failed submitting read urb,"
-                        " error %d\n", __func__, result);
+                dev_err(dev, "%s - failed submitting read urb, error %d\n", __func__, result);
                 iuu_close(port);
         } else {
-                dbg("%s - rxcmd OK", __func__);
+                dev_dbg(dev, "%s - rxcmd OK\n", __func__);
         }
 
         return result;
@@ -1159,9 +1143,9 @@ static int iuu_vcc_set(struct usb_serial_port *port, unsigned int vcc)
         kfree(buf);
 
         if (status != IUU_OPERATION_OK)
-                dbg("%s - vcc error status = %2x", __func__, status);
+                dev_dbg(&port->dev, "%s - vcc error status = %2x\n", __func__, status);
         else
-                dbg("%s - vcc OK !", __func__);
+                dev_dbg(&port->dev, "%s - vcc OK !\n", __func__);
 
         return status;
 }
@@ -1192,7 +1176,7 @@ static ssize_t store_vcc_mode(struct device *dev,
                 goto fail_store_vcc_mode;
         }
 
-        dbg("%s: setting vcc_mode = %ld", __func__, v);
+        dev_dbg(dev, "%s: setting vcc_mode = %ld", __func__, v);
 
         if ((v != 3) && (v != 5)) {
                 dev_err(dev, "%s - vcc_mode %ld is invalid\n", __func__, v);
@@ -1257,8 +1241,6 @@ MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
 
 MODULE_VERSION(DRIVER_VERSION);
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
 
 module_param(xmas, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(xmas, "Xmas colors enabled or not");
diff --git a/drivers/usb/serial/keyspan.c b/drivers/usb/serial/keyspan.c
index 7bcbb47e1449..29c943d737d0 100644
--- a/drivers/usb/serial/keyspan.c
+++ b/drivers/usb/serial/keyspan.c
@@ -38,15 +38,12 @@
 #include <linux/tty_flip.h>
 #include <linux/module.h>
 #include <linux/spinlock.h>
-#include <linux/firmware.h>
-#include <linux/ihex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
+#include <linux/usb/ezusb.h>
 #include "keyspan.h"
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -165,7 +162,7 @@ static void keyspan_set_termios(struct tty_struct *tty,
            so other rates can be generated if desired. */
         baud_rate = tty_get_baud_rate(tty);
         /* If no match or invalid, don't change */
-        if (d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
+        if (d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
                                 NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
                 /* FIXME - more to do here to ensure rate changes cleanly */
                 /* FIXME - calcuate exact rate from divisor ? */
@@ -241,8 +238,8 @@ static int keyspan_write(struct tty_struct *tty,
                 dataOffset = 1;
         }
 
-        dbg("%s - for port %d (%d chars), flip=%d",
-            __func__, port->number, count, p_priv->out_flip);
+        dev_dbg(&port->dev, "%s - for port %d (%d chars), flip=%d\n",
+                __func__, port->number, count, p_priv->out_flip);
 
         for (left = count; left > 0; left -= todo) {
                 todo = left;
@@ -255,11 +252,11 @@ static int keyspan_write(struct tty_struct *tty,
                 this_urb = p_priv->out_urbs[flip];
                 if (this_urb == NULL) {
                         /* no bulk out, so return 0 bytes written */
-                        dbg("%s - no output urb :(", __func__);
+                        dev_dbg(&port->dev, "%s - no output urb :(\n", __func__);
                         return count;
                 }
 
-                dbg("%s - endpoint %d flip %d",
+                dev_dbg(&port->dev, "%s - endpoint %d flip %d\n",
                         __func__, usb_pipeendpoint(this_urb->pipe), flip);
 
                 if (this_urb->status == -EINPROGRESS) {
@@ -282,7 +279,7 @@ static int keyspan_write(struct tty_struct *tty,
 
                 err = usb_submit_urb(this_urb, GFP_ATOMIC);
                 if (err != 0)
-                        dbg("usb_submit_urb(write bulk) failed (%d)", err);
+                        dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed (%d)\n", err);
                 p_priv->tx_start_time[flip] = jiffies;
 
                 /* Flip for next time if usa26 or usa28 interface
@@ -305,8 +302,8 @@ static void	usa26_indat_callback(struct urb *urb)
         endpoint = usb_pipeendpoint(urb->pipe);
 
         if (status) {
-                dbg("%s - nonzero status: %x on endpoint %d.",
-                    __func__, status, endpoint);
+                dev_dbg(&urb->dev->dev,"%s - nonzero status: %x on endpoint %d.\n",
+                        __func__, status, endpoint);
                 return;
         }
 
@@ -325,7 +322,7 @@ static void	usa26_indat_callback(struct urb *urb)
                                 tty_insert_flip_char(tty, data[i], err);
                 } else {
                         /* some bytes had errors, every byte has status */
-                        dbg("%s - RX error!!!!", __func__);
+                        dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
                         for (i = 0; i + 1 < urb->actual_length; i += 2) {
                                 int stat = data[i], flag = 0;
                                 if (stat & RXERROR_OVERRUN)
@@ -345,7 +342,7 @@ static void	usa26_indat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 }
 
 /* Outdat handling is common for all devices */
@@ -356,7 +353,7 @@ static void	usa2x_outdat_callback(struct urb *urb)
 
         port =  urb->context;
         p_priv = usb_get_serial_port_data(port);
-        dbg("%s - urb %d", __func__, urb == p_priv->out_urbs[1]);
+        dev_dbg(&port->dev, "%s - urb %d\n", __func__, urb == p_priv->out_urbs[1]);
 
         usb_serial_port_softint(port);
 }
@@ -374,7 +371,7 @@ static void	usa26_outcont_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
 
         if (p_priv->resend_cont) {
-                dbg("%s - sending setup", __func__);
+                dev_dbg(&port->dev, "%s - sending setup\n", __func__);
                 keyspan_usa26_send_setup(port->serial, port,
                                                 p_priv->resend_cont - 1);
         }
@@ -394,20 +391,22 @@ static void	usa26_instat_callback(struct urb *urb)
         serial =  urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
         if (urb->actual_length != 9) {
-                dbg("%s - %d byte report??", __func__, urb->actual_length);
+                dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
                 goto exit;
         }
 
         msg = (struct keyspan_usa26_portStatusMessage *)data;
 
 #if 0
-        dbg("%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
-            __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr, msg->ri, msg->_txOff,
-            msg->_txXoff, msg->rxEnabled, msg->controlResponse);
+        dev_dbg(&urb->dev->dev,
+                "%s - port status: port %d cts %d dcd %d dsr %d ri %d toff %d txoff %d rxen %d cr %d",
+                __func__, msg->port, msg->hskia_cts, msg->gpia_dcd, msg->dsr,
+                msg->ri, msg->_txOff, msg->_txXoff, msg->rxEnabled,
+                msg->controlResponse);
 #endif
 
         /* Now do something useful with the data */
@@ -415,7 +414,7 @@ static void	usa26_instat_callback(struct urb *urb)
 
         /* Check port number from message and retrieve private data */
         if (msg->port >= serial->num_ports) {
-                dbg("%s - Unexpected port number %d", __func__, msg->port);
+                dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
                 goto exit;
         }
         port = serial->port[msg->port];
@@ -438,7 +437,7 @@ static void	usa26_instat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 exit: ;
 }
 
@@ -465,8 +464,8 @@ static void usa28_indat_callback(struct urb *urb)
 
         do {
                 if (status) {
-                        dbg("%s - nonzero status: %x on endpoint %d.",
-                            __func__, status, usb_pipeendpoint(urb->pipe));
+                        dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
+                                __func__, status, usb_pipeendpoint(urb->pipe));
                         return;
                 }
 
@@ -484,7 +483,7 @@ static void usa28_indat_callback(struct urb *urb)
                 /* Resubmit urb so we continue receiving */
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err != 0)
-                        dbg("%s - resubmit read urb failed. (%d)",
+                        dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n",
                                                         __func__, err);
                 p_priv->in_flip ^= 1;
 
@@ -505,7 +504,7 @@ static void	usa28_outcont_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
 
         if (p_priv->resend_cont) {
-                dbg("%s - sending setup", __func__);
+                dev_dbg(&port->dev, "%s - sending setup\n", __func__);
                 keyspan_usa28_send_setup(port->serial, port,
                                                 p_priv->resend_cont - 1);
         }
@@ -526,25 +525,28 @@ static void	usa28_instat_callback(struct urb *urb)
         serial =  urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
 
         if (urb->actual_length != sizeof(struct keyspan_usa28_portStatusMessage)) {
-                dbg("%s - bad length %d", __func__, urb->actual_length);
+                dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
                 goto exit;
         }
 
-        /*dbg("%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__
-            data[0], data[1], data[2], data[3], data[4], data[5],
-            data[6], data[7], data[8], data[9], data[10], data[11]);*/
+        /*
+        dev_dbg(&urb->dev->dev,
+                "%s %x %x %x %x %x %x %x %x %x %x %x %x", __func__,
+                data[0], data[1], data[2], data[3], data[4], data[5],
+                data[6], data[7], data[8], data[9], data[10], data[11]);
+        */
 
         /* Now do something useful with the data */
         msg = (struct keyspan_usa28_portStatusMessage *)data;
 
         /* Check port number from message and retrieve private data */
         if (msg->port >= serial->num_ports) {
-                dbg("%s - Unexpected port number %d", __func__, msg->port);
+                dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
                 goto exit;
         }
         port = serial->port[msg->port];
@@ -567,7 +569,7 @@ static void	usa28_instat_callback(struct urb *urb)
                 /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 exit: ;
 }
 
@@ -589,7 +591,7 @@ static void	usa49_glocont_callback(struct urb *urb)
                 p_priv = usb_get_serial_port_data(port);
 
                 if (p_priv->resend_cont) {
-                        dbg("%s - sending setup", __func__);
+                        dev_dbg(&port->dev, "%s - sending setup\n", __func__);
                         keyspan_usa49_send_setup(serial, port,
                                                 p_priv->resend_cont - 1);
                         break;
@@ -613,27 +615,29 @@ static void	usa49_instat_callback(struct urb *urb)
         serial =  urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
 
         if (urb->actual_length !=
                         sizeof(struct keyspan_usa49_portStatusMessage)) {
-                dbg("%s - bad length %d", __func__, urb->actual_length);
+                dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
                 goto exit;
         }
 
-        /*dbg(" %x %x %x %x %x %x %x %x %x %x %x", __func__,
-            data[0], data[1], data[2], data[3], data[4], data[5],
-            data[6], data[7], data[8], data[9], data[10]);*/
+        /*
+        dev_dbg(&urb->dev->dev, "%s: %x %x %x %x %x %x %x %x %x %x %x",
+                __func__, data[0], data[1], data[2], data[3], data[4],
+                data[5], data[6], data[7], data[8], data[9], data[10]);
+        */
 
         /* Now do something useful with the data */
         msg = (struct keyspan_usa49_portStatusMessage *)data;
 
         /* Check port number from message and retrieve private data */
         if (msg->portNumber >= serial->num_ports) {
-                dbg("%s - Unexpected port number %d",
-                                        __func__, msg->portNumber);
+                dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
+                        __func__, msg->portNumber);
                 goto exit;
         }
         port = serial->port[msg->portNumber];
@@ -656,7 +660,7 @@ static void	usa49_instat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 exit:   ;
 }
 
@@ -676,8 +680,8 @@ static void	usa49_indat_callback(struct urb *urb)
         endpoint = usb_pipeendpoint(urb->pipe);
 
         if (status) {
-                dbg("%s - nonzero status: %x on endpoint %d.", __func__,
-                    status, endpoint);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
+                        __func__, status, endpoint);
                 return;
         }
 
@@ -710,7 +714,7 @@ static void	usa49_indat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 }
 
 static void usa49wg_indat_callback(struct urb *urb)
@@ -725,7 +729,7 @@ static void usa49wg_indat_callback(struct urb *urb)
         serial = urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
 
@@ -738,7 +742,7 @@ static void usa49wg_indat_callback(struct urb *urb)
 
                         /* Check port number from message*/
                         if (data[i] >= serial->num_ports) {
-                                dbg("%s - Unexpected port number %d",
+                                dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n",
                                         __func__, data[i]);
                                 return;
                         }
@@ -778,7 +782,7 @@ static void usa49wg_indat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&urb->dev->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 }
 
 /* not used, usa-49 doesn't have per-port control endpoints */
@@ -799,7 +803,7 @@ static void usa90_indat_callback(struct urb *urb)
         endpoint = usb_pipeendpoint(urb->pipe);
 
         if (status) {
-                dbg("%s - nonzero status: %x on endpoint %d.",
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x on endpoint %d.\n",
                     __func__, status, endpoint);
                 return;
         }
@@ -828,7 +832,7 @@ static void usa90_indat_callback(struct urb *urb)
                                                                         err);
                         }  else {
                         /* some bytes had errors, every byte has status */
-                                dbg("%s - RX error!!!!", __func__);
+                                dev_dbg(&port->dev, "%s - RX error!!!!\n", __func__);
                                 for (i = 0; i + 1 < urb->actual_length; i += 2) {
                                         int stat = data[i], flag = 0;
                                         if (stat & RXERROR_OVERRUN)
@@ -850,7 +854,7 @@ static void usa90_indat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 }
 
 
@@ -868,11 +872,11 @@ static void	usa90_instat_callback(struct urb *urb)
         serial =  urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
         if (urb->actual_length < 14) {
-                dbg("%s - %d byte report??", __func__, urb->actual_length);
+                dev_dbg(&urb->dev->dev, "%s - %d byte report??\n", __func__, urb->actual_length);
                 goto exit;
         }
 
@@ -900,7 +904,7 @@ static void	usa90_instat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 exit:
         ;
 }
@@ -914,7 +918,7 @@ static void	usa90_outcont_callback(struct urb *urb)
         p_priv = usb_get_serial_port_data(port);
 
         if (p_priv->resend_cont) {
-                dbg("%s - sending setup", __func__);
+                dev_dbg(&urb->dev->dev, "%s - sending setup\n", __func__);
                 keyspan_usa90_send_setup(port->serial, port,
                                                 p_priv->resend_cont - 1);
         }
@@ -935,13 +939,13 @@ static void	usa67_instat_callback(struct urb *urb)
         serial = urb->context;
 
         if (status) {
-                dbg("%s - nonzero status: %x", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero status: %x\n", __func__, status);
                 return;
         }
 
         if (urb->actual_length !=
                         sizeof(struct keyspan_usa67_portStatusMessage)) {
-                dbg("%s - bad length %d", __func__, urb->actual_length);
+                dev_dbg(&urb->dev->dev, "%s - bad length %d\n", __func__, urb->actual_length);
                 return;
         }
 
@@ -951,7 +955,7 @@ static void	usa67_instat_callback(struct urb *urb)
 
         /* Check port number from message and retrieve private data */
         if (msg->port >= serial->num_ports) {
-                dbg("%s - Unexpected port number %d", __func__, msg->port);
+                dev_dbg(&urb->dev->dev, "%s - Unexpected port number %d\n", __func__, msg->port);
                 return;
         }
 
@@ -973,7 +977,7 @@ static void	usa67_instat_callback(struct urb *urb)
         /* Resubmit urb so we continue receiving */
         err = usb_submit_urb(urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - resubmit read urb failed. (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - resubmit read urb failed. (%d)\n", __func__, err);
 }
 
 static void usa67_glocont_callback(struct urb *urb)
@@ -989,7 +993,7 @@ static void usa67_glocont_callback(struct urb *urb)
                 p_priv = usb_get_serial_port_data(port);
 
                 if (p_priv->resend_cont) {
-                        dbg("%s - sending setup", __func__);
+                        dev_dbg(&port->dev, "%s - sending setup\n", __func__);
                         keyspan_usa67_send_setup(serial, port,
                                                 p_priv->resend_cont - 1);
                         break;
@@ -1068,8 +1072,7 @@ static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
                 usb_clear_halt(urb->dev, urb->pipe);
                 err = usb_submit_urb(urb, GFP_KERNEL);
                 if (err != 0)
-                        dbg("%s - submit urb %d failed (%d)",
-                                                        __func__, i, err);
+                        dev_dbg(&port->dev, "%s - submit urb %d failed (%d)\n", __func__, i, err);
         }
 
         /* Reset low level data toggle on out endpoints */
@@ -1092,7 +1095,7 @@ static int keyspan_open(struct tty_struct *tty, struct usb_serial_port *port)
                 baud_rate = tty_get_baud_rate(tty);
                 /* If no match or invalid, leave as default */
                 if (baud_rate >= 0
-                    && d_details->calculate_baud_rate(baud_rate, d_details->baudclk,
+                    && d_details->calculate_baud_rate(port, baud_rate, d_details->baudclk,
                                         NULL, NULL, NULL, device_port) == KEYSPAN_BAUD_RATE_OK) {
                         p_priv->baud = baud_rate;
                 }
@@ -1142,7 +1145,7 @@ static void keyspan_close(struct usb_serial_port *port)
         }
 
         /*while (p_priv->outcont_urb->status == -EINPROGRESS) {
-                dbg("%s - urb in progress", __func__);
+                dev_dbg(&port->dev, "%s - urb in progress\n", __func__);
         }*/
 
         p_priv->out_flip = 0;
@@ -1162,18 +1165,15 @@ static void keyspan_close(struct usb_serial_port *port)
 /* download the firmware to a pre-renumeration device */
 static int keyspan_fake_startup(struct usb_serial *serial)
 {
-        int                             response;
-        const struct ihex_binrec        *record;
-        char                            *fw_name;
-        const struct firmware           *fw;
+        char    *fw_name;
 
-        dbg("Keyspan startup version %04x product %04x",
-            le16_to_cpu(serial->dev->descriptor.bcdDevice),
-            le16_to_cpu(serial->dev->descriptor.idProduct));
+        dev_dbg(&serial->dev->dev, "Keyspan startup version %04x product %04x\n",
+                le16_to_cpu(serial->dev->descriptor.bcdDevice),
+                le16_to_cpu(serial->dev->descriptor.idProduct));
 
         if ((le16_to_cpu(serial->dev->descriptor.bcdDevice) & 0x8000)
                                                                 != 0x8000) {
-                dbg("Firmware already loaded.  Quitting.");
+                dev_dbg(&serial->dev->dev, "Firmware already loaded.  Quitting.\n");
                 return 1;
         }
 
@@ -1233,34 +1233,16 @@ static int keyspan_fake_startup(struct usb_serial *serial)
                 return 1;
         }
 
-        if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
-                dev_err(&serial->dev->dev, "Required keyspan firmware image (%s) unavailable.\n", fw_name);
-                return 1;
-        }
-
-        dbg("Uploading Keyspan %s firmware.", fw_name);
+        dev_dbg(&serial->dev->dev, "Uploading Keyspan %s firmware.\n", fw_name);
 
-                /* download the firmware image */
-        response = ezusb_set_reset(serial, 1);
-
-        record = (const struct ihex_binrec *)fw->data;
-
-        while (record) {
-                response = ezusb_writememory(serial, be32_to_cpu(record->addr),
-                                             (unsigned char *)record->data,
-                                             be16_to_cpu(record->len), 0xa0);
-                if (response < 0) {
-                        dev_err(&serial->dev->dev, "ezusb_writememory failed for Keyspan firmware (%d %04X %p %d)\n",
-                                response, be32_to_cpu(record->addr),
-                                record->data, be16_to_cpu(record->len));
-                        break;
-                }
-                record = ihex_next_binrec(record);
+        if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
+                dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
+                        fw_name);
+                return -ENOENT;
         }
-        release_firmware(fw);
-                /* bring device out of reset. Renumeration will occur in a
-                   moment and the new device will bind to the real driver */
-        response = ezusb_set_reset(serial, 0);
+
+        /* after downloading firmware Renumeration will occur in a
+          moment and the new device will bind to the real driver */
 
         /* we don't want this device to have a driver assigned to it. */
         return 1;
@@ -1296,10 +1278,10 @@ static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
         if (endpoint == -1)
                 return NULL;            /* endpoint not needed */
 
-        dbg("%s - alloc for endpoint %d.", __func__, endpoint);
+        dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d.\n", __func__, endpoint);
         urb = usb_alloc_urb(0, GFP_KERNEL);             /* No ISO */
         if (urb == NULL) {
-                dbg("%s - alloc for endpoint %d failed.", __func__, endpoint);
+                dev_dbg(&serial->interface->dev, "%s - alloc for endpoint %d failed.\n", __func__, endpoint);
                 return NULL;
         }
 
@@ -1332,7 +1314,7 @@ static struct urb *keyspan_setup_urb(struct usb_serial *serial, int endpoint,
                 return NULL;
         }
 
-        dbg("%s - using urb %p for %s endpoint %x",
+        dev_dbg(&serial->interface->dev, "%s - using urb %p for %s endpoint %x\n",
             __func__, urb, ep_type_name, endpoint);
         return urb;
 }
@@ -1464,14 +1446,15 @@ static void keyspan_setup_urbs(struct usb_serial *serial)
 }
 
 /* usa19 function doesn't require prescaler */
-static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
+static int keyspan_usa19_calc_baud(struct usb_serial_port *port,
+                                   u32 baud_rate, u32 baudclk, u8 *rate_hi,
                                    u8 *rate_low, u8 *prescaler, int portnum)
 {
         u32     b16,    /* baud rate times 16 (actual rate used internally) */
                 div,    /* divisor */
                 cnt;    /* inverse of divisor (programmed into 8051) */
 
-        dbg("%s - %d.", __func__, baud_rate);
+        dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
 
         /* prevent divide by zero...  */
         b16 = baud_rate * 16L;
@@ -1498,19 +1481,20 @@ static int keyspan_usa19_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
         if (rate_hi)
                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
         if (rate_low && rate_hi)
-                dbg("%s - %d %02x %02x.",
+                dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
                                 __func__, baud_rate, *rate_hi, *rate_low);
         return KEYSPAN_BAUD_RATE_OK;
 }
 
 /* usa19hs function doesn't require prescaler */
-static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
-                                   u8 *rate_low, u8 *prescaler, int portnum)
+static int keyspan_usa19hs_calc_baud(struct usb_serial_port *port,
+                                     u32 baud_rate, u32 baudclk, u8 *rate_hi,
+                                     u8 *rate_low, u8 *prescaler, int portnum)
 {
         u32     b16,    /* baud rate times 16 (actual rate used internally) */
                         div;    /* divisor */
 
-        dbg("%s - %d.", __func__, baud_rate);
+        dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
 
         /* prevent divide by zero...  */
         b16 = baud_rate * 16L;
@@ -1533,13 +1517,14 @@ static int keyspan_usa19hs_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
                 *rate_hi = (u8) ((div >> 8) & 0xff);
 
         if (rate_low && rate_hi)
-                dbg("%s - %d %02x %02x.",
+                dev_dbg(&port->dev, "%s - %d %02x %02x.\n",
                         __func__, baud_rate, *rate_hi, *rate_low);
 
         return KEYSPAN_BAUD_RATE_OK;
 }
 
-static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
+static int keyspan_usa19w_calc_baud(struct usb_serial_port *port,
+                                    u32 baud_rate, u32 baudclk, u8 *rate_hi,
                                     u8 *rate_low, u8 *prescaler, int portnum)
 {
         u32     b16,    /* baud rate times 16 (actual rate used internally) */
@@ -1551,7 +1536,7 @@ static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
         u8      best_prescaler;
         int     i;
 
-        dbg("%s - %d.", __func__, baud_rate);
+        dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
 
         /* prevent divide by zero */
         b16 = baud_rate * 16L;
@@ -1596,20 +1581,21 @@ static int keyspan_usa19w_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
                 *rate_hi = (u8) ((div >> 8) & 0xff);
         if (prescaler) {
                 *prescaler = best_prescaler;
-                /*  dbg("%s - %d %d", __func__, *prescaler, div); */
+                /*  dev_dbg(&port->dev, "%s - %d %d\n", __func__, *prescaler, div); */
         }
         return KEYSPAN_BAUD_RATE_OK;
 }
 
         /* USA-28 supports different maximum baud rates on each port */
-static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
-                                    u8 *rate_low, u8 *prescaler, int portnum)
+static int keyspan_usa28_calc_baud(struct usb_serial_port *port,
+                                   u32 baud_rate, u32 baudclk, u8 *rate_hi,
+                                   u8 *rate_low, u8 *prescaler, int portnum)
 {
         u32     b16,    /* baud rate times 16 (actual rate used internally) */
                 div,    /* divisor */
                 cnt;    /* inverse of divisor (programmed into 8051) */
 
-        dbg("%s - %d.", __func__, baud_rate);
+        dev_dbg(&port->dev, "%s - %d.\n", __func__, baud_rate);
 
                 /* prevent divide by zero */
         b16 = baud_rate * 16L;
@@ -1642,7 +1628,7 @@ static int keyspan_usa28_calc_baud(u32 baud_rate, u32 baudclk, u8 *rate_hi,
                 *rate_low = (u8) (cnt & 0xff);
         if (rate_hi)
                 *rate_hi = (u8) ((cnt >> 8) & 0xff);
-        dbg("%s - %d OK.", __func__, baud_rate);
+        dev_dbg(&port->dev, "%s - %d OK.\n", __func__, baud_rate);
         return KEYSPAN_BAUD_RATE_OK;
 }
 
@@ -1658,7 +1644,7 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
         struct urb                              *this_urb;
         int                                     device_port, err;
 
-        dbg("%s reset=%d", __func__, reset_port);
+        dev_dbg(&port->dev, "%s reset=%d\n", __func__, reset_port);
 
         s_priv = usb_get_serial_data(serial);
         p_priv = usb_get_serial_port_data(port);
@@ -1668,11 +1654,11 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
         outcont_urb = d_details->outcont_endpoints[port->number];
         this_urb = p_priv->outcont_urb;
 
-        dbg("%s - endpoint %d", __func__, usb_pipeendpoint(this_urb->pipe));
+        dev_dbg(&port->dev, "%s - endpoint %d\n", __func__, usb_pipeendpoint(this_urb->pipe));
 
                 /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
-                dbg("%s - oops no urb.", __func__);
+                dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
                 return -1;
         }
 
@@ -1681,7 +1667,7 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
         if ((reset_port + 1) > p_priv->resend_cont)
                 p_priv->resend_cont = reset_port + 1;
         if (this_urb->status == -EINPROGRESS) {
-                /*  dbg("%s - already writing", __func__); */
+                /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
                 mdelay(5);
                 return -1;
         }
@@ -1692,11 +1678,11 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
         if (p_priv->old_baud != p_priv->baud) {
                 p_priv->old_baud = p_priv->baud;
                 msg.setClocking = 0xff;
-                if (d_details->calculate_baud_rate
-                    (p_priv->baud, d_details->baudclk, &msg.baudHi,
-                     &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
-                        dbg("%s - Invalid baud rate %d requested, using 9600.",
-                                                __func__, p_priv->baud);
+                if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
+                                                   &msg.baudHi, &msg.baudLo, &msg.prescaler,
+                                                   device_port) == KEYSPAN_INVALID_BAUD_RATE) {
+                        dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
+                                __func__, p_priv->baud);
                         msg.baudLo = 0;
                         msg.baudHi = 125;       /* Values for 9600 baud */
                         msg.prescaler = 10;
@@ -1790,12 +1776,12 @@ static int keyspan_usa26_send_setup(struct usb_serial *serial,
 
         err = usb_submit_urb(this_urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
 #if 0
         else {
-                dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__
-                    outcont_urb, this_urb->transfer_buffer_length,
-                    usb_pipeendpoint(this_urb->pipe));
+                dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__
+                        outcont_urb, this_urb->transfer_buffer_length,
+                        usb_pipeendpoint(this_urb->pipe));
         }
 #endif
 
@@ -1821,7 +1807,7 @@ static int keyspan_usa28_send_setup(struct usb_serial *serial,
         /* only do something if we have a bulk out endpoint */
         this_urb = p_priv->outcont_urb;
         if (this_urb == NULL) {
-                dbg("%s - oops no urb.", __func__);
+                dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
                 return -1;
         }
 
@@ -1830,7 +1816,7 @@ static int keyspan_usa28_send_setup(struct usb_serial *serial,
         if ((reset_port + 1) > p_priv->resend_cont)
                 p_priv->resend_cont = reset_port + 1;
         if (this_urb->status == -EINPROGRESS) {
-                dbg("%s already writing", __func__);
+                dev_dbg(&port->dev, "%s already writing\n", __func__);
                 mdelay(5);
                 return -1;
         }
@@ -1838,9 +1824,10 @@ static int keyspan_usa28_send_setup(struct usb_serial *serial,
         memset(&msg, 0, sizeof(struct keyspan_usa28_portControlMessage));
 
         msg.setBaudRate = 1;
-        if (d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk,
-                &msg.baudHi, &msg.baudLo, NULL, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
-                dbg("%s - Invalid baud rate requested %d.",
+        if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
+                                           &msg.baudHi, &msg.baudLo, NULL,
+                                           device_port) == KEYSPAN_INVALID_BAUD_RATE) {
+                dev_dbg(&port->dev, "%s - Invalid baud rate requested %d.\n",
                                                 __func__, p_priv->baud);
                 msg.baudLo = 0xff;
                 msg.baudHi = 0xb2;      /* Values for 9600 baud */
@@ -1915,10 +1902,10 @@ static int keyspan_usa28_send_setup(struct usb_serial *serial,
 
         err = usb_submit_urb(this_urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - usb_submit_urb(setup) failed", __func__);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed\n", __func__);
 #if 0
         else {
-                dbg("%s - usb_submit_urb(setup) OK %d bytes", __func__,
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) OK %d bytes\n", __func__,
                     this_urb->transfer_buffer_length);
         }
 #endif
@@ -1949,13 +1936,13 @@ static int keyspan_usa49_send_setup(struct usb_serial *serial,
 
         /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
-                dbg("%s - oops no urb for port %d.", __func__, port->number);
+                dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__, port->number);
                 return -1;
         }
 
-        dbg("%s - endpoint %d port %d (%d)",
-                        __func__, usb_pipeendpoint(this_urb->pipe),
-                        port->number, device_port);
+        dev_dbg(&port->dev, "%s - endpoint %d port %d (%d)\n",
+                __func__, usb_pipeendpoint(this_urb->pipe),
+                port->number, device_port);
 
         /* Save reset port val for resend.
            Don't overwrite resend for open/close condition. */
@@ -1963,7 +1950,7 @@ static int keyspan_usa49_send_setup(struct usb_serial *serial,
                 p_priv->resend_cont = reset_port + 1;
 
         if (this_urb->status == -EINPROGRESS) {
-                /*  dbg("%s - already writing", __func__); */
+                /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
                 mdelay(5);
                 return -1;
         }
@@ -1977,11 +1964,11 @@ static int keyspan_usa49_send_setup(struct usb_serial *serial,
         if (p_priv->old_baud != p_priv->baud) {
                 p_priv->old_baud = p_priv->baud;
                 msg.setClocking = 0xff;
-                if (d_details->calculate_baud_rate
-                    (p_priv->baud, d_details->baudclk, &msg.baudHi,
-                     &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
-                        dbg("%s - Invalid baud rate %d requested, using 9600.",
-                                                __func__, p_priv->baud);
+                if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
+                                                   &msg.baudHi, &msg.baudLo, &msg.prescaler,
+                                                   device_port) == KEYSPAN_INVALID_BAUD_RATE) {
+                        dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
+                                __func__, p_priv->baud);
                         msg.baudLo = 0;
                         msg.baudHi = 125;       /* Values for 9600 baud */
                         msg.prescaler = 10;
@@ -2100,12 +2087,12 @@ static int keyspan_usa49_send_setup(struct usb_serial *serial,
         }
         err = usb_submit_urb(this_urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
 #if 0
         else {
-                dbg("%s - usb_submit_urb(%d) OK %d bytes (end %d)", __func__,
-                           outcont_urb, this_urb->transfer_buffer_length,
-                           usb_pipeendpoint(this_urb->pipe));
+                dev_dbg(&port->dev, "%s - usb_submit_urb(%d) OK %d bytes (end %d)\n", __func__,
+                        outcont_urb, this_urb->transfer_buffer_length,
+                        usb_pipeendpoint(this_urb->pipe));
         }
 #endif
 
@@ -2131,7 +2118,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
         /* only do something if we have a bulk out endpoint */
         this_urb = p_priv->outcont_urb;
         if (this_urb == NULL) {
-                dbg("%s - oops no urb.", __func__);
+                dev_dbg(&port->dev, "%s - oops no urb.\n", __func__);
                 return -1;
         }
 
@@ -2140,7 +2127,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
         if ((reset_port + 1) > p_priv->resend_cont)
                 p_priv->resend_cont = reset_port + 1;
         if (this_urb->status == -EINPROGRESS) {
-                dbg("%s already writing", __func__);
+                dev_dbg(&port->dev, "%s already writing\n", __func__);
                 mdelay(5);
                 return -1;
         }
@@ -2151,13 +2138,12 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
         if (p_priv->old_baud != p_priv->baud) {
                 p_priv->old_baud = p_priv->baud;
                 msg.setClocking = 0x01;
-                if (d_details->calculate_baud_rate
-                    (p_priv->baud, d_details->baudclk, &msg.baudHi,
-                     &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
-                        dbg("%s - Invalid baud rate %d requested, using 9600.",
-                                                __func__, p_priv->baud);
+                if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
+                                                   &msg.baudHi, &msg.baudLo, &prescaler, 0) == KEYSPAN_INVALID_BAUD_RATE) {
+                        dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
+                                __func__, p_priv->baud);
                         p_priv->baud = 9600;
-                        d_details->calculate_baud_rate(p_priv->baud, d_details->baudclk,
+                        d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
                                 &msg.baudHi, &msg.baudLo, &prescaler, 0);
                 }
                 msg.setRxMode = 1;
@@ -2239,7 +2225,7 @@ static int keyspan_usa90_send_setup(struct usb_serial *serial,
 
         err = usb_submit_urb(this_urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - usb_submit_urb(setup) failed (%d)", __func__, err);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
         return 0;
 }
 
@@ -2265,7 +2251,7 @@ static int keyspan_usa67_send_setup(struct usb_serial *serial,
 
         /* Make sure we have an urb then send the message */
         if (this_urb == NULL) {
-                dbg("%s - oops no urb for port %d.", __func__,
+                dev_dbg(&port->dev, "%s - oops no urb for port %d.\n", __func__,
                         port->number);
                 return -1;
         }
@@ -2275,7 +2261,7 @@ static int keyspan_usa67_send_setup(struct usb_serial *serial,
         if ((reset_port + 1) > p_priv->resend_cont)
                 p_priv->resend_cont = reset_port + 1;
         if (this_urb->status == -EINPROGRESS) {
-                /*  dbg("%s - already writing", __func__); */
+                /*  dev_dbg(&port->dev, "%s - already writing\n", __func__); */
                 mdelay(5);
                 return -1;
         }
@@ -2288,11 +2274,11 @@ static int keyspan_usa67_send_setup(struct usb_serial *serial,
         if (p_priv->old_baud != p_priv->baud) {
                 p_priv->old_baud = p_priv->baud;
                 msg.setClocking = 0xff;
-                if (d_details->calculate_baud_rate
-                    (p_priv->baud, d_details->baudclk, &msg.baudHi,
-                     &msg.baudLo, &msg.prescaler, device_port) == KEYSPAN_INVALID_BAUD_RATE) {
-                        dbg("%s - Invalid baud rate %d requested, using 9600.",
-                                                __func__, p_priv->baud);
+                if (d_details->calculate_baud_rate(port, p_priv->baud, d_details->baudclk,
+                                                   &msg.baudHi, &msg.baudLo, &msg.prescaler,
+                                                   device_port) == KEYSPAN_INVALID_BAUD_RATE) {
+                        dev_dbg(&port->dev, "%s - Invalid baud rate %d requested, using 9600.\n",
+                                __func__, p_priv->baud);
                         msg.baudLo = 0;
                         msg.baudHi = 125;       /* Values for 9600 baud */
                         msg.prescaler = 10;
@@ -2383,8 +2369,7 @@ static int keyspan_usa67_send_setup(struct usb_serial *serial,
 
         err = usb_submit_urb(this_urb, GFP_ATOMIC);
         if (err != 0)
-                dbg("%s - usb_submit_urb(setup) failed (%d)", __func__,
-                                err);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(setup) failed (%d)\n", __func__, err);
         return 0;
 }
 
@@ -2440,8 +2425,7 @@ static int keyspan_startup(struct usb_serial *serial)
         /* Setup private data for serial driver */
         s_priv = kzalloc(sizeof(struct keyspan_serial_private), GFP_KERNEL);
         if (!s_priv) {
-                dbg("%s - kmalloc for keyspan_serial_private failed.",
-                                                                __func__);
+                dev_dbg(&serial->dev->dev, "%s - kmalloc for keyspan_serial_private failed.\n", __func__);
                 return -ENOMEM;
         }
 
@@ -2454,7 +2438,7 @@ static int keyspan_startup(struct usb_serial *serial)
                 p_priv = kzalloc(sizeof(struct keyspan_port_private),
                                                                 GFP_KERNEL);
                 if (!p_priv) {
-                        dbg("%s - kmalloc for keyspan_port_private (%d) failed!.", __func__, i);
+                        dev_dbg(&port->dev, "%s - kmalloc for keyspan_port_private (%d) failed!.\n", __func__, i);
                         return 1;
                 }
                 p_priv->device_details = d_details;
@@ -2466,14 +2450,12 @@ static int keyspan_startup(struct usb_serial *serial)
         if (s_priv->instat_urb != NULL) {
                 err = usb_submit_urb(s_priv->instat_urb, GFP_KERNEL);
                 if (err != 0)
-                        dbg("%s - submit instat urb failed %d", __func__,
-                                err);
+                        dev_dbg(&serial->dev->dev, "%s - submit instat urb failed %d\n", __func__, err);
         }
         if (s_priv->indat_urb != NULL) {
                 err = usb_submit_urb(s_priv->indat_urb, GFP_KERNEL);
                 if (err != 0)
-                        dbg("%s - submit indat urb failed %d", __func__,
-                                err);
+                        dev_dbg(&serial->dev->dev, "%s - submit indat urb failed %d\n", __func__, err);
         }
 
         return 0;
@@ -2527,10 +2509,8 @@ static void keyspan_release(struct usb_serial *serial)
 
         s_priv = usb_get_serial_data(serial);
 
-        /*  dbg("Freeing serial->private."); */
         kfree(s_priv);
 
-        /*  dbg("Freeing port->private."); */
         /* Now free per port private data */
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
@@ -2554,7 +2534,3 @@ MODULE_FIRMWARE("keyspan/usa18x.fw");
 MODULE_FIRMWARE("keyspan/usa19w.fw");
 MODULE_FIRMWARE("keyspan/usa49w.fw");
 MODULE_FIRMWARE("keyspan/usa49wlc.fw");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
diff --git a/drivers/usb/serial/keyspan.h b/drivers/usb/serial/keyspan.h
index fe1c5d91692c..0a8a40b5711e 100644
--- a/drivers/usb/serial/keyspan.h
+++ b/drivers/usb/serial/keyspan.h
@@ -64,19 +64,23 @@ static int  keyspan_tiocmset		(struct tty_struct *tty,
                                          unsigned int clear);
 static int  keyspan_fake_startup        (struct usb_serial *serial);
 
-static int  keyspan_usa19_calc_baud     (u32 baud_rate, u32 baudclk, 
+static int  keyspan_usa19_calc_baud     (struct usb_serial_port *port,
+                                         u32 baud_rate, u32 baudclk,
                                          u8 *rate_hi, u8 *rate_low,
                                          u8 *prescaler, int portnum);
 
-static int  keyspan_usa19w_calc_baud    (u32 baud_rate, u32 baudclk,
+static int  keyspan_usa19w_calc_baud    (struct usb_serial_port *port,
+                                         u32 baud_rate, u32 baudclk,
                                          u8 *rate_hi, u8 *rate_low,
                                          u8 *prescaler, int portnum);
 
-static int  keyspan_usa28_calc_baud     (u32 baud_rate, u32 baudclk,
+static int  keyspan_usa28_calc_baud     (struct usb_serial_port *port,
+                                         u32 baud_rate, u32 baudclk,
                                          u8 *rate_hi, u8 *rate_low,
                                          u8 *prescaler, int portnum);
 
-static int  keyspan_usa19hs_calc_baud   (u32 baud_rate, u32 baudclk,
+static int  keyspan_usa19hs_calc_baud   (struct usb_serial_port *port,
+                                         u32 baud_rate, u32 baudclk,
                                          u8 *rate_hi, u8 *rate_low,
                                          u8 *prescaler, int portnum);
 
@@ -188,8 +192,9 @@ struct keyspan_device_details {
                 /* Endpoint used for global control functions */
         int     glocont_endpoint;
 
-        int     (*calculate_baud_rate) (u32 baud_rate, u32 baudclk,
-                        u8 *rate_hi, u8 *rate_low, u8 *prescaler, int portnum);
+        int     (*calculate_baud_rate) (struct usb_serial_port *port,
+                                        u32 baud_rate, u32 baudclk,
+                                        u8 *rate_hi, u8 *rate_low, u8 *prescaler, int portnum);
         u32     baudclk;
 }; 
 
diff --git a/drivers/usb/serial/keyspan_pda.c b/drivers/usb/serial/keyspan_pda.c
index dcada8615fcf..ca43ecb4a2bd 100644
--- a/drivers/usb/serial/keyspan_pda.c
+++ b/drivers/usb/serial/keyspan_pda.c
@@ -25,13 +25,10 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
 #include <linux/workqueue.h>
-#include <linux/firmware.h>
-#include <linux/ihex.h>
 #include <linux/uaccess.h>
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
-
-static bool debug;
+#include <linux/usb/ezusb.h>
 
 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
 #if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
@@ -137,8 +134,8 @@ static void keyspan_pda_request_unthrottle(struct work_struct *work)
                                  0,
                                  2000);
         if (result < 0)
-                dbg("%s - error %d from usb_control_msg",
-                    __func__, result);
+                dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n",
+                        __func__, result);
 }
 
 
@@ -160,12 +157,10 @@ static void keyspan_pda_rx_interrupt(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d",
-                    __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
                 goto exit;
         }
 
@@ -183,7 +178,7 @@ static void keyspan_pda_rx_interrupt(struct urb *urb)
                 break;
         case 1:
                 /* status interrupt */
-                dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
+                dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]);
                 switch (data[1]) {
                 case 1: /* modemline change */
                         break;
@@ -229,7 +224,7 @@ static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
         /* just restart the receive interrupt URB */
 
         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
-                dbg(" usb_submit_urb(read urb) failed");
+                dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
 }
 
 
@@ -308,8 +303,8 @@ static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
                         value, 0, NULL, 0, 2000);
         if (result < 0)
-                dbg("%s - error %d from usb_control_msg",
-                    __func__, result);
+                dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
+                        __func__, result);
         /* there is something funky about this.. the TCSBRK that 'cu' performs
            ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
            seconds apart, but it feels like the break sent isn't as long as it
@@ -347,7 +342,7 @@ static void keyspan_pda_set_termios(struct tty_struct *tty,
         speed = keyspan_pda_setbaud(serial, speed);
 
         if (speed == 0) {
-                dbg("can't handle requested baud rate");
+                dev_dbg(&port->dev, "can't handle requested baud rate\n");
                 /* It hasn't changed so.. */
                 speed = tty_termios_baud_rate(old_termios);
         }
@@ -459,7 +454,7 @@ static int keyspan_pda_write(struct tty_struct *tty,
            Block if we can't write anything at all, otherwise write as much as
            we can. */
         if (count == 0) {
-                dbg(" write request of 0 bytes");
+                dev_dbg(&port->dev, "write request of 0 bytes\n");
                 return 0;
         }
 
@@ -505,16 +500,16 @@ static int keyspan_pda_write(struct tty_struct *tty,
                                      1,
                                      2000);
                 if (rc > 0) {
-                        dbg(" roomquery says %d", *room);
+                        dev_dbg(&port->dev, "roomquery says %d\n", *room);
                         priv->tx_room = *room;
                 }
                 kfree(room);
                 if (rc < 0) {
-                        dbg(" roomquery failed");
+                        dev_dbg(&port->dev, "roomquery failed\n");
                         goto exit;
                 }
                 if (rc == 0) {
-                        dbg(" roomquery returned 0 bytes");
+                        dev_dbg(&port->dev, "roomquery returned 0 bytes\n");
                         rc = -EIO; /* device didn't return any data */
                         goto exit;
                 }
@@ -536,7 +531,7 @@ static int keyspan_pda_write(struct tty_struct *tty,
 
                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
                 if (rc) {
-                        dbg(" usb_submit_urb(write bulk) failed");
+                        dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
                         goto exit;
                 }
         } else {
@@ -639,11 +634,11 @@ static int keyspan_pda_open(struct tty_struct *tty,
                              1,
                              2000);
         if (rc < 0) {
-                dbg("%s - roomquery failed", __func__);
+                dev_dbg(&port->dev, "%s - roomquery failed\n", __func__);
                 goto error;
         }
         if (rc == 0) {
-                dbg("%s - roomquery returned 0 bytes", __func__);
+                dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__);
                 rc = -EIO;
                 goto error;
         }
@@ -654,7 +649,7 @@ static int keyspan_pda_open(struct tty_struct *tty,
         /*Start reading from the device*/
         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
         if (rc) {
-                dbg("%s - usb_submit_urb(read int) failed", __func__);
+                dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
                 goto error;
         }
 error:
@@ -678,11 +673,9 @@ static int keyspan_pda_fake_startup(struct usb_serial *serial)
 {
         int response;
         const char *fw_name;
-        const struct ihex_binrec *record;
-        const struct firmware *fw;
 
         /* download the firmware here ... */
-        response = ezusb_set_reset(serial, 1);
+        response = ezusb_fx1_set_reset(serial->dev, 1);
 
         if (0) { ; }
 #ifdef KEYSPAN
@@ -699,30 +692,15 @@ static int keyspan_pda_fake_startup(struct usb_serial *serial)
                         __func__);
                 return -ENODEV;
         }
-        if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
+
+        if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
                         fw_name);
                 return -ENOENT;
         }
-        record = (const struct ihex_binrec *)fw->data;
-
-        while (record) {
-                response = ezusb_writememory(serial, be32_to_cpu(record->addr),
-                                             (unsigned char *)record->data,
-                                             be16_to_cpu(record->len), 0xa0);
-                if (response < 0) {
-                        dev_err(&serial->dev->dev, "ezusb_writememory failed "
-                                "for Keyspan PDA firmware (%d %04X %p %d)\n",
-                                response, be32_to_cpu(record->addr),
-                                record->data, be16_to_cpu(record->len));
-                        break;
-                }
-                record = ihex_next_binrec(record);
-        }
-        release_firmware(fw);
-        /* bring device out of reset. Renumeration will occur in a moment
-           and the new device will bind to the real driver */
-        response = ezusb_set_reset(serial, 0);
+
+        /* after downloading firmware Renumeration will occur in a
+          moment and the new device will bind to the real driver */
 
         /* we want this device to fail to have a driver assigned to it. */
         return 1;
@@ -828,6 +806,3 @@ module_usb_serial_driver(serial_drivers, id_table_combined);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/kl5kusb105.c b/drivers/usb/serial/kl5kusb105.c
index def9ad258715..3f6d7376c02d 100644
--- a/drivers/usb/serial/kl5kusb105.c
+++ b/drivers/usb/serial/kl5kusb105.c
@@ -49,8 +49,6 @@
 #include <linux/usb/serial.h>
 #include "kl5kusb105.h"
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -239,7 +237,9 @@ static int klsi_105_startup(struct usb_serial *serial)
                 priv = kmalloc(sizeof(struct klsi_105_private),
                                                    GFP_KERNEL);
                 if (!priv) {
-                        dbg("%skmalloc for klsi_105_private failed.", __func__);
+                        dev_dbg(&serial->interface->dev,
+                                "%s - kmalloc for klsi_105_private failed.\n",
+                                __func__);
                         i--;
                         goto err_cleanup;
                 }
@@ -344,14 +344,14 @@ static int  klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
                 dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc);
                 retval = rc;
         } else
-                dbg("%s - enabled reading", __func__);
+                dev_dbg(&port->dev, "%s - enabled reading\n", __func__);
 
         rc = klsi_105_get_line_state(port, &line_state);
         if (rc >= 0) {
                 spin_lock_irqsave(&priv->lock, flags);
                 priv->line_state = line_state;
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - read line state 0x%lx", __func__, line_state);
+                dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
                 retval = 0;
         } else
                 retval = rc;
@@ -421,7 +421,7 @@ static void klsi_105_process_read_urb(struct urb *urb)
                 return;
 
         if (urb->actual_length <= KLSI_HDR_LEN) {
-                dbg("%s - malformed packet", __func__);
+                dev_dbg(&port->dev, "%s - malformed packet\n", __func__);
                 return;
         }
 
@@ -431,7 +431,7 @@ static void klsi_105_process_read_urb(struct urb *urb)
 
         len = get_unaligned_le16(data);
         if (len > urb->actual_length - KLSI_HDR_LEN) {
-                dbg("%s - packet length mismatch", __func__);
+                dev_dbg(&port->dev, "%s - packet length mismatch\n", __func__);
                 len = urb->actual_length - KLSI_HDR_LEN;
         }
 
@@ -445,6 +445,7 @@ static void klsi_105_set_termios(struct tty_struct *tty,
                                  struct ktermios *old_termios)
 {
         struct klsi_105_private *priv = usb_get_serial_port_data(port);
+        struct device *dev = &port->dev;
         unsigned int iflag = tty->termios.c_iflag;
         unsigned int old_iflag = old_termios->c_iflag;
         unsigned int cflag = tty->termios.c_cflag;
@@ -455,8 +456,7 @@ static void klsi_105_set_termios(struct tty_struct *tty,
 
         cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
         if (!cfg) {
-                dev_err(&port->dev, "%s - out of memory for config buffer.\n",
-                                __func__);
+                dev_err(dev, "%s - out of memory for config buffer.\n", __func__);
                 return;
         }
 
@@ -471,7 +471,7 @@ static void klsi_105_set_termios(struct tty_struct *tty,
         if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
                 /* reassert DTR and (maybe) RTS on transition from B0 */
                 if ((old_cflag & CBAUD) == B0) {
-                        dbg("%s: baud was B0", __func__);
+                        dev_dbg(dev, "%s: baud was B0\n", __func__);
 #if 0
                         priv->control_state |= TIOCM_DTR;
                         /* don't set RTS if using hardware flow control */
@@ -509,14 +509,13 @@ static void klsi_105_set_termios(struct tty_struct *tty,
                 priv->cfg.baudrate = kl5kusb105a_sio_b115200;
                 break;
         default:
-                dbg("KLSI USB->Serial converter:"
-                    " unsupported baudrate request, using default of 9600");
-                        priv->cfg.baudrate = kl5kusb105a_sio_b9600;
+                dev_dbg(dev, "KLSI USB->Serial converter: unsupported baudrate request, using default of 9600");
+                priv->cfg.baudrate = kl5kusb105a_sio_b9600;
                 baud = 9600;
                 break;
         }
         if ((cflag & CBAUD) == B0) {
-                dbg("%s: baud is B0", __func__);
+                dev_dbg(dev, "%s: baud is B0\n", __func__);
                 /* Drop RTS and DTR */
                 /* maybe this should be simulated by sending read
                  * disable and read enable messages?
@@ -533,11 +532,11 @@ static void klsi_105_set_termios(struct tty_struct *tty,
                 /* set the number of data bits */
                 switch (cflag & CSIZE) {
                 case CS5:
-                        dbg("%s - 5 bits/byte not supported", __func__);
+                        dev_dbg(dev, "%s - 5 bits/byte not supported\n", __func__);
                         spin_unlock_irqrestore(&priv->lock, flags);
                         goto err;
                 case CS6:
-                        dbg("%s - 6 bits/byte not supported", __func__);
+                        dev_dbg(dev, "%s - 6 bits/byte not supported\n", __func__);
                         spin_unlock_irqrestore(&priv->lock, flags);
                         goto err;
                 case CS7:
@@ -547,8 +546,7 @@ static void klsi_105_set_termios(struct tty_struct *tty,
                         priv->cfg.databits = kl5kusb105a_dtb_8;
                         break;
                 default:
-                        dev_err(&port->dev,
-                                "CSIZE was not CS5-CS8, using default of 8\n");
+                        dev_err(dev, "CSIZE was not CS5-CS8, using default of 8\n");
                         priv->cfg.databits = kl5kusb105a_dtb_8;
                         break;
                 }
@@ -616,7 +614,7 @@ static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
                                 (struct mct_u232_private *)port->private;
         unsigned char lcr = priv->last_lcr;
 
-        dbg("%sstate=%d", __func__, break_state);
+        dev_dbg(&port->dev, "%s - state=%d\n", __func__, break_state);
 
         /* LOCKING */
         if (break_state)
@@ -645,7 +643,7 @@ static int klsi_105_tiocmget(struct tty_struct *tty)
         spin_lock_irqsave(&priv->lock, flags);
         priv->line_state = line_state;
         spin_unlock_irqrestore(&priv->lock, flags);
-        dbg("%s - read line state 0x%lx", __func__, line_state);
+        dev_dbg(&port->dev, "%s - read line state 0x%lx\n", __func__, line_state);
         return (int)line_state;
 }
 
@@ -681,6 +679,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "enable extensive debugging messages");
diff --git a/drivers/usb/serial/kobil_sct.c b/drivers/usb/serial/kobil_sct.c
index bf5c74965d34..5c4d2fbd4e11 100644
--- a/drivers/usb/serial/kobil_sct.c
+++ b/drivers/usb/serial/kobil_sct.c
@@ -38,8 +38,6 @@
 #include <linux/ioctl.h>
 #include "kobil_sct.h"
 
-static bool debug;
-
 /* Version Information */
 #define DRIVER_VERSION "21/05/2004"
 #define DRIVER_AUTHOR "KOBIL Systems GmbH - http://www.kobil.com"
@@ -139,17 +137,16 @@ static int kobil_startup(struct usb_serial *serial)
 
         switch (priv->device_type) {
         case KOBIL_ADAPTER_B_PRODUCT_ID:
-                printk(KERN_DEBUG "KOBIL B1 PRO / KAAN PRO detected\n");
+                dev_dbg(&serial->dev->dev, "KOBIL B1 PRO / KAAN PRO detected\n");
                 break;
         case KOBIL_ADAPTER_K_PRODUCT_ID:
-                printk(KERN_DEBUG
-                  "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
+                dev_dbg(&serial->dev->dev, "KOBIL KAAN Standard Plus / SecOVID Reader Plus detected\n");
                 break;
         case KOBIL_USBTWIN_PRODUCT_ID:
-                printk(KERN_DEBUG "KOBIL USBTWIN detected\n");
+                dev_dbg(&serial->dev->dev, "KOBIL USBTWIN detected\n");
                 break;
         case KOBIL_KAAN_SIM_PRODUCT_ID:
-                printk(KERN_DEBUG "KOBIL KAAN SIM detected\n");
+                dev_dbg(&serial->dev->dev, "KOBIL KAAN SIM detected\n");
                 break;
         }
         usb_set_serial_port_data(serial->port[0], priv);
@@ -164,13 +161,15 @@ static int kobil_startup(struct usb_serial *serial)
         for (i = 0; i < altsetting->desc.bNumEndpoints; i++) {
                 endpoint = &altsetting->endpoint[i];
                 if (usb_endpoint_is_int_out(&endpoint->desc)) {
-                        dbg("%s Found interrupt out endpoint. Address: %d",
+                        dev_dbg(&serial->dev->dev,
+                                "%s Found interrupt out endpoint. Address: %d\n",
                                 __func__, endpoint->desc.bEndpointAddress);
                         priv->write_int_endpoint_address =
                                 endpoint->desc.bEndpointAddress;
                 }
                 if (usb_endpoint_is_int_in(&endpoint->desc)) {
-                        dbg("%s Found interrupt in  endpoint. Address: %d",
+                        dev_dbg(&serial->dev->dev,
+                                "%s Found interrupt in  endpoint. Address: %d\n",
                                 __func__, endpoint->desc.bEndpointAddress);
                         priv->read_int_endpoint_address =
                                 endpoint->desc.bEndpointAddress;
@@ -200,6 +199,7 @@ static void kobil_init_termios(struct tty_struct *tty)
 
 static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
 {
+        struct device *dev = &port->dev;
         int result = 0;
         struct kobil_private *priv;
         unsigned char *transfer_buffer;
@@ -215,12 +215,10 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         /* allocate write_urb */
         if (!port->write_urb) {
-                dbg("%s - port %d  Allocating port->write_urb",
-                                                __func__, port->number);
+                dev_dbg(dev, "%s - Allocating port->write_urb\n", __func__);
                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
                 if (!port->write_urb) {
-                        dbg("%s - port %d usb_alloc_urb failed",
-                                                __func__, port->number);
+                        dev_dbg(dev, "%s - usb_alloc_urb failed\n", __func__);
                         kfree(transfer_buffer);
                         return -ENOMEM;
                 }
@@ -247,10 +245,9 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                           transfer_buffer_length,
                           KOBIL_TIMEOUT
         );
-        dbg("%s - port %d Send get_HW_version URB returns: %i",
-                __func__, port->number, result);
-        dbg("Harware version: %i.%i.%i",
-                transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
+        dev_dbg(dev, "%s - Send get_HW_version URB returns: %i\n", __func__, result);
+        dev_dbg(dev, "Harware version: %i.%i.%i\n", transfer_buffer[0],
+                transfer_buffer[1], transfer_buffer[2]);
 
         /* get firmware version */
         result = usb_control_msg(port->serial->dev,
@@ -263,10 +260,9 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                           transfer_buffer_length,
                           KOBIL_TIMEOUT
         );
-        dbg("%s - port %d Send get_FW_version URB returns: %i",
-                                        __func__, port->number, result);
-        dbg("Firmware version: %i.%i.%i",
-                transfer_buffer[0], transfer_buffer[1], transfer_buffer[2]);
+        dev_dbg(dev, "%s - Send get_FW_version URB returns: %i\n", __func__, result);
+        dev_dbg(dev, "Firmware version: %i.%i.%i\n", transfer_buffer[0],
+                transfer_buffer[1], transfer_buffer[2]);
 
         if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
                         priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
@@ -282,8 +278,7 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                           0,
                           KOBIL_TIMEOUT
                 );
-                dbg("%s - port %d Send set_baudrate URB returns: %i",
-                                        __func__, port->number, result);
+                dev_dbg(dev, "%s - Send set_baudrate URB returns: %i\n", __func__, result);
 
                 /* reset all queues */
                 result = usb_control_msg(port->serial->dev,
@@ -296,16 +291,14 @@ static int kobil_open(struct tty_struct *tty, struct usb_serial_port *port)
                           0,
                           KOBIL_TIMEOUT
                 );
-                dbg("%s - port %d Send reset_all_queues URB returns: %i",
-                                        __func__, port->number, result);
+                dev_dbg(dev, "%s - Send reset_all_queues URB returns: %i\n", __func__, result);
         }
         if (priv->device_type == KOBIL_USBTWIN_PRODUCT_ID ||
             priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID ||
             priv->device_type == KOBIL_KAAN_SIM_PRODUCT_ID) {
                 /* start reading (Adapter B 'cause PNP string) */
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-                dbg("%s - port %d Send read URB returns: %i",
-                                        __func__, port->number, result);
+                dev_dbg(dev, "%s - Send read URB returns: %i\n", __func__, result);
         }
 
         kfree(transfer_buffer);
@@ -333,11 +326,9 @@ static void kobil_read_int_callback(struct urb *urb)
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
-/*      char *dbg_data; */
 
         if (status) {
-                dbg("%s - port %d Read int status not zero: %d",
-                    __func__, port->number, status);
+                dev_dbg(&port->dev, "%s - Read int status not zero: %d\n", __func__, status);
                 return;
         }
 
@@ -346,6 +337,8 @@ static void kobil_read_int_callback(struct urb *urb)
 
                 /* BEGIN DEBUG */
                 /*
+                  char *dbg_data;
+
                   dbg_data = kzalloc((3 *  purb->actual_length + 10)
                                                 * sizeof(char), GFP_KERNEL);
                   if (! dbg_data) {
@@ -354,7 +347,7 @@ static void kobil_read_int_callback(struct urb *urb)
                   for (i = 0; i < purb->actual_length; i++) {
                           sprintf(dbg_data +3*i, "%02X ", data[i]);
                   }
-                  dbg(" <-- %s", dbg_data);
+                  dev_dbg(&port->dev, " <-- %s\n", dbg_data);
                   kfree(dbg_data);
                 */
                 /* END DEBUG */
@@ -365,8 +358,7 @@ static void kobil_read_int_callback(struct urb *urb)
         tty_kref_put(tty);
 
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
-        dbg("%s - port %d Send read URB returns: %i",
-                        __func__, port->number, result);
+        dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result);
 }
 
 
@@ -384,22 +376,20 @@ static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
         struct kobil_private *priv;
 
         if (count == 0) {
-                dbg("%s - port %d write request of 0 bytes",
-                                                __func__, port->number);
+                dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
                 return 0;
         }
 
         priv = usb_get_serial_port_data(port);
 
         if (count > (KOBIL_BUF_LENGTH - priv->filled)) {
-                dbg("%s - port %d Error: write request bigger than buffer size", __func__, port->number);
+                dev_dbg(&port->dev, "%s - Error: write request bigger than buffer size\n", __func__);
                 return -ENOMEM;
         }
 
         /* Copy data to buffer */
         memcpy(priv->buf + priv->filled, buf, count);
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                                priv->buf + priv->filled);
+        usb_serial_debug_data(&port->dev, __func__, count, priv->buf + priv->filled);
         priv->filled = priv->filled + count;
 
         /* only send complete block. TWIN, KAAN SIM and adapter K
@@ -432,8 +422,7 @@ static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
 
                         priv->cur_pos = priv->cur_pos + length;
                         result = usb_submit_urb(port->write_urb, GFP_NOIO);
-                        dbg("%s - port %d Send write URB returns: %i",
-                                        __func__, port->number, result);
+                        dev_dbg(&port->dev, "%s - Send write URB returns: %i\n", __func__, result);
                         todo = priv->filled - priv->cur_pos;
 
                         if (todo > 0)
@@ -448,8 +437,7 @@ static int kobil_write(struct tty_struct *tty, struct usb_serial_port *port,
                         priv->device_type == KOBIL_ADAPTER_K_PRODUCT_ID) {
                         result = usb_submit_urb(port->interrupt_in_urb,
                                                                 GFP_NOIO);
-                        dbg("%s - port %d Send read URB returns: %i",
-                                        __func__, port->number, result);
+                        dev_dbg(&port->dev, "%s - Send read URB returns: %i\n", __func__, result);
                 }
         }
         return count;
@@ -493,8 +481,8 @@ static int kobil_tiocmget(struct tty_struct *tty)
                           transfer_buffer_length,
                           KOBIL_TIMEOUT);
 
-        dbg("%s - port %d Send get_status_line_state URB returns: %i. Statusline: %02x",
-            __func__, port->number, result, transfer_buffer[0]);
+        dev_dbg(&port->dev, "%s - Send get_status_line_state URB returns: %i. Statusline: %02x\n",
+                __func__, result, transfer_buffer[0]);
 
         result = 0;
         if ((transfer_buffer[0] & SUSBCR_GSL_DSR) != 0)
@@ -507,6 +495,7 @@ static int kobil_tiocmset(struct tty_struct *tty,
                            unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
+        struct device *dev = &port->dev;
         struct kobil_private *priv;
         int result;
         int dtr = 0;
@@ -538,11 +527,9 @@ static int kobil_tiocmset(struct tty_struct *tty,
 
         if (priv->device_type == KOBIL_ADAPTER_B_PRODUCT_ID) {
                 if (dtr != 0)
-                        dbg("%s - port %d Setting DTR",
-                                                __func__, port->number);
+                        dev_dbg(dev, "%s - Setting DTR\n", __func__);
                 else
-                        dbg("%s - port %d Clearing DTR",
-                                                __func__, port->number);
+                        dev_dbg(dev, "%s - Clearing DTR\n", __func__);
                 result = usb_control_msg(port->serial->dev,
                           usb_rcvctrlpipe(port->serial->dev, 0),
                           SUSBCRequest_SetStatusLinesOrQueues,
@@ -554,11 +541,9 @@ static int kobil_tiocmset(struct tty_struct *tty,
                           KOBIL_TIMEOUT);
         } else {
                 if (rts != 0)
-                        dbg("%s - port %d Setting RTS",
-                                                __func__, port->number);
+                        dev_dbg(dev, "%s - Setting RTS\n", __func__);
                 else
-                        dbg("%s - port %d Clearing RTS",
-                                                __func__, port->number);
+                        dev_dbg(dev, "%s - Clearing RTS\n", __func__);
                 result = usb_control_msg(port->serial->dev,
                         usb_rcvctrlpipe(port->serial->dev, 0),
                         SUSBCRequest_SetStatusLinesOrQueues,
@@ -569,8 +554,7 @@ static int kobil_tiocmset(struct tty_struct *tty,
                         0,
                         KOBIL_TIMEOUT);
         }
-        dbg("%s - port %d Send set_status_line URB returns: %i",
-                                        __func__, port->number, result);
+        dev_dbg(dev, "%s - Send set_status_line URB returns: %i\n", __func__, result);
         kfree(transfer_buffer);
         return (result < 0) ? result : 0;
 }
@@ -658,7 +642,8 @@ static int kobil_ioctl(struct tty_struct *tty,
                           KOBIL_TIMEOUT
                         );
 
-                dbg("%s - port %d Send reset_all_queues (FLUSH) URB returns: %i", __func__, port->number, result);
+                dev_dbg(&port->dev,
+                        "%s - Send reset_all_queues (FLUSH) URB returns: %i", __func__, result);
                 kfree(transfer_buffer);
                 return (result < 0) ? -EIO: 0;
         default:
@@ -671,6 +656,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index df98cffdba65..f3947712e137 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -45,8 +45,6 @@
 #define DRIVER_AUTHOR "Wolfgang Grandegger <wolfgang@ces.ch>"
 #define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver"
 
-static bool debug;
-
 /*
  * Function prototypes
  */
@@ -214,7 +212,7 @@ static int mct_u232_set_baud_rate(struct tty_struct *tty,
                         value, rc);
         else
                 tty_encode_baud_rate(tty, speed, speed);
-        dbg("set_baud_rate: value: 0x%x, divisor: 0x%x", value, divisor);
+        dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor);
 
         /* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which
            always sends two extra USB 'device request' messages after the
@@ -247,8 +245,8 @@ static int mct_u232_set_baud_rate(struct tty_struct *tty,
         if (port && C_CRTSCTS(tty))
            cts_enable_byte = 1;
 
-        dbg("set_baud_rate: send second control message, data = %02X",
-                                                        cts_enable_byte);
+        dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n",
+                cts_enable_byte);
         buf[0] = cts_enable_byte;
         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
                         MCT_U232_SET_CTS_REQUEST,
@@ -263,7 +261,8 @@ static int mct_u232_set_baud_rate(struct tty_struct *tty,
         return rc;
 } /* mct_u232_set_baud_rate */
 
-static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
+static int mct_u232_set_line_ctrl(struct usb_serial_port *port,
+                                  unsigned char lcr)
 {
         int rc;
         unsigned char *buf;
@@ -273,20 +272,19 @@ static int mct_u232_set_line_ctrl(struct usb_serial *serial, unsigned char lcr)
                 return -ENOMEM;
 
         buf[0] = lcr;
-        rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
+        rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
                         MCT_U232_SET_LINE_CTRL_REQUEST,
                         MCT_U232_SET_REQUEST_TYPE,
                         0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0)
-                dev_err(&serial->dev->dev,
-                        "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
-        dbg("set_line_ctrl: 0x%x", lcr);
+                dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc);
+        dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr);
         kfree(buf);
         return rc;
 } /* mct_u232_set_line_ctrl */
 
-static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
+static int mct_u232_set_modem_ctrl(struct usb_serial_port *port,
                                    unsigned int control_state)
 {
         int rc;
@@ -304,25 +302,24 @@ static int mct_u232_set_modem_ctrl(struct usb_serial *serial,
                 mcr |= MCT_U232_MCR_RTS;
 
         buf[0] = mcr;
-        rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
+        rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
                         MCT_U232_SET_MODEM_CTRL_REQUEST,
                         MCT_U232_SET_REQUEST_TYPE,
                         0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE,
                         WDR_TIMEOUT);
         kfree(buf);
 
-        dbg("set_modem_ctrl: state=0x%x ==> mcr=0x%x", control_state, mcr);
+        dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr);
 
         if (rc < 0) {
-                dev_err(&serial->dev->dev,
-                        "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
+                dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc);
                 return rc;
         }
         return 0;
 } /* mct_u232_set_modem_ctrl */
 
-static int mct_u232_get_modem_stat(struct usb_serial *serial,
-                                                unsigned char *msr)
+static int mct_u232_get_modem_stat(struct usb_serial_port *port,
+                                   unsigned char *msr)
 {
         int rc;
         unsigned char *buf;
@@ -332,19 +329,18 @@ static int mct_u232_get_modem_stat(struct usb_serial *serial,
                 *msr = 0;
                 return -ENOMEM;
         }
-        rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
+        rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0),
                         MCT_U232_GET_MODEM_STAT_REQUEST,
                         MCT_U232_GET_REQUEST_TYPE,
                         0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE,
                         WDR_TIMEOUT);
         if (rc < 0) {
-                dev_err(&serial->dev->dev,
-                        "Get MODEM STATus failed (error = %d)\n", rc);
+                dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc);
                 *msr = 0;
         } else {
                 *msr = buf[0];
         }
-        dbg("get_modem_stat: 0x%x", *msr);
+        dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr);
         kfree(buf);
         return rc;
 } /* mct_u232_get_modem_stat */
@@ -363,8 +359,8 @@ static void mct_u232_msr_to_icount(struct async_icount *icount,
                 icount->dcd++;
 } /* mct_u232_msr_to_icount */
 
-static void mct_u232_msr_to_state(unsigned int *control_state,
-                                                unsigned char msr)
+static void mct_u232_msr_to_state(struct usb_serial_port *port,
+                                  unsigned int *control_state, unsigned char msr)
 {
         /* Translate Control Line states */
         if (msr & MCT_U232_MSR_DSR)
@@ -383,7 +379,7 @@ static void mct_u232_msr_to_state(unsigned int *control_state,
                 *control_state |=  TIOCM_CD;
         else
                 *control_state &= ~TIOCM_CD;
-        dbg("msr_to_state: msr=0x%x ==> state=0x%x", msr, *control_state);
+        dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state);
 } /* mct_u232_msr_to_state */
 
 /*
@@ -465,14 +461,14 @@ static int  mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port)
         control_state = priv->control_state;
         last_lcr = priv->last_lcr;
         spin_unlock_irqrestore(&priv->lock, flags);
-        mct_u232_set_modem_ctrl(serial, control_state);
-        mct_u232_set_line_ctrl(serial, last_lcr);
+        mct_u232_set_modem_ctrl(port, control_state);
+        mct_u232_set_line_ctrl(port, last_lcr);
 
         /* Read modem status and update control state */
-        mct_u232_get_modem_stat(serial, &last_msr);
+        mct_u232_get_modem_stat(port, &last_msr);
         spin_lock_irqsave(&priv->lock, flags);
         priv->last_msr = last_msr;
-        mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
+        mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
         spin_unlock_irqrestore(&priv->lock, flags);
 
         retval = usb_submit_urb(port->read_urb, GFP_KERNEL);
@@ -512,7 +508,7 @@ static void mct_u232_dtr_rts(struct usb_serial_port *port, int on)
                         priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
                 control_state = priv->control_state;
                 spin_unlock_irq(&priv->lock);
-                mct_u232_set_modem_ctrl(port->serial, control_state);
+                mct_u232_set_modem_ctrl(port, control_state);
         }
         mutex_unlock(&port->serial->disc_mutex);
 }
@@ -532,7 +528,6 @@ static void mct_u232_read_int_callback(struct urb *urb)
 {
         struct usb_serial_port *port = urb->context;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
-        struct usb_serial *serial = port->serial;
         struct tty_struct *tty;
         unsigned char *data = urb->transfer_buffer;
         int retval;
@@ -547,22 +542,16 @@ static void mct_u232_read_int_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __func__, status);
+                dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d",
-                    __func__, status);
+                dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, status);
                 goto exit;
         }
 
-        if (!serial) {
-                dbg("%s - bad serial pointer, exiting", __func__);
-                return;
-        }
-
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                                        urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         /*
          * Work-a-round: handle the 'usual' bulk-in pipe here
@@ -588,7 +577,7 @@ static void mct_u232_read_int_callback(struct urb *urb)
         priv->last_msr = data[MCT_U232_MSR_INDEX];
 
         /* Record Control Line states */
-        mct_u232_msr_to_state(&priv->control_state, priv->last_msr);
+        mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr);
 
         mct_u232_msr_to_icount(&priv->icount, priv->last_msr);
 
@@ -656,18 +645,18 @@ static void mct_u232_set_termios(struct tty_struct *tty,
 
         /* reassert DTR and RTS on transition from B0 */
         if ((old_cflag & CBAUD) == B0) {
-                dbg("%s: baud was B0", __func__);
+                dev_dbg(&port->dev, "%s: baud was B0\n", __func__);
                 control_state |= TIOCM_DTR | TIOCM_RTS;
-                mct_u232_set_modem_ctrl(serial, control_state);
+                mct_u232_set_modem_ctrl(port, control_state);
         }
 
         mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty));
 
         if ((cflag & CBAUD) == B0) {
-                dbg("%s: baud is B0", __func__);
+                dev_dbg(&port->dev, "%s: baud is B0\n", __func__);
                 /* Drop RTS and DTR */
                 control_state &= ~(TIOCM_DTR | TIOCM_RTS);
-                mct_u232_set_modem_ctrl(serial, control_state);
+                mct_u232_set_modem_ctrl(port, control_state);
         }
 
         /*
@@ -704,7 +693,7 @@ static void mct_u232_set_termios(struct tty_struct *tty,
         last_lcr |= (cflag & CSTOPB) ?
                 MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
 
-        mct_u232_set_line_ctrl(serial, last_lcr);
+        mct_u232_set_line_ctrl(port, last_lcr);
 
         /* save off the modified port settings */
         spin_lock_irqsave(&priv->lock, flags);
@@ -716,7 +705,6 @@ static void mct_u232_set_termios(struct tty_struct *tty,
 static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
-        struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned char lcr;
         unsigned long flags;
@@ -728,7 +716,7 @@ static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
                 lcr |= MCT_U232_SET_BREAK;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        mct_u232_set_line_ctrl(serial, lcr);
+        mct_u232_set_line_ctrl(port, lcr);
 } /* mct_u232_break_ctl */
 
 
@@ -750,7 +738,6 @@ static int mct_u232_tiocmset(struct tty_struct *tty,
                               unsigned int set, unsigned int clear)
 {
         struct usb_serial_port *port = tty->driver_data;
-        struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv = usb_get_serial_port_data(port);
         unsigned int control_state;
         unsigned long flags;
@@ -769,7 +756,7 @@ static int mct_u232_tiocmset(struct tty_struct *tty,
 
         priv->control_state = control_state;
         spin_unlock_irqrestore(&priv->lock, flags);
-        return mct_u232_set_modem_ctrl(serial, control_state);
+        return mct_u232_set_modem_ctrl(port, control_state);
 }
 
 static void mct_u232_throttle(struct tty_struct *tty)
@@ -784,7 +771,7 @@ static void mct_u232_throttle(struct tty_struct *tty)
                 priv->control_state &= ~TIOCM_RTS;
                 control_state = priv->control_state;
                 spin_unlock_irq(&priv->lock);
-                (void) mct_u232_set_modem_ctrl(port->serial, control_state);
+                mct_u232_set_modem_ctrl(port, control_state);
         } else {
                 spin_unlock_irq(&priv->lock);
         }
@@ -802,7 +789,7 @@ static void mct_u232_unthrottle(struct tty_struct *tty)
                 priv->control_state |= TIOCM_RTS;
                 control_state = priv->control_state;
                 spin_unlock_irq(&priv->lock);
-                (void) mct_u232_set_modem_ctrl(port->serial, control_state);
+                mct_u232_set_modem_ctrl(port, control_state);
         } else {
                 spin_unlock_irq(&priv->lock);
         }
@@ -817,13 +804,13 @@ static int  mct_u232_ioctl(struct tty_struct *tty,
         struct async_icount cnow, cprev;
         unsigned long flags;
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
 
         switch (cmd) {
 
         case TIOCMIWAIT:
 
-                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+                dev_dbg(&port->dev, "%s TIOCMIWAIT", __func__);
 
                 spin_lock_irqsave(&mct_u232_port->lock, flags);
                 cprev = mct_u232_port->icount;
@@ -879,8 +866,8 @@ static int  mct_u232_get_icount(struct tty_struct *tty,
 
         spin_unlock_irqrestore(&mct_u232_port->lock, flags);
 
-        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d",
-                __func__,  port->number, icount->rx, icount->tx);
+        dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n",
+                __func__,  icount->rx, icount->tx);
         return 0;
 }
 
@@ -889,6 +876,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/metro-usb.c b/drivers/usb/serial/metro-usb.c
index 2b0627b5fe2c..0b257ddffbdb 100644
--- a/drivers/usb/serial/metro-usb.c
+++ b/drivers/usb/serial/metro-usb.c
@@ -52,9 +52,6 @@ static struct usb_device_id id_table[] = {
 };
 MODULE_DEVICE_TABLE(usb, id_table);
 
-/* Input parameter constants. */
-static bool debug;
-
 /* UNI-Directional mode commands for device configure */
 #define UNI_CMD_OPEN    0x80
 #define UNI_CMD_CLOSE   0xFF
@@ -436,7 +433,3 @@ MODULE_LICENSE("GPL");
 MODULE_AUTHOR("Philip Nicastro");
 MODULE_AUTHOR("Aleksey Babahin <tamerlan311@gmail.com>");
 MODULE_DESCRIPTION(DRIVER_DESC);
-
-/* Module input parameters */
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Print debug info (bool 1=on, 0=off)");
diff --git a/drivers/usb/serial/mos7720.c b/drivers/usb/serial/mos7720.c
index 012f67b2e4cc..1bf1ad066666 100644
--- a/drivers/usb/serial/mos7720.c
+++ b/drivers/usb/serial/mos7720.c
@@ -71,8 +71,6 @@ struct moschip_port {
         struct urb              *write_urb_pool[NUM_URBS];
 };
 
-static bool debug;
-
 static struct usb_serial_driver moschip7720_2port_driver;
 
 #define USB_VENDOR_ID_MOSCHIP           0x9710
@@ -281,16 +279,19 @@ static void send_deferred_urbs(unsigned long _mos_parport)
         int ret_val;
         unsigned long flags;
         struct mos7715_parport *mos_parport = (void *)_mos_parport;
-        struct urbtracker *urbtrack;
+        struct urbtracker *urbtrack, *tmp;
         struct list_head *cursor, *next;
+        struct device *dev;
 
         /* if release function ran, game over */
         if (unlikely(mos_parport->serial == NULL))
                 return;
 
+        dev = &mos_parport->serial->dev->dev;
+
         /* try again to get the mutex */
         if (!mutex_trylock(&mos_parport->serial->disc_mutex)) {
-                dbg("%s: rescheduling tasklet", __func__);
+                dev_dbg(dev, "%s: rescheduling tasklet\n", __func__);
                 tasklet_schedule(&mos_parport->urb_tasklet);
                 return;
         }
@@ -305,20 +306,19 @@ static void send_deferred_urbs(unsigned long _mos_parport)
         if (list_empty(&mos_parport->deferred_urbs)) {
                 spin_unlock_irqrestore(&mos_parport->listlock, flags);
                 mutex_unlock(&mos_parport->serial->disc_mutex);
-                dbg("%s: deferred_urbs list empty", __func__);
+                dev_dbg(dev, "%s: deferred_urbs list empty\n", __func__);
                 return;
         }
 
         /* move contents of deferred_urbs list to active_urbs list and submit */
         list_for_each_safe(cursor, next, &mos_parport->deferred_urbs)
                 list_move_tail(cursor, &mos_parport->active_urbs);
-        list_for_each_entry(urbtrack, &mos_parport->active_urbs,
+        list_for_each_entry_safe(urbtrack, tmp, &mos_parport->active_urbs,
                             urblist_entry) {
                 ret_val = usb_submit_urb(urbtrack->urb, GFP_ATOMIC);
-                dbg("%s: urb submitted", __func__);
+                dev_dbg(dev, "%s: urb submitted\n", __func__);
                 if (ret_val) {
-                        dev_err(&mos_parport->serial->dev->dev,
-                                "usb_submit_urb() failed: %d", ret_val);
+                        dev_err(dev, "usb_submit_urb() failed: %d\n", ret_val);
                         list_del(&urbtrack->urblist_entry);
                         kref_put(&urbtrack->ref_count, destroy_urbtracker);
                 }
@@ -334,7 +334,7 @@ static void async_complete(struct urb *urb)
         int status = urb->status;
 
         if (unlikely(status))
-                dbg("%s - nonzero urb status received: %d", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
 
         /* remove the urbtracker from the active_urbs list */
         spin_lock(&urbtrack->mos_parport->listlock);
@@ -389,7 +389,7 @@ static int write_parport_reg_nonblock(struct mos7715_parport *mos_parport,
                               &mos_parport->deferred_urbs);
                 spin_unlock_irqrestore(&mos_parport->listlock, flags);
                 tasklet_schedule(&mos_parport->urb_tasklet);
-                dbg("tasklet scheduled");
+                dev_dbg(&usbdev->dev, "tasklet scheduled");
                 return 0;
         }
 
@@ -690,7 +690,7 @@ static int mos7715_parport_init(struct usb_serial *serial)
         /* allocate and initialize parallel port control struct */
         mos_parport = kzalloc(sizeof(struct mos7715_parport), GFP_KERNEL);
         if (mos_parport == NULL) {
-                dbg("mos7715_parport_init: kzalloc failed");
+                dev_dbg(&serial->dev->dev, "%s: kzalloc failed\n", __func__);
                 return -ENOMEM;
         }
         mos_parport->msg_pending = false;
@@ -743,6 +743,7 @@ static void mos7720_interrupt_callback(struct urb *urb)
         int result;
         int length;
         int status = urb->status;
+        struct device *dev = &urb->dev->dev;
         __u8 *data;
         __u8 sp1;
         __u8 sp2;
@@ -755,12 +756,10 @@ static void mos7720_interrupt_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
                 goto exit;
         }
 
@@ -777,7 +776,7 @@ static void mos7720_interrupt_callback(struct urb *urb)
          *      oneukum 2007-03-14 */
 
         if (unlikely(length != 4)) {
-                dbg("Wrong data !!!");
+                dev_dbg(dev, "Wrong data !!!\n");
                 return;
         }
 
@@ -786,31 +785,29 @@ static void mos7720_interrupt_callback(struct urb *urb)
 
         if ((sp1 | sp2) & 0x01) {
                 /* No Interrupt Pending in both the ports */
-                dbg("No Interrupt !!!");
+                dev_dbg(dev, "No Interrupt !!!\n");
         } else {
                 switch (sp1 & 0x0f) {
                 case SERIAL_IIR_RLS:
-                        dbg("Serial Port 1: Receiver status error or address "
-                            "bit detected in 9-bit mode\n");
+                        dev_dbg(dev, "Serial Port 1: Receiver status error or address bit detected in 9-bit mode\n");
                         break;
                 case SERIAL_IIR_CTI:
-                        dbg("Serial Port 1: Receiver time out");
+                        dev_dbg(dev, "Serial Port 1: Receiver time out\n");
                         break;
                 case SERIAL_IIR_MS:
-                        /* dbg("Serial Port 1: Modem status change"); */
+                        /* dev_dbg(dev, "Serial Port 1: Modem status change\n"); */
                         break;
                 }
 
                 switch (sp2 & 0x0f) {
                 case SERIAL_IIR_RLS:
-                        dbg("Serial Port 2: Receiver status error or address "
-                            "bit detected in 9-bit mode");
+                        dev_dbg(dev, "Serial Port 2: Receiver status error or address bit detected in 9-bit mode\n");
                         break;
                 case SERIAL_IIR_CTI:
-                        dbg("Serial Port 2: Receiver time out");
+                        dev_dbg(dev, "Serial Port 2: Receiver time out\n");
                         break;
                 case SERIAL_IIR_MS:
-                        /* dbg("Serial Port 2: Modem status change"); */
+                        /* dev_dbg(dev, "Serial Port 2: Modem status change\n"); */
                         break;
                 }
         }
@@ -818,9 +815,7 @@ static void mos7720_interrupt_callback(struct urb *urb)
 exit:
         result = usb_submit_urb(urb, GFP_ATOMIC);
         if (result)
-                dev_err(&urb->dev->dev,
-                        "%s - Error %d submitting control urb\n",
-                        __func__, result);
+                dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
 }
 
 /*
@@ -833,6 +828,7 @@ static void mos7715_interrupt_callback(struct urb *urb)
         int result;
         int length;
         int status = urb->status;
+        struct device *dev = &urb->dev->dev;
         __u8 *data;
         __u8 iir;
 
@@ -845,12 +841,10 @@ static void mos7715_interrupt_callback(struct urb *urb)
         case -ESHUTDOWN:
         case -ENODEV:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
                 goto exit;
         }
 
@@ -864,7 +858,7 @@ static void mos7715_interrupt_callback(struct urb *urb)
          * Byte 4: FIFO status for both */
 
         if (unlikely(length != 4)) {
-                dbg("Wrong data !!!");
+                dev_dbg(dev, "Wrong data !!!\n");
                 return;
         }
 
@@ -872,14 +866,13 @@ static void mos7715_interrupt_callback(struct urb *urb)
         if (!(iir & 0x01)) {    /* serial port interrupt pending */
                 switch (iir & 0x0f) {
                 case SERIAL_IIR_RLS:
-                        dbg("Serial Port: Receiver status error or address "
-                            "bit detected in 9-bit mode\n");
+                        dev_dbg(dev, "Serial Port: Receiver status error or address bit detected in 9-bit mode\n\n");
                         break;
                 case SERIAL_IIR_CTI:
-                        dbg("Serial Port: Receiver time out");
+                        dev_dbg(dev, "Serial Port: Receiver time out\n");
                         break;
                 case SERIAL_IIR_MS:
-                        /* dbg("Serial Port: Modem status change"); */
+                        /* dev_dbg(dev, "Serial Port: Modem status change\n"); */
                         break;
                 }
         }
@@ -897,9 +890,7 @@ static void mos7715_interrupt_callback(struct urb *urb)
 exit:
         result = usb_submit_urb(urb, GFP_ATOMIC);
         if (result)
-                dev_err(&urb->dev->dev,
-                        "%s - Error %d submitting control urb\n",
-                        __func__, result);
+                dev_err(dev, "%s - Error %d submitting control urb\n", __func__, result);
 }
 
 /*
@@ -916,13 +907,13 @@ static void mos7720_bulk_in_callback(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                dbg("nonzero read bulk status received: %d", status);
+                dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
                 return;
         }
 
         port = urb->context;
 
-        dbg("Entering...%s", __func__);
+        dev_dbg(&port->dev, "Entering...%s\n", __func__);
 
         data = urb->transfer_buffer;
 
@@ -936,8 +927,7 @@ static void mos7720_bulk_in_callback(struct urb *urb)
         if (port->read_urb->status != -EINPROGRESS) {
                 retval = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                 if (retval)
-                        dbg("usb_submit_urb(read bulk) failed, retval = %d",
-                            retval);
+                        dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
         }
 }
 
@@ -953,13 +943,13 @@ static void mos7720_bulk_out_data_callback(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                dbg("nonzero write bulk status received:%d", status);
+                dev_dbg(&urb->dev->dev, "nonzero write bulk status received:%d\n", status);
                 return;
         }
 
         mos7720_port = urb->context;
         if (!mos7720_port) {
-                dbg("NULL mos7720_port pointer");
+                dev_dbg(&urb->dev->dev, "NULL mos7720_port pointer\n");
                 return ;
         }
 
@@ -1061,9 +1051,7 @@ static int mos7720_open(struct tty_struct *tty, struct usb_serial_port *port)
         port_number = port->number - port->serial->minor;
         read_mos_reg(serial, port_number, LSR, &data);
 
-        dbg("SS::%p LSR:%x", mos7720_port, data);
-
-        dbg("Check:Sending Command ..........");
+        dev_dbg(&port->dev, "SS::%p LSR:%x\n", mos7720_port, data);
 
         write_mos_reg(serial, dummy, SP1_REG, 0x02);
         write_mos_reg(serial, dummy, SP2_REG, 0x02);
@@ -1122,20 +1110,16 @@ static int mos7720_chars_in_buffer(struct tty_struct *tty)
         int chars = 0;
         struct moschip_port *mos7720_port;
 
-        dbg("%s:entering ...........", __func__);
-
         mos7720_port = usb_get_serial_port_data(port);
-        if (mos7720_port == NULL) {
-                dbg("%s:leaving ...........", __func__);
+        if (mos7720_port == NULL)
                 return 0;
-        }
 
         for (i = 0; i < NUM_URBS; ++i) {
                 if (mos7720_port->write_urb_pool[i] &&
                     mos7720_port->write_urb_pool[i]->status == -EINPROGRESS)
                         chars += URB_TRANSFER_BUFFER_SIZE;
         }
-        dbg("%s - returns %d", __func__, chars);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
         return chars;
 }
 
@@ -1145,8 +1129,6 @@ static void mos7720_close(struct usb_serial_port *port)
         struct moschip_port *mos7720_port;
         int j;
 
-        dbg("mos7720_close:entering...");
-
         serial = port->serial;
 
         mos7720_port = usb_get_serial_port_data(port);
@@ -1166,9 +1148,7 @@ static void mos7720_close(struct usb_serial_port *port)
 
         /* While closing port, shutdown all bulk read, write  *
          * and interrupt read if they exists, otherwise nop   */
-        dbg("Shutdown bulk write");
         usb_kill_urb(port->write_urb);
-        dbg("Shutdown bulk read");
         usb_kill_urb(port->read_urb);
 
         mutex_lock(&serial->disc_mutex);
@@ -1182,8 +1162,6 @@ static void mos7720_close(struct usb_serial_port *port)
         }
         mutex_unlock(&serial->disc_mutex);
         mos7720_port->open = 0;
-
-        dbg("Leaving %s", __func__);
 }
 
 static void mos7720_break(struct tty_struct *tty, int break_state)
@@ -1193,8 +1171,6 @@ static void mos7720_break(struct tty_struct *tty, int break_state)
         struct usb_serial *serial;
         struct moschip_port *mos7720_port;
 
-        dbg("Entering %s", __func__);
-
         serial = port->serial;
 
         mos7720_port = usb_get_serial_port_data(port);
@@ -1225,13 +1201,9 @@ static int mos7720_write_room(struct tty_struct *tty)
         int room = 0;
         int i;
 
-        dbg("%s:entering ...........", __func__);
-
         mos7720_port = usb_get_serial_port_data(port);
-        if (mos7720_port == NULL) {
-                dbg("%s:leaving ...........", __func__);
+        if (mos7720_port == NULL)
                 return -ENODEV;
-        }
 
         /* FIXME: Locking */
         for (i = 0; i < NUM_URBS; ++i) {
@@ -1240,7 +1212,7 @@ static int mos7720_write_room(struct tty_struct *tty)
                         room += URB_TRANSFER_BUFFER_SIZE;
         }
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
         return room;
 }
 
@@ -1257,15 +1229,11 @@ static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
         struct urb    *urb;
         const unsigned char *current_position = data;
 
-        dbg("%s:entering ...........", __func__);
-
         serial = port->serial;
 
         mos7720_port = usb_get_serial_port_data(port);
-        if (mos7720_port == NULL) {
-                dbg("mos7720_port is NULL");
+        if (mos7720_port == NULL)
                 return -ENODEV;
-        }
 
         /* try to find a free urb in the list */
         urb = NULL;
@@ -1274,13 +1242,13 @@ static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
                 if (mos7720_port->write_urb_pool[i] &&
                     mos7720_port->write_urb_pool[i]->status != -EINPROGRESS) {
                         urb = mos7720_port->write_urb_pool[i];
-                        dbg("URB:%d", i);
+                        dev_dbg(&port->dev, "URB:%d\n", i);
                         break;
                 }
         }
 
         if (urb == NULL) {
-                dbg("%s - no more free urbs", __func__);
+                dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
                 goto exit;
         }
 
@@ -1296,7 +1264,7 @@ static int mos7720_write(struct tty_struct *tty, struct usb_serial_port *port,
         transfer_size = min(count, URB_TRANSFER_BUFFER_SIZE);
 
         memcpy(urb->transfer_buffer, current_position, transfer_size);
-        usb_serial_debug_data(debug, &port->dev, __func__, transfer_size,
+        usb_serial_debug_data(&port->dev, __func__, transfer_size,
                               urb->transfer_buffer);
 
         /* fill urb with data and submit  */
@@ -1326,20 +1294,16 @@ static void mos7720_throttle(struct tty_struct *tty)
         struct moschip_port *mos7720_port;
         int status;
 
-        dbg("%s- port %d", __func__, port->number);
-
         mos7720_port = usb_get_serial_port_data(port);
 
         if (mos7720_port == NULL)
                 return;
 
         if (!mos7720_port->open) {
-                dbg("port not opened");
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
-        dbg("%s: Entering ..........", __func__);
-
         /* if we are implementing XON/XOFF, send the stop character */
         if (I_IXOFF(tty)) {
                 unsigned char stop_char = STOP_CHAR(tty);
@@ -1368,12 +1332,10 @@ static void mos7720_unthrottle(struct tty_struct *tty)
                 return;
 
         if (!mos7720_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
-        dbg("%s: Entering ..........", __func__);
-
         /* if we are implementing XON/XOFF, send the start character */
         if (I_IXOFF(tty)) {
                 unsigned char start_char = START_CHAR(tty);
@@ -1409,7 +1371,7 @@ static int set_higher_rates(struct moschip_port *mos7720_port,
          /***********************************************
          *      Init Sequence for higher rates
          ***********************************************/
-        dbg("Sending Setting Commands ..........");
+        dev_dbg(&port->dev, "Sending Setting Commands ..........\n");
         port_number = port->number - port->serial->minor;
 
         write_mos_reg(serial, port_number, IER, 0x00);
@@ -1478,7 +1440,7 @@ static struct divisor_table_entry divisor_table[] = {
  *      this function calculates the proper baud rate divisor for the specified
  *      baud rate.
  *****************************************************************************/
-static int calc_baud_rate_divisor(int baudrate, int *divisor)
+static int calc_baud_rate_divisor(struct usb_serial_port *port, int baudrate, int *divisor)
 {
         int i;
         __u16 custom;
@@ -1486,7 +1448,7 @@ static int calc_baud_rate_divisor(int baudrate, int *divisor)
         __u16 round;
 
 
-        dbg("%s - %d", __func__, baudrate);
+        dev_dbg(&port->dev, "%s - %d\n", __func__, baudrate);
 
         for (i = 0; i < ARRAY_SIZE(divisor_table); i++) {
                 if (divisor_table[i].baudrate == baudrate) {
@@ -1508,11 +1470,11 @@ static int calc_baud_rate_divisor(int baudrate, int *divisor)
                         custom++;
                 *divisor = custom;
 
-                dbg("Baud %d = %d", baudrate, custom);
+                dev_dbg(&port->dev, "Baud %d = %d\n", baudrate, custom);
                 return 0;
         }
 
-        dbg("Baud calculation Failed...");
+        dev_dbg(&port->dev, "Baud calculation Failed...\n");
         return -EINVAL;
 }
 
@@ -1536,13 +1498,11 @@ static int send_cmd_write_baud_rate(struct moschip_port *mos7720_port,
         port = mos7720_port->port;
         serial = port->serial;
 
-        dbg("%s: Entering ..........", __func__);
-
         number = port->number - port->serial->minor;
-        dbg("%s - port = %d, baud = %d", __func__, port->number, baudrate);
+        dev_dbg(&port->dev, "%s - baud = %d\n", __func__, baudrate);
 
         /* Calculate the Divisor */
-        status = calc_baud_rate_divisor(baudrate, &divisor);
+        status = calc_baud_rate_divisor(port, baudrate, &divisor);
         if (status) {
                 dev_err(&port->dev, "%s - bad baud rate\n", __func__);
                 return status;
@@ -1591,15 +1551,11 @@ static void change_port_settings(struct tty_struct *tty,
         serial = port->serial;
         port_number = port->number - port->serial->minor;
 
-        dbg("%s - port %d", __func__, port->number);
-
         if (!mos7720_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
-        dbg("%s: Entering ..........", __func__);
-
         lData = UART_LCR_WLEN8;
         lStop = 0x00;   /* 1 stop bit */
         lParity = 0x00; /* No parity */
@@ -1633,14 +1589,14 @@ static void change_port_settings(struct tty_struct *tty,
         if (cflag & PARENB) {
                 if (cflag & PARODD) {
                         lParity = UART_LCR_PARITY;
-                        dbg("%s - parity = odd", __func__);
+                        dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
                 } else {
                         lParity = (UART_LCR_EPAR | UART_LCR_PARITY);
-                        dbg("%s - parity = even", __func__);
+                        dev_dbg(&port->dev, "%s - parity = even\n", __func__);
                 }
 
         } else {
-                dbg("%s - parity = none", __func__);
+                dev_dbg(&port->dev, "%s - parity = none\n", __func__);
         }
 
         if (cflag & CMSPAR)
@@ -1649,10 +1605,10 @@ static void change_port_settings(struct tty_struct *tty,
         /* Change the Stop bit */
         if (cflag & CSTOPB) {
                 lStop = UART_LCR_STOP;
-                dbg("%s - stop bits = 2", __func__);
+                dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
         } else {
                 lStop = 0x00;
-                dbg("%s - stop bits = 1", __func__);
+                dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
         }
 
 #define LCR_BITS_MASK           0x03    /* Mask for bits/char field */
@@ -1698,7 +1654,7 @@ static void change_port_settings(struct tty_struct *tty,
         baud = tty_get_baud_rate(tty);
         if (!baud) {
                 /* pick a default, any default... */
-                dbg("Picked default baud...");
+                dev_dbg(&port->dev, "Picked default baud...\n");
                 baud = 9600;
         }
 
@@ -1709,7 +1665,7 @@ static void change_port_settings(struct tty_struct *tty,
                 return;
         }
 
-        dbg("%s - baud rate = %d", __func__, baud);
+        dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
         status = send_cmd_write_baud_rate(mos7720_port, baud);
         /* FIXME: needs to write actual resulting baud back not just
            blindly do so */
@@ -1721,8 +1677,7 @@ static void change_port_settings(struct tty_struct *tty,
         if (port->read_urb->status != -EINPROGRESS) {
                 status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                 if (status)
-                        dbg("usb_submit_urb(read bulk) failed, status = %d",
-                            status);
+                        dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
         }
 }
 
@@ -1747,23 +1702,19 @@ static void mos7720_set_termios(struct tty_struct *tty,
                 return;
 
         if (!mos7720_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
-        dbg("%s\n", "setting termios - ASPIRE");
+        dev_dbg(&port->dev, "setting termios - ASPIRE\n");
 
         cflag = tty->termios.c_cflag;
 
-        dbg("%s - cflag %08x iflag %08x", __func__,
-            tty->termios.c_cflag,
-            RELEVANT_IFLAG(tty->termios.c_iflag));
+        dev_dbg(&port->dev, "%s - cflag %08x iflag %08x\n", __func__,
+                tty->termios.c_cflag, RELEVANT_IFLAG(tty->termios.c_iflag));
 
-        dbg("%s - old cflag %08x old iflag %08x", __func__,
-            old_termios->c_cflag,
-            RELEVANT_IFLAG(old_termios->c_iflag));
-
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(&port->dev, "%s - old cflag %08x old iflag %08x\n", __func__,
+                old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
 
         /* change the port settings to the new ones specified */
         change_port_settings(tty, mos7720_port, old_termios);
@@ -1771,8 +1722,7 @@ static void mos7720_set_termios(struct tty_struct *tty,
         if (port->read_urb->status != -EINPROGRESS) {
                 status = usb_submit_urb(port->read_urb, GFP_ATOMIC);
                 if (status)
-                        dbg("usb_submit_urb(read bulk) failed, status = %d",
-                            status);
+                        dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n", status);
         }
 }
 
@@ -1800,7 +1750,7 @@ static int get_lsr_info(struct tty_struct *tty,
                 read_mos_reg(port->serial, port_number, LSR, &data);
                 if ((data & (UART_LSR_TEMT | UART_LSR_THRE))
                                         == (UART_LSR_TEMT | UART_LSR_THRE)) {
-                        dbg("%s -- Empty", __func__);
+                        dev_dbg(&port->dev, "%s -- Empty\n", __func__);
                         result = TIOCSER_TEMT;
                 }
         }
@@ -1817,8 +1767,6 @@ static int mos7720_tiocmget(struct tty_struct *tty)
         unsigned int mcr ;
         unsigned int msr ;
 
-        dbg("%s - port %d", __func__, port->number);
-
         mcr = mos7720_port->shadowMCR;
         msr = mos7720_port->shadowMSR;
 
@@ -1829,8 +1777,6 @@ static int mos7720_tiocmget(struct tty_struct *tty)
           | ((msr & UART_MSR_RI)    ? TIOCM_RI :  0)   /* 0x080 */
           | ((msr & UART_MSR_DSR)   ? TIOCM_DSR : 0);  /* 0x100 */
 
-        dbg("%s -- %x", __func__, result);
-
         return result;
 }
 
@@ -1840,8 +1786,6 @@ static int mos7720_tiocmset(struct tty_struct *tty,
         struct usb_serial_port *port = tty->driver_data;
         struct moschip_port *mos7720_port = usb_get_serial_port_data(port);
         unsigned int mcr ;
-        dbg("%s - port %d", __func__, port->number);
-        dbg("he was at tiocmset");
 
         mcr = mos7720_port->shadowMCR;
 
@@ -1888,8 +1832,8 @@ static int mos7720_get_icount(struct tty_struct *tty,
         icount->brk = cnow.brk;
         icount->buf_overrun = cnow.buf_overrun;
 
-        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                port->number, icount->rx, icount->tx);
+        dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n", __func__,
+                icount->rx, icount->tx);
         return 0;
 }
 
@@ -1975,29 +1919,28 @@ static int mos7720_ioctl(struct tty_struct *tty,
         if (mos7720_port == NULL)
                 return -ENODEV;
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - cmd = 0x%x", __func__, cmd);
 
         switch (cmd) {
         case TIOCSERGETLSR:
-                dbg("%s (%d) TIOCSERGETLSR", __func__,  port->number);
+                dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
                 return get_lsr_info(tty, mos7720_port,
                                         (unsigned int __user *)arg);
 
         /* FIXME: These should be using the mode methods */
         case TIOCMBIS:
         case TIOCMBIC:
-                dbg("%s (%d) TIOCMSET/TIOCMBIC/TIOCMSET",
-                                        __func__, port->number);
+                dev_dbg(&port->dev, "%s TIOCMSET/TIOCMBIC/TIOCMSET\n", __func__);
                 return set_modem_info(mos7720_port, cmd,
                                       (unsigned int __user *)arg);
 
         case TIOCGSERIAL:
-                dbg("%s (%d) TIOCGSERIAL", __func__,  port->number);
+                dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__);
                 return get_serial_info(mos7720_port,
                                        (struct serial_struct __user *)arg);
 
         case TIOCMIWAIT:
-                dbg("%s (%d) TIOCMIWAIT", __func__,  port->number);
+                dev_dbg(&port->dev, "%s TIOCMIWAIT\n", __func__);
                 cprev = mos7720_port->icount;
                 while (1) {
                         if (signal_pending(current))
@@ -2030,13 +1973,6 @@ static int mos7720_startup(struct usb_serial *serial)
         u16 product;
         int ret_val;
 
-        dbg("%s: Entering ..........", __func__);
-
-        if (!serial) {
-                dbg("Invalid Handler");
-                return -ENODEV;
-        }
-
         product = le16_to_cpu(serial->dev->descriptor.idProduct);
         dev = serial->dev;
 
@@ -2081,8 +2017,8 @@ static int mos7720_startup(struct usb_serial *serial)
                 mos7720_port->port = serial->port[i];
                 usb_set_serial_port_data(serial->port[i], mos7720_port);
 
-                dbg("port number is %d", serial->port[i]->number);
-                dbg("serial number is %d", serial->minor);
+                dev_dbg(&dev->dev, "port number is %d\n", serial->port[i]->number);
+                dev_dbg(&dev->dev, "serial number is %d\n", serial->minor);
         }
 
 
@@ -2106,7 +2042,7 @@ static int mos7720_startup(struct usb_serial *serial)
 #endif
         /* LSR For Port 1 */
         read_mos_reg(serial, 0, LSR, &data);
-        dbg("LSR:%x", data);
+        dev_dbg(&dev->dev, "LSR:%x\n", data);
 
         return 0;
 }
@@ -2195,6 +2131,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/mos7840.c b/drivers/usb/serial/mos7840.c
index 402c32d7accb..d6d4eeca8c68 100644
--- a/drivers/usb/serial/mos7840.c
+++ b/drivers/usb/serial/mos7840.c
@@ -252,8 +252,6 @@ struct moschip_port {
         struct timer_list led_timer2;   /* Timer for LED off */
 };
 
-static bool debug;
-
 /*
  * mos7840_set_reg_sync
  *      To set the Control register by calling usb_fill_control_urb function
@@ -265,7 +263,7 @@ static int mos7840_set_reg_sync(struct usb_serial_port *port, __u16 reg,
 {
         struct usb_device *dev = port->serial->dev;
         val = val & 0x00ff;
-        dbg("mos7840_set_reg_sync offset is %x, value %x", reg, val);
+        dev_dbg(&port->dev, "mos7840_set_reg_sync offset is %x, value %x\n", reg, val);
 
         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
                                MCS_WR_RTYPE, val, reg, NULL, 0,
@@ -293,7 +291,7 @@ static int mos7840_get_reg_sync(struct usb_serial_port *port, __u16 reg,
                               MCS_RD_RTYPE, 0, reg, buf, VENDOR_READ_LENGTH,
                               MOS_WDR_TIMEOUT);
         *val = buf[0];
-        dbg("mos7840_get_reg_sync offset is %x, return val %x", reg, *val);
+        dev_dbg(&port->dev, "%s offset is %x, return val %x\n", __func__, reg, *val);
 
         kfree(buf);
         return ret;
@@ -316,21 +314,16 @@ static int mos7840_set_uart_reg(struct usb_serial_port *port, __u16 reg,
         if (port->serial->num_ports == 4) {
                 val |= (((__u16) port->number -
                                 (__u16) (port->serial->minor)) + 1) << 8;
-                dbg("mos7840_set_uart_reg application number is %x", val);
         } else {
                 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) {
                         val |= (((__u16) port->number -
                               (__u16) (port->serial->minor)) + 1) << 8;
-                        dbg("mos7840_set_uart_reg application number is %x",
-                            val);
                 } else {
-                        val |=
-                            (((__u16) port->number -
+                        val |= (((__u16) port->number -
                               (__u16) (port->serial->minor)) + 2) << 8;
-                        dbg("mos7840_set_uart_reg application number is %x",
-                            val);
                 }
         }
+        dev_dbg(&port->dev, "%s application number is %x\n", __func__, val);
         return usb_control_msg(dev, usb_sndctrlpipe(dev, 0), MCS_WRREQ,
                                MCS_WR_RTYPE, val, reg, NULL, 0,
                                MOS_WDR_TIMEOUT);
@@ -354,27 +347,21 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
         if (!buf)
                 return -ENOMEM;
 
-        /* dbg("application number is %4x",
-            (((__u16)port->number - (__u16)(port->serial->minor))+1)<<8); */
         /* Wval  is same as application number */
         if (port->serial->num_ports == 4) {
                 Wval =
                     (((__u16) port->number - (__u16) (port->serial->minor)) +
                      1) << 8;
-                dbg("mos7840_get_uart_reg application number is %x", Wval);
         } else {
                 if (((__u16) port->number - (__u16) (port->serial->minor)) == 0) {
                         Wval = (((__u16) port->number -
                               (__u16) (port->serial->minor)) + 1) << 8;
-                        dbg("mos7840_get_uart_reg application number is %x",
-                            Wval);
                 } else {
                         Wval = (((__u16) port->number -
                               (__u16) (port->serial->minor)) + 2) << 8;
-                        dbg("mos7840_get_uart_reg application number is %x",
-                            Wval);
                 }
         }
+        dev_dbg(&port->dev, "%s application number is %x\n", __func__, Wval);
         ret = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), MCS_RDREQ,
                               MCS_RD_RTYPE, Wval, reg, buf, VENDOR_READ_LENGTH,
                               MOS_WDR_TIMEOUT);
@@ -384,14 +371,13 @@ static int mos7840_get_uart_reg(struct usb_serial_port *port, __u16 reg,
         return ret;
 }
 
-static void mos7840_dump_serial_port(struct moschip_port *mos7840_port)
+static void mos7840_dump_serial_port(struct usb_serial_port *port,
+                                     struct moschip_port *mos7840_port)
 {
 
-        dbg("***************************************");
-        dbg("SpRegOffset is %2x", mos7840_port->SpRegOffset);
-        dbg("ControlRegOffset is %2x", mos7840_port->ControlRegOffset);
-        dbg("DCRRegOffset is %2x", mos7840_port->DcrRegOffset);
-        dbg("***************************************");
+        dev_dbg(&port->dev, "SpRegOffset is %2x\n", mos7840_port->SpRegOffset);
+        dev_dbg(&port->dev, "ControlRegOffset is %2x\n", mos7840_port->ControlRegOffset);
+        dev_dbg(&port->dev, "DCRRegOffset is %2x\n", mos7840_port->DcrRegOffset);
 
 }
 
@@ -450,8 +436,6 @@ static void mos7840_handle_new_lsr(struct moschip_port *port, __u8 new_lsr)
 {
         struct async_icount *icount;
 
-        dbg("%s - %02x", __func__, new_lsr);
-
         if (new_lsr & SERIAL_LSR_BI) {
                 /*
                  * Parity and Framing errors only count if they
@@ -492,6 +476,7 @@ static void mos7840_control_callback(struct urb *urb)
 {
         unsigned char *data;
         struct moschip_port *mos7840_port;
+        struct device *dev = &urb->dev->dev;
         __u8 regval = 0x0;
         int result = 0;
         int status = urb->status;
@@ -506,21 +491,19 @@ static void mos7840_control_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - urb shutting down with status: %d\n", __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                    status);
+                dev_dbg(dev, "%s - nonzero urb status received: %d\n", __func__, status);
                 goto exit;
         }
 
-        dbg("%s urb buffer size is %d", __func__, urb->actual_length);
-        dbg("%s mos7840_port->MsrLsr is %d port %d", __func__,
-            mos7840_port->MsrLsr, mos7840_port->port_num);
+        dev_dbg(dev, "%s urb buffer size is %d\n", __func__, urb->actual_length);
+        dev_dbg(dev, "%s mos7840_port->MsrLsr is %d port %d\n", __func__,
+                mos7840_port->MsrLsr, mos7840_port->port_num);
         data = urb->transfer_buffer;
         regval = (__u8) data[0];
-        dbg("%s data is %x", __func__, regval);
+        dev_dbg(dev, "%s data is %x\n", __func__, regval);
         if (mos7840_port->MsrLsr == 0)
                 mos7840_handle_new_msr(mos7840_port, regval);
         else if (mos7840_port->MsrLsr == 1)
@@ -532,8 +515,7 @@ exit:
                 result = usb_submit_urb(mos7840_port->int_urb, GFP_ATOMIC);
         spin_unlock(&mos7840_port->pool_lock);
         if (result) {
-                dev_err(&urb->dev->dev,
-                        "%s - Error %d submitting interrupt urb\n",
+                dev_err(dev, "%s - Error %d submitting interrupt urb\n",
                         __func__, result);
         }
 }
@@ -570,12 +552,12 @@ static void mos7840_set_led_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* This urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                        urb->status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d",
+                        __func__, urb->status);
                 break;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                        urb->status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d",
+                        __func__, urb->status);
         }
 }
 
@@ -650,12 +632,12 @@ static void mos7840_interrupt_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d", __func__,
-                    status);
+                dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d", __func__,
-                    status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, status);
                 goto exit;
         }
 
@@ -672,7 +654,7 @@ static void mos7840_interrupt_callback(struct urb *urb)
          * Byte 5 FIFO status for both */
 
         if (length && length > 5) {
-                dbg("%s", "Wrong data !!!");
+                dev_dbg(&urb->dev->dev, "%s", "Wrong data !!!\n");
                 return;
         }
 
@@ -689,17 +671,17 @@ static void mos7840_interrupt_callback(struct urb *urb)
                       (__u16) (serial->minor)) + 1) << 8;
                 if (mos7840_port->open) {
                         if (sp[i] & 0x01) {
-                                dbg("SP%d No Interrupt !!!", i);
+                                dev_dbg(&urb->dev->dev, "SP%d No Interrupt !!!\n", i);
                         } else {
                                 switch (sp[i] & 0x0f) {
                                 case SERIAL_IIR_RLS:
-                                        dbg("Serial Port %d: Receiver status error or ", i);
-                                        dbg("address bit detected in 9-bit mode");
+                                        dev_dbg(&urb->dev->dev, "Serial Port %d: Receiver status error or \n", i);
+                                        dev_dbg(&urb->dev->dev, "address bit detected in 9-bit mode\n");
                                         mos7840_port->MsrLsr = 1;
                                         wreg = LINE_STATUS_REGISTER;
                                         break;
                                 case SERIAL_IIR_MS:
-                                        dbg("Serial Port %d: Modem status change", i);
+                                        dev_dbg(&urb->dev->dev, "Serial Port %d: Modem status change\n", i);
                                         mos7840_port->MsrLsr = 0;
                                         wreg = MODEM_STATUS_REGISTER;
                                         break;
@@ -731,11 +713,11 @@ static int mos7840_port_paranoia_check(struct usb_serial_port *port,
                                        const char *function)
 {
         if (!port) {
-                dbg("%s - port == NULL", function);
+                pr_debug("%s - port == NULL\n", function);
                 return -1;
         }
         if (!port->serial) {
-                dbg("%s - port->serial == NULL", function);
+                pr_debug("%s - port->serial == NULL\n", function);
                 return -1;
         }
 
@@ -747,11 +729,11 @@ static int mos7840_serial_paranoia_check(struct usb_serial *serial,
                                          const char *function)
 {
         if (!serial) {
-                dbg("%s - serial == NULL", function);
+                pr_debug("%s - serial == NULL\n", function);
                 return -1;
         }
         if (!serial->type) {
-                dbg("%s - serial->type == NULL!", function);
+                pr_debug("%s - serial->type == NULL!\n", function);
                 return -1;
         }
 
@@ -790,49 +772,44 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         int status = urb->status;
 
         mos7840_port = urb->context;
-        if (!mos7840_port) {
-                dbg("%s", "NULL mos7840_port pointer");
+        if (!mos7840_port)
                 return;
-        }
 
         if (status) {
-                dbg("nonzero read bulk status received: %d", status);
+                dev_dbg(&urb->dev->dev, "nonzero read bulk status received: %d\n", status);
                 mos7840_port->read_urb_busy = false;
                 return;
         }
 
-        port = (struct usb_serial_port *)mos7840_port->port;
+        port = mos7840_port->port;
         if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
                 mos7840_port->read_urb_busy = false;
                 return;
         }
 
         serial = mos7840_get_usb_serial(port, __func__);
         if (!serial) {
-                dbg("%s", "Bad serial pointer");
                 mos7840_port->read_urb_busy = false;
                 return;
         }
 
         data = urb->transfer_buffer;
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         if (urb->actual_length) {
                 tty = tty_port_tty_get(&mos7840_port->port->port);
                 if (tty) {
                         tty_insert_flip_string(tty, data, urb->actual_length);
-                        dbg(" %s ", data);
                         tty_flip_buffer_push(tty);
                         tty_kref_put(tty);
                 }
                 mos7840_port->icount.rx += urb->actual_length;
                 smp_wmb();
-                dbg("mos7840_port->icount.rx is %d:",
-                    mos7840_port->icount.rx);
+                dev_dbg(&port->dev, "mos7840_port->icount.rx is %d:\n", mos7840_port->icount.rx);
         }
 
         if (!mos7840_port->read_urb) {
-                dbg("%s", "URB KILLED !!!");
+                dev_dbg(&port->dev, "%s", "URB KILLED !!!\n");
                 mos7840_port->read_urb_busy = false;
                 return;
         }
@@ -850,7 +827,7 @@ static void mos7840_bulk_in_callback(struct urb *urb)
         retval = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
 
         if (retval) {
-                dbg("usb_submit_urb(read bulk) failed, retval = %d", retval);
+                dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, retval = %d\n", retval);
                 mos7840_port->read_urb_busy = false;
         }
 }
@@ -864,11 +841,13 @@ static void mos7840_bulk_in_callback(struct urb *urb)
 static void mos7840_bulk_out_data_callback(struct urb *urb)
 {
         struct moschip_port *mos7840_port;
+        struct usb_serial_port *port;
         struct tty_struct *tty;
         int status = urb->status;
         int i;
 
         mos7840_port = urb->context;
+        port = mos7840_port->port;
         spin_lock(&mos7840_port->pool_lock);
         for (i = 0; i < NUM_URBS; i++) {
                 if (urb == mos7840_port->write_urb_pool[i]) {
@@ -879,16 +858,14 @@ static void mos7840_bulk_out_data_callback(struct urb *urb)
         spin_unlock(&mos7840_port->pool_lock);
 
         if (status) {
-                dbg("nonzero write bulk status received:%d", status);
+                dev_dbg(&port->dev, "nonzero write bulk status received:%d\n", status);
                 return;
         }
 
-        if (mos7840_port_paranoia_check(mos7840_port->port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
-        tty = tty_port_tty_get(&mos7840_port->port->port);
+        tty = tty_port_tty_get(&port->port);
         if (tty && mos7840_port->open)
                 tty_wakeup(tty);
         tty_kref_put(tty);
@@ -929,17 +906,13 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         struct moschip_port *mos7840_port;
         struct moschip_port *port0;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return -ENODEV;
-        }
 
         serial = port->serial;
 
-        if (mos7840_serial_paranoia_check(serial, __func__)) {
-                dbg("%s", "Serial Paranoia failed");
+        if (mos7840_serial_paranoia_check(serial, __func__))
                 return -ENODEV;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
         port0 = mos7840_get_port_private(serial->port[0]);
@@ -990,20 +963,20 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         Data = 0x0;
         status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset, &Data);
         if (status < 0) {
-                dbg("Reading Spreg failed");
+                dev_dbg(&port->dev, "Reading Spreg failed\n");
                 return -1;
         }
         Data |= 0x80;
         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
         if (status < 0) {
-                dbg("writing Spreg failed");
+                dev_dbg(&port->dev, "writing Spreg failed\n");
                 return -1;
         }
 
         Data &= ~0x80;
         status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset, Data);
         if (status < 0) {
-                dbg("writing Spreg failed");
+                dev_dbg(&port->dev, "writing Spreg failed\n");
                 return -1;
         }
         /* End of block to be checked */
@@ -1012,7 +985,7 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         status = mos7840_get_reg_sync(port, mos7840_port->ControlRegOffset,
                                                                         &Data);
         if (status < 0) {
-                dbg("Reading Controlreg failed");
+                dev_dbg(&port->dev, "Reading Controlreg failed\n");
                 return -1;
         }
         Data |= 0x08;           /* Driver done bit */
@@ -1020,7 +993,7 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         status = mos7840_set_reg_sync(port,
                                 mos7840_port->ControlRegOffset, Data);
         if (status < 0) {
-                dbg("writing Controlreg failed");
+                dev_dbg(&port->dev, "writing Controlreg failed\n");
                 return -1;
         }
         /* do register settings here */
@@ -1031,21 +1004,21 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         Data = 0x00;
         status = mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
         if (status < 0) {
-                dbg("disabling interrupts failed");
+                dev_dbg(&port->dev, "disabling interrupts failed\n");
                 return -1;
         }
         /* Set FIFO_CONTROL_REGISTER to the default value */
         Data = 0x00;
         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
         if (status < 0) {
-                dbg("Writing FIFO_CONTROL_REGISTER  failed");
+                dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
                 return -1;
         }
 
         Data = 0xcf;
         status = mos7840_set_uart_reg(port, FIFO_CONTROL_REGISTER, Data);
         if (status < 0) {
-                dbg("Writing FIFO_CONTROL_REGISTER  failed");
+                dev_dbg(&port->dev, "Writing FIFO_CONTROL_REGISTER  failed\n");
                 return -1;
         }
 
@@ -1142,12 +1115,12 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
          * (can't set it up in mos7840_startup as the  *
          * structures were not set up at that time.)   */
 
-        dbg("port number is %d", port->number);
-        dbg("serial number is %d", port->serial->minor);
-        dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress);
-        dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress);
-        dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress);
-        dbg("port's number in the device is %d", mos7840_port->port_num);
+        dev_dbg(&port->dev, "port number is %d\n", port->number);
+        dev_dbg(&port->dev, "serial number is %d\n", port->serial->minor);
+        dev_dbg(&port->dev, "Bulkin endpoint is %d\n", port->bulk_in_endpointAddress);
+        dev_dbg(&port->dev, "BulkOut endpoint is %d\n", port->bulk_out_endpointAddress);
+        dev_dbg(&port->dev, "Interrupt endpoint is %d\n", port->interrupt_in_endpointAddress);
+        dev_dbg(&port->dev, "port's number in the device is %d\n", mos7840_port->port_num);
         mos7840_port->read_urb = port->read_urb;
 
         /* set up our bulk in urb */
@@ -1171,8 +1144,7 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
                         mos7840_bulk_in_callback, mos7840_port);
         }
 
-        dbg("mos7840_open: bulkin endpoint is %d",
-            port->bulk_in_endpointAddress);
+        dev_dbg(&port->dev, "%s: bulkin endpoint is %d\n", __func__, port->bulk_in_endpointAddress);
         mos7840_port->read_urb_busy = true;
         response = usb_submit_urb(mos7840_port->read_urb, GFP_KERNEL);
         if (response) {
@@ -1197,9 +1169,6 @@ static int mos7840_open(struct tty_struct *tty, struct usb_serial_port *port)
         mos7840_port->icount.tx = 0;
         mos7840_port->icount.rx = 0;
 
-        dbg("usb_serial serial:%p       mos7840_port:%p\n      usb_serial_port port:%p",
-                                serial, mos7840_port, port);
-
         return 0;
 }
 
@@ -1221,10 +1190,8 @@ static int mos7840_chars_in_buffer(struct tty_struct *tty)
         unsigned long flags;
         struct moschip_port *mos7840_port;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return 0;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
         if (mos7840_port == NULL)
@@ -1238,7 +1205,7 @@ static int mos7840_chars_in_buffer(struct tty_struct *tty)
                 }
         }
         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
-        dbg("%s - returns %d", __func__, chars);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
         return chars;
 
 }
@@ -1256,16 +1223,12 @@ static void mos7840_close(struct usb_serial_port *port)
         int j;
         __u16 Data;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
         serial = mos7840_get_usb_serial(port, __func__);
-        if (!serial) {
-                dbg("%s", "Serial Paranoia failed");
+        if (!serial)
                 return;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
         port0 = mos7840_get_port_private(serial->port[0]);
@@ -1291,27 +1254,26 @@ static void mos7840_close(struct usb_serial_port *port)
          * and interrupt read if they exists                  */
         if (serial->dev) {
                 if (mos7840_port->write_urb) {
-                        dbg("%s", "Shutdown bulk write");
+                        dev_dbg(&port->dev, "%s", "Shutdown bulk write\n");
                         usb_kill_urb(mos7840_port->write_urb);
                 }
                 if (mos7840_port->read_urb) {
-                        dbg("%s", "Shutdown bulk read");
+                        dev_dbg(&port->dev, "%s", "Shutdown bulk read\n");
                         usb_kill_urb(mos7840_port->read_urb);
                         mos7840_port->read_urb_busy = false;
                 }
                 if ((&mos7840_port->control_urb)) {
-                        dbg("%s", "Shutdown control read");
+                        dev_dbg(&port->dev, "%s", "Shutdown control read\n");
                         /*/      usb_kill_urb (mos7840_port->control_urb); */
                 }
         }
 /*      if(mos7840_port->ctrl_buf != NULL) */
 /*              kfree(mos7840_port->ctrl_buf); */
         port0->open_ports--;
-        dbg("mos7840_num_open_ports in close%d:in port%d",
-            port0->open_ports, port->number);
+        dev_dbg(&port->dev, "%s in close%d:in port%d\n", __func__, port0->open_ports, port->number);
         if (port0->open_ports == 0) {
                 if (serial->port[0]->interrupt_in_urb) {
-                        dbg("%s", "Shutdown interrupt_in_urb");
+                        dev_dbg(&port->dev, "Shutdown interrupt_in_urb\n");
                         usb_kill_urb(serial->port[0]->interrupt_in_urb);
                 }
         }
@@ -1363,7 +1325,7 @@ static void mos7840_block_until_chase_response(struct tty_struct *tty,
                 /* No activity.. count down section */
                 wait--;
                 if (wait == 0) {
-                        dbg("%s - TIMEOUT", __func__);
+                        dev_dbg(&mos7840_port->port->dev, "%s - TIMEOUT\n", __func__);
                         return;
                 } else {
                         /* Reset timeout value back to seconds */
@@ -1384,16 +1346,12 @@ static void mos7840_break(struct tty_struct *tty, int break_state)
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
         serial = mos7840_get_usb_serial(port, __func__);
-        if (!serial) {
-                dbg("%s", "Serial Paranoia failed");
+        if (!serial)
                 return;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
 
@@ -1411,8 +1369,7 @@ static void mos7840_break(struct tty_struct *tty, int break_state)
 
         /* FIXME: no locking on shadowLCR anywhere in driver */
         mos7840_port->shadowLCR = data;
-        dbg("mcs7840_break mos7840_port->shadowLCR is %x",
-            mos7840_port->shadowLCR);
+        dev_dbg(&port->dev, "%s mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
         mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER,
                              mos7840_port->shadowLCR);
 }
@@ -1433,17 +1390,12 @@ static int mos7840_write_room(struct tty_struct *tty)
         unsigned long flags;
         struct moschip_port *mos7840_port;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
-                dbg("%s", " mos7840_write_room:leaving ...........");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return -1;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
-        if (mos7840_port == NULL) {
-                dbg("%s", "mos7840_break:leaving ...........");
+        if (mos7840_port == NULL)
                 return -1;
-        }
 
         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
         for (i = 0; i < NUM_URBS; ++i) {
@@ -1453,7 +1405,7 @@ static int mos7840_write_room(struct tty_struct *tty)
         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 
         room = (room == 0) ? 0 : room - URB_TRANSFER_BUFFER_SIZE + 1;
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&mos7840_port->port->dev, "%s - returns %d\n", __func__, room);
         return room;
 
 }
@@ -1486,9 +1438,8 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
         Data = 0x00;
         status = mos7840_get_uart_reg(port, LINE_CONTROL_REGISTER, &Data);
         mos7840_port->shadowLCR = Data;
-        dbg("mos7840_write: LINE_CONTROL_REGISTER is %x", Data);
-        dbg("mos7840_write: mos7840_port->shadowLCR is %x",
-            mos7840_port->shadowLCR);
+        dev_dbg(&port->dev, "%s: LINE_CONTROL_REGISTER is %x\n", __func__, Data);
+        dev_dbg(&port->dev, "%s: mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
 
         /* Data = 0x03; */
         /* status = mos7840_set_uart_reg(port,LINE_CONTROL_REGISTER,Data); */
@@ -1501,34 +1452,27 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
         /* status = mos7840_set_uart_reg(port,DIVISOR_LATCH_LSB,Data); */
         Data = 0x00;
         status = mos7840_get_uart_reg(port, DIVISOR_LATCH_LSB, &Data);
-        dbg("mos7840_write:DLL value is %x", Data);
+        dev_dbg(&port->dev, "%s: DLL value is %x\n", __func__, Data);
 
         Data = 0x0;
         status = mos7840_get_uart_reg(port, DIVISOR_LATCH_MSB, &Data);
-        dbg("mos7840_write:DLM value is %x", Data);
+        dev_dbg(&port->dev, "%s: DLM value is %x\n", __func__, Data);
 
         Data = Data & ~SERIAL_LCR_DLAB;
-        dbg("mos7840_write: mos7840_port->shadowLCR is %x",
-            mos7840_port->shadowLCR);
+        dev_dbg(&port->dev, "%s: mos7840_port->shadowLCR is %x\n", __func__, mos7840_port->shadowLCR);
         status = mos7840_set_uart_reg(port, LINE_CONTROL_REGISTER, Data);
 #endif
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Port Paranoia failed");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return -1;
-        }
 
         serial = port->serial;
-        if (mos7840_serial_paranoia_check(serial, __func__)) {
-                dbg("%s", "Serial Paranoia failed");
+        if (mos7840_serial_paranoia_check(serial, __func__))
                 return -1;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
-        if (mos7840_port == NULL) {
-                dbg("%s", "mos7840_port is NULL");
+        if (mos7840_port == NULL)
                 return -1;
-        }
 
         /* try to find a free urb in the list */
         urb = NULL;
@@ -1538,14 +1482,14 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
                 if (!mos7840_port->busy[i]) {
                         mos7840_port->busy[i] = 1;
                         urb = mos7840_port->write_urb_pool[i];
-                        dbg("URB:%d", i);
+                        dev_dbg(&port->dev, "URB:%d\n", i);
                         break;
                 }
         }
         spin_unlock_irqrestore(&mos7840_port->pool_lock, flags);
 
         if (urb == NULL) {
-                dbg("%s - no more free urbs", __func__);
+                dev_dbg(&port->dev, "%s - no more free urbs\n", __func__);
                 goto exit;
         }
 
@@ -1585,7 +1529,7 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
         }
 
         data1 = urb->transfer_buffer;
-        dbg("bulkout endpoint is %d", port->bulk_out_endpointAddress);
+        dev_dbg(&port->dev, "bulkout endpoint is %d\n", port->bulk_out_endpointAddress);
 
         /* Turn on LED */
         if (mos7840_port->has_led && !mos7840_port->led_flag) {
@@ -1608,7 +1552,7 @@ static int mos7840_write(struct tty_struct *tty, struct usb_serial_port *port,
         bytes_sent = transfer_size;
         mos7840_port->icount.tx += transfer_size;
         smp_wmb();
-        dbg("mos7840_port->icount.tx is %d:", mos7840_port->icount.tx);
+        dev_dbg(&port->dev, "mos7840_port->icount.tx is %d:\n", mos7840_port->icount.tx);
 exit:
         return bytes_sent;
 
@@ -1626,12 +1570,8 @@ static void mos7840_throttle(struct tty_struct *tty)
         struct moschip_port *mos7840_port;
         int status;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
-
-        dbg("- port %d", port->number);
 
         mos7840_port = mos7840_get_port_private(port);
 
@@ -1639,7 +1579,7 @@ static void mos7840_throttle(struct tty_struct *tty)
                 return;
 
         if (!mos7840_port->open) {
-                dbg("%s", "port not opened");
+                dev_dbg(&port->dev, "%s", "port not opened\n");
                 return;
         }
 
@@ -1672,16 +1612,14 @@ static void mos7840_unthrottle(struct tty_struct *tty)
         int status;
         struct moschip_port *mos7840_port = mos7840_get_port_private(port);
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
         if (mos7840_port == NULL)
                 return;
 
         if (!mos7840_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -1726,7 +1664,7 @@ static int mos7840_tiocmget(struct tty_struct *tty)
             | ((msr & MOS7840_MSR_RI) ? TIOCM_RI : 0)
             | ((msr & MOS7840_MSR_DSR) ? TIOCM_DSR : 0);
 
-        dbg("%s - 0x%04X", __func__, result);
+        dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
 
         return result;
 }
@@ -1764,7 +1702,7 @@ static int mos7840_tiocmset(struct tty_struct *tty,
 
         status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER, mcr);
         if (status < 0) {
-                dbg("setting MODEM_CONTROL_REGISTER Failed");
+                dev_dbg(&port->dev, "setting MODEM_CONTROL_REGISTER Failed\n");
                 return status;
         }
 
@@ -1776,10 +1714,11 @@ static int mos7840_tiocmset(struct tty_struct *tty,
  *      this function calculates the proper baud rate divisor for the specified
  *      baud rate.
  *****************************************************************************/
-static int mos7840_calc_baud_rate_divisor(int baudRate, int *divisor,
+static int mos7840_calc_baud_rate_divisor(struct usb_serial_port *port,
+                                          int baudRate, int *divisor,
                                           __u16 *clk_sel_val)
 {
-        dbg("%s - %d", __func__, baudRate);
+        dev_dbg(&port->dev, "%s - %d\n", __func__, baudRate);
 
         if (baudRate <= 115200) {
                 *divisor = 115200 / baudRate;
@@ -1832,11 +1771,11 @@ static int mos7840_calc_baud_rate_divisor(int baudRate, int *divisor,
                         custom++;
                 *divisor = custom;
 
-                dbg(" Baud %d = %d", baudrate, custom);
+                dev_dbg(&port->dev, " Baud %d = %d\n", baudrate, custom);
                 return 0;
         }
 
-        dbg("%s", " Baud calculation Failed...");
+        dev_dbg(&port->dev, "%s", " Baud calculation Failed...\n");
         return -1;
 #endif
 }
@@ -1860,21 +1799,17 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
         if (mos7840_port == NULL)
                 return -1;
 
-        port = (struct usb_serial_port *)mos7840_port->port;
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        port = mos7840_port->port;
+        if (mos7840_port_paranoia_check(port, __func__))
                 return -1;
-        }
 
-        if (mos7840_serial_paranoia_check(port->serial, __func__)) {
-                dbg("%s", "Invalid Serial");
+        if (mos7840_serial_paranoia_check(port->serial, __func__))
                 return -1;
-        }
 
         number = mos7840_port->port->number - mos7840_port->port->serial->minor;
 
-        dbg("%s - port = %d, baud = %d", __func__,
-            mos7840_port->port->number, baudRate);
+        dev_dbg(&port->dev, "%s - port = %d, baud = %d\n", __func__,
+                mos7840_port->port->number, baudRate);
         /* reset clk_uart_sel in spregOffset */
         if (baudRate > 115200) {
 #ifdef HW_flow_control
@@ -1885,7 +1820,7 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
                                                                         Data);
                 if (status < 0) {
-                        dbg("Writing spreg failed in set_serial_baud");
+                        dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
                         return -1;
                 }
 #endif
@@ -1898,7 +1833,7 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
                 status = mos7840_set_uart_reg(port, MODEM_CONTROL_REGISTER,
                                                                         Data);
                 if (status < 0) {
-                        dbg("Writing spreg failed in set_serial_baud");
+                        dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
                         return -1;
                 }
 #endif
@@ -1908,19 +1843,19 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
         if (1) {                /* baudRate <= 115200) */
                 clk_sel_val = 0x0;
                 Data = 0x0;
-                status = mos7840_calc_baud_rate_divisor(baudRate, &divisor,
+                status = mos7840_calc_baud_rate_divisor(port, baudRate, &divisor,
                                                    &clk_sel_val);
                 status = mos7840_get_reg_sync(port, mos7840_port->SpRegOffset,
                                                                  &Data);
                 if (status < 0) {
-                        dbg("reading spreg failed in set_serial_baud");
+                        dev_dbg(&port->dev, "reading spreg failed in set_serial_baud\n");
                         return -1;
                 }
                 Data = (Data & 0x8f) | clk_sel_val;
                 status = mos7840_set_reg_sync(port, mos7840_port->SpRegOffset,
                                                                 Data);
                 if (status < 0) {
-                        dbg("Writing spreg failed in set_serial_baud");
+                        dev_dbg(&port->dev, "Writing spreg failed in set_serial_baud\n");
                         return -1;
                 }
                 /* Calculate the Divisor */
@@ -1936,11 +1871,11 @@ static int mos7840_send_cmd_write_baud_rate(struct moschip_port *mos7840_port,
 
                 /* Write the divisor */
                 Data = (unsigned char)(divisor & 0xff);
-                dbg("set_serial_baud Value to write DLL is %x", Data);
+                dev_dbg(&port->dev, "set_serial_baud Value to write DLL is %x\n", Data);
                 mos7840_set_uart_reg(port, DIVISOR_LATCH_LSB, Data);
 
                 Data = (unsigned char)((divisor & 0xff00) >> 8);
-                dbg("set_serial_baud Value to write DLM is %x", Data);
+                dev_dbg(&port->dev, "set_serial_baud Value to write DLM is %x\n", Data);
                 mos7840_set_uart_reg(port, DIVISOR_LATCH_MSB, Data);
 
                 /* Disable access to divisor latch */
@@ -1975,24 +1910,18 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
         if (mos7840_port == NULL)
                 return;
 
-        port = (struct usb_serial_port *)mos7840_port->port;
+        port = mos7840_port->port;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
-        if (mos7840_serial_paranoia_check(port->serial, __func__)) {
-                dbg("%s", "Invalid Serial");
+        if (mos7840_serial_paranoia_check(port->serial, __func__))
                 return;
-        }
 
         serial = port->serial;
 
-        dbg("%s - port %d", __func__, mos7840_port->port->number);
-
         if (!mos7840_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
@@ -2027,14 +1956,14 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
         if (cflag & PARENB) {
                 if (cflag & PARODD) {
                         lParity = LCR_PAR_ODD;
-                        dbg("%s - parity = odd", __func__);
+                        dev_dbg(&port->dev, "%s - parity = odd\n", __func__);
                 } else {
                         lParity = LCR_PAR_EVEN;
-                        dbg("%s - parity = even", __func__);
+                        dev_dbg(&port->dev, "%s - parity = even\n", __func__);
                 }
 
         } else {
-                dbg("%s - parity = none", __func__);
+                dev_dbg(&port->dev, "%s - parity = none\n", __func__);
         }
 
         if (cflag & CMSPAR)
@@ -2043,10 +1972,10 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
         /* Change the Stop bit */
         if (cflag & CSTOPB) {
                 lStop = LCR_STOP_2;
-                dbg("%s - stop bits = 2", __func__);
+                dev_dbg(&port->dev, "%s - stop bits = 2\n", __func__);
         } else {
                 lStop = LCR_STOP_1;
-                dbg("%s - stop bits = 1", __func__);
+                dev_dbg(&port->dev, "%s - stop bits = 1\n", __func__);
         }
 
         /* Update the LCR with the correct value */
@@ -2054,8 +1983,8 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
             ~(LCR_BITS_MASK | LCR_STOP_MASK | LCR_PAR_MASK);
         mos7840_port->shadowLCR |= (lData | lParity | lStop);
 
-        dbg("mos7840_change_port_settings mos7840_port->shadowLCR is %x",
-            mos7840_port->shadowLCR);
+        dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is %x\n", __func__,
+                mos7840_port->shadowLCR);
         /* Disable Interrupts */
         Data = 0x00;
         mos7840_set_uart_reg(port, INTERRUPT_ENABLE_REGISTER, Data);
@@ -2096,11 +2025,11 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
 
         if (!baud) {
                 /* pick a default, any default... */
-                dbg("%s", "Picked default baud...");
+                dev_dbg(&port->dev, "%s", "Picked default baud...\n");
                 baud = 9600;
         }
 
-        dbg("%s - baud rate = %d", __func__, baud);
+        dev_dbg(&port->dev, "%s - baud rate = %d\n", __func__, baud);
         status = mos7840_send_cmd_write_baud_rate(mos7840_port, baud);
 
         /* Enable Interrupts */
@@ -2111,15 +2040,15 @@ static void mos7840_change_port_settings(struct tty_struct *tty,
                 mos7840_port->read_urb_busy = true;
                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
                 if (status) {
-                        dbg("usb_submit_urb(read bulk) failed, status = %d",
+                        dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
                             status);
                         mos7840_port->read_urb_busy = false;
                 }
         }
         wake_up(&mos7840_port->delta_msr_wait);
         mos7840_port->delta_msr_cond = 1;
-        dbg("mos7840_change_port_settings mos7840_port->shadowLCR is End %x",
-            mos7840_port->shadowLCR);
+        dev_dbg(&port->dev, "%s - mos7840_port->shadowLCR is End %x\n", __func__,
+                mos7840_port->shadowLCR);
 }
 
 /*****************************************************************************
@@ -2137,17 +2066,13 @@ static void mos7840_set_termios(struct tty_struct *tty,
         struct usb_serial *serial;
         struct moschip_port *mos7840_port;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return;
-        }
 
         serial = port->serial;
 
-        if (mos7840_serial_paranoia_check(serial, __func__)) {
-                dbg("%s", "Invalid Serial");
+        if (mos7840_serial_paranoia_check(serial, __func__))
                 return;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
 
@@ -2155,26 +2080,26 @@ static void mos7840_set_termios(struct tty_struct *tty,
                 return;
 
         if (!mos7840_port->open) {
-                dbg("%s - port not opened", __func__);
+                dev_dbg(&port->dev, "%s - port not opened\n", __func__);
                 return;
         }
 
-        dbg("%s", "setting termios - ");
+        dev_dbg(&port->dev, "%s", "setting termios - \n");
 
         cflag = tty->termios.c_cflag;
 
-        dbg("%s - clfag %08x iflag %08x", __func__,
-            tty->termios.c_cflag, RELEVANT_IFLAG(tty->termios.c_iflag));
-        dbg("%s - old clfag %08x old iflag %08x", __func__,
-            old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(&port->dev, "%s - clfag %08x iflag %08x\n", __func__,
+                tty->termios.c_cflag, RELEVANT_IFLAG(tty->termios.c_iflag));
+        dev_dbg(&port->dev, "%s - old clfag %08x old iflag %08x\n", __func__,
+                old_termios->c_cflag, RELEVANT_IFLAG(old_termios->c_iflag));
+        dev_dbg(&port->dev, "%s - port %d\n", __func__, port->number);
 
         /* change the port settings to the new ones specified */
 
         mos7840_change_port_settings(tty, mos7840_port, old_termios);
 
         if (!mos7840_port->read_urb) {
-                dbg("%s", "URB KILLED !!!!!");
+                dev_dbg(&port->dev, "%s", "URB KILLED !!!!!\n");
                 return;
         }
 
@@ -2182,7 +2107,7 @@ static void mos7840_set_termios(struct tty_struct *tty,
                 mos7840_port->read_urb_busy = true;
                 status = usb_submit_urb(mos7840_port->read_urb, GFP_ATOMIC);
                 if (status) {
-                        dbg("usb_submit_urb(read bulk) failed, status = %d",
+                        dev_dbg(&port->dev, "usb_submit_urb(read bulk) failed, status = %d\n",
                             status);
                         mos7840_port->read_urb_busy = false;
                 }
@@ -2207,10 +2132,8 @@ static int mos7840_get_lsr_info(struct tty_struct *tty,
         unsigned int result = 0;
 
         count = mos7840_chars_in_buffer(tty);
-        if (count == 0) {
-                dbg("%s -- Empty", __func__);
+        if (count == 0)
                 result = TIOCSER_TEMT;
-        }
 
         if (copy_to_user(value, &result, sizeof(int)))
                 return -EFAULT;
@@ -2273,8 +2196,8 @@ static int mos7840_get_icount(struct tty_struct *tty,
         icount->brk = cnow.brk;
         icount->buf_overrun = cnow.buf_overrun;
 
-        dbg("%s (%d) TIOCGICOUNT RX=%d, TX=%d", __func__,
-                port->number, icount->rx, icount->tx);
+        dev_dbg(&port->dev, "%s TIOCGICOUNT RX=%d, TX=%d\n", __func__,
+                icount->rx, icount->tx);
         return 0;
 }
 
@@ -2293,35 +2216,33 @@ static int mos7840_ioctl(struct tty_struct *tty,
         struct async_icount cnow;
         struct async_icount cprev;
 
-        if (mos7840_port_paranoia_check(port, __func__)) {
-                dbg("%s", "Invalid port");
+        if (mos7840_port_paranoia_check(port, __func__))
                 return -1;
-        }
 
         mos7840_port = mos7840_get_port_private(port);
 
         if (mos7840_port == NULL)
                 return -1;
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - cmd = 0x%x\n", __func__, cmd);
 
         switch (cmd) {
                 /* return number of bytes available */
 
         case TIOCSERGETLSR:
-                dbg("%s (%d) TIOCSERGETLSR", __func__, port->number);
+                dev_dbg(&port->dev, "%s TIOCSERGETLSR\n", __func__);
                 return mos7840_get_lsr_info(tty, argp);
 
         case TIOCGSERIAL:
-                dbg("%s (%d) TIOCGSERIAL", __func__, port->number);
+                dev_dbg(&port->dev, "%s TIOCGSERIAL\n", __func__);
                 return mos7840_get_serial_info(mos7840_port, argp);
 
         case TIOCSSERIAL:
-                dbg("%s (%d) TIOCSSERIAL", __func__, port->number);
+                dev_dbg(&port->dev, "%s TIOCSSERIAL\n", __func__);
                 break;
 
         case TIOCMIWAIT:
-                dbg("%s (%d) TIOCMIWAIT", __func__, port->number);
+                dev_dbg(&port->dev, "%s  TIOCMIWAIT\n", __func__);
                 cprev = mos7840_port->icount;
                 while (1) {
                         /* interruptible_sleep_on(&mos7840_port->delta_msr_wait); */
@@ -2437,11 +2358,6 @@ static int mos7840_startup(struct usb_serial *serial)
         int i, status;
         __u16 Data;
 
-        if (!serial) {
-                dbg("%s", "Invalid Handler");
-                return -1;
-        }
-
         dev = serial->dev;
 
         /* we set up the pointers to the endpoints in the mos7840_open *
@@ -2449,7 +2365,7 @@ static int mos7840_startup(struct usb_serial *serial)
 
         /* set up port private structures */
         for (i = 0; i < serial->num_ports; ++i) {
-                dbg ("mos7840_startup: configuring port %d............", i);
+                dev_dbg(&dev->dev, "mos7840_startup: configuring port %d............\n", i);
                 mos7840_port = kzalloc(sizeof(struct moschip_port), GFP_KERNEL);
                 if (mos7840_port == NULL) {
                         dev_err(&dev->dev, "%s - Out of memory\n", __func__);
@@ -2470,10 +2386,10 @@ static int mos7840_startup(struct usb_serial *serial)
                  * usb-serial.c:get_free_serial() and cannot therefore be used
                  * to index device instances */
                 mos7840_port->port_num = i + 1;
-                dbg ("serial->port[i]->number = %d", serial->port[i]->number);
-                dbg ("serial->port[i]->serial->minor = %d", serial->port[i]->serial->minor);
-                dbg ("mos7840_port->port_num = %d", mos7840_port->port_num);
-                dbg ("serial->minor = %d", serial->minor);
+                dev_dbg(&dev->dev, "serial->port[i]->number = %d\n", serial->port[i]->number);
+                dev_dbg(&dev->dev, "serial->port[i]->serial->minor = %d\n", serial->port[i]->serial->minor);
+                dev_dbg(&dev->dev, "mos7840_port->port_num = %d\n", mos7840_port->port_num);
+                dev_dbg(&dev->dev, "serial->minor = %d\n", serial->minor);
 
                 if (mos7840_port->port_num == 1) {
                         mos7840_port->SpRegOffset = 0x0;
@@ -2500,18 +2416,17 @@ static int mos7840_startup(struct usb_serial *serial)
                         mos7840_port->ControlRegOffset = 0xd;
                         mos7840_port->DcrRegOffset = 0x1c;
                 }
-                mos7840_dump_serial_port(mos7840_port);
+                mos7840_dump_serial_port(serial->port[i], mos7840_port);
                 mos7840_set_port_private(serial->port[i], mos7840_port);
 
                 /* enable rx_disable bit in control register */
                 status = mos7840_get_reg_sync(serial->port[i],
                                  mos7840_port->ControlRegOffset, &Data);
                 if (status < 0) {
-                        dbg("Reading ControlReg failed status-0x%x", status);
+                        dev_dbg(&dev->dev, "Reading ControlReg failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("ControlReg Reading success val is %x, status%d",
-                            Data, status);
+                        dev_dbg(&dev->dev, "ControlReg Reading success val is %x, status%d\n", Data, status);
                 Data |= 0x08;   /* setting driver done bit */
                 Data |= 0x04;   /* sp1_bit to have cts change reflect in
                                    modem status reg */
@@ -2520,11 +2435,10 @@ static int mos7840_startup(struct usb_serial *serial)
                 status = mos7840_set_reg_sync(serial->port[i],
                                          mos7840_port->ControlRegOffset, Data);
                 if (status < 0) {
-                        dbg("Writing ControlReg failed(rx_disable) status-0x%x", status);
+                        dev_dbg(&dev->dev, "Writing ControlReg failed(rx_disable) status-0x%x\n", status);
                         break;
                 } else
-                        dbg("ControlReg Writing success(rx_disable) status%d",
-                            status);
+                        dev_dbg(&dev->dev, "ControlReg Writing success(rx_disable) status%d\n", status);
 
                 /* Write default values in DCR (i.e 0x01 in DCR0, 0x05 in DCR2
                    and 0x24 in DCR3 */
@@ -2532,61 +2446,57 @@ static int mos7840_startup(struct usb_serial *serial)
                 status = mos7840_set_reg_sync(serial->port[i],
                          (__u16) (mos7840_port->DcrRegOffset + 0), Data);
                 if (status < 0) {
-                        dbg("Writing DCR0 failed status-0x%x", status);
+                        dev_dbg(&dev->dev, "Writing DCR0 failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("DCR0 Writing success status%d", status);
+                        dev_dbg(&dev->dev, "DCR0 Writing success status%d\n", status);
 
                 Data = 0x05;
                 status = mos7840_set_reg_sync(serial->port[i],
                          (__u16) (mos7840_port->DcrRegOffset + 1), Data);
                 if (status < 0) {
-                        dbg("Writing DCR1 failed status-0x%x", status);
+                        dev_dbg(&dev->dev, "Writing DCR1 failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("DCR1 Writing success status%d", status);
+                        dev_dbg(&dev->dev, "DCR1 Writing success status%d\n", status);
 
                 Data = 0x24;
                 status = mos7840_set_reg_sync(serial->port[i],
                          (__u16) (mos7840_port->DcrRegOffset + 2), Data);
                 if (status < 0) {
-                        dbg("Writing DCR2 failed status-0x%x", status);
+                        dev_dbg(&dev->dev, "Writing DCR2 failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("DCR2 Writing success status%d", status);
+                        dev_dbg(&dev->dev, "DCR2 Writing success status%d\n", status);
 
                 /* write values in clkstart0x0 and clkmulti 0x20 */
                 Data = 0x0;
                 status = mos7840_set_reg_sync(serial->port[i],
                                          CLK_START_VALUE_REGISTER, Data);
                 if (status < 0) {
-                        dbg("Writing CLK_START_VALUE_REGISTER failed status-0x%x", status);
+                        dev_dbg(&dev->dev, "Writing CLK_START_VALUE_REGISTER failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("CLK_START_VALUE_REGISTER Writing success status%d", status);
+                        dev_dbg(&dev->dev, "CLK_START_VALUE_REGISTER Writing success status%d\n", status);
 
                 Data = 0x20;
                 status = mos7840_set_reg_sync(serial->port[i],
                                         CLK_MULTI_REGISTER, Data);
                 if (status < 0) {
-                        dbg("Writing CLK_MULTI_REGISTER failed status-0x%x",
-                            status);
+                        dev_dbg(&dev->dev, "Writing CLK_MULTI_REGISTER failed status-0x%x\n", status);
                         goto error;
                 } else
-                        dbg("CLK_MULTI_REGISTER Writing success status%d",
-                            status);
+                        dev_dbg(&dev->dev, "CLK_MULTI_REGISTER Writing success status%d\n", status);
 
                 /* write value 0x0 to scratchpad register */
                 Data = 0x00;
                 status = mos7840_set_uart_reg(serial->port[i],
                                                 SCRATCH_PAD_REGISTER, Data);
                 if (status < 0) {
-                        dbg("Writing SCRATCH_PAD_REGISTER failed status-0x%x",
-                            status);
+                        dev_dbg(&dev->dev, "Writing SCRATCH_PAD_REGISTER failed status-0x%x\n", status);
                         break;
                 } else
-                        dbg("SCRATCH_PAD_REGISTER Writing success status%d",
-                            status);
+                        dev_dbg(&dev->dev, "SCRATCH_PAD_REGISTER Writing success status%d\n", status);
 
                 /* Zero Length flag register */
                 if ((mos7840_port->port_num != 1)
@@ -2596,31 +2506,25 @@ static int mos7840_startup(struct usb_serial *serial)
                         status = mos7840_set_reg_sync(serial->port[i],
                                       (__u16) (ZLP_REG1 +
                                       ((__u16)mos7840_port->port_num)), Data);
-                        dbg("ZLIP offset %x",
-                            (__u16) (ZLP_REG1 +
-                                        ((__u16) mos7840_port->port_num)));
+                        dev_dbg(&dev->dev, "ZLIP offset %x\n",
+                                (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num)));
                         if (status < 0) {
-                                dbg("Writing ZLP_REG%d failed status-0x%x",
-                                    i + 2, status);
+                                dev_dbg(&dev->dev, "Writing ZLP_REG%d failed status-0x%x\n", i + 2, status);
                                 break;
                         } else
-                                dbg("ZLP_REG%d Writing success status%d",
-                                    i + 2, status);
+                                dev_dbg(&dev->dev, "ZLP_REG%d Writing success status%d\n", i + 2, status);
                 } else {
                         Data = 0xff;
                         status = mos7840_set_reg_sync(serial->port[i],
                               (__u16) (ZLP_REG1 +
                               ((__u16)mos7840_port->port_num) - 0x1), Data);
-                        dbg("ZLIP offset %x",
-                            (__u16) (ZLP_REG1 +
-                                     ((__u16) mos7840_port->port_num) - 0x1));
+                        dev_dbg(&dev->dev, "ZLIP offset %x\n",
+                                (__u16)(ZLP_REG1 + ((__u16) mos7840_port->port_num) - 0x1));
                         if (status < 0) {
-                                dbg("Writing ZLP_REG%d failed status-0x%x",
-                                    i + 1, status);
+                                dev_dbg(&dev->dev, "Writing ZLP_REG%d failed status-0x%x\n", i + 1, status);
                                 break;
                         } else
-                                dbg("ZLP_REG%d Writing success status%d",
-                                    i + 1, status);
+                                dev_dbg(&dev->dev, "ZLP_REG%d Writing success status%d\n", i + 1, status);
 
                 }
                 mos7840_port->control_urb = usb_alloc_urb(0, GFP_KERNEL);
@@ -2661,16 +2565,15 @@ static int mos7840_startup(struct usb_serial *serial)
                                                 MODEM_CONTROL_REGISTER, 0x0300);
                 }
         }
-        dbg ("mos7840_startup: all ports configured...........");
 
         /* Zero Length flag enable */
         Data = 0x0f;
         status = mos7840_set_reg_sync(serial->port[0], ZLP_REG5, Data);
         if (status < 0) {
-                dbg("Writing ZLP_REG5 failed status-0x%x", status);
+                dev_dbg(&dev->dev, "Writing ZLP_REG5 failed status-0x%x\n", status);
                 goto error;
         } else
-                dbg("ZLP_REG5 Writing success status%d", status);
+                dev_dbg(&dev->dev, "ZLP_REG5 Writing success status%d\n", status);
 
         /* setting configuration feature to one */
         usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
@@ -2700,11 +2603,6 @@ static void mos7840_disconnect(struct usb_serial *serial)
         unsigned long flags;
         struct moschip_port *mos7840_port;
 
-        if (!serial) {
-                dbg("%s", "Invalid Handler");
-                return;
-        }
-
         /* check for the ports to be closed,close the ports and disconnect */
 
         /* free private structure allocated for serial port  *
@@ -2712,7 +2610,6 @@ static void mos7840_disconnect(struct usb_serial *serial)
 
         for (i = 0; i < serial->num_ports; ++i) {
                 mos7840_port = mos7840_get_port_private(serial->port[i]);
-                dbg ("mos7840_port %d = %p", i, mos7840_port);
                 if (mos7840_port) {
                         spin_lock_irqsave(&mos7840_port->pool_lock, flags);
                         mos7840_port->zombie = 1;
@@ -2732,11 +2629,6 @@ static void mos7840_release(struct usb_serial *serial)
         int i;
         struct moschip_port *mos7840_port;
 
-        if (!serial) {
-                dbg("%s", "Invalid Handler");
-                return;
-        }
-
         /* check for the ports to be closed,close the ports and disconnect */
 
         /* free private structure allocated for serial port  *
@@ -2744,7 +2636,6 @@ static void mos7840_release(struct usb_serial *serial)
 
         for (i = 0; i < serial->num_ports; ++i) {
                 mos7840_port = mos7840_get_port_private(serial->port[i]);
-                dbg("mos7840_port %d = %p", i, mos7840_port);
                 if (mos7840_port) {
                         if (mos7840_port->has_led) {
                                 /* Turn off LED */
@@ -2801,6 +2692,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/navman.c b/drivers/usb/serial/navman.c
index d95452cc076d..1566f8f500ae 100644
--- a/drivers/usb/serial/navman.c
+++ b/drivers/usb/serial/navman.c
@@ -21,8 +21,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x0a99, 0x0001) }, /* Talon Technology device */
         { USB_DEVICE(0x0df7, 0x0900) }, /* Mobile Action i-gotU */
@@ -55,8 +53,7 @@ static void navman_read_int_callback(struct urb *urb)
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                              urb->actual_length, data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         tty = tty_port_tty_get(&port->port);
         if (tty && urb->actual_length) {
@@ -123,6 +120,3 @@ static struct usb_serial_driver * const serial_drivers[] = {
 module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/omninet.c b/drivers/usb/serial/omninet.c
index 6f3d7051c7f4..6def58b79382 100644
--- a/drivers/usb/serial/omninet.c
+++ b/drivers/usb/serial/omninet.c
@@ -23,8 +23,6 @@
 #include <linux/usb.h>
 #include <linux/usb/serial.h>
 
-static bool debug;
-
 /*
  * Version Information
  */
@@ -164,31 +162,21 @@ static void omninet_read_bulk_callback(struct urb *urb)
         struct omninet_header   *header = (struct omninet_header *) &data[0];
         int status = urb->status;
         int result;
-        int i;
 
         if (status) {
-                dbg("%s - nonzero read bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&port->dev, "%s - nonzero read bulk status received: %d\n",
+                        __func__, status);
                 return;
         }
 
-        if (debug && header->oh_xxx != 0x30) {
-                if (urb->actual_length) {
-                        printk(KERN_DEBUG "%s: omninet_read %d: ",
-                               __FILE__, header->oh_len);
-                        for (i = 0; i < (header->oh_len +
-                                                OMNINET_HEADERLEN); i++)
-                                printk("%.2x ", data[i]);
-                        printk("\n");
-                }
-        }
-
         if (urb->actual_length && header->oh_len) {
                 struct tty_struct *tty = tty_port_tty_get(&port->port);
-                tty_insert_flip_string(tty, data + OMNINET_DATAOFFSET,
+                if (tty) {
+                        tty_insert_flip_string(tty, data + OMNINET_DATAOFFSET,
                                                         header->oh_len);
-                tty_flip_buffer_push(tty);
-                tty_kref_put(tty);
+                        tty_flip_buffer_push(tty);
+                        tty_kref_put(tty);
+                }
         }
 
         /* Continue trying to always read  */
@@ -212,12 +200,12 @@ static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
         int                     result;
 
         if (count == 0) {
-                dbg("%s - write request of 0 bytes", __func__);
+                dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
                 return 0;
         }
 
         if (!test_and_clear_bit(0, &port->write_urbs_free)) {
-                dbg("%s - already writing", __func__);
+                dev_dbg(&port->dev, "%s - already writing\n", __func__);
                 return 0;
         }
 
@@ -226,8 +214,8 @@ static int omninet_write(struct tty_struct *tty, struct usb_serial_port *port,
         memcpy(wport->write_urb->transfer_buffer + OMNINET_DATAOFFSET,
                                                                 buf, count);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                        wport->write_urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, count,
+                              wport->write_urb->transfer_buffer);
 
         header->oh_seq  = od->od_outseq++;
         header->oh_len  = count;
@@ -261,7 +249,7 @@ static int omninet_write_room(struct tty_struct *tty)
         if (test_bit(0, &wport->write_urbs_free))
                 room = wport->bulk_out_size - OMNINET_HEADERLEN;
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
 
         return room;
 }
@@ -275,8 +263,8 @@ static void omninet_write_bulk_callback(struct urb *urb)
 
         set_bit(0, &port->write_urbs_free);
         if (status) {
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&port->dev, "%s - nonzero write bulk status received: %d\n",
+                        __func__, status);
                 return;
         }
 
@@ -304,6 +292,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/opticon.c b/drivers/usb/serial/opticon.c
index 02cb1b7f6559..41b1647306eb 100644
--- a/drivers/usb/serial/opticon.c
+++ b/drivers/usb/serial/opticon.c
@@ -32,8 +32,6 @@
  * an examples of 1D barcode types are EAN, UPC, Code39, IATA etc.. */
 #define DRIVER_DESC     "Opticon USB barcode to serial driver (1D)"
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x065a, 0x0009) },
         { },
@@ -78,17 +76,16 @@ static void opticon_read_bulk_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s - urb shutting down with status: %d",
-                    __func__, status);
+                dev_dbg(&priv->udev->dev, "%s - urb shutting down with status: %d\n",
+                        __func__, status);
                 return;
         default:
-                dbg("%s - nonzero urb status received: %d",
-                    __func__, status);
+                dev_dbg(&priv->udev->dev, "%s - nonzero urb status received: %d\n",
+                        __func__, status);
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
-                              data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         if (urb->actual_length > 2) {
                 data_length = urb->actual_length - 2;
@@ -229,8 +226,8 @@ static void opticon_write_control_callback(struct urb *urb)
         kfree(urb->setup_packet);
 
         if (status)
-                dbg("%s - nonzero write bulk status received: %d",
-                    __func__, status);
+                dev_dbg(&priv->udev->dev, "%s - nonzero write bulk status received: %d\n",
+                        __func__, status);
 
         spin_lock_irqsave(&priv->lock, flags);
         --priv->outstanding_urbs;
@@ -253,7 +250,7 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit", __func__);
+                dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
                 return 0;
         }
         priv->outstanding_urbs++;
@@ -276,7 +273,7 @@ static int opticon_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         memcpy(buffer, buf, count);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count, buffer);
+        usb_serial_debug_data(&port->dev, __func__, count, buffer);
 
         /* The conncected devices do not have a bulk write endpoint,
          * to transmit data to de barcode device the control endpoint is used */
@@ -338,7 +335,7 @@ static int opticon_write_room(struct tty_struct *tty)
         spin_lock_irqsave(&priv->lock, flags);
         if (priv->outstanding_urbs > URB_UPPER_LIMIT * 2 / 3) {
                 spin_unlock_irqrestore(&priv->lock, flags);
-                dbg("%s - write limit hit", __func__);
+                dev_dbg(&port->dev, "%s - write limit hit\n", __func__);
                 return 0;
         }
         spin_unlock_irqrestore(&priv->lock, flags);
@@ -394,7 +391,7 @@ static int opticon_tiocmget(struct tty_struct *tty)
                 result |= TIOCM_CTS;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s - %x", __func__, result);
+        dev_dbg(&port->dev, "%s - %x\n", __func__, result);
         return result;
 }
 
@@ -466,7 +463,7 @@ static int opticon_ioctl(struct tty_struct *tty,
         struct usb_serial_port *port = tty->driver_data;
         struct opticon_private *priv = usb_get_serial_data(port->serial);
 
-        dbg("%s - port %d, cmd = 0x%x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - port %d, cmd = 0x%x\n", __func__, port->number, cmd);
 
         switch (cmd) {
         case TIOCGSERIAL:
@@ -612,6 +609,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 5ce88d1bc6f1..30cff03e9f01 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -870,7 +870,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0153, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0155, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0156, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0157, 0xff, 0xff, 0xff) },
+        { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0157, 0xff, 0xff, 0xff),
+          .driver_info = (kernel_ulong_t)&net_intf5_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0158, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0159, 0xff, 0xff, 0xff) },
         { USB_DEVICE_AND_INTERFACE_INFO(ZTE_VENDOR_ID, 0x0161, 0xff, 0xff, 0xff) },
@@ -1257,8 +1258,6 @@ static struct usb_serial_driver * const serial_drivers[] = {
         &option_1port_device, NULL
 };
 
-static bool debug;
-
 struct option_private {
         u8 bInterfaceNumber;
 };
@@ -1369,18 +1368,19 @@ static void option_instat_callback(struct urb *urb)
 {
         int err;
         int status = urb->status;
-        struct usb_serial_port *port =  urb->context;
+        struct usb_serial_port *port = urb->context;
+        struct device *dev = &port->dev;
         struct usb_wwan_port_private *portdata =
                                         usb_get_serial_port_data(port);
 
-        dbg("%s: urb %p port %p has data %p", __func__, urb, port, portdata);
+        dev_dbg(dev, "%s: urb %p port %p has data %p\n", __func__, urb, port, portdata);
 
         if (status == 0) {
                 struct usb_ctrlrequest *req_pkt =
                                 (struct usb_ctrlrequest *)urb->transfer_buffer;
 
                 if (!req_pkt) {
-                        dbg("%s: NULL req_pkt", __func__);
+                        dev_dbg(dev, "%s: NULL req_pkt\n", __func__);
                         return;
                 }
                 if ((req_pkt->bRequestType == 0xA1) &&
@@ -1390,7 +1390,7 @@ static void option_instat_callback(struct urb *urb)
                                         urb->transfer_buffer +
                                         sizeof(struct usb_ctrlrequest));
 
-                        dbg("%s: signal x%x", __func__, signals);
+                        dev_dbg(dev, "%s: signal x%x\n", __func__, signals);
 
                         old_dcd_state = portdata->dcd_state;
                         portdata->cts_state = 1;
@@ -1406,17 +1406,17 @@ static void option_instat_callback(struct urb *urb)
                                 tty_kref_put(tty);
                         }
                 } else {
-                        dbg("%s: type %x req %x", __func__,
+                        dev_dbg(dev, "%s: type %x req %x\n", __func__,
                                 req_pkt->bRequestType, req_pkt->bRequest);
                 }
         } else
-                dev_err(&port->dev, "%s: error %d\n", __func__, status);
+                dev_err(dev, "%s: error %d\n", __func__, status);
 
         /* Resubmit urb so we continue receiving IRQ data */
         if (status != -ESHUTDOWN && status != -ENOENT) {
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err)
-                        dbg("%s: resubmit intr urb failed. (%d)",
+                        dev_dbg(dev, "%s: resubmit intr urb failed. (%d)\n",
                                 __func__, err);
         }
 }
@@ -1450,6 +1450,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug messages");
diff --git a/drivers/usb/serial/oti6858.c b/drivers/usb/serial/oti6858.c
index 9f555560bfbf..933241f03fd8 100644
--- a/drivers/usb/serial/oti6858.c
+++ b/drivers/usb/serial/oti6858.c
@@ -66,8 +66,6 @@ static const struct usb_device_id id_table[] = {
 
 MODULE_DEVICE_TABLE(usb, id_table);
 
-static bool debug;
-
 /* requests */
 #define OTI6858_REQ_GET_STATUS          (USB_DIR_IN | USB_TYPE_VENDOR | 0x00)
 #define OTI6858_REQ_T_GET_STATUS        0x01
@@ -256,11 +254,11 @@ static void setup_line(struct work_struct *work)
         priv->setup_done = 1;
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        dbg("%s(): submitting interrupt urb", __func__);
+        dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
         if (result != 0) {
-                dev_err(&port->dev, "%s(): usb_submit_urb() failed"
-                                " with error %d\n", __func__, result);
+                dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
+                        __func__, result);
         }
 }
 
@@ -310,11 +308,11 @@ static void send_data(struct work_struct *work)
         if (count == 0) {
                 priv->flags.write_urb_in_use = 0;
 
-                dbg("%s(): submitting interrupt urb", __func__);
+                dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
                 result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
                 if (result != 0) {
-                        dev_err(&port->dev, "%s(): usb_submit_urb() failed"
-                                " with error %d\n", __func__, result);
+                        dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
+                                __func__, result);
                 }
                 return;
         }
@@ -325,8 +323,8 @@ static void send_data(struct work_struct *work)
         port->write_urb->transfer_buffer_length = count;
         result = usb_submit_urb(port->write_urb, GFP_NOIO);
         if (result != 0) {
-                dev_err_console(port, "%s(): usb_submit_urb() failed"
-                               " with error %d\n", __func__, result);
+                dev_err_console(port, "%s(): usb_submit_urb() failed with error %d\n",
+                                __func__, result);
                 priv->flags.write_urb_in_use = 0;
         }
 
@@ -420,10 +418,8 @@ static void oti6858_set_termios(struct tty_struct *tty,
         __le16 divisor;
         int br;
 
-        if (!tty) {
-                dbg("%s(): no tty structures", __func__);
+        if (!tty)
                 return;
-        }
 
         cflag = tty->termios.c_cflag;
 
@@ -560,11 +556,11 @@ static int oti6858_open(struct tty_struct *tty, struct usb_serial_port *port)
         spin_unlock_irqrestore(&priv->lock, flags);
         kfree(buf);
 
-        dbg("%s(): submitting interrupt urb", __func__);
+        dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
         if (result != 0) {
-                dev_err(&port->dev, "%s(): usb_submit_urb() failed"
-                               " with error %d\n", __func__, result);
+                dev_err(&port->dev, "%s(): usb_submit_urb() failed with error %d\n",
+                        __func__, result);
                 oti6858_close(port);
                 return result;
         }
@@ -586,14 +582,14 @@ static void oti6858_close(struct usb_serial_port *port)
         kfifo_reset_out(&port->write_fifo);
         spin_unlock_irqrestore(&port->lock, flags);
 
-        dbg("%s(): after buf_clear()", __func__);
+        dev_dbg(&port->dev, "%s(): after buf_clear()\n", __func__);
 
         /* cancel scheduled setup */
         cancel_delayed_work_sync(&priv->delayed_setup_work);
         cancel_delayed_work_sync(&priv->delayed_write_work);
 
         /* shutdown our urbs */
-        dbg("%s(): shutting down urbs", __func__);
+        dev_dbg(&port->dev, "%s(): shutting down urbs\n", __func__);
         usb_kill_urb(port->write_urb);
         usb_kill_urb(port->read_urb);
         usb_kill_urb(port->interrupt_in_urb);
@@ -607,8 +603,8 @@ static int oti6858_tiocmset(struct tty_struct *tty,
         unsigned long flags;
         u8 control;
 
-        dbg("%s(port = %d, set = 0x%08x, clear = 0x%08x)",
-                                __func__, port->number, set, clear);
+        dev_dbg(&port->dev, "%s(set = 0x%08x, clear = 0x%08x)\n",
+                __func__, set, clear);
 
         /* FIXME: check if this is correct (active high/low) */
         spin_lock_irqsave(&priv->lock, flags);
@@ -655,7 +651,7 @@ static int oti6858_tiocmget(struct tty_struct *tty)
         if ((pin_state & PIN_DCD) != 0)
                 result |= TIOCM_CD;
 
-        dbg("%s() = 0x%08x", __func__, result);
+        dev_dbg(&port->dev, "%s() = 0x%08x\n", __func__, result);
 
         return result;
 }
@@ -700,15 +696,14 @@ static int oti6858_ioctl(struct tty_struct *tty,
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s(port = %d, cmd = 0x%04x, arg = 0x%08lx)",
-                                __func__, port->number, cmd, arg);
+        dev_dbg(&port->dev, "%s(cmd = 0x%04x, arg = 0x%08lx)\n", __func__, cmd, arg);
 
         switch (cmd) {
         case TIOCMIWAIT:
-                dbg("%s(): TIOCMIWAIT", __func__);
+                dev_dbg(&port->dev, "%s(): TIOCMIWAIT\n", __func__);
                 return wait_modem_info(port, arg);
         default:
-                dbg("%s(): 0x%04x not supported", __func__, cmd);
+                dev_dbg(&port->dev, "%s(): 0x%04x not supported\n", __func__, cmd);
                 break;
         }
         return -ENOIOCTLCMD;
@@ -738,12 +733,12 @@ static void oti6858_read_int_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s(): urb shutting down with status: %d",
-                                        __func__, status);
+                dev_dbg(&urb->dev->dev, "%s(): urb shutting down with status: %d\n",
+                        __func__, status);
                 return;
         default:
-                dbg("%s(): nonzero urb status received: %d",
-                                        __func__, status);
+                dev_dbg(&urb->dev->dev, "%s(): nonzero urb status received: %d\n",
+                        __func__, status);
                 break;
         }
 
@@ -759,8 +754,7 @@ static void oti6858_read_int_callback(struct urb *urb)
                                         priv->transient = 4;
                                         priv->setup_done = 0;
                                         resubmit = 0;
-                                        dbg("%s(): scheduling setup_line()",
-                                            __func__);
+                                        dev_dbg(&port->dev, "%s(): scheduling setup_line()\n", __func__);
                                         schedule_delayed_work(&priv->delayed_setup_work, 0);
                                 }
                         }
@@ -774,8 +768,7 @@ static void oti6858_read_int_callback(struct urb *urb)
                                         priv->transient = 4;
                                         priv->setup_done = 0;
                                         resubmit = 0;
-                                        dbg("%s(): scheduling setup_line()",
-                                            __func__);
+                                        dev_dbg(&port->dev, "%s(): scheduling setup_line()\n", __func__);
                                         schedule_delayed_work(&priv->delayed_setup_work, 0);
                                 }
                         }
@@ -826,7 +819,7 @@ static void oti6858_read_int_callback(struct urb *urb)
         if (resubmit) {
                 int result;
 
-/*              dbg("%s(): submitting interrupt urb", __func__); */
+/*              dev_dbg(&urb->dev->dev, "%s(): submitting interrupt urb\n", __func__); */
                 result = usb_submit_urb(urb, GFP_ATOMIC);
                 if (result != 0) {
                         dev_err(&urb->dev->dev,
@@ -851,7 +844,7 @@ static void oti6858_read_bulk_callback(struct urb *urb)
         spin_unlock_irqrestore(&priv->lock, flags);
 
         if (status != 0) {
-                dbg("%s(): unable to handle the error, exiting", __func__);
+                dev_dbg(&urb->dev->dev, "%s(): unable to handle the error, exiting\n", __func__);
                 return;
         }
 
@@ -885,15 +878,13 @@ static void oti6858_write_bulk_callback(struct urb *urb)
         case -ENOENT:
         case -ESHUTDOWN:
                 /* this urb is terminated, clean up */
-                dbg("%s(): urb shutting down with status: %d",
-                                        __func__, status);
+                dev_dbg(&urb->dev->dev, "%s(): urb shutting down with status: %d\n", __func__, status);
                 priv->flags.write_urb_in_use = 0;
                 return;
         default:
                 /* error in the urb, so we have to resubmit it */
-                dbg("%s(): nonzero write bulk status received: %d",
-                                        __func__, status);
-                dbg("%s(): overflow in write", __func__);
+                dev_dbg(&urb->dev->dev, "%s(): nonzero write bulk status received: %d\n", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s(): overflow in write\n", __func__);
 
                 port->write_urb->transfer_buffer_length = 1;
                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
@@ -908,7 +899,7 @@ static void oti6858_write_bulk_callback(struct urb *urb)
         priv->flags.write_urb_in_use = 0;
 
         /* schedule the interrupt urb if we are still open */
-        dbg("%s(): submitting interrupt urb", __func__);
+        dev_dbg(&port->dev, "%s(): submitting interrupt urb\n", __func__);
         result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
         if (result != 0) {
                 dev_err(&port->dev, "%s(): failed submitting int urb,"
@@ -922,7 +913,3 @@ MODULE_DESCRIPTION(OTI6858_DESCRIPTION);
 MODULE_AUTHOR(OTI6858_AUTHOR);
 MODULE_VERSION(OTI6858_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "enable debug output");
-
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 2b9108a8ea64..892ebdc7a364 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -36,8 +36,6 @@
  */
 #define DRIVER_DESC "Prolific PL2303 USB to serial adaptor driver"
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_RSAQ2) },
@@ -741,7 +739,7 @@ static void pl2303_read_int_callback(struct urb *urb)
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__,
+        usb_serial_debug_data(&port->dev, __func__,
                               urb->actual_length, urb->transfer_buffer);
 
         pl2303_update_line_status(port, data, actual_length);
@@ -839,7 +837,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
diff --git a/drivers/usb/serial/qcaux.c b/drivers/usb/serial/qcaux.c
index a4edc7ee9c8a..9b1b96f2d095 100644
--- a/drivers/usb/serial/qcaux.c
+++ b/drivers/usb/serial/qcaux.c
@@ -36,8 +36,6 @@
 #define UTSTARCOM_PRODUCT_UM175_V1              0x3712
 #define UTSTARCOM_PRODUCT_UM175_V2              0x3714
 #define UTSTARCOM_PRODUCT_UM175_ALLTEL          0x3715
-#define PANTECH_PRODUCT_UML190_VZW              0x3716
-#define PANTECH_PRODUCT_UML290_VZW              0x3718
 
 /* CMOTECH devices */
 #define CMOTECH_VENDOR_ID                       0x16d8
@@ -68,11 +66,9 @@ static struct usb_device_id id_table[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(LG_VENDOR_ID, LG_PRODUCT_VX4400_6000, 0xff, 0xff, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(SANYO_VENDOR_ID, SANYO_PRODUCT_KATANA_LX, 0xff, 0xff, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(SAMSUNG_VENDOR_ID, SAMSUNG_PRODUCT_U520, 0xff, 0x00, 0x00) },
-        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML190_VZW, 0xff, 0xff, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML190_VZW, 0xff, 0xfe, 0xff) },
-        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML290_VZW, 0xff, 0xfd, 0xff) },  /* NMEA */
-        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML290_VZW, 0xff, 0xfe, 0xff) },  /* WMC */
-        { USB_DEVICE_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, PANTECH_PRODUCT_UML290_VZW, 0xff, 0xff, 0xff) },  /* DIAG */
+        { USB_VENDOR_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, 0xff, 0xfd, 0xff) },  /* NMEA */
+        { USB_VENDOR_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, 0xff, 0xfe, 0xff) },  /* WMC */
+        { USB_VENDOR_AND_INTERFACE_INFO(UTSTARCOM_VENDOR_ID, 0xff, 0xff, 0xff) },  /* DIAG */
         { },
 };
 MODULE_DEVICE_TABLE(usb, id_table);
diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c
index bfd50779f0c9..c3ddb65c05f2 100644
--- a/drivers/usb/serial/qcserial.c
+++ b/drivers/usb/serial/qcserial.c
@@ -22,8 +22,6 @@
 #define DRIVER_AUTHOR "Qualcomm Inc"
 #define DRIVER_DESC "Qualcomm USB Serial driver"
 
-static bool debug;
-
 #define DEVICE_G1K(v, p) \
         USB_DEVICE(v, p), .driver_info = 1
 
@@ -305,6 +303,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL v2");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/quatech2.c b/drivers/usb/serial/quatech2.c
index 7df9cdb053ed..2cdfdcc90b37 100644
--- a/drivers/usb/serial/quatech2.c
+++ b/drivers/usb/serial/quatech2.c
@@ -27,8 +27,6 @@
 #include <linux/serial_reg.h>
 #include <linux/uaccess.h>
 
-static bool debug;
-
 /* default urb timeout for usb operations */
 #define QT2_USB_TIMEOUT USB_CTRL_SET_TIMEOUT
 
@@ -1089,7 +1087,7 @@ static int qt2_write(struct tty_struct *tty,
         data = write_urb->transfer_buffer;
         spin_lock_irqsave(&port_priv->urb_lock, flags);
         if (port_priv->urb_in_use == true) {
-                printk(KERN_INFO "qt2_write - urb is in use\n");
+                dev_err(&port->dev, "qt2_write - urb is in use\n");
                 goto write_out;
         }
 
@@ -1146,6 +1144,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/safe_serial.c b/drivers/usb/serial/safe_serial.c
index 36e9d9fc0618..c949ce6ef0c6 100644
--- a/drivers/usb/serial/safe_serial.c
+++ b/drivers/usb/serial/safe_serial.c
@@ -62,6 +62,7 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
 #include <linux/kernel.h>
 #include <linux/errno.h>
@@ -81,11 +82,9 @@
 #define CONFIG_USB_SERIAL_SAFE_PADDED 0
 #endif
 
-static bool debug;
 static bool safe = 1;
 static bool padded = CONFIG_USB_SERIAL_SAFE_PADDED;
 
-#define DRIVER_VERSION "v0.1"
 #define DRIVER_AUTHOR "sl@lineo.com, tbr@lineo.com, Johan Hovold <jhovold@gmail.com>"
 #define DRIVER_DESC "USB Safe Encapsulated Serial"
 
@@ -100,9 +99,6 @@ MODULE_PARM_DESC(vendor, "User specified USB idVendor (required)");
 module_param(product, ushort, 0);
 MODULE_PARM_DESC(product, "User specified USB idProduct (required)");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
-
 module_param(safe, bool, 0);
 MODULE_PARM_DESC(safe, "Turn Safe Encapsulation On/Off");
 
@@ -315,13 +311,9 @@ static int __init safe_init(void)
 {
         int i;
 
-        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
-               DRIVER_DESC "\n");
-
         /* if we have vendor / product parameters patch them into id list */
         if (vendor || product) {
-                printk(KERN_INFO KBUILD_MODNAME ": vendor: %x product: %x\n",
-                       vendor, product);
+                pr_info("vendor: %x product: %x\n", vendor, product);
 
                 for (i = 0; i < ARRAY_SIZE(id_table); i++) {
                         if (!id_table[i].idVendor && !id_table[i].idProduct) {
diff --git a/drivers/usb/serial/sierra.c b/drivers/usb/serial/sierra.c
index b14ebbd73567..01d882cf3775 100644
--- a/drivers/usb/serial/sierra.c
+++ b/drivers/usb/serial/sierra.c
@@ -46,7 +46,6 @@
    allocations > PAGE_SIZE and the number of packets in a page
    is an integer 512 is the largest possible packet on EHCI */
 
-static bool debug;
 static bool nmea;
 
 /* Used in interface blacklisting */
@@ -518,7 +517,7 @@ static int sierra_write(struct tty_struct *tty, struct usb_serial_port *port,
 
         memcpy(buffer, buf, writesize);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, writesize, buffer);
+        usb_serial_debug_data(&port->dev, __func__, writesize, buffer);
 
         usb_fill_bulk_urb(urb, serial->dev,
                           usb_sndbulkpipe(serial->dev,
@@ -595,8 +594,8 @@ static void sierra_indat_callback(struct urb *urb)
                                 tty_flip_buffer_push(tty);
 
                                 tty_kref_put(tty);
-                                usb_serial_debug_data(debug, &port->dev,
-                                        __func__, urb->actual_length, data);
+                                usb_serial_debug_data(&port->dev, __func__,
+                                                      urb->actual_length, data);
                         }
                 } else {
                         dev_dbg(&port->dev, "%s: empty read urb"
@@ -765,7 +764,6 @@ static struct urb *sierra_setup_urb(struct usb_serial *serial, int endpoint,
                         usb_sndbulkpipe(serial->dev, endpoint) | dir,
                         buf, len, callback, ctx);
 
-                /* debug */
                 dev_dbg(&serial->dev->dev, "%s %c u : %p d:%p\n", __func__,
                                 dir == USB_DIR_IN ? 'i' : 'o', urb, buf);
         } else {
@@ -1082,6 +1080,3 @@ MODULE_LICENSE("GPL");
 
 module_param(nmea, bool, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(nmea, "NMEA streaming");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug messages");
diff --git a/drivers/usb/serial/spcp8x5.c b/drivers/usb/serial/spcp8x5.c
index ab68a4d74d61..9716efe92955 100644
--- a/drivers/usb/serial/spcp8x5.c
+++ b/drivers/usb/serial/spcp8x5.c
@@ -33,8 +33,6 @@
 #define DRIVER_VERSION  "v0.10"
 #define DRIVER_DESC     "SPCP8x5 USB to serial adaptor driver"
 
-static bool debug;
-
 #define SPCP8x5_007_VID         0x04FC
 #define SPCP8x5_007_PID         0x0201
 #define SPCP8x5_008_VID         0x04fc
@@ -665,6 +663,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ssu100.c b/drivers/usb/serial/ssu100.c
index cf2d30cf7588..015810b3785b 100644
--- a/drivers/usb/serial/ssu100.c
+++ b/drivers/usb/serial/ssu100.c
@@ -46,8 +46,6 @@
 #define FULLPWRBIT          0x00000080
 #define NEXT_BOARD_POWER_BIT        0x00000004
 
-static bool debug;
-
 /* Version Information */
 #define DRIVER_VERSION "v0.1"
 #define DRIVER_DESC "Quatech SSU-100 USB to Serial Driver"
@@ -135,7 +133,7 @@ static inline int update_mctrl(struct usb_device *dev, unsigned int set,
         int result;
 
         if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
-                dbg("%s - DTR|RTS not being set|cleared", __func__);
+                dev_dbg(&dev->dev, "%s - DTR|RTS not being set|cleared\n", __func__);
                 return 0;       /* no change */
         }
 
@@ -148,7 +146,7 @@ static inline int update_mctrl(struct usb_device *dev, unsigned int set,
 
         result = ssu100_setregister(dev, 0, UART_MCR, urb_value);
         if (result < 0)
-                dbg("%s Error from MODEM_CTRL urb", __func__);
+                dev_dbg(&dev->dev, "%s Error from MODEM_CTRL urb\n", __func__);
 
         return result;
 }
@@ -164,7 +162,7 @@ static int ssu100_initdevice(struct usb_device *dev)
 
         result = ssu100_getdevice(dev, data);
         if (result < 0) {
-                dbg("%s - get_device failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
                 goto out;
         }
 
@@ -172,25 +170,25 @@ static int ssu100_initdevice(struct usb_device *dev)
 
         result = ssu100_setdevice(dev, data);
         if (result < 0) {
-                dbg("%s - setdevice failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
                 goto out;
         }
 
         result = ssu100_control_msg(dev, QT_GET_SET_PREBUF_TRIG_LVL, 128, 0);
         if (result < 0) {
-                dbg("%s - set prebuffer level failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - set prebuffer level failed %i\n", __func__, result);
                 goto out;
         }
 
         result = ssu100_control_msg(dev, QT_SET_ATF, ATC_DISABLED, 0);
         if (result < 0) {
-                dbg("%s - set ATFprebuffer level failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - set ATFprebuffer level failed %i\n", __func__, result);
                 goto out;
         }
 
         result = ssu100_getdevice(dev, data);
         if (result < 0) {
-                dbg("%s - get_device failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - get_device failed %i\n", __func__, result);
                 goto out;
         }
 
@@ -201,7 +199,7 @@ static int ssu100_initdevice(struct usb_device *dev)
 
         result = ssu100_setdevice(dev, data);
         if (result < 0) {
-                dbg("%s - setdevice failed %i", __func__, result);
+                dev_dbg(&dev->dev, "%s - setdevice failed %i\n", __func__, result);
                 goto out;
         }
 
@@ -249,7 +247,7 @@ static void ssu100_set_termios(struct tty_struct *tty,
         if (!baud)
                 baud = 9600;
 
-        dbg("%s - got baud = %d\n", __func__, baud);
+        dev_dbg(&port->dev, "%s - got baud = %d\n", __func__, baud);
 
 
         divisor = MAX_BAUD_RATE / baud;
@@ -261,7 +259,7 @@ static void ssu100_set_termios(struct tty_struct *tty,
 
         result = ssu100_control_msg(dev, QT_GET_SET_UART, divisor, urb_value);
         if (result < 0)
-                dbg("%s - set uart failed", __func__);
+                dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
 
         if (cflag & CRTSCTS)
                 result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
@@ -270,7 +268,7 @@ static void ssu100_set_termios(struct tty_struct *tty,
                 result = ssu100_control_msg(dev, QT_HW_FLOW_CONTROL_MASK,
                                             0, 0);
         if (result < 0)
-                dbg("%s - set HW flow control failed", __func__);
+                dev_dbg(&port->dev, "%s - set HW flow control failed\n", __func__);
 
         if (I_IXOFF(tty) || I_IXON(tty)) {
                 u16 x = ((u16)(START_CHAR(tty) << 8) | (u16)(STOP_CHAR(tty)));
@@ -282,7 +280,7 @@ static void ssu100_set_termios(struct tty_struct *tty,
                                             0, 0);
 
         if (result < 0)
-                dbg("%s - set SW flow control failed", __func__);
+                dev_dbg(&port->dev, "%s - set SW flow control failed\n", __func__);
 
 }
 
@@ -304,7 +302,7 @@ static int ssu100_open(struct tty_struct *tty, struct usb_serial_port *port)
                                  QT_TRANSFER_IN, 0x01,
                                  0, data, 2, 300);
         if (result < 0) {
-                dbg("%s - open failed %i", __func__, result);
+                dev_dbg(&port->dev, "%s - open failed %i\n", __func__, result);
                 kfree(data);
                 return result;
         }
@@ -319,7 +317,7 @@ static int ssu100_open(struct tty_struct *tty, struct usb_serial_port *port)
 /* set to 9600 */
         result = ssu100_control_msg(dev, QT_GET_SET_UART, 0x30, 0x0300);
         if (result < 0)
-                dbg("%s - set uart failed", __func__);
+                dev_dbg(&port->dev, "%s - set uart failed\n", __func__);
 
         if (tty)
                 ssu100_set_termios(tty, port, &tty->termios);
@@ -423,7 +421,7 @@ static int ssu100_ioctl(struct tty_struct *tty,
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s cmd 0x%04x", __func__, cmd);
+        dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
 
         switch (cmd) {
         case TIOCGSERIAL:
@@ -437,7 +435,7 @@ static int ssu100_ioctl(struct tty_struct *tty,
                 break;
         }
 
-        dbg("%s arg not supported", __func__);
+        dev_dbg(&port->dev, "%s arg not supported\n", __func__);
 
         return -ENOIOCTLCMD;
 }
@@ -668,6 +666,3 @@ module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/symbolserial.c b/drivers/usb/serial/symbolserial.c
index e53d2aac35c5..701fffa8431f 100644
--- a/drivers/usb/serial/symbolserial.c
+++ b/drivers/usb/serial/symbolserial.c
@@ -20,8 +20,6 @@
 #include <linux/usb/serial.h>
 #include <linux/uaccess.h>
 
-static bool debug;
-
 static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x05e0, 0x0600) },
         { },
@@ -71,8 +69,7 @@ static void symbol_int_callback(struct urb *urb)
                 goto exit;
         }
 
-        usb_serial_debug_data(debug, &port->dev, __func__, urb->actual_length,
-                              data);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data);
 
         if (urb->actual_length > 1) {
                 data_length = urb->actual_length - 1;
@@ -292,6 +289,3 @@ static struct usb_serial_driver * const serial_drivers[] = {
 module_usb_serial_driver(serial_drivers, id_table);
 
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/ti_usb_3410_5052.c b/drivers/usb/serial/ti_usb_3410_5052.c
index f502a16aac21..6f49392cda5b 100644
--- a/drivers/usb/serial/ti_usb_3410_5052.c
+++ b/drivers/usb/serial/ti_usb_3410_5052.c
@@ -40,7 +40,6 @@
 
 /* Defines */
 
-#define TI_DRIVER_VERSION       "v0.10"
 #define TI_DRIVER_AUTHOR        "Al Borchers <alborchers@steinerpoint.com>"
 #define TI_DRIVER_DESC          "TI USB 3410/5052 Serial Driver"
 
@@ -141,8 +140,8 @@ static int ti_command_out_sync(struct ti_device *tdev, __u8 command,
 static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
         __u16 moduleid, __u16 value, __u8 *data, int size);
 
-static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
-        __u8 mask, __u8 byte);
+static int ti_write_byte(struct usb_serial_port *port, struct ti_device *tdev,
+                         unsigned long addr, __u8 mask, __u8 byte);
 
 static int ti_download_firmware(struct ti_device *tdev);
 
@@ -150,7 +149,6 @@ static int ti_download_firmware(struct ti_device *tdev);
 /* Data */
 
 /* module parameters */
-static bool debug;
 static int closing_wait = TI_DEFAULT_CLOSING_WAIT;
 static ushort vendor_3410[TI_EXTRA_VID_PID_COUNT];
 static unsigned int vendor_3410_count;
@@ -277,7 +275,6 @@ static struct usb_serial_driver * const serial_drivers[] = {
 
 MODULE_AUTHOR(TI_DRIVER_AUTHOR);
 MODULE_DESCRIPTION(TI_DRIVER_DESC);
-MODULE_VERSION(TI_DRIVER_VERSION);
 MODULE_LICENSE("GPL");
 
 MODULE_FIRMWARE("ti_3410.fw");
@@ -288,9 +285,6 @@ MODULE_FIRMWARE("mts_edge.fw");
 MODULE_FIRMWARE("mts_mt9234mu.fw");
 MODULE_FIRMWARE("mts_mt9234zba.fw");
 
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Enable debugging, 0=no, 1=yes");
-
 module_param(closing_wait, int, S_IRUGO | S_IWUSR);
 MODULE_PARM_DESC(closing_wait,
     "Maximum wait for data to drain in close, in .01 secs, default is 4000");
@@ -316,7 +310,6 @@ MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
 static int __init ti_init(void)
 {
         int i, j, c;
-        int ret;
 
         /* insert extra vendor and product ids */
         c = ARRAY_SIZE(ti_id_table_combined) - 2 * TI_EXTRA_VID_PID_COUNT - 1;
@@ -339,11 +332,7 @@ static int __init ti_init(void)
                 ti_id_table_combined[c].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
         }
 
-        ret = usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ti_id_table_combined);
-        if (ret == 0)
-                printk(KERN_INFO KBUILD_MODNAME ": " TI_DRIVER_VERSION ":"
-                               TI_DRIVER_DESC "\n");
-        return ret;
+        return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, ti_id_table_combined);
 }
 
 static void __exit ti_exit(void)
@@ -364,10 +353,11 @@ static int ti_startup(struct usb_serial *serial)
         int i;
 
 
-        dbg("%s - product 0x%4X, num configurations %d, configuration value %d",
-            __func__, le16_to_cpu(dev->descriptor.idProduct),
-            dev->descriptor.bNumConfigurations,
-            dev->actconfig->desc.bConfigurationValue);
+        dev_dbg(&dev->dev,
+                "%s - product 0x%4X, num configurations %d, configuration value %d",
+                __func__, le16_to_cpu(dev->descriptor.idProduct),
+                dev->descriptor.bNumConfigurations,
+                dev->actconfig->desc.bConfigurationValue);
 
         /* create device structure */
         tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
@@ -382,8 +372,8 @@ static int ti_startup(struct usb_serial *serial)
         /* determine device type */
         if (usb_match_id(serial->interface, ti_id_table_3410))
                 tdev->td_is_3410 = 1;
-        dbg("%s - device type is %s", __func__,
-                                tdev->td_is_3410 ? "3410" : "5052");
+        dev_dbg(&dev->dev, "%s - device type is %s\n", __func__,
+                tdev->td_is_3410 ? "3410" : "5052");
 
         /* if we have only 1 configuration, download firmware */
         if (dev->descriptor.bNumConfigurations == 1) {
@@ -501,20 +491,17 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
 
         /* start interrupt urb the first time a port is opened on this device */
         if (tdev->td_open_port_count == 0) {
-                dbg("%s - start interrupt in urb", __func__);
+                dev_dbg(&port->dev, "%s - start interrupt in urb\n", __func__);
                 urb = tdev->td_serial->port[0]->interrupt_in_urb;
                 if (!urb) {
-                        dev_err(&port->dev, "%s - no interrupt urb\n",
-                                                                __func__);
+                        dev_err(&port->dev, "%s - no interrupt urb\n", __func__);
                         status = -EINVAL;
                         goto release_lock;
                 }
                 urb->context = tdev;
                 status = usb_submit_urb(urb, GFP_KERNEL);
                 if (status) {
-                        dev_err(&port->dev,
-                                "%s - submit interrupt urb failed, %d\n",
-                                        __func__, status);
+                        dev_err(&port->dev, "%s - submit interrupt urb failed, %d\n", __func__, status);
                         goto release_lock;
                 }
         }
@@ -522,16 +509,16 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
         if (tty)
                 ti_set_termios(tty, port, &tty->termios);
 
-        dbg("%s - sending TI_OPEN_PORT", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_OPEN_PORT\n", __func__);
         status = ti_command_out_sync(tdev, TI_OPEN_PORT,
                 (__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
         if (status) {
                 dev_err(&port->dev, "%s - cannot send open command, %d\n",
-                                                        __func__, status);
+                        __func__, status);
                 goto unlink_int_urb;
         }
 
-        dbg("%s - sending TI_START_PORT", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_START_PORT\n", __func__);
         status = ti_command_out_sync(tdev, TI_START_PORT,
                 (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
         if (status) {
@@ -540,7 +527,7 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
                 goto unlink_int_urb;
         }
 
-        dbg("%s - sending TI_PURGE_PORT", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_PURGE_PORT\n", __func__);
         status = ti_command_out_sync(tdev, TI_PURGE_PORT,
                 (__u8)(TI_UART1_PORT + port_number), TI_PURGE_INPUT, NULL, 0);
         if (status) {
@@ -564,7 +551,7 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
         if (tty)
                 ti_set_termios(tty, port, &tty->termios);
 
-        dbg("%s - sending TI_OPEN_PORT (2)", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_OPEN_PORT (2)\n", __func__);
         status = ti_command_out_sync(tdev, TI_OPEN_PORT,
                 (__u8)(TI_UART1_PORT + port_number), open_settings, NULL, 0);
         if (status) {
@@ -573,7 +560,7 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
                 goto unlink_int_urb;
         }
 
-        dbg("%s - sending TI_START_PORT (2)", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_START_PORT (2)\n", __func__);
         status = ti_command_out_sync(tdev, TI_START_PORT,
                 (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
         if (status) {
@@ -583,7 +570,7 @@ static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
         }
 
         /* start read urb */
-        dbg("%s - start read urb", __func__);
+        dev_dbg(&port->dev, "%s - start read urb\n", __func__);
         urb = port->read_urb;
         if (!urb) {
                 dev_err(&port->dev, "%s - no read urb\n", __func__);
@@ -609,7 +596,7 @@ unlink_int_urb:
                 usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
 release_lock:
         mutex_unlock(&tdev->td_open_close_lock);
-        dbg("%s - exit %d", __func__, status);
+        dev_dbg(&port->dev, "%s - exit %d\n", __func__, status);
         return status;
 }
 
@@ -637,7 +624,7 @@ static void ti_close(struct usb_serial_port *port)
 
         port_number = port->number - port->serial->minor;
 
-        dbg("%s - sending TI_CLOSE_PORT", __func__);
+        dev_dbg(&port->dev, "%s - sending TI_CLOSE_PORT\n", __func__);
         status = ti_command_out_sync(tdev, TI_CLOSE_PORT,
                      (__u8)(TI_UART1_PORT + port_number), 0, NULL, 0);
         if (status)
@@ -664,7 +651,7 @@ static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
         struct ti_port *tport = usb_get_serial_port_data(port);
 
         if (count == 0) {
-                dbg("%s - write request of 0 bytes", __func__);
+                dev_dbg(&port->dev, "%s - write request of 0 bytes\n", __func__);
                 return 0;
         }
 
@@ -693,7 +680,7 @@ static int ti_write_room(struct tty_struct *tty)
         room = kfifo_avail(&tport->write_fifo);
         spin_unlock_irqrestore(&tport->tp_lock, flags);
 
-        dbg("%s - returns %d", __func__, room);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
         return room;
 }
 
@@ -712,7 +699,7 @@ static int ti_chars_in_buffer(struct tty_struct *tty)
         chars = kfifo_len(&tport->write_fifo);
         spin_unlock_irqrestore(&tport->tp_lock, flags);
 
-        dbg("%s - returns %d", __func__, chars);
+        dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
         return chars;
 }
 
@@ -755,8 +742,7 @@ static int ti_get_icount(struct tty_struct *tty,
         struct ti_port *tport = usb_get_serial_port_data(port);
         struct async_icount cnow = tport->tp_icount;
 
-        dbg("%s - (%d) TIOCGICOUNT RX=%d, TX=%d",
-                __func__, port->number,
+        dev_dbg(&port->dev, "%s - TIOCGICOUNT RX=%d, TX=%d\n", __func__,
                 cnow.rx, cnow.tx);
 
         icount->cts = cnow.cts;
@@ -782,22 +768,22 @@ static int ti_ioctl(struct tty_struct *tty,
         struct async_icount cnow;
         struct async_icount cprev;
 
-        dbg("%s - port %d, cmd = 0x%04X", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - cmd = 0x%04X\n", __func__, cmd);
 
         if (tport == NULL)
                 return -ENODEV;
 
         switch (cmd) {
         case TIOCGSERIAL:
-                dbg("%s - (%d) TIOCGSERIAL", __func__, port->number);
+                dev_dbg(&port->dev, "%s - TIOCGSERIAL\n", __func__);
                 return ti_get_serial_info(tport,
                                 (struct serial_struct __user *)arg);
         case TIOCSSERIAL:
-                dbg("%s - (%d) TIOCSSERIAL", __func__, port->number);
+                dev_dbg(&port->dev, "%s - TIOCSSERIAL\n", __func__);
                 return ti_set_serial_info(tty, tport,
                                 (struct serial_struct __user *)arg);
         case TIOCMIWAIT:
-                dbg("%s - (%d) TIOCMIWAIT", __func__, port->number);
+                dev_dbg(&port->dev, "%s - TIOCMIWAIT\n", __func__);
                 cprev = tport->tp_icount;
                 while (1) {
                         interruptible_sleep_on(&tport->tp_msr_wait);
@@ -834,9 +820,9 @@ static void ti_set_termios(struct tty_struct *tty,
         cflag = tty->termios.c_cflag;
         iflag = tty->termios.c_iflag;
 
-        dbg("%s - cflag %08x, iflag %08x", __func__, cflag, iflag);
-        dbg("%s - old clfag %08x, old iflag %08x", __func__,
-                                old_termios->c_cflag, old_termios->c_iflag);
+        dev_dbg(&port->dev, "%s - cflag %08x, iflag %08x\n", __func__, cflag, iflag);
+        dev_dbg(&port->dev, "%s - old clfag %08x, old iflag %08x\n", __func__,
+                old_termios->c_cflag, old_termios->c_iflag);
 
         if (tport == NULL)
                 return;
@@ -926,8 +912,11 @@ static void ti_set_termios(struct tty_struct *tty,
         if ((cflag & CBAUD) != B0)
                 tty_encode_baud_rate(tty, baud, baud);
 
-        dbg("%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d",
-        __func__, baud, config->wBaudRate, config->wFlags, config->bDataBits, config->bParity, config->bStopBits, config->cXon, config->cXoff, config->bUartMode);
+        dev_dbg(&port->dev,
+                "%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d",
+                __func__, baud, config->wBaudRate, config->wFlags,
+                config->bDataBits, config->bParity, config->bStopBits,
+                config->cXon, config->cXoff, config->bUartMode);
 
         cpu_to_be16s(&config->wBaudRate);
         cpu_to_be16s(&config->wFlags);
@@ -979,7 +968,7 @@ static int ti_tiocmget(struct tty_struct *tty)
                 | ((msr & TI_MSR_RI) ? TIOCM_RI : 0)
                 | ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0);
 
-        dbg("%s - 0x%04X", __func__, result);
+        dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
 
         return result;
 }
@@ -1024,19 +1013,19 @@ static void ti_break(struct tty_struct *tty, int break_state)
         struct ti_port *tport = usb_get_serial_port_data(port);
         int status;
 
-        dbg("%s - state = %d", __func__, break_state);
+        dev_dbg(&port->dev, "%s - state = %d\n", __func__, break_state);
 
         if (tport == NULL)
                 return;
 
         ti_drain(tport, (tport->tp_closing_wait*HZ)/100, 0);
 
-        status = ti_write_byte(tport->tp_tdev,
+        status = ti_write_byte(port, tport->tp_tdev,
                 tport->tp_uart_base_addr + TI_UART_OFFSET_LCR,
                 TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0);
 
         if (status)
-                dbg("%s - error setting break, %d", __func__, status);
+                dev_dbg(&port->dev, "%s - error setting break, %d\n", __func__, status);
 }
 
 
@@ -1061,18 +1050,17 @@ static void ti_interrupt_callback(struct urb *urb)
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
-                dbg("%s - urb shutting down, %d", __func__, status);
+                dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
                 tdev->td_urb_error = 1;
                 return;
         default:
-                dev_err(dev, "%s - nonzero urb status, %d\n",
-                        __func__, status);
+                dev_err(dev, "%s - nonzero urb status, %d\n", __func__, status);
                 tdev->td_urb_error = 1;
                 goto exit;
         }
 
         if (length != 2) {
-                dbg("%s - bad packet size, %d", __func__, length);
+                dev_dbg(dev, "%s - bad packet size, %d\n", __func__, length);
                 goto exit;
         }
 
@@ -1084,8 +1072,8 @@ static void ti_interrupt_callback(struct urb *urb)
         port_number = TI_GET_PORT_FROM_CODE(data[0]);
         function = TI_GET_FUNC_FROM_CODE(data[0]);
 
-        dbg("%s - port_number %d, function %d, data 0x%02X",
-                                __func__, port_number, function, data[1]);
+        dev_dbg(dev, "%s - port_number %d, function %d, data 0x%02X\n",
+                __func__, port_number, function, data[1]);
 
         if (port_number >= serial->num_ports) {
                 dev_err(dev, "%s - bad port number, %d\n",
@@ -1102,12 +1090,12 @@ static void ti_interrupt_callback(struct urb *urb)
         switch (function) {
         case TI_CODE_DATA_ERROR:
                 dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
-                                        __func__, port_number, data[1]);
+                        __func__, port_number, data[1]);
                 break;
 
         case TI_CODE_MODEM_STATUS:
                 msr = data[1];
-                dbg("%s - port %d, msr 0x%02X", __func__, port_number, msr);
+                dev_dbg(dev, "%s - port %d, msr 0x%02X\n", __func__, port_number, msr);
                 ti_handle_new_msr(tport, msr);
                 break;
 
@@ -1140,7 +1128,7 @@ static void ti_bulk_in_callback(struct urb *urb)
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
-                dbg("%s - urb shutting down, %d", __func__, status);
+                dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
                 tport->tp_tdev->td_urb_error = 1;
                 wake_up_interruptible(&tport->tp_write_wait);
                 return;
@@ -1162,11 +1150,11 @@ static void ti_bulk_in_callback(struct urb *urb)
         tty = tty_port_tty_get(&port->port);
         if (tty) {
                 if (urb->actual_length) {
-                        usb_serial_debug_data(debug, dev, __func__,
-                                urb->actual_length, urb->transfer_buffer);
+                        usb_serial_debug_data(dev, __func__, urb->actual_length,
+                                              urb->transfer_buffer);
 
                         if (!tport->tp_is_open)
-                                dbg("%s - port closed, dropping data",
+                                dev_dbg(dev, "%s - port closed, dropping data\n",
                                         __func__);
                         else
                                 ti_recv(&urb->dev->dev, tty,
@@ -1208,7 +1196,7 @@ static void ti_bulk_out_callback(struct urb *urb)
         case -ECONNRESET:
         case -ENOENT:
         case -ESHUTDOWN:
-                dbg("%s - urb shutting down, %d", __func__, status);
+                dev_dbg(&port->dev, "%s - urb shutting down, %d\n", __func__, status);
                 tport->tp_tdev->td_urb_error = 1;
                 wake_up_interruptible(&tport->tp_write_wait);
                 return;
@@ -1268,8 +1256,8 @@ static void ti_send(struct ti_port *tport)
 
         spin_unlock_irqrestore(&tport->tp_lock, flags);
 
-        usb_serial_debug_data(debug, &port->dev, __func__, count,
-                                        port->write_urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, count,
+                              port->write_urb->transfer_buffer);
 
         usb_fill_bulk_urb(port->write_urb, port->serial->dev,
                            usb_sndbulkpipe(port->serial->dev,
@@ -1307,7 +1295,7 @@ static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
         unsigned long flags;
         int status;
 
-        status = ti_write_byte(tport->tp_tdev,
+        status = ti_write_byte(tport->tp_port, tport->tp_tdev,
                 tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
                 TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);
 
@@ -1344,7 +1332,7 @@ static int ti_get_lsr(struct ti_port *tport)
                 goto free_data;
         }
 
-        dbg("%s - lsr 0x%02X", __func__, data->bLSR);
+        dev_dbg(&port->dev, "%s - lsr 0x%02X\n", __func__, data->bLSR);
 
         tport->tp_lsr = data->bLSR;
 
@@ -1401,7 +1389,7 @@ static void ti_handle_new_msr(struct ti_port *tport, __u8 msr)
         struct tty_struct *tty;
         unsigned long flags;
 
-        dbg("%s - msr 0x%02X", __func__, msr);
+        dev_dbg(&tport->tp_port->dev, "%s - msr 0x%02X\n", __func__, msr);
 
         if (msr & TI_MSR_DELTA_MASK) {
                 spin_lock_irqsave(&tport->tp_lock, flags);
@@ -1560,21 +1548,21 @@ static int ti_command_in_sync(struct ti_device *tdev, __u8 command,
 }
 
 
-static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
-        __u8 mask, __u8 byte)
+static int ti_write_byte(struct usb_serial_port *port,
+                        struct ti_device *tdev, unsigned long addr,
+                        __u8 mask, __u8 byte)
 {
         int status;
         unsigned int size;
         struct ti_write_data_bytes *data;
-        struct device *dev = &tdev->td_serial->dev->dev;
 
-        dbg("%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X",
-                                        __func__, addr, mask, byte);
+        dev_dbg(&port->dev, "%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X\n", __func__,
+                addr, mask, byte);
 
         size = sizeof(struct ti_write_data_bytes) + 2;
         data = kmalloc(size, GFP_KERNEL);
         if (!data) {
-                dev_err(dev, "%s - out of memory\n", __func__);
+                dev_err(&port->dev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
 
@@ -1590,7 +1578,7 @@ static int ti_write_byte(struct ti_device *tdev, unsigned long addr,
                 (__u8 *)data, size);
 
         if (status < 0)
-                dev_err(dev, "%s - failed, %d\n", __func__, status);
+                dev_err(&port->dev, "%s - failed, %d\n", __func__, status);
 
         kfree(data);
 
@@ -1615,7 +1603,7 @@ static int ti_do_download(struct usb_device *dev, int pipe,
                                         - sizeof(struct ti_firmware_header)));
         header->bCheckSum = cs;
 
-        dbg("%s - downloading firmware", __func__);
+        dev_dbg(&dev->dev, "%s - downloading firmware\n", __func__);
         for (pos = 0; pos < size; pos += done) {
                 len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
                 status = usb_bulk_msg(dev, pipe, buffer + pos, len,
@@ -1691,7 +1679,7 @@ static int ti_download_firmware(struct ti_device *tdev)
                 status = ti_do_download(dev, pipe, buffer, fw_p->size);
                 kfree(buffer);
         } else {
-                dbg("%s ENOMEM\n", __func__);
+                dev_dbg(&dev->dev, "%s ENOMEM\n", __func__);
                 status = -ENOMEM;
         }
         release_firmware(fw_p);
@@ -1701,7 +1689,7 @@ static int ti_download_firmware(struct ti_device *tdev)
                 return status;
         }
 
-        dbg("%s - download successful", __func__);
+        dev_dbg(&dev->dev, "%s - download successful\n", __func__);
 
         return 0;
 }
diff --git a/drivers/usb/serial/usb-serial.c b/drivers/usb/serial/usb-serial.c
index aa4b0d775992..73b8e0569164 100644
--- a/drivers/usb/serial/usb-serial.c
+++ b/drivers/usb/serial/usb-serial.c
@@ -17,6 +17,8 @@
  *
  */
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/init.h>
@@ -37,10 +39,7 @@
 #include <linux/kfifo.h>
 #include "pl2303.h"
 
-/*
- * Version Information
- */
-#define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
+#define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
 #define DRIVER_DESC "USB Serial Driver core"
 
 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
@@ -50,7 +49,6 @@
    drivers depend on it.
 */
 
-static bool debug;
 /* initially all NULL */
 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];
 static DEFINE_MUTEX(table_lock);
@@ -87,7 +85,7 @@ static struct usb_serial *get_free_serial(struct usb_serial *serial,
         unsigned int i, j;
         int good_spot;
 
-        dbg("%s %d", __func__, num_ports);
+        dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
 
         *minor = 0;
         mutex_lock(&table_lock);
@@ -107,7 +105,7 @@ static struct usb_serial *get_free_serial(struct usb_serial *serial,
 
                 *minor = i;
                 j = 0;
-                dbg("%s - minor base = %d", __func__, *minor);
+                dev_dbg(&serial->interface->dev, "%s - minor base = %d\n", __func__, *minor);
                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
                         serial_table[i] = serial;
                         serial->port[j++]->number = i;
@@ -123,8 +121,6 @@ static void return_serial(struct usb_serial *serial)
 {
         int i;
 
-        dbg("%s", __func__);
-
         mutex_lock(&table_lock);
         for (i = 0; i < serial->num_ports; ++i)
                 serial_table[serial->minor + i] = NULL;
@@ -139,8 +135,6 @@ static void destroy_serial(struct kref *kref)
 
         serial = to_usb_serial(kref);
 
-        dbg("%s - %s", __func__, serial->type->description);
-
         /* return the minor range that this device had */
         if (serial->minor != SERIAL_TTY_NO_MINOR)
                 return_serial(serial);
@@ -191,8 +185,6 @@ static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
         struct usb_serial_port *port;
         int retval = -ENODEV;
 
-        dbg("%s", __func__);
-
         serial = usb_serial_get_by_index(idx);
         if (!serial)
                 return retval;
@@ -256,7 +248,7 @@ static int serial_open(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
         return tty_port_open(&port->port, tty, filp);
 }
 
@@ -287,14 +279,16 @@ static void serial_down(struct tty_port *tport)
 static void serial_hangup(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
         tty_port_hangup(&port->port);
 }
 
 static void serial_close(struct tty_struct *tty, struct file *filp)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
         tty_port_close(&port->port, tty, filp);
 }
 
@@ -319,7 +313,7 @@ static void serial_cleanup(struct tty_struct *tty)
         if (port->port.console)
                 return;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         tty->driver_data = NULL;
 
@@ -344,7 +338,8 @@ static int serial_write(struct tty_struct *tty, const unsigned char *buf,
         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
                 goto exit;
 
-        dbg("%s - port %d, %d byte(s)", __func__, port->number, count);
+        dev_dbg(tty->dev, "%s - port %d, %d byte(s)\n", __func__,
+                port->number, count);
 
         /* pass on to the driver specific version of this function */
         retval = port->serial->type->write(tty, port, buf, count);
@@ -357,7 +352,8 @@ exit:
 static int serial_write_room(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
         /* pass on to the driver specific version of this function */
         return port->serial->type->write_room(tty);
 }
@@ -365,7 +361,8 @@ static int serial_write_room(struct tty_struct *tty)
 static int serial_chars_in_buffer(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         /* if the device was unplugged then any remaining characters
            fell out of the connector ;) */
@@ -378,7 +375,8 @@ static int serial_chars_in_buffer(struct tty_struct *tty)
 static void serial_throttle(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         /* pass on to the driver specific version of this function */
         if (port->serial->type->throttle)
@@ -388,7 +386,8 @@ static void serial_throttle(struct tty_struct *tty)
 static void serial_unthrottle(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         /* pass on to the driver specific version of this function */
         if (port->serial->type->unthrottle)
@@ -401,7 +400,8 @@ static int serial_ioctl(struct tty_struct *tty,
         struct usb_serial_port *port = tty->driver_data;
         int retval = -ENODEV;
 
-        dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
+        dev_dbg(tty->dev, "%s - port %d, cmd 0x%.4x\n", __func__,
+                port->number, cmd);
 
         /* pass on to the driver specific version of this function
            if it is available */
@@ -415,7 +415,8 @@ static int serial_ioctl(struct tty_struct *tty,
 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 {
         struct usb_serial_port *port = tty->driver_data;
-        dbg("%s - port %d", __func__, port->number);
+
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         /* pass on to the driver specific version of this function
            if it is available */
@@ -429,7 +430,7 @@ static int serial_break(struct tty_struct *tty, int break_state)
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         /* pass on to the driver specific version of this function
            if it is available */
@@ -444,7 +445,6 @@ static int serial_proc_show(struct seq_file *m, void *v)
         int i;
         char tmp[40];
 
-        dbg("%s", __func__);
         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
                 serial = usb_serial_get_by_index(i);
@@ -489,7 +489,7 @@ static int serial_tiocmget(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         if (port->serial->type->tiocmget)
                 return port->serial->type->tiocmget(tty);
@@ -501,7 +501,7 @@ static int serial_tiocmset(struct tty_struct *tty,
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         if (port->serial->type->tiocmset)
                 return port->serial->type->tiocmset(tty, set, clear);
@@ -513,7 +513,7 @@ static int serial_get_icount(struct tty_struct *tty,
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s - port %d", __func__, port->number);
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
 
         if (port->serial->type->get_icount)
                 return port->serial->type->get_icount(tty, icount);
@@ -537,12 +537,12 @@ static void usb_serial_port_work(struct work_struct *work)
                 container_of(work, struct usb_serial_port, work);
         struct tty_struct *tty;
 
-        dbg("%s - port %d", __func__, port->number);
-
         tty = tty_port_tty_get(&port->port);
         if (!tty)
                 return;
 
+        dev_dbg(tty->dev, "%s - port %d\n", __func__, port->number);
+
         tty_wakeup(tty);
         tty_kref_put(tty);
 }
@@ -575,7 +575,7 @@ static void port_release(struct device *dev)
         struct usb_serial_port *port = to_usb_serial_port(dev);
         int i;
 
-        dbg ("%s - %s", __func__, dev_name(dev));
+        dev_dbg(dev, "%s\n", __func__);
 
         /*
          * Stop all the traffic before cancelling the work, so that
@@ -644,12 +644,12 @@ static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 
         id = usb_match_id(intf, drv->id_table);
         if (id) {
-                dbg("static descriptor matches");
+                dev_dbg(&intf->dev, "static descriptor matches\n");
                 goto exit;
         }
         id = match_dynamic_id(intf, drv);
         if (id)
-                dbg("dynamic descriptor matches");
+                dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 exit:
         return id;
 }
@@ -703,6 +703,7 @@ static const struct tty_port_operations serial_port_ops = {
 static int usb_serial_probe(struct usb_interface *interface,
                                const struct usb_device_id *id)
 {
+        struct device *ddev = &interface->dev;
         struct usb_device *dev = interface_to_usbdev(interface);
         struct usb_serial *serial = NULL;
         struct usb_serial_port *port;
@@ -729,13 +730,13 @@ static int usb_serial_probe(struct usb_interface *interface,
         type = search_serial_device(interface);
         if (!type) {
                 mutex_unlock(&table_lock);
-                dbg("none matched");
+                dev_dbg(ddev, "none matched\n");
                 return -ENODEV;
         }
 
         if (!try_module_get(type->driver.owner)) {
                 mutex_unlock(&table_lock);
-                dev_err(&interface->dev, "module get failed, exiting\n");
+                dev_err(ddev, "module get failed, exiting\n");
                 return -EIO;
         }
         mutex_unlock(&table_lock);
@@ -743,7 +744,7 @@ static int usb_serial_probe(struct usb_interface *interface,
         serial = create_serial(dev, interface, type);
         if (!serial) {
                 module_put(type->driver.owner);
-                dev_err(&interface->dev, "%s - out of memory\n", __func__);
+                dev_err(ddev, "%s - out of memory\n", __func__);
                 return -ENOMEM;
         }
 
@@ -755,7 +756,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                 retval = type->probe(serial, id);
 
                 if (retval) {
-                        dbg("sub driver rejected device");
+                        dev_dbg(ddev, "sub driver rejected device\n");
                         usb_serial_put(serial);
                         module_put(type->driver.owner);
                         return retval;
@@ -770,28 +771,28 @@ static int usb_serial_probe(struct usb_interface *interface,
 
                 if (usb_endpoint_is_bulk_in(endpoint)) {
                         /* we found a bulk in endpoint */
-                        dbg("found bulk in on endpoint %d", i);
+                        dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
                         bulk_in_endpoint[num_bulk_in] = endpoint;
                         ++num_bulk_in;
                 }
 
                 if (usb_endpoint_is_bulk_out(endpoint)) {
                         /* we found a bulk out endpoint */
-                        dbg("found bulk out on endpoint %d", i);
+                        dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
                         bulk_out_endpoint[num_bulk_out] = endpoint;
                         ++num_bulk_out;
                 }
 
                 if (usb_endpoint_is_int_in(endpoint)) {
                         /* we found a interrupt in endpoint */
-                        dbg("found interrupt in on endpoint %d", i);
+                        dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
                         ++num_interrupt_in;
                 }
 
                 if (usb_endpoint_is_int_out(endpoint)) {
                         /* we found an interrupt out endpoint */
-                        dbg("found interrupt out on endpoint %d", i);
+                        dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
                         ++num_interrupt_out;
                 }
@@ -815,7 +816,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                                 endpoint = &iface_desc->endpoint[i].desc;
                                 if (usb_endpoint_is_int_in(endpoint)) {
                                         /* we found a interrupt in endpoint */
-                                        dbg("found interrupt in for Prolific device on separate interface");
+                                        dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
                                         ++num_interrupt_in;
                                 }
@@ -827,7 +828,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                  * properly during a later invocation of usb_serial_probe
                  */
                 if (num_bulk_in == 0 || num_bulk_out == 0) {
-                        dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
+                        dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
                         usb_serial_put(serial);
                         module_put(type->driver.owner);
                         return -ENODEV;
@@ -840,14 +841,13 @@ static int usb_serial_probe(struct usb_interface *interface,
         if (type == &usb_serial_generic_device) {
                 num_ports = num_bulk_out;
                 if (num_ports == 0) {
-                        dev_err(&interface->dev,
-                            "Generic device with no bulk out, not allowed.\n");
+                        dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
                         usb_serial_put(serial);
                         module_put(type->driver.owner);
                         return -EIO;
                 }
-                dev_info(&interface->dev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
-                dev_info(&interface->dev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
+                dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
+                dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
         }
 #endif
         if (!num_ports) {
@@ -865,8 +865,7 @@ static int usb_serial_probe(struct usb_interface *interface,
         serial->num_interrupt_out = num_interrupt_out;
 
         /* found all that we need */
-        dev_info(&interface->dev, "%s converter detected\n",
-                        type->description);
+        dev_info(ddev, "%s converter detected\n", type->description);
 
         /* create our ports, we need as many as the max endpoints */
         /* we don't use num_ports here because some devices have more
@@ -877,8 +876,7 @@ static int usb_serial_probe(struct usb_interface *interface,
         max_endpoints = max(max_endpoints, (int)serial->num_ports);
         serial->num_port_pointers = max_endpoints;
 
-        dbg("%s - setting up %d port structures for this device",
-                                                __func__, max_endpoints);
+        dev_dbg(ddev, "setting up %d port structures for this device", max_endpoints);
         for (i = 0; i < max_endpoints; ++i) {
                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
                 if (!port)
@@ -911,15 +909,13 @@ static int usb_serial_probe(struct usb_interface *interface,
                         set_bit(j, &port->read_urbs_free);
                         port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
                         if (!port->read_urbs[j]) {
-                                dev_err(&interface->dev,
-                                                "No free urbs available\n");
+                                dev_err(ddev, "No free urbs available\n");
                                 goto probe_error;
                         }
                         port->bulk_in_buffers[j] = kmalloc(buffer_size,
                                                                 GFP_KERNEL);
                         if (!port->bulk_in_buffers[j]) {
-                                dev_err(&interface->dev,
-                                        "Couldn't allocate bulk_in_buffer\n");
+                                dev_err(ddev, "Couldn't allocate bulk_in_buffer\n");
                                 goto probe_error;
                         }
                         usb_fill_bulk_urb(port->read_urbs[j], dev,
@@ -949,15 +945,13 @@ static int usb_serial_probe(struct usb_interface *interface,
                         set_bit(j, &port->write_urbs_free);
                         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
                         if (!port->write_urbs[j]) {
-                                dev_err(&interface->dev,
-                                                "No free urbs available\n");
+                                dev_err(ddev, "No free urbs available\n");
                                 goto probe_error;
                         }
                         port->bulk_out_buffers[j] = kmalloc(buffer_size,
                                                                 GFP_KERNEL);
                         if (!port->bulk_out_buffers[j]) {
-                                dev_err(&interface->dev,
-                                        "Couldn't allocate bulk_out_buffer\n");
+                                dev_err(ddev, "Couldn't allocate bulk_out_buffer\n");
                                 goto probe_error;
                         }
                         usb_fill_bulk_urb(port->write_urbs[j], dev,
@@ -978,8 +972,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                         port = serial->port[i];
                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
                         if (!port->interrupt_in_urb) {
-                                dev_err(&interface->dev,
-                                                "No free urbs available\n");
+                                dev_err(ddev, "No free urbs available\n");
                                 goto probe_error;
                         }
                         buffer_size = usb_endpoint_maxp(endpoint);
@@ -988,8 +981,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                         port->interrupt_in_buffer = kmalloc(buffer_size,
                                                                 GFP_KERNEL);
                         if (!port->interrupt_in_buffer) {
-                                dev_err(&interface->dev,
-                                    "Couldn't allocate interrupt_in_buffer\n");
+                                dev_err(ddev, "Couldn't allocate interrupt_in_buffer\n");
                                 goto probe_error;
                         }
                         usb_fill_int_urb(port->interrupt_in_urb, dev,
@@ -1000,7 +992,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                                 endpoint->bInterval);
                 }
         } else if (num_interrupt_in) {
-                dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
+                dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
         }
 
         if (serial->type->write_int_callback) {
@@ -1009,8 +1001,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                         port = serial->port[i];
                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
                         if (!port->interrupt_out_urb) {
-                                dev_err(&interface->dev,
-                                                "No free urbs available\n");
+                                dev_err(ddev, "No free urbs available\n");
                                 goto probe_error;
                         }
                         buffer_size = usb_endpoint_maxp(endpoint);
@@ -1020,8 +1011,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                         port->interrupt_out_buffer = kmalloc(buffer_size,
                                                                 GFP_KERNEL);
                         if (!port->interrupt_out_buffer) {
-                                dev_err(&interface->dev,
-                                  "Couldn't allocate interrupt_out_buffer\n");
+                                dev_err(ddev, "Couldn't allocate interrupt_out_buffer\n");
                                 goto probe_error;
                         }
                         usb_fill_int_urb(port->interrupt_out_urb, dev,
@@ -1032,7 +1022,7 @@ static int usb_serial_probe(struct usb_interface *interface,
                                 endpoint->bInterval);
                 }
         } else if (num_interrupt_out) {
-                dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
+                dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
         }
 
         usb_set_intfdata(interface, serial);
@@ -1060,7 +1050,7 @@ static int usb_serial_probe(struct usb_interface *interface,
         serial->disconnected = 1;
 
         if (get_free_serial(serial, num_ports, &minor) == NULL) {
-                dev_err(&interface->dev, "No more free serial devices\n");
+                dev_err(ddev, "No more free serial devices\n");
                 goto probe_error;
         }
         serial->minor = minor;
@@ -1069,18 +1059,17 @@ static int usb_serial_probe(struct usb_interface *interface,
         for (i = 0; i < num_ports; ++i) {
                 port = serial->port[i];
                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
-                dbg ("%s - registering %s", __func__, dev_name(&port->dev));
+                dev_dbg(ddev, "registering %s", dev_name(&port->dev));
                 device_enable_async_suspend(&port->dev);
 
                 retval = device_add(&port->dev);
                 if (retval)
-                        dev_err(&port->dev, "Error registering port device, "
-                                "continuing\n");
+                        dev_err(ddev, "Error registering port device, continuing\n");
         }
 
         serial->disconnected = 0;
 
-        usb_serial_console_init(debug, minor);
+        usb_serial_console_init(minor);
 exit:
         module_put(type->driver.owner);
         return 0;
@@ -1099,7 +1088,6 @@ static void usb_serial_disconnect(struct usb_interface *interface)
         struct usb_serial_port *port;
 
         usb_serial_console_disconnect(serial);
-        dbg("%s", __func__);
 
         mutex_lock(&serial->disc_mutex);
         /* must set a flag, to signal subdrivers */
@@ -1234,8 +1222,7 @@ static int __init usb_serial_init(void)
 
         result = bus_register(&usb_serial_bus_type);
         if (result) {
-                printk(KERN_ERR "usb-serial: %s - registering bus driver "
-                       "failed\n", __func__);
+                pr_err("%s - registering bus driver failed\n", __func__);
                 goto exit_bus;
         }
 
@@ -1255,29 +1242,24 @@ static int __init usb_serial_init(void)
         tty_set_operations(usb_serial_tty_driver, &serial_ops);
         result = tty_register_driver(usb_serial_tty_driver);
         if (result) {
-                printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
-                       __func__);
+                pr_err("%s - tty_register_driver failed\n", __func__);
                 goto exit_reg_driver;
         }
 
         /* register the USB driver */
         result = usb_register(&usb_serial_driver);
         if (result < 0) {
-                printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
-                       __func__);
+                pr_err("%s - usb_register failed\n", __func__);
                 goto exit_tty;
         }
 
         /* register the generic driver, if we should */
-        result = usb_serial_generic_register(debug);
+        result = usb_serial_generic_register();
         if (result < 0) {
-                printk(KERN_ERR "usb-serial: %s - registering generic "
-                       "driver failed\n", __func__);
+                pr_err("%s - registering generic driver failed\n", __func__);
                 goto exit_generic;
         }
 
-        printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
-
         return result;
 
 exit_generic:
@@ -1290,8 +1272,7 @@ exit_reg_driver:
         bus_unregister(&usb_serial_bus_type);
 
 exit_bus:
-        printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
-               __func__, result);
+        pr_err("%s - returning with error %d\n", __func__, result);
         put_tty_driver(usb_serial_tty_driver);
         return result;
 }
@@ -1317,7 +1298,7 @@ module_exit(usb_serial_exit);
         do {                                                            \
                 if (!type->function) {                                  \
                         type->function = usb_serial_generic_##function; \
-                        dbg("Had to override the " #function            \
+                        pr_debug("Had to override the " #function       \
                                 " usb serial operation with the generic one.");\
                         }                                               \
         } while (0)
@@ -1360,12 +1341,10 @@ static int usb_serial_register(struct usb_serial_driver *driver)
 
         retval = usb_serial_bus_register(driver);
         if (retval) {
-                printk(KERN_ERR "usb-serial: problem %d when registering "
-                       "driver %s\n", retval, driver->description);
+                pr_err("problem %d when registering driver %s\n", retval, driver->description);
                 list_del(&driver->driver_list);
         } else
-                printk(KERN_INFO "USB Serial support registered for %s\n",
-                                                driver->description);
+                pr_info("USB Serial support registered for %s\n", driver->description);
 
         mutex_unlock(&table_lock);
         return retval;
@@ -1373,8 +1352,7 @@ static int usb_serial_register(struct usb_serial_driver *driver)
 
 static void usb_serial_deregister(struct usb_serial_driver *device)
 {
-        printk(KERN_INFO "USB Serial deregistering driver %s\n",
-               device->description);
+        pr_info("USB Serial deregistering driver %s\n", device->description);
         mutex_lock(&table_lock);
         list_del(&device->driver_list);
         usb_serial_bus_deregister(device);
@@ -1425,9 +1403,10 @@ int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[]
 
         /* we only set the reset_resume field if the serial_driver has one */
         for (sd = serial_drivers; *sd; ++sd) {
-                if ((*sd)->reset_resume)
+                if ((*sd)->reset_resume) {
                         udriver->reset_resume = usb_serial_reset_resume;
                         break;
+                }
         }
 
         rc = usb_register(udriver);
@@ -1477,6 +1456,3 @@ EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/usb_wwan.c b/drivers/usb/serial/usb_wwan.c
index 72b678d90831..e42aa398ed37 100644
--- a/drivers/usb/serial/usb_wwan.c
+++ b/drivers/usb/serial/usb_wwan.c
@@ -37,8 +37,6 @@
 #include <linux/serial.h>
 #include "usb-wwan.h"
 
-static bool debug;
-
 void usb_wwan_dtr_rts(struct usb_serial_port *port, int on)
 {
         struct usb_serial *serial = port->serial;
@@ -178,7 +176,7 @@ int usb_wwan_ioctl(struct tty_struct *tty,
 {
         struct usb_serial_port *port = tty->driver_data;
 
-        dbg("%s cmd 0x%04x", __func__, cmd);
+        dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
 
         switch (cmd) {
         case TIOCGSERIAL:
@@ -191,7 +189,7 @@ int usb_wwan_ioctl(struct tty_struct *tty,
                 break;
         }
 
-        dbg("%s arg not supported", __func__);
+        dev_dbg(&port->dev, "%s arg not supported\n", __func__);
 
         return -ENOIOCTLCMD;
 }
@@ -212,7 +210,7 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
         portdata = usb_get_serial_port_data(port);
         intfdata = port->serial->private;
 
-        dbg("%s: write (%d chars)", __func__, count);
+        dev_dbg(&port->dev, "%s: write (%d chars)\n", __func__, count);
 
         i = 0;
         left = count;
@@ -229,8 +227,8 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         usb_unlink_urb(this_urb);
                         continue;
                 }
-                dbg("%s: endpoint %d buf %d", __func__,
-                    usb_pipeendpoint(this_urb->pipe), i);
+                dev_dbg(&port->dev, "%s: endpoint %d buf %d\n", __func__,
+                        usb_pipeendpoint(this_urb->pipe), i);
 
                 err = usb_autopm_get_interface_async(port->serial->interface);
                 if (err < 0)
@@ -249,8 +247,9 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
                         spin_unlock_irqrestore(&intfdata->susp_lock, flags);
                         err = usb_submit_urb(this_urb, GFP_ATOMIC);
                         if (err) {
-                                dbg("usb_submit_urb %p (write bulk) failed "
-                                    "(%d)", this_urb, err);
+                                dev_dbg(&port->dev,
+                                        "usb_submit_urb %p (write bulk) failed (%d)\n",
+                                        this_urb, err);
                                 clear_bit(i, &portdata->out_busy);
                                 spin_lock_irqsave(&intfdata->susp_lock, flags);
                                 intfdata->in_flight--;
@@ -267,7 +266,7 @@ int usb_wwan_write(struct tty_struct *tty, struct usb_serial_port *port,
         }
 
         count -= left;
-        dbg("%s: wrote (did %d)", __func__, count);
+        dev_dbg(&port->dev, "%s: wrote (did %d)\n", __func__, count);
         return count;
 }
 EXPORT_SYMBOL(usb_wwan_write);
@@ -278,15 +277,17 @@ static void usb_wwan_indat_callback(struct urb *urb)
         int endpoint;
         struct usb_serial_port *port;
         struct tty_struct *tty;
+        struct device *dev;
         unsigned char *data = urb->transfer_buffer;
         int status = urb->status;
 
         endpoint = usb_pipeendpoint(urb->pipe);
         port = urb->context;
+        dev = &port->dev;
 
         if (status) {
-                dbg("%s: nonzero status: %d on endpoint %02x.",
-                    __func__, status, endpoint);
+                dev_dbg(dev, "%s: nonzero status: %d on endpoint %02x.\n",
+                        __func__, status, endpoint);
         } else {
                 tty = tty_port_tty_get(&port->port);
                 if (tty) {
@@ -295,7 +296,7 @@ static void usb_wwan_indat_callback(struct urb *urb)
                                                 urb->actual_length);
                                 tty_flip_buffer_push(tty);
                         } else
-                                dbg("%s: empty read urb received", __func__);
+                                dev_dbg(dev, "%s: empty read urb received\n", __func__);
                         tty_kref_put(tty);
                 }
 
@@ -303,8 +304,7 @@ static void usb_wwan_indat_callback(struct urb *urb)
                 err = usb_submit_urb(urb, GFP_ATOMIC);
                 if (err) {
                         if (err != -EPERM) {
-                                printk(KERN_ERR "%s: resubmit read urb failed. "
-                                        "(%d)", __func__, err);
+                                dev_err(dev, "%s: resubmit read urb failed. (%d)\n", __func__, err);
                                 /* busy also in error unless we are killed */
                                 usb_mark_last_busy(port->serial->dev);
                         }
@@ -356,7 +356,7 @@ int usb_wwan_write_room(struct tty_struct *tty)
                         data_len += OUT_BUFLEN;
         }
 
-        dbg("%s: %d", __func__, data_len);
+        dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
         return data_len;
 }
 EXPORT_SYMBOL(usb_wwan_write_room);
@@ -378,7 +378,7 @@ int usb_wwan_chars_in_buffer(struct tty_struct *tty)
                 if (this_urb && test_bit(i, &portdata->out_busy))
                         data_len += this_urb->transfer_buffer_length;
         }
-        dbg("%s: %d", __func__, data_len);
+        dev_dbg(&port->dev, "%s: %d\n", __func__, data_len);
         return data_len;
 }
 EXPORT_SYMBOL(usb_wwan_chars_in_buffer);
@@ -401,8 +401,8 @@ int usb_wwan_open(struct tty_struct *tty, struct usb_serial_port *port)
                         continue;
                 err = usb_submit_urb(urb, GFP_KERNEL);
                 if (err) {
-                        dbg("%s: submit urb %d failed (%d) %d",
-                            __func__, i, err, urb->transfer_buffer_length);
+                        dev_dbg(&port->dev, "%s: submit urb %d failed (%d) %d\n",
+                                __func__, i, err, urb->transfer_buffer_length);
                 }
         }
 
@@ -458,7 +458,9 @@ static struct urb *usb_wwan_setup_urb(struct usb_serial *serial, int endpoint,
 
         urb = usb_alloc_urb(0, GFP_KERNEL);     /* No ISO */
         if (urb == NULL) {
-                dbg("%s: alloc for endpoint %d failed.", __func__, endpoint);
+                dev_dbg(&serial->interface->dev,
+                        "%s: alloc for endpoint %d failed.\n", __func__,
+                        endpoint);
                 return NULL;
         }
 
@@ -522,8 +524,8 @@ int usb_wwan_startup(struct usb_serial *serial)
                 port = serial->port[i];
                 portdata = kzalloc(sizeof(*portdata), GFP_KERNEL);
                 if (!portdata) {
-                        dbg("%s: kmalloc for usb_wwan_port_private (%d) failed!.",
-                            __func__, i);
+                        dev_dbg(&port->dev, "%s: kmalloc for usb_wwan_port_private (%d) failed!.\n",
+                                __func__, i);
                         return 1;
                 }
                 init_usb_anchor(&portdata->delayed);
@@ -548,7 +550,8 @@ int usb_wwan_startup(struct usb_serial *serial)
                         continue;
                 err = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
                 if (err)
-                        dbg("%s: submit irq_in urb failed %d", __func__, err);
+                        dev_dbg(&port->dev, "%s: submit irq_in urb failed %d\n",
+                                __func__, err);
         }
         usb_wwan_setup_urbs(serial);
         return 0;
@@ -683,11 +686,11 @@ int usb_wwan_resume(struct usb_serial *serial)
         for (i = 0; i < serial->num_ports; i++) {
                 port = serial->port[i];
                 if (!port->interrupt_in_urb) {
-                        dbg("%s: No interrupt URB for port %d", __func__, i);
+                        dev_dbg(&port->dev, "%s: No interrupt URB for port\n", __func__);
                         continue;
                 }
                 err = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
-                dbg("Submitted interrupt URB for port %d (result %d)", i, err);
+                dev_dbg(&port->dev, "Submitted interrupt URB for port (result %d)\n", err);
                 if (err < 0) {
                         dev_err(&port->dev, "%s: Error %d for interrupt URB\n",
                                 __func__, err);
@@ -733,6 +736,3 @@ MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_VERSION(DRIVER_VERSION);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug messages");
diff --git a/drivers/usb/serial/visor.c b/drivers/usb/serial/visor.c
index f253c91383da..1129aa73c23e 100644
--- a/drivers/usb/serial/visor.c
+++ b/drivers/usb/serial/visor.c
@@ -51,9 +51,6 @@ static int palm_os_3_probe(struct usb_serial *serial,
 static int palm_os_4_probe(struct usb_serial *serial,
                                         const struct usb_device_id *id);
 
-/* Parameters that may be passed into the module. */
-static bool debug;
-
 static struct usb_device_id id_table [] = {
         { USB_DEVICE(HANDSPRING_VENDOR_ID, HANDSPRING_VISOR_ID),
                 .driver_info = (kernel_ulong_t)&palm_os_3_probe },
@@ -310,8 +307,8 @@ static void visor_read_int_callback(struct urb *urb)
          * Rumor has it this endpoint is used to notify when data
          * is ready to be read from the bulk ones.
          */
-        usb_serial_debug_data(debug, &port->dev, __func__,
-                              urb->actual_length, urb->transfer_buffer);
+        usb_serial_debug_data(&port->dev, __func__, urb->actual_length,
+                              urb->transfer_buffer);
 
 exit:
         result = usb_submit_urb(urb, GFP_ATOMIC);
@@ -443,8 +440,7 @@ static int palm_os_4_probe(struct usb_serial *serial,
                 dev_err(dev, "%s - error %d getting connection info\n",
                         __func__, retval);
         else
-                usb_serial_debug_data(debug, &serial->dev->dev, __func__,
-                                      retval, transfer_buffer);
+                usb_serial_debug_data(dev, __func__, retval, transfer_buffer);
 
         kfree(transfer_buffer);
         return 0;
@@ -625,6 +621,3 @@ module_usb_serial_driver(serial_drivers, id_table_combined);
 MODULE_AUTHOR(DRIVER_AUTHOR);
 MODULE_DESCRIPTION(DRIVER_DESC);
 MODULE_LICENSE("GPL");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/whiteheat.c b/drivers/usb/serial/whiteheat.c
index b36077de72b9..346c7efc20b0 100644
--- a/drivers/usb/serial/whiteheat.c
+++ b/drivers/usb/serial/whiteheat.c
@@ -32,12 +32,9 @@
 #include <linux/serial_reg.h>
 #include <linux/serial.h>
 #include <linux/usb/serial.h>
-#include <linux/firmware.h>
-#include <linux/ihex.h>
+#include <linux/usb/ezusb.h>
 #include "whiteheat.h"                  /* WhiteHEAT specific commands */
 
-static bool debug;
-
 #ifndef CMSPAR
 #define CMSPAR 0
 #endif
@@ -195,84 +192,15 @@ static int firm_report_tx_done(struct usb_serial_port *port);
 static int whiteheat_firmware_download(struct usb_serial *serial,
                                         const struct usb_device_id *id)
 {
-        int response, ret = -ENOENT;
-        const struct firmware *loader_fw = NULL, *firmware_fw = NULL;
-        const struct ihex_binrec *record;
+        int response;
 
-        if (request_ihex_firmware(&firmware_fw, "whiteheat.fw",
-                                  &serial->dev->dev)) {
-                dev_err(&serial->dev->dev,
-                        "%s - request \"whiteheat.fw\" failed\n", __func__);
-                goto out;
-        }
-        if (request_ihex_firmware(&loader_fw, "whiteheat_loader.fw",
-                             &serial->dev->dev)) {
-                dev_err(&serial->dev->dev,
-                        "%s - request \"whiteheat_loader.fw\" failed\n",
-                        __func__);
-                goto out;
+        response = ezusb_fx1_ihex_firmware_download(serial->dev, "whiteheat_loader.fw");
+        if (response >= 0) {
+                response = ezusb_fx1_ihex_firmware_download(serial->dev, "whiteheat.fw");
+                if (response >= 0)
+                        return 0;
         }
-        ret = 0;
-        response = ezusb_set_reset (serial, 1);
-
-        record = (const struct ihex_binrec *)loader_fw->data;
-        while (record) {
-                response = ezusb_writememory (serial, be32_to_cpu(record->addr),
-                                              (unsigned char *)record->data,
-                                              be16_to_cpu(record->len), 0xa0);
-                if (response < 0) {
-                        dev_err(&serial->dev->dev, "%s - ezusb_writememory "
-                                "failed for loader (%d %04X %p %d)\n",
-                                __func__, response, be32_to_cpu(record->addr),
-                                record->data, be16_to_cpu(record->len));
-                        break;
-                }
-                record = ihex_next_binrec(record);
-        }
-
-        response = ezusb_set_reset(serial, 0);
-
-        record = (const struct ihex_binrec *)firmware_fw->data;
-        while (record && be32_to_cpu(record->addr) < 0x1b40)
-                record = ihex_next_binrec(record);
-        while (record) {
-                response = ezusb_writememory (serial, be32_to_cpu(record->addr),
-                                              (unsigned char *)record->data,
-                                              be16_to_cpu(record->len), 0xa3);
-                if (response < 0) {
-                        dev_err(&serial->dev->dev, "%s - ezusb_writememory "
-                                "failed for first firmware step "
-                                "(%d %04X %p %d)\n", __func__, response,
-                                be32_to_cpu(record->addr), record->data,
-                                be16_to_cpu(record->len));
-                        break;
-                }
-                ++record;
-        }
-
-        response = ezusb_set_reset(serial, 1);
-
-        record = (const struct ihex_binrec *)firmware_fw->data;
-        while (record && be32_to_cpu(record->addr) < 0x1b40) {
-                response = ezusb_writememory (serial, be32_to_cpu(record->addr),
-                                              (unsigned char *)record->data,
-                                              be16_to_cpu(record->len), 0xa0);
-                if (response < 0) {
-                        dev_err(&serial->dev->dev, "%s - ezusb_writememory "
-                                "failed for second firmware step "
-                                "(%d %04X %p %d)\n", __func__, response,
-                                be32_to_cpu(record->addr), record->data,
-                                be16_to_cpu(record->len));
-                        break;
-                }
-                ++record;
-        }
-        ret = 0;
-        response = ezusb_set_reset (serial, 0);
- out:
-        release_firmware(loader_fw);
-        release_firmware(firmware_fw);
-        return ret;
+        return -ENOENT;
 }
 
 
@@ -533,7 +461,7 @@ static int whiteheat_ioctl(struct tty_struct *tty,
         struct serial_struct serstruct;
         void __user *user_arg = (void __user *)arg;
 
-        dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
+        dev_dbg(&port->dev, "%s - cmd 0x%.4x\n", __func__, cmd);
 
         switch (cmd) {
         case TIOCGSERIAL:
@@ -580,7 +508,7 @@ static void command_port_write_callback(struct urb *urb)
         int status = urb->status;
 
         if (status) {
-                dbg("nonzero urb status: %d", status);
+                dev_dbg(&urb->dev->dev, "nonzero urb status: %d\n", status);
                 return;
         }
 }
@@ -596,19 +524,18 @@ static void command_port_read_callback(struct urb *urb)
 
         command_info = usb_get_serial_port_data(command_port);
         if (!command_info) {
-                dbg("%s - command_info is NULL, exiting.", __func__);
+                dev_dbg(&urb->dev->dev, "%s - command_info is NULL, exiting.\n", __func__);
                 return;
         }
         if (status) {
-                dbg("%s - nonzero urb status: %d", __func__, status);
+                dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", __func__, status);
                 if (status != -ENOENT)
                         command_info->command_finished = WHITEHEAT_CMD_FAILURE;
                 wake_up(&command_info->wait_command);
                 return;
         }
 
-        usb_serial_debug_data(debug, &command_port->dev,
-                                __func__, urb->actual_length, data);
+        usb_serial_debug_data(&command_port->dev, __func__, urb->actual_length, data);
 
         if (data[0] == WHITEHEAT_CMD_COMPLETE) {
                 command_info->command_finished = WHITEHEAT_CMD_COMPLETE;
@@ -619,19 +546,19 @@ static void command_port_read_callback(struct urb *urb)
         } else if (data[0] == WHITEHEAT_EVENT) {
                 /* These are unsolicited reports from the firmware, hence no
                    waiting command to wakeup */
-                dbg("%s - event received", __func__);
+                dev_dbg(&urb->dev->dev, "%s - event received\n", __func__);
         } else if (data[0] == WHITEHEAT_GET_DTR_RTS) {
                 memcpy(command_info->result_buffer, &data[1],
                                                 urb->actual_length - 1);
                 command_info->command_finished = WHITEHEAT_CMD_COMPLETE;
                 wake_up(&command_info->wait_command);
         } else
-                dbg("%s - bad reply from firmware", __func__);
+                dev_dbg(&urb->dev->dev, "%s - bad reply from firmware\n", __func__);
 
         /* Continue trying to always read */
         result = usb_submit_urb(command_port->read_urb, GFP_ATOMIC);
         if (result)
-                dbg("%s - failed resubmitting read urb, error %d",
+                dev_dbg(&urb->dev->dev, "%s - failed resubmitting read urb, error %d\n",
                         __func__, result);
 }
 
@@ -645,11 +572,12 @@ static int firm_send_command(struct usb_serial_port *port, __u8 command,
         struct usb_serial_port *command_port;
         struct whiteheat_command_private *command_info;
         struct whiteheat_private *info;
+        struct device *dev = &port->dev;
         __u8 *transfer_buffer;
         int retval = 0;
         int t;
 
-        dbg("%s - command %d", __func__, command);
+        dev_dbg(dev, "%s - command %d\n", __func__, command);
 
         command_port = port->serial->port[COMMAND_PORT];
         command_info = usb_get_serial_port_data(command_port);
@@ -662,7 +590,7 @@ static int firm_send_command(struct usb_serial_port *port, __u8 command,
         command_port->write_urb->transfer_buffer_length = datasize + 1;
         retval = usb_submit_urb(command_port->write_urb, GFP_NOIO);
         if (retval) {
-                dbg("%s - submit urb failed", __func__);
+                dev_dbg(dev, "%s - submit urb failed\n", __func__);
                 goto exit;
         }
 
@@ -673,19 +601,19 @@ static int firm_send_command(struct usb_serial_port *port, __u8 command,
                 usb_kill_urb(command_port->write_urb);
 
         if (command_info->command_finished == false) {
-                dbg("%s - command timed out.", __func__);
+                dev_dbg(dev, "%s - command timed out.\n", __func__);
                 retval = -ETIMEDOUT;
                 goto exit;
         }
 
         if (command_info->command_finished == WHITEHEAT_CMD_FAILURE) {
-                dbg("%s - command failed.", __func__);
+                dev_dbg(dev, "%s - command failed.\n", __func__);
                 retval = -EIO;
                 goto exit;
         }
 
         if (command_info->command_finished == WHITEHEAT_CMD_COMPLETE) {
-                dbg("%s - command completed.", __func__);
+                dev_dbg(dev, "%s - command completed.\n", __func__);
                 switch (command) {
                 case WHITEHEAT_GET_DTR_RTS:
                         info = usb_get_serial_port_data(port);
@@ -723,6 +651,7 @@ static int firm_close(struct usb_serial_port *port)
 static void firm_setup_port(struct tty_struct *tty)
 {
         struct usb_serial_port *port = tty->driver_data;
+        struct device *dev = &port->dev;
         struct whiteheat_port_settings port_settings;
         unsigned int cflag = tty->termios.c_cflag;
 
@@ -736,7 +665,7 @@ static void firm_setup_port(struct tty_struct *tty)
         default:
         case CS8:       port_settings.bits = 8;   break;
         }
-        dbg("%s - data bits = %d", __func__, port_settings.bits);
+        dev_dbg(dev, "%s - data bits = %d\n", __func__, port_settings.bits);
 
         /* determine the parity */
         if (cflag & PARENB)
@@ -752,14 +681,14 @@ static void firm_setup_port(struct tty_struct *tty)
                                 port_settings.parity = WHITEHEAT_PAR_EVEN;
         else
                 port_settings.parity = WHITEHEAT_PAR_NONE;
-        dbg("%s - parity = %c", __func__, port_settings.parity);
+        dev_dbg(dev, "%s - parity = %c\n", __func__, port_settings.parity);
 
         /* figure out the stop bits requested */
         if (cflag & CSTOPB)
                 port_settings.stop = 2;
         else
                 port_settings.stop = 1;
-        dbg("%s - stop bits = %d", __func__, port_settings.stop);
+        dev_dbg(dev, "%s - stop bits = %d\n", __func__, port_settings.stop);
 
         /* figure out the flow control settings */
         if (cflag & CRTSCTS)
@@ -767,7 +696,7 @@ static void firm_setup_port(struct tty_struct *tty)
                                                 WHITEHEAT_HFLOW_RTS);
         else
                 port_settings.hflow = WHITEHEAT_HFLOW_NONE;
-        dbg("%s - hardware flow control = %s %s %s %s", __func__,
+        dev_dbg(dev, "%s - hardware flow control = %s %s %s %s\n", __func__,
             (port_settings.hflow & WHITEHEAT_HFLOW_CTS) ? "CTS" : "",
             (port_settings.hflow & WHITEHEAT_HFLOW_RTS) ? "RTS" : "",
             (port_settings.hflow & WHITEHEAT_HFLOW_DSR) ? "DSR" : "",
@@ -778,16 +707,15 @@ static void firm_setup_port(struct tty_struct *tty)
                 port_settings.sflow = WHITEHEAT_SFLOW_RXTX;
         else
                 port_settings.sflow = WHITEHEAT_SFLOW_NONE;
-        dbg("%s - software flow control = %c", __func__, port_settings.sflow);
+        dev_dbg(dev, "%s - software flow control = %c\n", __func__, port_settings.sflow);
 
         port_settings.xon = START_CHAR(tty);
         port_settings.xoff = STOP_CHAR(tty);
-        dbg("%s - XON = %2x, XOFF = %2x",
-                        __func__, port_settings.xon, port_settings.xoff);
+        dev_dbg(dev, "%s - XON = %2x, XOFF = %2x\n", __func__, port_settings.xon, port_settings.xoff);
 
         /* get the baud rate wanted */
         port_settings.baud = tty_get_baud_rate(tty);
-        dbg("%s - baud rate = %d", __func__, port_settings.baud);
+        dev_dbg(dev, "%s - baud rate = %d\n", __func__, port_settings.baud);
 
         /* fixme: should set validated settings */
         tty_encode_baud_rate(tty, port_settings.baud, port_settings.baud);
@@ -918,6 +846,3 @@ MODULE_LICENSE("GPL");
 
 MODULE_FIRMWARE("whiteheat.fw");
 MODULE_FIRMWARE("whiteheat_loader.fw");
-
-module_param(debug, bool, S_IRUGO | S_IWUSR);
-MODULE_PARM_DESC(debug, "Debug enabled or not");
diff --git a/drivers/usb/serial/zte_ev.c b/drivers/usb/serial/zte_ev.c
new file mode 100644
index 000000000000..39ee7373b4ee
--- /dev/null
+++ b/drivers/usb/serial/zte_ev.c
@@ -0,0 +1,307 @@
+/*
+ * ZTE_EV USB serial driver
+ *
+ * Copyright (C) 2012 Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+ * Copyright (C) 2012 Linux Foundation
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This driver is based on code found in a ZTE_ENV patch that modified
+ * the usb-serial generic driver.  Comments were left in that I think
+ * show the commands used to talk to the device, but I am not sure.
+ */
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/tty.h>
+#include <linux/slab.h>
+#include <linux/module.h>
+#include <linux/usb.h>
+#include <linux/usb/serial.h>
+#include <linux/uaccess.h>
+
+#define  MAX_SETUP_DATA_SIZE    32
+
+static void debug_data(struct device *dev, const char *function, int len,
+                       const unsigned char *data, int result)
+{
+        dev_dbg(dev, "result = %d\n", result);
+        if (result == len)
+                dev_dbg(dev, "%s - length = %d, data = %*ph\n", function,
+                        len, len, data);
+}
+
+static int zte_ev_usb_serial_open(struct tty_struct *tty,
+                                  struct usb_serial_port *port)
+{
+        struct usb_device *udev = port->serial->dev;
+        struct device *dev = &port->dev;
+        int result = 0;
+        int len;
+        unsigned char *buf;
+
+        if (port->number != 0)
+                return -ENODEV;
+
+        buf = kmalloc(MAX_SETUP_DATA_SIZE, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        /* send 1st ctl cmd(CTL    21 22 01 00  00 00 00 00) */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0001, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        /* send  2st cmd and recieve data */
+        /*
+         * 16.0  CTL    a1 21 00 00  00 00 07 00   CLASS              25.1.0(5)
+         * 16.0  DI     00 96 00 00  00 00 08
+         */
+        len = 0x0007;
+        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                 0x21, 0xa1,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 3 cmd */
+        /*
+         * 16.0 CTL    21 20 00 00  00 00 07 00    CLASS                30.1.0
+         * 16.0 DO     80 25 00 00  00 00 08       .%.....              30.2.0
+         */
+        len = 0x0007;
+        buf[0] = 0x80;
+        buf[1] = 0x25;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        buf[4] = 0x00;
+        buf[5] = 0x00;
+        buf[6] = 0x08;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x20, 0x21,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 4 cmd */
+        /*
+         * 16.0 CTL    21 22 03 00  00 00 00 00
+         */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0003, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        /* send 5 cmd */
+        /*
+         * 16.0  CTL    a1 21 00 00  00 00 07 00   CLASS               33.1.0
+         * 16.0  DI     80 25 00 00  00 00 08
+         */
+        len = 0x0007;
+        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                 0x21, 0xa1,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 6 cmd */
+        /*
+         * 16.0  CTL    21 20 00 00  00 00 07 00    CLASS               34.1.0
+         * 16.0  DO     80 25 00 00  00 00 08
+         */
+        len = 0x0007;
+        buf[0] = 0x80;
+        buf[1] = 0x25;
+        buf[2] = 0x00;
+        buf[3] = 0x00;
+        buf[4] = 0x00;
+        buf[5] = 0x00;
+        buf[6] = 0x08;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x20, 0x21,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+        kfree(buf);
+
+        return usb_serial_generic_open(tty, port);
+}
+
+/*
+ *       CTL    21 22 02 00  00 00 00 00         CLASS               338.1.0
+ *
+ * 16.1  DI     a1 20 00 00  00 00 02 00  02 00  . ........          340.1.0
+ * 16.0  CTL    21 22 03 00  00 00 00 00         CLASS               341.1.0
+ *
+ * 16.0  CTL    a1 21 00 00  00 00 07 00         CLASS               346.1.0(3)
+ * 16.0  DI     00 08 07 00  00 00 08            .......             346.2.0
+ *
+ * 16.0  CTL    21 20 00 00  00 00 07 00         CLASS               349.1.0
+ * 16.0  DO     00 c2 01 00  00 00 08            .......             349.2.0
+ *
+ * 16.0  CTL    21 22 03 00  00 00 00 00         CLASS               350.1.0(2)
+ *
+ * 16.0  CTL    a1 21 00 00  00 00 07 00         CLASS               352.1.0
+ * 16.0  DI     00 c2 01 00  00 00 08            .......             352.2.0
+ *
+ * 16.1  DI     a1 20 00 00  00 00 02 00  02 00  . ........          353.1.0
+ *
+ * 16.0  CTL    21 20 00 00  00 00 07 00         CLASS               354.1.0
+ * 16.0  DO     00 c2 01 00  00 00 08            .......             354.2.0
+ *
+ * 16.0  CTL    21 22 03 00  00 00 00 00
+*/
+
+static void zte_ev_usb_serial_close(struct usb_serial_port *port)
+{
+        struct usb_device *udev = port->serial->dev;
+        struct device *dev = &port->dev;
+        int result = 0;
+        int len;
+        unsigned char *buf;
+
+        if (port->number != 0)
+                return;
+
+        buf = kmalloc(MAX_SETUP_DATA_SIZE, GFP_KERNEL);
+        if (!buf)
+                return;
+
+        /* send 1st ctl cmd(CTL    21 22 02 00  00 00 00 00) */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0002, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        /* send 2st ctl cmd(CTL    21 22 03 00  00 00 00 00 ) */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0003, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        /* send  3st cmd and recieve data */
+        /*
+         * 16.0  CTL    a1 21 00 00  00 00 07 00      CLASS         25.1.0(5)
+         * 16.0  DI     00 08 07 00  00 00 08
+         */
+        len = 0x0007;
+        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                 0x21, 0xa1,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 4 cmd */
+        /*
+         * 16.0 CTL    21 20 00 00  00 00 07 00      CLASS            30.1.0
+         * 16.0  DO    00 c2 01 00  00 00 08         .%.....          30.2.0
+         */
+        len = 0x0007;
+        buf[0] = 0x00;
+        buf[1] = 0xc2;
+        buf[2] = 0x01;
+        buf[3] = 0x00;
+        buf[4] = 0x00;
+        buf[5] = 0x00;
+        buf[6] = 0x08;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x20, 0x21,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 5 cmd */
+        /*
+         * 16.0 CTL    21 22 03 00  00 00 00 00
+         */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0003, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        /* send 6 cmd */
+        /*
+         * 16.0  CTL    a1 21 00 00  00 00 07 00        CLASS          33.1.0
+         * 16.0  DI     00 c2 01 00  00 00 08
+         */
+        len = 0x0007;
+        result = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
+                                 0x21, 0xa1,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 7 cmd */
+        /*
+         * 16.0  CTL    21 20 00 00  00 00 07 00  CLASS               354.1.0
+         * 16.0  DO     00 c2 01 00  00 00 08     .......             354.2.0
+         */
+        len = 0x0007;
+        buf[0] = 0x00;
+        buf[1] = 0xc2;
+        buf[2] = 0x01;
+        buf[3] = 0x00;
+        buf[4] = 0x00;
+        buf[5] = 0x00;
+        buf[6] = 0x08;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x20, 0x21,
+                                 0x0000, 0x0000, buf, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        debug_data(dev, __func__, len, buf, result);
+
+        /* send 8 cmd */
+        /*
+         * 16.0 CTL    21 22 03 00  00 00 00 00
+         */
+        len = 0;
+        result = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
+                                 0x22, 0x21,
+                                 0x0003, 0x0000, NULL, len,
+                                 HZ * USB_CTRL_GET_TIMEOUT);
+        dev_dbg(dev, "result = %d\n", result);
+
+        kfree(buf);
+
+        usb_serial_generic_close(port);
+}
+
+static const struct usb_device_id id_table[] = {
+        { USB_DEVICE(0x19d2, 0xffff) }, /* AC8700 */
+        { USB_DEVICE(0x19d2, 0xfffe) },
+        { USB_DEVICE(0x19d2, 0xfffd) }, /* MG880 */
+        { USB_DEVICE(0x05C6, 0x3197) },
+        { USB_DEVICE(0x05C6, 0x6000) },
+        { },
+};
+MODULE_DEVICE_TABLE(usb, id_table);
+
+static struct usb_serial_driver zio_device = {
+        .driver = {
+                .owner =        THIS_MODULE,
+                .name =         "zte_ev",
+        },
+        .id_table =             id_table,
+        .num_ports =            1,
+        .open =                 zte_ev_usb_serial_open,
+        .close =                zte_ev_usb_serial_close,
+};
+
+static struct usb_serial_driver * const serial_drivers[] = {
+        &zio_device, NULL
+};
+
+module_usb_serial_driver(serial_drivers, id_table);
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/usb/storage/Kconfig b/drivers/usb/storage/Kconfig
index 7691c866637b..0ae7bb64b5ea 100644
--- a/drivers/usb/storage/Kconfig
+++ b/drivers/usb/storage/Kconfig
@@ -213,17 +213,3 @@ config USB_UAS
           say 'Y' or 'M' here and the kernel will use the right driver.
 
           If you compile this driver as a module, it will be named uas.
-
-config USB_LIBUSUAL
-        bool "The shared table of common (or usual) storage devices"
-        depends on USB
-        help
-          This module contains a table of common (or usual) devices
-          for usb-storage and ub drivers, and allows to switch binding
-          of these devices without rebuilding modules.
-
-          Typical syntax of /etc/modprobe.d/*conf is:
-
-                options libusual bias="ub"
-
-          If unsure, say N.
diff --git a/drivers/usb/storage/Makefile b/drivers/usb/storage/Makefile
index 82e6416a2d47..4cd55481b309 100644
--- a/drivers/usb/storage/Makefile
+++ b/drivers/usb/storage/Makefile
@@ -12,16 +12,9 @@ obj-$(CONFIG_USB_STORAGE)	+= usb-storage.o
 
 usb-storage-y := scsiglue.o protocol.o transport.o usb.o
 usb-storage-y += initializers.o sierra_ms.o option_ms.o
-
+usb-storage-y += usual-tables.o
 usb-storage-$(CONFIG_USB_STORAGE_DEBUG) += debug.o
 
-ifeq ($(CONFIG_USB_LIBUSUAL),)
-        usb-storage-y           += usual-tables.o
-else
-        obj-$(CONFIG_USB)       += usb-libusual.o
-        usb-libusual-y          := libusual.o usual-tables.o
-endif
-
 obj-$(CONFIG_USB_STORAGE_ALAUDA)        += ums-alauda.o
 obj-$(CONFIG_USB_STORAGE_CYPRESS_ATACB) += ums-cypress.o
 obj-$(CONFIG_USB_STORAGE_DATAFAB)       += ums-datafab.o
diff --git a/drivers/usb/storage/alauda.c b/drivers/usb/storage/alauda.c
index bab8c8fe8290..be5564cc8e01 100644
--- a/drivers/usb/storage/alauda.c
+++ b/drivers/usb/storage/alauda.c
@@ -137,7 +137,7 @@ static int init_alauda(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id alauda_usb_ids[] = {
 #       include "unusual_alauda.h"
diff --git a/drivers/usb/storage/cypress_atacb.c b/drivers/usb/storage/cypress_atacb.c
index 5fe451d16e68..070b5c0ebbf9 100644
--- a/drivers/usb/storage/cypress_atacb.c
+++ b/drivers/usb/storage/cypress_atacb.c
@@ -41,7 +41,7 @@ MODULE_LICENSE("GPL");
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id cypress_usb_ids[] = {
 #       include "unusual_cypress.h"
diff --git a/drivers/usb/storage/datafab.c b/drivers/usb/storage/datafab.c
index 35e9c51e6696..494fee5af41d 100644
--- a/drivers/usb/storage/datafab.c
+++ b/drivers/usb/storage/datafab.c
@@ -86,7 +86,7 @@ static int datafab_determine_lun(struct us_data *us,
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id datafab_usb_ids[] = {
 #       include "unusual_datafab.h"
diff --git a/drivers/usb/storage/ene_ub6250.c b/drivers/usb/storage/ene_ub6250.c
index b28f2ad127d4..118b134a1dad 100644
--- a/drivers/usb/storage/ene_ub6250.c
+++ b/drivers/usb/storage/ene_ub6250.c
@@ -29,9 +29,21 @@
 #include "protocol.h"
 #include "debug.h"
 
+#define SD_INIT1_FIRMWARE "ene-ub6250/sd_init1.bin"
+#define SD_INIT2_FIRMWARE "ene-ub6250/sd_init2.bin"
+#define SD_RW_FIRMWARE "ene-ub6250/sd_rdwr.bin"
+#define MS_INIT_FIRMWARE "ene-ub6250/ms_init.bin"
+#define MSP_RW_FIRMWARE "ene-ub6250/msp_rdwr.bin"
+#define MS_RW_FIRMWARE "ene-ub6250/ms_rdwr.bin"
+
 MODULE_DESCRIPTION("Driver for ENE UB6250 reader");
 MODULE_LICENSE("GPL");
-
+MODULE_FIRMWARE(SD_INIT1_FIRMWARE);
+MODULE_FIRMWARE(SD_INIT2_FIRMWARE);
+MODULE_FIRMWARE(SD_RW_FIRMWARE);
+MODULE_FIRMWARE(MS_INIT_FIRMWARE);
+MODULE_FIRMWARE(MSP_RW_FIRMWARE);
+MODULE_FIRMWARE(MS_RW_FIRMWARE);
 
 /*
  * The table of devices
@@ -40,7 +52,7 @@ MODULE_LICENSE("GPL");
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-        .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+        .driver_info = (flags)}
 
 static struct usb_device_id ene_ub6250_usb_ids[] = {
 #       include "unusual_ene_ub6250.h"
@@ -1883,28 +1895,28 @@ static int ene_load_bincode(struct us_data *us, unsigned char flag)
         /* For SD */
         case SD_INIT1_PATTERN:
                 US_DEBUGP("SD_INIT1_PATTERN\n");
-                fw_name = "ene-ub6250/sd_init1.bin";
+                fw_name = SD_INIT1_FIRMWARE;
                 break;
         case SD_INIT2_PATTERN:
                 US_DEBUGP("SD_INIT2_PATTERN\n");
-                fw_name = "ene-ub6250/sd_init2.bin";
+                fw_name = SD_INIT2_FIRMWARE;
                 break;
         case SD_RW_PATTERN:
-                US_DEBUGP("SD_RDWR_PATTERN\n");
-                fw_name = "ene-ub6250/sd_rdwr.bin";
+                US_DEBUGP("SD_RW_PATTERN\n");
+                fw_name = SD_RW_FIRMWARE;
                 break;
         /* For MS */
         case MS_INIT_PATTERN:
                 US_DEBUGP("MS_INIT_PATTERN\n");
-                fw_name = "ene-ub6250/ms_init.bin";
+                fw_name = MS_INIT_FIRMWARE;
                 break;
         case MSP_RW_PATTERN:
                 US_DEBUGP("MSP_RW_PATTERN\n");
-                fw_name = "ene-ub6250/msp_rdwr.bin";
+                fw_name = MSP_RW_FIRMWARE;
                 break;
         case MS_RW_PATTERN:
                 US_DEBUGP("MS_RW_PATTERN\n");
-                fw_name = "ene-ub6250/ms_rdwr.bin";
+                fw_name = MS_RW_FIRMWARE;
                 break;
         default:
                 US_DEBUGP("----------- Unknown PATTERN ----------\n");
diff --git a/drivers/usb/storage/freecom.c b/drivers/usb/storage/freecom.c
index 042cf9ef3153..e6df087dca9d 100644
--- a/drivers/usb/storage/freecom.c
+++ b/drivers/usb/storage/freecom.c
@@ -117,7 +117,7 @@ static int init_freecom(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id freecom_usb_ids[] = {
 #       include "unusual_freecom.h"
diff --git a/drivers/usb/storage/isd200.c b/drivers/usb/storage/isd200.c
index 31fa24e7e68a..ecea47877364 100644
--- a/drivers/usb/storage/isd200.c
+++ b/drivers/usb/storage/isd200.c
@@ -74,7 +74,7 @@ static int isd200_Initialization(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id isd200_usb_ids[] = {
 #       include "unusual_isd200.h"
@@ -83,7 +83,6 @@ static struct usb_device_id isd200_usb_ids[] = {
 MODULE_DEVICE_TABLE(usb, isd200_usb_ids);
 
 #undef UNUSUAL_DEV
-#undef USUAL_DEV
 
 /*
  * The flags table
@@ -105,8 +104,6 @@ static struct us_unusual_dev isd200_unusual_dev_list[] = {
 };
 
 #undef UNUSUAL_DEV
-#undef USUAL_DEV
-
 
 /* Timeout defines (in Seconds) */
 
diff --git a/drivers/usb/storage/jumpshot.c b/drivers/usb/storage/jumpshot.c
index e3b97383186a..ddc78780b1ad 100644
--- a/drivers/usb/storage/jumpshot.c
+++ b/drivers/usb/storage/jumpshot.c
@@ -69,7 +69,7 @@ MODULE_LICENSE("GPL");
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id jumpshot_usb_ids[] = {
 #       include "unusual_jumpshot.h"
diff --git a/drivers/usb/storage/karma.c b/drivers/usb/storage/karma.c
index a8708eae9788..f085ffb606c8 100644
--- a/drivers/usb/storage/karma.c
+++ b/drivers/usb/storage/karma.c
@@ -57,7 +57,7 @@ static int rio_karma_init(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id karma_usb_ids[] = {
 #       include "unusual_karma.h"
diff --git a/drivers/usb/storage/libusual.c b/drivers/usb/storage/libusual.c
deleted file mode 100644
index fe3ffe1459b2..000000000000
--- a/drivers/usb/storage/libusual.c
+++ /dev/null
@@ -1,243 +0,0 @@
-/*
- * libusual
- *
- * The libusual contains the table of devices common for ub and usb-storage.
- */
-#include <linux/kernel.h>
-#include <linux/module.h>
-#include <linux/usb.h>
-#include <linux/usb_usual.h>
-#include <linux/vmalloc.h>
-#include <linux/kthread.h>
-#include <linux/mutex.h>
-
-/*
- */
-#define USU_MOD_FL_THREAD   1   /* Thread is running */
-#define USU_MOD_FL_PRESENT  2   /* The module is loaded */
-
-struct mod_status {
-        unsigned long fls;
-};
-
-static struct mod_status stat[3];
-static DEFINE_SPINLOCK(usu_lock);
-
-/*
- */
-#define USB_US_DEFAULT_BIAS     USB_US_TYPE_STOR
-static atomic_t usu_bias = ATOMIC_INIT(USB_US_DEFAULT_BIAS);
-
-#define BIAS_NAME_SIZE  (sizeof("usb-storage"))
-static const char *bias_names[3] = { "none", "usb-storage", "ub" };
-
-static DEFINE_MUTEX(usu_probe_mutex);
-static DECLARE_COMPLETION(usu_end_notify);
-static atomic_t total_threads = ATOMIC_INIT(0);
-
-static int usu_probe_thread(void *arg);
-
-/*
- * @type: the module type as an integer
- */
-void usb_usual_set_present(int type)
-{
-        struct mod_status *st;
-        unsigned long flags;
-
-        if (type <= 0 || type >= 3)
-                return;
-        st = &stat[type];
-        spin_lock_irqsave(&usu_lock, flags);
-        st->fls |= USU_MOD_FL_PRESENT;
-        spin_unlock_irqrestore(&usu_lock, flags);
-}
-EXPORT_SYMBOL_GPL(usb_usual_set_present);
-
-void usb_usual_clear_present(int type)
-{
-        struct mod_status *st;
-        unsigned long flags;
-
-        if (type <= 0 || type >= 3)
-                return;
-        st = &stat[type];
-        spin_lock_irqsave(&usu_lock, flags);
-        st->fls &= ~USU_MOD_FL_PRESENT;
-        spin_unlock_irqrestore(&usu_lock, flags);
-}
-EXPORT_SYMBOL_GPL(usb_usual_clear_present);
-
-/*
- * Match the calling driver type against the table.
- * Returns: 0 if the device matches.
- */
-int usb_usual_check_type(const struct usb_device_id *id, int caller_type)
-{
-        int id_type = USB_US_TYPE(id->driver_info);
-
-        if (caller_type <= 0 || caller_type >= 3)
-                return -EINVAL;
-
-        /* Drivers grab fixed assignment devices */
-        if (id_type == caller_type)
-                return 0;
-        /* Drivers grab devices biased to them */
-        if (id_type == USB_US_TYPE_NONE && caller_type == atomic_read(&usu_bias))
-                return 0;
-        return -ENODEV;
-}
-EXPORT_SYMBOL_GPL(usb_usual_check_type);
-
-/*
- */
-static int usu_probe(struct usb_interface *intf,
-                         const struct usb_device_id *id)
-{
-        int rc;
-        unsigned long type;
-        struct task_struct* task;
-        unsigned long flags;
-
-        type = USB_US_TYPE(id->driver_info);
-        if (type == 0)
-                type = atomic_read(&usu_bias);
-
-        spin_lock_irqsave(&usu_lock, flags);
-        if ((stat[type].fls & (USU_MOD_FL_THREAD|USU_MOD_FL_PRESENT)) != 0) {
-                spin_unlock_irqrestore(&usu_lock, flags);
-                return -ENXIO;
-        }
-        stat[type].fls |= USU_MOD_FL_THREAD;
-        spin_unlock_irqrestore(&usu_lock, flags);
-
-        task = kthread_run(usu_probe_thread, (void*)type, "libusual_%ld", type);
-        if (IS_ERR(task)) {
-                rc = PTR_ERR(task);
-                printk(KERN_WARNING "libusual: "
-                    "Unable to start the thread for %s: %d\n",
-                    bias_names[type], rc);
-                spin_lock_irqsave(&usu_lock, flags);
-                stat[type].fls &= ~USU_MOD_FL_THREAD;
-                spin_unlock_irqrestore(&usu_lock, flags);
-                return rc;      /* Not being -ENXIO causes a message printed */
-        }
-        atomic_inc(&total_threads);
-
-        return -ENXIO;
-}
-
-static void usu_disconnect(struct usb_interface *intf)
-{
-        ;       /* We should not be here. */
-}
-
-static struct usb_driver usu_driver = {
-        .name =         "libusual",
-        .probe =        usu_probe,
-        .disconnect =   usu_disconnect,
-        .id_table =     usb_storage_usb_ids,
-};
-
-/*
- * A whole new thread for a purpose of request_module seems quite stupid.
- * The request_module forks once inside again. However, if we attempt
- * to load a storage module from our own modprobe thread, that module
- * references our symbols, which cannot be resolved until our module is
- * initialized. I wish there was a way to wait for the end of initialization.
- * The module notifier reports MODULE_STATE_COMING only.
- * So, we wait until module->init ends as the next best thing.
- */
-static int usu_probe_thread(void *arg)
-{
-        int type = (unsigned long) arg;
-        struct mod_status *st = &stat[type];
-        int rc;
-        unsigned long flags;
-
-        mutex_lock(&usu_probe_mutex);
-        rc = request_module(bias_names[type]);
-        spin_lock_irqsave(&usu_lock, flags);
-        if (rc == 0 && (st->fls & USU_MOD_FL_PRESENT) == 0) {
-                /*
-                 * This should not happen, but let us keep tabs on it.
-                 */
-                printk(KERN_NOTICE "libusual: "
-                    "modprobe for %s succeeded, but module is not present\n",
-                    bias_names[type]);
-        }
-        st->fls &= ~USU_MOD_FL_THREAD;
-        spin_unlock_irqrestore(&usu_lock, flags);
-        mutex_unlock(&usu_probe_mutex);
-
-        complete_and_exit(&usu_end_notify, 0);
-}
-
-/*
- */
-static int __init usb_usual_init(void)
-{
-        int rc;
-
-        mutex_lock(&usu_probe_mutex);
-        rc = usb_register(&usu_driver);
-        mutex_unlock(&usu_probe_mutex);
-        return rc;
-}
-
-static void __exit usb_usual_exit(void)
-{
-        /*
-         * We do not check for any drivers present, because
-         * they keep us pinned with symbol references.
-         */
-
-        usb_deregister(&usu_driver);
-
-        while (atomic_read(&total_threads) > 0) {
-                wait_for_completion(&usu_end_notify);
-                atomic_dec(&total_threads);
-        }
-}
-
-/*
- * Validate and accept the bias parameter.
- */
-static int usu_set_bias(const char *bias_s, struct kernel_param *kp)
-{
-        int i;
-        int len;
-        int bias_n = 0;
-
-        len = strlen(bias_s);
-        if (len == 0)
-                return -EDOM;
-        if (bias_s[len-1] == '\n')
-                --len;
-
-        for (i = 1; i < 3; i++) {
-                if (strncmp(bias_s, bias_names[i], len) == 0) {
-                        bias_n = i;
-                        break;
-                }
-        }
-        if (bias_n == 0)
-                return -EINVAL;
-
-        atomic_set(&usu_bias, bias_n);
-        return 0;
-}
-
-static int usu_get_bias(char *buffer, struct kernel_param *kp)
-{
-        return strlen(strcpy(buffer, bias_names[atomic_read(&usu_bias)]));
-}
-
-module_init(usb_usual_init);
-module_exit(usb_usual_exit);
-
-module_param_call(bias, usu_set_bias, usu_get_bias, NULL, S_IRUGO|S_IWUSR);
-__MODULE_PARM_TYPE(bias, "string");
-MODULE_PARM_DESC(bias, "Bias to usb-storage or ub");
-
-MODULE_LICENSE("GPL");
diff --git a/drivers/usb/storage/onetouch.c b/drivers/usb/storage/onetouch.c
index 886567a3806d..cb79de61f4c8 100644
--- a/drivers/usb/storage/onetouch.c
+++ b/drivers/usb/storage/onetouch.c
@@ -67,7 +67,7 @@ struct usb_onetouch {
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id onetouch_usb_ids[] = {
 #       include "unusual_onetouch.h"
diff --git a/drivers/usb/storage/realtek_cr.c b/drivers/usb/storage/realtek_cr.c
index 63cf2822e299..d36446dd7ae8 100644
--- a/drivers/usb/storage/realtek_cr.c
+++ b/drivers/usb/storage/realtek_cr.c
@@ -172,7 +172,7 @@ static int init_realtek_cr(struct us_data *us);
                     initFunction, flags) \
 {\
         USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-        .driver_info = (flags)|(USB_US_TYPE_STOR<<24)\
+        .driver_info = (flags) \
 }
 
 static const struct usb_device_id realtek_cr_ids[] = {
diff --git a/drivers/usb/storage/sddr09.c b/drivers/usb/storage/sddr09.c
index 3252a62b31bc..7bd54e0d5120 100644
--- a/drivers/usb/storage/sddr09.c
+++ b/drivers/usb/storage/sddr09.c
@@ -69,7 +69,7 @@ static int usb_stor_sddr09_init(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id sddr09_usb_ids[] = {
 #       include "unusual_sddr09.h"
diff --git a/drivers/usb/storage/sddr55.c b/drivers/usb/storage/sddr55.c
index c144078065a7..d278c5a99b7a 100644
--- a/drivers/usb/storage/sddr55.c
+++ b/drivers/usb/storage/sddr55.c
@@ -46,7 +46,7 @@ MODULE_LICENSE("GPL");
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id sddr55_usb_ids[] = {
 #       include "unusual_sddr55.h"
diff --git a/drivers/usb/storage/shuttle_usbat.c b/drivers/usb/storage/shuttle_usbat.c
index fa1ceebc465c..daf2fc58ae02 100644
--- a/drivers/usb/storage/shuttle_usbat.c
+++ b/drivers/usb/storage/shuttle_usbat.c
@@ -168,7 +168,7 @@ static int init_usbat_flash(struct us_data *us);
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
+  .driver_info = (flags) }
 
 static struct usb_device_id usbat_usb_ids[] = {
 #       include "unusual_usbat.h"
diff --git a/drivers/usb/storage/sierra_ms.c b/drivers/usb/storage/sierra_ms.c
index 37539c89e3ba..17e36952bced 100644
--- a/drivers/usb/storage/sierra_ms.c
+++ b/drivers/usb/storage/sierra_ms.c
@@ -130,14 +130,13 @@ int sierra_ms_init(struct us_data *us)
         struct swoc_info *swocInfo;
         struct usb_device *udev;
         struct Scsi_Host *sh;
-        struct scsi_device *sd;
 
         retries = 3;
         result = 0;
         udev = us->pusb_dev;
 
         sh = us_to_host(us);
-        sd = scsi_get_host_dev(sh);
+        scsi_get_host_dev(sh);
 
         US_DEBUGP("SWIMS: sierra_ms_init called\n");
 
diff --git a/drivers/usb/storage/transport.c b/drivers/usb/storage/transport.c
index c70109e5d60b..c0543c83923e 100644
--- a/drivers/usb/storage/transport.c
+++ b/drivers/usb/storage/transport.c
@@ -1331,7 +1331,7 @@ int usb_stor_port_reset(struct us_data *us)
         int result;
 
         /*for these devices we must use the class specific method */
-        if (us->pusb_dev->quirks & USB_QUIRK_RESET_MORPHS)
+        if (us->pusb_dev->quirks & USB_QUIRK_RESET)
                 return -EPERM;
 
         result = usb_lock_device_for_reset(us->pusb_dev, us->pusb_intf);
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 638cd64f9610..98b98eef7527 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -41,6 +41,7 @@ struct sense_iu_old {
 struct uas_dev_info {
         struct usb_interface *intf;
         struct usb_device *udev;
+        struct usb_anchor cmd_urbs;
         struct usb_anchor sense_urbs;
         struct usb_anchor data_urbs;
         int qdepth, resetting;
@@ -49,6 +50,7 @@ struct uas_dev_info {
         unsigned use_streams:1;
         unsigned uas_sense_old:1;
         struct scsi_cmnd *cmnd;
+        spinlock_t lock;
 };
 
 enum {
@@ -63,13 +65,13 @@ enum {
         DATA_IN_URB_INFLIGHT    = (1 << 9),
         DATA_OUT_URB_INFLIGHT   = (1 << 10),
         COMMAND_COMPLETED       = (1 << 11),
+        COMMAND_ABORTED         = (1 << 12),
 };
 
 /* Overrides scsi_pointer */
 struct uas_cmd_info {
         unsigned int state;
         unsigned int stream;
-        unsigned int aborted;
         struct urb *cmd_urb;
         struct urb *data_in_urb;
         struct urb *data_out_urb;
@@ -90,6 +92,7 @@ static void uas_do_work(struct work_struct *work)
         struct uas_cmd_info *cmdinfo;
         struct uas_cmd_info *temp;
         struct list_head list;
+        unsigned long flags;
         int err;
 
         spin_lock_irq(&uas_work_lock);
@@ -100,7 +103,10 @@ static void uas_do_work(struct work_struct *work)
                 struct scsi_pointer *scp = (void *)cmdinfo;
                 struct scsi_cmnd *cmnd = container_of(scp,
                                                         struct scsi_cmnd, SCp);
-                err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_NOIO);
+                struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
+                spin_lock_irqsave(&devinfo->lock, flags);
+                err = uas_submit_urbs(cmnd, cmnd->device->hostdata, GFP_ATOMIC);
+                spin_unlock_irqrestore(&devinfo->lock, flags);
                 if (err) {
                         list_del(&cmdinfo->list);
                         spin_lock_irq(&uas_work_lock);
@@ -162,7 +168,7 @@ static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller)
         struct uas_cmd_info *ci = (void *)&cmnd->SCp;
 
         scmd_printk(KERN_INFO, cmnd, "%s %p tag %d, inflight:"
-                    "%s%s%s%s%s%s%s%s%s%s%s\n",
+                    "%s%s%s%s%s%s%s%s%s%s%s%s\n",
                     caller, cmnd, cmnd->request->tag,
                     (ci->state & SUBMIT_STATUS_URB)     ? " s-st"  : "",
                     (ci->state & ALLOC_DATA_IN_URB)     ? " a-in"  : "",
@@ -174,13 +180,16 @@ static void uas_log_cmd_state(struct scsi_cmnd *cmnd, const char *caller)
                     (ci->state & COMMAND_INFLIGHT)      ? " CMD"   : "",
                     (ci->state & DATA_IN_URB_INFLIGHT)  ? " IN"    : "",
                     (ci->state & DATA_OUT_URB_INFLIGHT) ? " OUT"   : "",
-                    (ci->state & COMMAND_COMPLETED)     ? " done"  : "");
+                    (ci->state & COMMAND_COMPLETED)     ? " done"  : "",
+                    (ci->state & COMMAND_ABORTED)       ? " abort" : "");
 }
 
 static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
 {
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
 
+        WARN_ON(!spin_is_locked(&devinfo->lock));
         if (cmdinfo->state & (COMMAND_INFLIGHT |
                               DATA_IN_URB_INFLIGHT |
                               DATA_OUT_URB_INFLIGHT))
@@ -189,6 +198,10 @@ static int uas_try_complete(struct scsi_cmnd *cmnd, const char *caller)
         cmdinfo->state |= COMMAND_COMPLETED;
         usb_free_urb(cmdinfo->data_in_urb);
         usb_free_urb(cmdinfo->data_out_urb);
+        if (cmdinfo->state & COMMAND_ABORTED) {
+                scmd_printk(KERN_INFO, cmnd, "abort completed\n");
+                cmnd->result = DID_ABORT << 16;
+        }
         cmnd->scsi_done(cmnd);
         return 0;
 }
@@ -216,6 +229,7 @@ static void uas_stat_cmplt(struct urb *urb)
         struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
         struct scsi_cmnd *cmnd;
         struct uas_cmd_info *cmdinfo;
+        unsigned long flags;
         u16 tag;
 
         if (urb->status) {
@@ -229,20 +243,24 @@ static void uas_stat_cmplt(struct urb *urb)
                 return;
         }
 
+        spin_lock_irqsave(&devinfo->lock, flags);
         tag = be16_to_cpup(&iu->tag) - 1;
         if (tag == 0)
                 cmnd = devinfo->cmnd;
         else
                 cmnd = scsi_host_find_tag(shost, tag - 1);
+
         if (!cmnd) {
-                if (iu->iu_id != IU_ID_RESPONSE) {
-                        usb_free_urb(urb);
-                        return;
+                if (iu->iu_id == IU_ID_RESPONSE) {
+                        /* store results for uas_eh_task_mgmt() */
+                        memcpy(&devinfo->response, iu, sizeof(devinfo->response));
                 }
-        } else {
-                cmdinfo = (void *)&cmnd->SCp;
+                usb_free_urb(urb);
+                spin_unlock_irqrestore(&devinfo->lock, flags);
+                return;
         }
 
+        cmdinfo = (void *)&cmnd->SCp;
         switch (iu->iu_id) {
         case IU_ID_STATUS:
                 if (devinfo->cmnd == cmnd)
@@ -256,10 +274,16 @@ static void uas_stat_cmplt(struct urb *urb)
                         uas_sense(urb, cmnd);
                 if (cmnd->result != 0) {
                         /* cancel data transfers on error */
-                        if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
+                        if (cmdinfo->state & DATA_IN_URB_INFLIGHT) {
+                                spin_unlock_irqrestore(&devinfo->lock, flags);
                                 usb_unlink_urb(cmdinfo->data_in_urb);
-                        if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
+                                spin_lock_irqsave(&devinfo->lock, flags);
+                        }
+                        if (cmdinfo->state & DATA_OUT_URB_INFLIGHT) {
+                                spin_unlock_irqrestore(&devinfo->lock, flags);
                                 usb_unlink_urb(cmdinfo->data_out_urb);
+                                spin_lock_irqsave(&devinfo->lock, flags);
+                        }
                 }
                 cmdinfo->state &= ~COMMAND_INFLIGHT;
                 uas_try_complete(cmnd, __func__);
@@ -270,23 +294,23 @@ static void uas_stat_cmplt(struct urb *urb)
         case IU_ID_WRITE_READY:
                 uas_xfer_data(urb, cmnd, SUBMIT_DATA_OUT_URB);
                 break;
-        case IU_ID_RESPONSE:
-                /* store results for uas_eh_task_mgmt() */
-                memcpy(&devinfo->response, iu, sizeof(devinfo->response));
-                break;
         default:
                 scmd_printk(KERN_ERR, cmnd,
                         "Bogus IU (%d) received on status pipe\n", iu->iu_id);
         }
         usb_free_urb(urb);
+        spin_unlock_irqrestore(&devinfo->lock, flags);
 }
 
 static void uas_data_cmplt(struct urb *urb)
 {
         struct scsi_cmnd *cmnd = urb->context;
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
         struct scsi_data_buffer *sdb = NULL;
+        unsigned long flags;
 
+        spin_lock_irqsave(&devinfo->lock, flags);
         if (cmdinfo->data_in_urb == urb) {
                 sdb = scsi_in(cmnd);
                 cmdinfo->state &= ~DATA_IN_URB_INFLIGHT;
@@ -301,10 +325,8 @@ static void uas_data_cmplt(struct urb *urb)
         } else {
                 sdb->resid = sdb->length - urb->actual_length;
         }
-        if (cmdinfo->aborted) {
-                return;
-        }
         uas_try_complete(cmnd, __func__);
+        spin_unlock_irqrestore(&devinfo->lock, flags);
 }
 
 static struct urb *uas_alloc_data_urb(struct uas_dev_info *devinfo, gfp_t gfp,
@@ -431,6 +453,7 @@ static int uas_submit_task_urb(struct scsi_cmnd *cmnd, gfp_t gfp,
         err = usb_submit_urb(urb, gfp);
         if (err)
                 goto err;
+        usb_anchor_urb(urb, &devinfo->cmd_urbs);
 
         return 0;
 
@@ -470,6 +493,7 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
         int err;
 
+        WARN_ON(!spin_is_locked(&devinfo->lock));
         if (cmdinfo->state & SUBMIT_STATUS_URB) {
                 err = uas_submit_sense_urb(cmnd->device->host, gfp,
                                            cmdinfo->stream);
@@ -521,18 +545,22 @@ static int uas_submit_urbs(struct scsi_cmnd *cmnd,
 
         if (cmdinfo->state & ALLOC_CMD_URB) {
                 cmdinfo->cmd_urb = uas_alloc_cmd_urb(devinfo, gfp, cmnd,
-                                                        cmdinfo->stream);
+                                                     cmdinfo->stream);
                 if (!cmdinfo->cmd_urb)
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 cmdinfo->state &= ~ALLOC_CMD_URB;
         }
 
         if (cmdinfo->state & SUBMIT_CMD_URB) {
+                usb_get_urb(cmdinfo->cmd_urb);
                 if (usb_submit_urb(cmdinfo->cmd_urb, gfp)) {
                         scmd_printk(KERN_INFO, cmnd,
                                         "cmd urb submission failure\n");
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
+                usb_anchor_urb(cmdinfo->cmd_urb, &devinfo->cmd_urbs);
+                usb_put_urb(cmdinfo->cmd_urb);
+                cmdinfo->cmd_urb = NULL;
                 cmdinfo->state &= ~SUBMIT_CMD_URB;
                 cmdinfo->state |= COMMAND_INFLIGHT;
         }
@@ -546,12 +574,16 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
         struct scsi_device *sdev = cmnd->device;
         struct uas_dev_info *devinfo = sdev->hostdata;
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        unsigned long flags;
         int err;
 
         BUILD_BUG_ON(sizeof(struct uas_cmd_info) > sizeof(struct scsi_pointer));
 
-        if (devinfo->cmnd)
+        spin_lock_irqsave(&devinfo->lock, flags);
+        if (devinfo->cmnd) {
+                spin_unlock_irqrestore(&devinfo->lock, flags);
                 return SCSI_MLQUEUE_DEVICE_BUSY;
+        }
 
         if (blk_rq_tagged(cmnd->request)) {
                 cmdinfo->stream = cmnd->request->tag + 2;
@@ -564,7 +596,6 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
 
         cmdinfo->state = SUBMIT_STATUS_URB |
                         ALLOC_CMD_URB | SUBMIT_CMD_URB;
-        cmdinfo->aborted = 0;
 
         switch (cmnd->sc_data_direction) {
         case DMA_FROM_DEVICE:
@@ -587,6 +618,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
         if (err) {
                 /* If we did nothing, give up now */
                 if (cmdinfo->state & SUBMIT_STATUS_URB) {
+                        spin_unlock_irqrestore(&devinfo->lock, flags);
                         return SCSI_MLQUEUE_DEVICE_BUSY;
                 }
                 spin_lock(&uas_work_lock);
@@ -595,6 +627,7 @@ static int uas_queuecommand_lck(struct scsi_cmnd *cmnd,
                 schedule_work(&uas_work);
         }
 
+        spin_unlock_irqrestore(&devinfo->lock, flags);
         return 0;
 }
 
@@ -605,22 +638,28 @@ static int uas_eh_task_mgmt(struct scsi_cmnd *cmnd,
 {
         struct Scsi_Host *shost = cmnd->device->host;
         struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
-        u16 tag = 9999; /* FIXME */
+        u16 tag = devinfo->qdepth - 1;
+        unsigned long flags;
 
+        spin_lock_irqsave(&devinfo->lock, flags);
         memset(&devinfo->response, 0, sizeof(devinfo->response));
-        if (uas_submit_sense_urb(shost, GFP_NOIO, tag)) {
+        if (uas_submit_sense_urb(shost, GFP_ATOMIC, tag)) {
                 shost_printk(KERN_INFO, shost,
                              "%s: %s: submit sense urb failed\n",
                              __func__, fname);
+                spin_unlock_irqrestore(&devinfo->lock, flags);
                 return FAILED;
         }
-        if (uas_submit_task_urb(cmnd, GFP_NOIO, function, tag)) {
+        if (uas_submit_task_urb(cmnd, GFP_ATOMIC, function, tag)) {
                 shost_printk(KERN_INFO, shost,
                              "%s: %s: submit task mgmt urb failed\n",
                              __func__, fname);
+                spin_unlock_irqrestore(&devinfo->lock, flags);
                 return FAILED;
         }
-        if (0 == usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 3000)) {
+        spin_unlock_irqrestore(&devinfo->lock, flags);
+
+        if (usb_wait_anchor_empty_timeout(&devinfo->sense_urbs, 3000) == 0) {
                 shost_printk(KERN_INFO, shost,
                              "%s: %s timed out\n", __func__, fname);
                 return FAILED;
@@ -643,15 +682,15 @@ static int uas_eh_task_mgmt(struct scsi_cmnd *cmnd,
 static int uas_eh_abort_handler(struct scsi_cmnd *cmnd)
 {
         struct uas_cmd_info *cmdinfo = (void *)&cmnd->SCp;
+        struct uas_dev_info *devinfo = (void *)cmnd->device->hostdata;
+        unsigned long flags;
         int ret;
 
         uas_log_cmd_state(cmnd, __func__);
-        cmdinfo->aborted = 1;
+        spin_lock_irqsave(&devinfo->lock, flags);
+        cmdinfo->state |= COMMAND_ABORTED;
+        spin_unlock_irqrestore(&devinfo->lock, flags);
         ret = uas_eh_task_mgmt(cmnd, "ABORT TASK", TMF_ABORT_TASK);
-        if (cmdinfo->state & DATA_IN_URB_INFLIGHT)
-                usb_kill_urb(cmdinfo->data_in_urb);
-        if (cmdinfo->state & DATA_OUT_URB_INFLIGHT)
-                usb_kill_urb(cmdinfo->data_out_urb);
         return ret;
 }
 
@@ -670,6 +709,7 @@ static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
         int err;
 
         devinfo->resetting = 1;
+        usb_kill_anchored_urbs(&devinfo->cmd_urbs);
         usb_kill_anchored_urbs(&devinfo->sense_urbs);
         usb_kill_anchored_urbs(&devinfo->data_urbs);
         err = usb_reset_device(udev);
@@ -694,7 +734,7 @@ static int uas_slave_configure(struct scsi_device *sdev)
 {
         struct uas_dev_info *devinfo = sdev->hostdata;
         scsi_set_tag_type(sdev, MSG_ORDERED_TAG);
-        scsi_activate_tcq(sdev, devinfo->qdepth - 2);
+        scsi_activate_tcq(sdev, devinfo->qdepth - 3);
         return 0;
 }
 
@@ -868,11 +908,13 @@ static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
         devinfo->intf = intf;
         devinfo->udev = udev;
         devinfo->resetting = 0;
+        init_usb_anchor(&devinfo->cmd_urbs);
         init_usb_anchor(&devinfo->sense_urbs);
         init_usb_anchor(&devinfo->data_urbs);
+        spin_lock_init(&devinfo->lock);
         uas_configure_endpoints(devinfo);
 
-        result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 2);
+        result = scsi_init_shared_tag_map(shost, devinfo->qdepth - 3);
         if (result)
                 goto free;
 
@@ -913,6 +955,7 @@ static void uas_disconnect(struct usb_interface *intf)
         struct uas_dev_info *devinfo = (void *)shost->hostdata[0];
 
         scsi_remove_host(shost);
+        usb_kill_anchored_urbs(&devinfo->cmd_urbs);
         usb_kill_anchored_urbs(&devinfo->sense_urbs);
         usb_kill_anchored_urbs(&devinfo->data_urbs);
         uas_free_streams(devinfo);
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index 62a31bea0634..779cd954abcb 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -2038,25 +2038,25 @@ UNUSUAL_DEV( 0xed10, 0x7636, 0x0001, 0x0001,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL, US_FL_NOT_LOCKABLE ),
 
 /* Control/Bulk transport for all SubClass values */
-USUAL_DEV(USB_SC_RBC, USB_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8020, USB_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_QIC, USB_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_UFI, USB_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8070, USB_PR_CB, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_SCSI, USB_PR_CB, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_RBC, USB_PR_CB),
+USUAL_DEV(USB_SC_8020, USB_PR_CB),
+USUAL_DEV(USB_SC_QIC, USB_PR_CB),
+USUAL_DEV(USB_SC_UFI, USB_PR_CB),
+USUAL_DEV(USB_SC_8070, USB_PR_CB),
+USUAL_DEV(USB_SC_SCSI, USB_PR_CB),
 
 /* Control/Bulk/Interrupt transport for all SubClass values */
-USUAL_DEV(USB_SC_RBC, USB_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8020, USB_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_QIC, USB_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_UFI, USB_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8070, USB_PR_CBI, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_SCSI, USB_PR_CBI, USB_US_TYPE_STOR),
+USUAL_DEV(USB_SC_RBC, USB_PR_CBI),
+USUAL_DEV(USB_SC_8020, USB_PR_CBI),
+USUAL_DEV(USB_SC_QIC, USB_PR_CBI),
+USUAL_DEV(USB_SC_UFI, USB_PR_CBI),
+USUAL_DEV(USB_SC_8070, USB_PR_CBI),
+USUAL_DEV(USB_SC_SCSI, USB_PR_CBI),
 
 /* Bulk-only transport for all SubClass values */
-USUAL_DEV(USB_SC_RBC, USB_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8020, USB_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_QIC, USB_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_UFI, USB_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_8070, USB_PR_BULK, USB_US_TYPE_STOR),
-USUAL_DEV(USB_SC_SCSI, USB_PR_BULK, 0),
+USUAL_DEV(USB_SC_RBC, USB_PR_BULK),
+USUAL_DEV(USB_SC_8020, USB_PR_BULK),
+USUAL_DEV(USB_SC_QIC, USB_PR_BULK),
+USUAL_DEV(USB_SC_UFI, USB_PR_BULK),
+USUAL_DEV(USB_SC_8070, USB_PR_BULK),
+USUAL_DEV(USB_SC_SCSI, USB_PR_BULK),
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index d012fe4329e7..12aa72630aed 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -114,7 +114,7 @@ MODULE_PARM_DESC(quirks, "supplemental list of device IDs and their quirks");
 
 #define COMPLIANT_DEV   UNUSUAL_DEV
 
-#define USUAL_DEV(use_protocol, use_transport, use_type) \
+#define USUAL_DEV(use_protocol, use_transport) \
 { \
         .useProtocol = use_protocol,    \
         .useTransport = use_transport,  \
@@ -126,7 +126,7 @@ static struct us_unusual_dev us_unusual_dev_list[] = {
 };
 
 static struct us_unusual_dev for_dynamic_ids =
-                USUAL_DEV(USB_SC_SCSI, USB_PR_BULK, 0);
+                USUAL_DEV(USB_SC_SCSI, USB_PR_BULK);
 
 #undef UNUSUAL_DEV
 #undef COMPLIANT_DEV
@@ -564,7 +564,7 @@ static int get_device_info(struct us_data *us, const struct usb_device_id *id,
         us->protocol = (unusual_dev->useTransport == USB_PR_DEVICE) ?
                         idesc->bInterfaceProtocol :
                         unusual_dev->useTransport;
-        us->fflags = USB_US_ORIG_FLAGS(id->driver_info);
+        us->fflags = id->driver_info;
         adjust_quirks(us);
 
         if (us->fflags & US_FL_IGNORE_DEVICE) {
@@ -1041,13 +1041,10 @@ static int storage_probe(struct usb_interface *intf,
         int size;
 
         /*
-         * If libusual is configured, let it decide whether a standard
-         * device should be handled by usb-storage or by ub.
          * If the device isn't standard (is handled by a subdriver
          * module) then don't accept it.
          */
-        if (usb_usual_check_type(id, USB_US_TYPE_STOR) ||
-                        usb_usual_ignore_device(intf))
+        if (usb_usual_ignore_device(intf))
                 return -ENXIO;
 
         /*
@@ -1105,10 +1102,8 @@ static int __init usb_stor_init(void)
 
         /* register the driver, return usb_register return code if error */
         retval = usb_register(&usb_storage_driver);
-        if (retval == 0) {
+        if (retval == 0)
                 pr_info("USB Mass Storage support registered.\n");
-                usb_usual_set_present(USB_US_TYPE_STOR);
-        }
         return retval;
 }
 
@@ -1122,8 +1117,6 @@ static void __exit usb_stor_exit(void)
          */
         US_DEBUGP("-- calling usb_deregister()\n");
         usb_deregister(&usb_storage_driver) ;
-
-        usb_usual_clear_present(USB_US_TYPE_STOR);
 }
 
 module_init(usb_stor_init);
diff --git a/drivers/usb/storage/usual-tables.c b/drivers/usb/storage/usual-tables.c
index b96927914f89..b78a526910fb 100644
--- a/drivers/usb/storage/usual-tables.c
+++ b/drivers/usb/storage/usual-tables.c
@@ -34,31 +34,23 @@
                     vendorName, productName, useProtocol, useTransport, \
                     initFunction, flags) \
 { USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
-  .driver_info = (flags)|(USB_US_TYPE_STOR<<24) }
-
-#define COMPLIANT_DEV(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax, \
-                    vendorName, productName, useProtocol, useTransport, \
-                    initFunction, flags) \
-{ USB_DEVICE_VER(id_vendor, id_product, bcdDeviceMin, bcdDeviceMax), \
   .driver_info = (flags) }
 
-#define USUAL_DEV(useProto, useTrans, useType) \
-{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans), \
-  .driver_info = ((useType)<<24) }
+#define COMPLIANT_DEV   UNUSUAL_DEV
+
+#define USUAL_DEV(useProto, useTrans) \
+{ USB_INTERFACE_INFO(USB_CLASS_MASS_STORAGE, useProto, useTrans) }
 
 struct usb_device_id usb_storage_usb_ids[] = {
 #       include "unusual_devs.h"
         { }             /* Terminating entry */
 };
-EXPORT_SYMBOL_GPL(usb_storage_usb_ids);
-
 MODULE_DEVICE_TABLE(usb, usb_storage_usb_ids);
 
 #undef UNUSUAL_DEV
 #undef COMPLIANT_DEV
 #undef USUAL_DEV
 
-
 /*
  * The table of devices to ignore
  */
@@ -95,7 +87,6 @@ static struct ignore_entry ignore_ids[] = {
 
 #undef UNUSUAL_DEV
 
-
 /* Return an error if a device is in the ignore_ids list */
 int usb_usual_ignore_device(struct usb_interface *intf)
 {
@@ -115,4 +106,3 @@ int usb_usual_ignore_device(struct usb_interface *intf)
         }
         return 0;
 }
-EXPORT_SYMBOL_GPL(usb_usual_ignore_device);
diff --git a/drivers/usb/wusbcore/Kconfig b/drivers/usb/wusbcore/Kconfig
index f29fdd7f6d75..8bf19760d447 100644
--- a/drivers/usb/wusbcore/Kconfig
+++ b/drivers/usb/wusbcore/Kconfig
@@ -2,8 +2,7 @@
 # Wireless USB Core configuration
 #
 config USB_WUSB
-        tristate "Enable Wireless USB extensions (EXPERIMENTAL)"
-        depends on EXPERIMENTAL
+        tristate "Enable Wireless USB extensions"
         depends on USB
         depends on PCI
         depends on UWB
diff --git a/drivers/usb/wusbcore/security.c b/drivers/usb/wusbcore/security.c
index fa810a83e830..dd88441c8f78 100644
--- a/drivers/usb/wusbcore/security.c
+++ b/drivers/usb/wusbcore/security.c
@@ -202,7 +202,7 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
 {
         int result, bytes, secd_size;
         struct device *dev = &usb_dev->dev;
-        struct usb_security_descriptor *secd;
+        struct usb_security_descriptor *secd, *new_secd;
         const struct usb_encryption_descriptor *etd, *ccm1_etd = NULL;
         const void *itr, *top;
         char buf[64];
@@ -221,11 +221,12 @@ int wusb_dev_sec_add(struct wusbhc *wusbhc,
                 goto out;
         }
         secd_size = le16_to_cpu(secd->wTotalLength);
-        secd = krealloc(secd, secd_size, GFP_KERNEL);
-        if (secd == NULL) {
+        new_secd = krealloc(secd, secd_size, GFP_KERNEL);
+        if (new_secd == NULL) {
                 dev_err(dev, "Can't allocate space for security descriptors\n");
                 goto out;
         }
+        secd = new_secd;
         result = usb_get_descriptor(usb_dev, USB_DT_SECURITY,
                                     0, secd, secd_size);
         if (result < secd_size) {
diff --git a/drivers/usb/wusbcore/wa-hc.c b/drivers/usb/wusbcore/wa-hc.c
index 9e4a92461688..a09b65ebd9bb 100644
--- a/drivers/usb/wusbcore/wa-hc.c
+++ b/drivers/usb/wusbcore/wa-hc.c
@@ -46,8 +46,10 @@ int wa_create(struct wahc *wa, struct usb_interface *iface)
         wa->dto_epd = &iface->cur_altsetting->endpoint[2].desc;
         wa->xfer_result_size = usb_endpoint_maxp(wa->dti_epd);
         wa->xfer_result = kmalloc(wa->xfer_result_size, GFP_KERNEL);
-        if (wa->xfer_result == NULL)
+        if (wa->xfer_result == NULL) {
+                result = -ENOMEM;
                 goto error_xfer_result_alloc;
+        }
         result = wa_nep_create(wa, iface);
         if (result < 0) {
                 dev_err(dev, "WA-CDS: can't initialize notif endpoint: %d\n",