usb: otg: isp1301_omap: Start using struct usb_otg

Use struct usb_otg members with OTG specific functions instead
of usb_phy members.

Signed-off-by: Heikki Krogerus <heikki.krogerus@linux.intel.com>
Reviewed-by: Marek Vasut <marek.vasut@gmail.com>
Signed-off-by: Felipe Balbi <balbi@ti.com>

diff --git a/drivers/usb/otg/isp1301_omap.c b/drivers/usb/otg/isp1301_omap.c
index 1bc27948ac229ca28ab18dd764bf06f3d01d4545..70cf5d7bca48ed25ee08aa6e5fa40dec52b4268a 100644 (file)
--- a/drivers/usb/otg/isp1301_omap.c
+++ b/drivers/usb/otg/isp1301_omap.c
@@ -52,7 +52,7 @@ MODULE_DESCRIPTION("ISP1301 USB OTG Transceiver Driver");
 MODULE_LICENSE("GPL");
 
 struct isp1301 {
-       struct usb_phy          otg;
+       struct usb_phy          phy;
        struct i2c_client       *client;
        void                    (*i2c_release)(struct device *dev);
 
@@ -236,7 +236,7 @@ isp1301_clear_bits(struct isp1301 *isp, u8 reg, u8 bits)
 
 static inline const char *state_name(struct isp1301 *isp)
 {
-       return otg_state_string(isp->otg.state);
+       return otg_state_string(isp->phy.state);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -251,7 +251,7 @@ static inline const char *state_name(struct isp1301 *isp)
 
 static void power_down(struct isp1301 *isp)
 {
-       isp->otg.state = OTG_STATE_UNDEFINED;
+       isp->phy.state = OTG_STATE_UNDEFINED;
 
        // isp1301_set_bits(isp, ISP1301_MODE_CONTROL_2, MC2_GLOBAL_PWR_DN);
        isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_SUSPEND);
@@ -280,13 +280,13 @@ static int host_suspend(struct isp1301 *isp)
 #else
        struct device   *dev;
 
-       if (!isp->otg.host)
+       if (!isp->phy.otg->host)
                return -ENODEV;
 
        /* Currently ASSUMES only the OTG port matters;
         * other ports could be active...
         */
-       dev = isp->otg.host->controller;
+       dev = isp->phy.otg->host->controller;
        return dev->driver->suspend(dev, 3, 0);
 #endif
 }
@@ -298,20 +298,20 @@ static int host_resume(struct isp1301 *isp)
 #else
        struct device   *dev;
 
-       if (!isp->otg.host)
+       if (!isp->phy.otg->host)
                return -ENODEV;
 
-       dev = isp->otg.host->controller;
+       dev = isp->phy.otg->host->controller;
        return dev->driver->resume(dev, 0);
 #endif
 }
 
 static int gadget_suspend(struct isp1301 *isp)
 {
-       isp->otg.gadget->b_hnp_enable = 0;
-       isp->otg.gadget->a_hnp_support = 0;
-       isp->otg.gadget->a_alt_hnp_support = 0;
-       return usb_gadget_vbus_disconnect(isp->otg.gadget);
+       isp->phy.otg->gadget->b_hnp_enable = 0;
+       isp->phy.otg->gadget->a_hnp_support = 0;
+       isp->phy.otg->gadget->a_alt_hnp_support = 0;
+       return usb_gadget_vbus_disconnect(isp->phy.otg->gadget);
 }
 
 /*-------------------------------------------------------------------------*/
@@ -341,19 +341,19 @@ static void a_idle(struct isp1301 *isp, const char *tag)
 {
        u32 l;
 
-       if (isp->otg.state == OTG_STATE_A_IDLE)
+       if (isp->phy.state == OTG_STATE_A_IDLE)
                return;
 
-       isp->otg.default_a = 1;
-       if (isp->otg.host) {
-               isp->otg.host->is_b_host = 0;
+       isp->phy.otg->default_a = 1;
+       if (isp->phy.otg->host) {
+               isp->phy.otg->host->is_b_host = 0;
                host_suspend(isp);
        }
-       if (isp->otg.gadget) {
-               isp->otg.gadget->is_a_peripheral = 1;
+       if (isp->phy.otg->gadget) {
+               isp->phy.otg->gadget->is_a_peripheral = 1;
                gadget_suspend(isp);
        }
-       isp->otg.state = OTG_STATE_A_IDLE;
+       isp->phy.state = OTG_STATE_A_IDLE;
        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
        omap_writel(l, OTG_CTRL);
        isp->last_otg_ctrl = l;
@@ -365,19 +365,19 @@ static void b_idle(struct isp1301 *isp, const char *tag)
 {
        u32 l;
 
-       if (isp->otg.state == OTG_STATE_B_IDLE)
+       if (isp->phy.state == OTG_STATE_B_IDLE)
                return;
 
-       isp->otg.default_a = 0;
-       if (isp->otg.host) {
-               isp->otg.host->is_b_host = 1;
+       isp->phy.otg->default_a = 0;
+       if (isp->phy.otg->host) {
+               isp->phy.otg->host->is_b_host = 1;
                host_suspend(isp);
        }
-       if (isp->otg.gadget) {
-               isp->otg.gadget->is_a_peripheral = 0;
+       if (isp->phy.otg->gadget) {
+               isp->phy.otg->gadget->is_a_peripheral = 0;
                gadget_suspend(isp);
        }
-       isp->otg.state = OTG_STATE_B_IDLE;
+       isp->phy.state = OTG_STATE_B_IDLE;
        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
        omap_writel(l, OTG_CTRL);
        isp->last_otg_ctrl = l;
@@ -478,7 +478,7 @@ static void check_state(struct isp1301 *isp, const char *tag)
        default:
                break;
        }
-       if (isp->otg.state == state && !extra)
+       if (isp->phy.state == state && !extra)
                return;
        pr_debug("otg: %s FSM %s/%02x, %s, %06x\n", tag,
                otg_state_string(state), fsm, state_name(isp),
@@ -502,22 +502,23 @@ static void update_otg1(struct isp1301 *isp, u8 int_src)
 
        if (int_src & INTR_SESS_VLD)
                otg_ctrl |= OTG_ASESSVLD;
-       else if (isp->otg.state == OTG_STATE_A_WAIT_VFALL) {
+       else if (isp->phy.state == OTG_STATE_A_WAIT_VFALL) {
                a_idle(isp, "vfall");
                otg_ctrl &= ~OTG_CTRL_BITS;
        }
        if (int_src & INTR_VBUS_VLD)
                otg_ctrl |= OTG_VBUSVLD;
        if (int_src & INTR_ID_GND) {            /* default-A */
-               if (isp->otg.state == OTG_STATE_B_IDLE
-                               || isp->otg.state == OTG_STATE_UNDEFINED) {
+               if (isp->phy.state == OTG_STATE_B_IDLE
+                               || isp->phy.state
+                                       == OTG_STATE_UNDEFINED) {
                        a_idle(isp, "init");
                        return;
                }
        } else {                                /* default-B */
                otg_ctrl |= OTG_ID;
-               if (isp->otg.state == OTG_STATE_A_IDLE
-                               || isp->otg.state == OTG_STATE_UNDEFINED) {
+               if (isp->phy.state == OTG_STATE_A_IDLE
+                       || isp->phy.state == OTG_STATE_UNDEFINED) {
                        b_idle(isp, "init");
                        return;
                }
@@ -551,14 +552,14 @@ static void otg_update_isp(struct isp1301 *isp)
        isp->last_otg_ctrl = otg_ctrl;
        otg_ctrl = otg_ctrl & OTG_XCEIV_INPUTS;
 
-       switch (isp->otg.state) {
+       switch (isp->phy.state) {
        case OTG_STATE_B_IDLE:
        case OTG_STATE_B_PERIPHERAL:
        case OTG_STATE_B_SRP_INIT:
                if (!(otg_ctrl & OTG_PULLUP)) {
                        // if (otg_ctrl & OTG_B_HNPEN) {
-                       if (isp->otg.gadget->b_hnp_enable) {
-                               isp->otg.state = OTG_STATE_B_WAIT_ACON;
+                       if (isp->phy.otg->gadget->b_hnp_enable) {
+                               isp->phy.state = OTG_STATE_B_WAIT_ACON;
                                pr_debug("  --> b_wait_acon\n");
                        }
                        goto pulldown;
@@ -585,10 +586,10 @@ pulldown:
                else clr |= ISP; \
                } while (0)
 
-       if (!(isp->otg.host))
+       if (!(isp->phy.otg->host))
                otg_ctrl &= ~OTG_DRV_VBUS;
 
-       switch (isp->otg.state) {
+       switch (isp->phy.state) {
        case OTG_STATE_A_SUSPEND:
                if (otg_ctrl & OTG_DRV_VBUS) {
                        set |= OTG1_VBUS_DRV;
@@ -599,7 +600,7 @@ pulldown:
 
                /* FALLTHROUGH */
        case OTG_STATE_A_VBUS_ERR:
-               isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+               isp->phy.state = OTG_STATE_A_WAIT_VFALL;
                pr_debug("  --> a_wait_vfall\n");
                /* FALLTHROUGH */
        case OTG_STATE_A_WAIT_VFALL:
@@ -608,7 +609,7 @@ pulldown:
                break;
        case OTG_STATE_A_IDLE:
                if (otg_ctrl & OTG_DRV_VBUS) {
-                       isp->otg.state = OTG_STATE_A_WAIT_VRISE;
+                       isp->phy.state = OTG_STATE_A_WAIT_VRISE;
                        pr_debug("  --> a_wait_vrise\n");
                }
                /* FALLTHROUGH */
@@ -628,17 +629,17 @@ pulldown:
        if (otg_change & OTG_PULLUP) {
                u32 l;
 
-               switch (isp->otg.state) {
+               switch (isp->phy.state) {
                case OTG_STATE_B_IDLE:
                        if (clr & OTG1_DP_PULLUP)
                                break;
-                       isp->otg.state = OTG_STATE_B_PERIPHERAL;
+                       isp->phy.state = OTG_STATE_B_PERIPHERAL;
                        pr_debug("  --> b_peripheral\n");
                        break;
                case OTG_STATE_A_SUSPEND:
                        if (clr & OTG1_DP_PULLUP)
                                break;
-                       isp->otg.state = OTG_STATE_A_PERIPHERAL;
+                       isp->phy.state = OTG_STATE_A_PERIPHERAL;
                        pr_debug("  --> a_peripheral\n");
                        break;
                default:
@@ -659,6 +660,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
        u32             otg_ctrl;
        int             ret = IRQ_NONE;
        struct isp1301  *isp = _isp;
+       struct usb_otg  *otg = isp->phy.otg;
 
        /* update ISP1301 transceiver from OTG controller */
        if (otg_irq & OPRT_CHG) {
@@ -675,7 +677,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                 * remote wakeup (SRP, normal) using their own timer
                 * to give "check cable and A-device" messages.
                 */
-               if (isp->otg.state == OTG_STATE_B_SRP_INIT)
+               if (isp->phy.state == OTG_STATE_B_SRP_INIT)
                        b_idle(isp, "srp_timeout");
 
                omap_writew(B_SRP_TMROUT, OTG_IRQ_SRC);
@@ -693,7 +695,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                omap_writel(otg_ctrl, OTG_CTRL);
 
                /* subset of b_peripheral()... */
-               isp->otg.state = OTG_STATE_B_PERIPHERAL;
+               isp->phy.state = OTG_STATE_B_PERIPHERAL;
                pr_debug("  --> b_peripheral\n");
 
                omap_writew(B_HNP_FAIL, OTG_IRQ_SRC);
@@ -705,9 +707,9 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                                state_name(isp), omap_readl(OTG_CTRL));
 
                isp1301_defer_work(isp, WORK_UPDATE_OTG);
-               switch (isp->otg.state) {
+               switch (isp->phy.state) {
                case OTG_STATE_A_IDLE:
-                       if (!isp->otg.host)
+                       if (!otg->host)
                                break;
                        isp1301_defer_work(isp, WORK_HOST_RESUME);
                        otg_ctrl = omap_readl(OTG_CTRL);
@@ -736,7 +738,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                otg_ctrl |= OTG_BUSDROP;
                otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
                omap_writel(otg_ctrl, OTG_CTRL);
-               isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+               isp->phy.state = OTG_STATE_A_WAIT_VFALL;
 
                omap_writew(A_REQ_TMROUT, OTG_IRQ_SRC);
                ret = IRQ_HANDLED;
@@ -750,7 +752,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                otg_ctrl |= OTG_BUSDROP;
                otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK & ~OTG_XCEIV_INPUTS;
                omap_writel(otg_ctrl, OTG_CTRL);
-               isp->otg.state = OTG_STATE_A_VBUS_ERR;
+               isp->phy.state = OTG_STATE_A_VBUS_ERR;
 
                omap_writew(A_VBUS_ERR, OTG_IRQ_SRC);
                ret = IRQ_HANDLED;
@@ -771,7 +773,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
 
                /* role is peripheral */
                if (otg_ctrl & OTG_DRIVER_SEL) {
-                       switch (isp->otg.state) {
+                       switch (isp->phy.state) {
                        case OTG_STATE_A_IDLE:
                                b_idle(isp, __func__);
                                break;
@@ -787,19 +789,19 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                                omap_writel(otg_ctrl | OTG_A_BUSREQ, OTG_CTRL);
                        }
 
-                       if (isp->otg.host) {
-                               switch (isp->otg.state) {
+                       if (otg->host) {
+                               switch (isp->phy.state) {
                                case OTG_STATE_B_WAIT_ACON:
-                                       isp->otg.state = OTG_STATE_B_HOST;
+                                       isp->phy.state = OTG_STATE_B_HOST;
                                        pr_debug("  --> b_host\n");
                                        kick = 1;
                                        break;
                                case OTG_STATE_A_WAIT_BCON:
-                                       isp->otg.state = OTG_STATE_A_HOST;
+                                       isp->phy.state = OTG_STATE_A_HOST;
                                        pr_debug("  --> a_host\n");
                                        break;
                                case OTG_STATE_A_PERIPHERAL:
-                                       isp->otg.state = OTG_STATE_A_WAIT_BCON;
+                                       isp->phy.state = OTG_STATE_A_WAIT_BCON;
                                        pr_debug("  --> a_wait_bcon\n");
                                        break;
                                default:
@@ -813,8 +815,7 @@ static irqreturn_t omap_otg_irq(int irq, void *_isp)
                ret = IRQ_HANDLED;
 
                if (kick)
-                       usb_bus_start_enum(isp->otg.host,
-                                               isp->otg.host->otg_port);
+                       usb_bus_start_enum(otg->host, otg->host->otg_port);
        }
 
        check_state(isp, __func__);
@@ -930,7 +931,7 @@ static void b_peripheral(struct isp1301 *isp)
        l = omap_readl(OTG_CTRL) & OTG_XCEIV_OUTPUTS;
        omap_writel(l, OTG_CTRL);
 
-       usb_gadget_vbus_connect(isp->otg.gadget);
+       usb_gadget_vbus_connect(isp->phy.otg->gadget);
 
 #ifdef CONFIG_USB_OTG
        enable_vbus_draw(isp, 8);
@@ -940,7 +941,7 @@ static void b_peripheral(struct isp1301 *isp)
        /* UDC driver just set OTG_BSESSVLD */
        isp1301_set_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLUP);
        isp1301_clear_bits(isp, ISP1301_OTG_CONTROL_1, OTG1_DP_PULLDOWN);
-       isp->otg.state = OTG_STATE_B_PERIPHERAL;
+       isp->phy.state = OTG_STATE_B_PERIPHERAL;
        pr_debug("  --> b_peripheral\n");
        dump_regs(isp, "2periph");
 #endif
@@ -948,8 +949,9 @@ static void b_peripheral(struct isp1301 *isp)
 
 static void isp_update_otg(struct isp1301 *isp, u8 stat)
 {
+       struct usb_otg          *otg = isp->phy.otg;
        u8                      isp_stat, isp_bstat;
-       enum usb_otg_state      state = isp->otg.state;
+       enum usb_otg_state      state = isp->phy.state;
 
        if (stat & INTR_BDIS_ACON)
                pr_debug("OTG:  BDIS_ACON, %s\n", state_name(isp));
@@ -957,7 +959,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
        /* start certain state transitions right away */
        isp_stat = isp1301_get_u8(isp, ISP1301_INTERRUPT_SOURCE);
        if (isp_stat & INTR_ID_GND) {
-               if (isp->otg.default_a) {
+               if (otg->default_a) {
                        switch (state) {
                        case OTG_STATE_B_IDLE:
                                a_idle(isp, "idle");
@@ -972,7 +974,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                                 * when HNP is used.
                                 */
                                if (isp_stat & INTR_VBUS_VLD)
-                                       isp->otg.state = OTG_STATE_A_HOST;
+                                       isp->phy.state = OTG_STATE_A_HOST;
                                break;
                        case OTG_STATE_A_WAIT_VFALL:
                                if (!(isp_stat & INTR_SESS_VLD))
@@ -980,7 +982,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                                break;
                        default:
                                if (!(isp_stat & INTR_VBUS_VLD))
-                                       isp->otg.state = OTG_STATE_A_VBUS_ERR;
+                                       isp->phy.state = OTG_STATE_A_VBUS_ERR;
                                break;
                        }
                        isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
@@ -989,14 +991,14 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                        case OTG_STATE_B_PERIPHERAL:
                        case OTG_STATE_B_HOST:
                        case OTG_STATE_B_WAIT_ACON:
-                               usb_gadget_vbus_disconnect(isp->otg.gadget);
+                               usb_gadget_vbus_disconnect(otg->gadget);
                                break;
                        default:
                                break;
                        }
                        if (state != OTG_STATE_A_IDLE)
                                a_idle(isp, "id");
-                       if (isp->otg.host && state == OTG_STATE_A_IDLE)
+                       if (otg->host && state == OTG_STATE_A_IDLE)
                                isp1301_defer_work(isp, WORK_HOST_RESUME);
                        isp_bstat = 0;
                }
@@ -1006,10 +1008,10 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                /* if user unplugged mini-A end of cable,
                 * don't bypass A_WAIT_VFALL.
                 */
-               if (isp->otg.default_a) {
+               if (otg->default_a) {
                        switch (state) {
                        default:
-                               isp->otg.state = OTG_STATE_A_WAIT_VFALL;
+                               isp->phy.state = OTG_STATE_A_WAIT_VFALL;
                                break;
                        case OTG_STATE_A_WAIT_VFALL:
                                state = OTG_STATE_A_IDLE;
@@ -1022,7 +1024,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                                host_suspend(isp);
                                isp1301_clear_bits(isp, ISP1301_MODE_CONTROL_1,
                                                MC1_BDIS_ACON_EN);
-                               isp->otg.state = OTG_STATE_B_IDLE;
+                               isp->phy.state = OTG_STATE_B_IDLE;
                                l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
                                l &= ~OTG_CTRL_BITS;
                                omap_writel(l, OTG_CTRL);
@@ -1033,7 +1035,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                }
                isp_bstat = isp1301_get_u8(isp, ISP1301_OTG_STATUS);
 
-               switch (isp->otg.state) {
+               switch (isp->phy.state) {
                case OTG_STATE_B_PERIPHERAL:
                case OTG_STATE_B_WAIT_ACON:
                case OTG_STATE_B_HOST:
@@ -1055,7 +1057,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                        omap_writel(l, OTG_CTRL);
                        /* FALLTHROUGH */
                case OTG_STATE_B_IDLE:
-                       if (isp->otg.gadget && (isp_bstat & OTG_B_SESS_VLD)) {
+                       if (otg->gadget && (isp_bstat & OTG_B_SESS_VLD)) {
 #ifdef CONFIG_USB_OTG
                                update_otg1(isp, isp_stat);
                                update_otg2(isp, isp_bstat);
@@ -1073,7 +1075,7 @@ static void isp_update_otg(struct isp1301 *isp, u8 stat)
                }
        }
 
-       if (state != isp->otg.state)
+       if (state != isp->phy.state)
                pr_debug("  isp, %s -> %s\n",
                                otg_state_string(state), state_name(isp));
 
@@ -1131,10 +1133,10 @@ isp1301_work(struct work_struct *work)
                         * skip A_WAIT_VRISE; hc transitions invisibly
                         * skip A_WAIT_BCON; same.
                         */
-                       switch (isp->otg.state) {
+                       switch (isp->phy.state) {
                        case OTG_STATE_A_WAIT_BCON:
                        case OTG_STATE_A_WAIT_VRISE:
-                               isp->otg.state = OTG_STATE_A_HOST;
+                               isp->phy.state = OTG_STATE_A_HOST;
                                pr_debug("  --> a_host\n");
                                otg_ctrl = omap_readl(OTG_CTRL);
                                otg_ctrl |= OTG_A_BUSREQ;
@@ -1143,7 +1145,7 @@ isp1301_work(struct work_struct *work)
                                omap_writel(otg_ctrl, OTG_CTRL);
                                break;
                        case OTG_STATE_B_WAIT_ACON:
-                               isp->otg.state = OTG_STATE_B_HOST;
+                               isp->phy.state = OTG_STATE_B_HOST;
                                pr_debug("  --> b_host (acon)\n");
                                break;
                        case OTG_STATE_B_HOST:
@@ -1204,6 +1206,7 @@ static void isp1301_release(struct device *dev)
        /* ugly -- i2c hijacks our memory hook to wait_for_completion() */
        if (isp->i2c_release)
                isp->i2c_release(dev);
+       kfree(isp->phy.otg);
        kfree (isp);
 }
 
@@ -1274,9 +1277,9 @@ static int isp1301_otg_enable(struct isp1301 *isp)
 
 /* add or disable the host device+driver */
 static int
-isp1301_set_host(struct usb_phy *otg, struct usb_bus *host)
+isp1301_set_host(struct usb_otg *otg, struct usb_bus *host)
 {
-       struct isp1301  *isp = container_of(otg, struct isp1301, otg);
+       struct isp1301  *isp = container_of(otg->phy, struct isp1301, phy);
 
        if (!otg || isp != the_transceiver)
                return -ENODEV;
@@ -1284,21 +1287,21 @@ isp1301_set_host(struct usb_phy *otg, struct usb_bus *host)
        if (!host) {
                omap_writew(0, OTG_IRQ_EN);
                power_down(isp);
-               isp->otg.host = NULL;
+               otg->host = NULL;
                return 0;
        }
 
 #ifdef CONFIG_USB_OTG
-       isp->otg.host = host;
+       otg->host = host;
        dev_dbg(&isp->client->dev, "registered host\n");
        host_suspend(isp);
-       if (isp->otg.gadget)
+       if (otg->gadget)
                return isp1301_otg_enable(isp);
        return 0;
 
 #elif  !defined(CONFIG_USB_GADGET_OMAP)
        // FIXME update its refcount
-       isp->otg.host = host;
+       otg->host = host;
 
        power_up(isp);
 
@@ -1330,9 +1333,9 @@ isp1301_set_host(struct usb_phy *otg, struct usb_bus *host)
 }
 
 static int
-isp1301_set_peripheral(struct usb_phy *otg, struct usb_gadget *gadget)
+isp1301_set_peripheral(struct usb_otg *otg, struct usb_gadget *gadget)
 {
-       struct isp1301  *isp = container_of(otg, struct isp1301, otg);
+       struct isp1301  *isp = container_of(otg->phy, struct isp1301, phy);
 #ifndef        CONFIG_USB_OTG
        u32 l;
 #endif
@@ -1342,24 +1345,24 @@ isp1301_set_peripheral(struct usb_phy *otg, struct usb_gadget *gadget)
 
        if (!gadget) {
                omap_writew(0, OTG_IRQ_EN);
-               if (!isp->otg.default_a)
+               if (!otg->default_a)
                        enable_vbus_draw(isp, 0);
-               usb_gadget_vbus_disconnect(isp->otg.gadget);
-               isp->otg.gadget = NULL;
+               usb_gadget_vbus_disconnect(otg->gadget);
+               otg->gadget = NULL;
                power_down(isp);
                return 0;
        }
 
 #ifdef CONFIG_USB_OTG
-       isp->otg.gadget = gadget;
+       otg->gadget = gadget;
        dev_dbg(&isp->client->dev, "registered gadget\n");
        /* gadget driver may be suspended until vbus_connect () */
-       if (isp->otg.host)
+       if (otg->host)
                return isp1301_otg_enable(isp);
        return 0;
 
 #elif  !defined(CONFIG_USB_OHCI_HCD) && !defined(CONFIG_USB_OHCI_HCD_MODULE)
-       isp->otg.gadget = gadget;
+       otg->gadget = gadget;
        // FIXME update its refcount
 
        l = omap_readl(OTG_CTRL) & OTG_CTRL_MASK;
@@ -1368,7 +1371,7 @@ isp1301_set_peripheral(struct usb_phy *otg, struct usb_gadget *gadget)
        omap_writel(l, OTG_CTRL);
 
        power_up(isp);
-       isp->otg.state = OTG_STATE_B_IDLE;
+       isp->phy.state = OTG_STATE_B_IDLE;
 
        if (machine_is_omap_h2() || machine_is_omap_h3())
                isp1301_set_bits(isp, ISP1301_MODE_CONTROL_1, MC1_DAT_SE0);
@@ -1409,13 +1412,13 @@ isp1301_set_power(struct usb_phy *dev, unsigned mA)
 }
 
 static int
-isp1301_start_srp(struct usb_phy *dev)
+isp1301_start_srp(struct usb_otg *otg)
 {
-       struct isp1301  *isp = container_of(dev, struct isp1301, otg);
+       struct isp1301  *isp = container_of(otg->phy, struct isp1301, phy);
        u32             otg_ctrl;
 
-       if (!dev || isp != the_transceiver
-                       || isp->otg.state != OTG_STATE_B_IDLE)
+       if (!otg || isp != the_transceiver
+                       || isp->phy.state != OTG_STATE_B_IDLE)
                return -ENODEV;
 
        otg_ctrl = omap_readl(OTG_CTRL);
@@ -1425,7 +1428,7 @@ isp1301_start_srp(struct usb_phy *dev)
        otg_ctrl |= OTG_B_BUSREQ;
        otg_ctrl &= ~OTG_A_BUSREQ & OTG_CTRL_MASK;
        omap_writel(otg_ctrl, OTG_CTRL);
-       isp->otg.state = OTG_STATE_B_SRP_INIT;
+       isp->phy.state = OTG_STATE_B_SRP_INIT;
 
        pr_debug("otg: SRP, %s ... %06x\n", state_name(isp),
                        omap_readl(OTG_CTRL));
@@ -1436,27 +1439,26 @@ isp1301_start_srp(struct usb_phy *dev)
 }
 
 static int
-isp1301_start_hnp(struct usb_phy *dev)
+isp1301_start_hnp(struct usb_otg *otg)
 {
 #ifdef CONFIG_USB_OTG
-       struct isp1301  *isp = container_of(dev, struct isp1301, otg);
+       struct isp1301  *isp = container_of(otg->phy, struct isp1301, phy);
        u32 l;
 
-       if (!dev || isp != the_transceiver)
+       if (!otg || isp != the_transceiver)
                return -ENODEV;
-       if (isp->otg.default_a && (isp->otg.host == NULL
-                       || !isp->otg.host->b_hnp_enable))
+       if (otg->default_a && (otg->host == NULL || !otg->host->b_hnp_enable))
                return -ENOTCONN;
-       if (!isp->otg.default_a && (isp->otg.gadget == NULL
-                       || !isp->otg.gadget->b_hnp_enable))
+       if (!otg->default_a && (otg->gadget == NULL
+                       || !otg->gadget->b_hnp_enable))
                return -ENOTCONN;
 
        /* We want hardware to manage most HNP protocol timings.
         * So do this part as early as possible...
         */
-       switch (isp->otg.state) {
+       switch (isp->phy.state) {
        case OTG_STATE_B_HOST:
-               isp->otg.state = OTG_STATE_B_PERIPHERAL;
+               isp->phy.state = OTG_STATE_B_PERIPHERAL;
                /* caller will suspend next */
                break;
        case OTG_STATE_A_HOST:
@@ -1466,7 +1468,7 @@ isp1301_start_hnp(struct usb_phy *dev)
                                MC1_BDIS_ACON_EN);
 #endif
                /* caller must suspend then clear A_BUSREQ */
-               usb_gadget_vbus_connect(isp->otg.gadget);
+               usb_gadget_vbus_connect(otg->gadget);
                l = omap_readl(OTG_CTRL);
                l |= OTG_A_SETB_HNPEN;
                omap_writel(l, OTG_CTRL);
@@ -1503,6 +1505,12 @@ isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
        if (!isp)
                return 0;
 
+       isp->phy.otg = kzalloc(sizeof *isp->phy.otg, GFP_KERNEL);
+       if (!isp->phy.otg) {
+               kfree(isp);
+               return 0;
+       }
+
        INIT_WORK(&isp->work, isp1301_work);
        init_timer(&isp->timer);
        isp->timer.function = isp1301_timer;
@@ -1576,14 +1584,15 @@ isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
                goto fail;
        }
 
-       isp->otg.dev = &i2c->dev;
-       isp->otg.label = DRIVER_NAME;
+       isp->phy.dev = &i2c->dev;
+       isp->phy.label = DRIVER_NAME;
+       isp->phy.set_power = isp1301_set_power,
 
-       isp->otg.set_host = isp1301_set_host,
-       isp->otg.set_peripheral = isp1301_set_peripheral,
-       isp->otg.set_power = isp1301_set_power,
-       isp->otg.start_srp = isp1301_start_srp,
-       isp->otg.start_hnp = isp1301_start_hnp,
+       isp->phy.otg->phy = &isp->phy;
+       isp->phy.otg->set_host = isp1301_set_host,
+       isp->phy.otg->set_peripheral = isp1301_set_peripheral,
+       isp->phy.otg->start_srp = isp1301_start_srp,
+       isp->phy.otg->start_hnp = isp1301_start_hnp,
 
        enable_vbus_draw(isp, 0);
        power_down(isp);
@@ -1601,7 +1610,7 @@ isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
        dev_dbg(&i2c->dev, "scheduled timer, %d min\n", TIMER_MINUTES);
 #endif
 
-       status = otg_set_transceiver(&isp->otg);
+       status = usb_set_transceiver(&isp->phy);
        if (status < 0)
                dev_err(&i2c->dev, "can't register transceiver, %d\n",
                        status);
@@ -1609,6 +1618,7 @@ isp1301_probe(struct i2c_client *i2c, const struct i2c_device_id *id)
        return 0;
 
 fail:
+       kfree(isp->phy.otg);
        kfree(isp);
        return -ENODEV;
 }
@@ -1639,7 +1649,7 @@ subsys_initcall(isp_init);
 static void __exit isp_exit(void)
 {
        if (the_transceiver)
-               otg_set_transceiver(NULL);
+               usb_set_transceiver(NULL);
        i2c_del_driver(&isp1301_driver);
 }
 module_exit(isp_exit);