usb: otg: mv_otg: Start using struct usb_otg

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

[ balbi@ti.com : fixed a compile error on isp1704_charger.c ]

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

3 files changed, 69 insertions, 55 deletions

diff --git a/drivers/power/isp1704_charger.c b/drivers/power/isp1704_charger.c
index 58ad6e998ca0..1289a5f790a1 100644
--- a/drivers/power/isp1704_charger.c
+++ b/drivers/power/isp1704_charger.c
@@ -274,8 +274,8 @@ static void isp1704_charger_work(struct work_struct *data)
                 case POWER_SUPPLY_TYPE_USB:
                 default:
                         /* enable data pullups */
-                        if (isp->phy->gadget)
-                                usb_gadget_connect(isp->phy->gadget);
+                        if (isp->phy->otg->gadget)
+                                usb_gadget_connect(isp->phy->otg->gadget);
                 }
                 break;
         case USB_EVENT_NONE:
@@ -293,8 +293,8 @@ static void isp1704_charger_work(struct work_struct *data)
                  * chargers. The pullups may be enabled elsewhere, so this can
                  * not be the final solution.
                  */
-                if (isp->phy->gadget)
-                        usb_gadget_disconnect(isp->phy->gadget);
+                if (isp->phy->otg->gadget)
+                        usb_gadget_disconnect(isp->phy->otg->gadget);
 
                 isp1704_charger_set_power(isp, 0);
                 break;
@@ -459,8 +459,8 @@ static int __devinit isp1704_charger_probe(struct platform_device *pdev)
          * enumerated. The charger driver should be always loaded before any
          * gadget is loaded.
          */
-        if (isp->phy->gadget)
-                usb_gadget_disconnect(isp->phy->gadget);
+        if (isp->phy->otg->gadget)
+                usb_gadget_disconnect(isp->phy->otg->gadget);
 
         /* Detect charger if VBUS is valid (the cable was already plugged). */
         ret = isp1704_read(isp, ULPI_USB_INT_STS);
diff --git a/drivers/usb/otg/mv_otg.c b/drivers/usb/otg/mv_otg.c
index 6e05d58effe1..6cc6c3ffbb83 100644
--- a/drivers/usb/otg/mv_otg.c
+++ b/drivers/usb/otg/mv_otg.c
@@ -55,16 +55,16 @@ static char *state_string[] = {
         "a_vbus_err"
 };
 
-static int mv_otg_set_vbus(struct usb_phy *otg, bool on)
+static int mv_otg_set_vbus(struct usb_otg *otg, bool on)
 {
-        struct mv_otg *mvotg = container_of(otg, struct mv_otg, otg);
+        struct mv_otg *mvotg = container_of(otg->phy, struct mv_otg, phy);
         if (mvotg->pdata->set_vbus == NULL)
                 return -ENODEV;
 
         return mvotg->pdata->set_vbus(on);
 }
 
-static int mv_otg_set_host(struct usb_phy *otg,
+static int mv_otg_set_host(struct usb_otg *otg,
                            struct usb_bus *host)
 {
         otg->host = host;
@@ -72,7 +72,7 @@ static int mv_otg_set_host(struct usb_phy *otg,
         return 0;
 }
 
-static int mv_otg_set_peripheral(struct usb_phy *otg,
+static int mv_otg_set_peripheral(struct usb_otg *otg,
                                  struct usb_gadget *gadget)
 {
         otg->gadget = gadget;
@@ -203,7 +203,7 @@ static void mv_otg_init_irq(struct mv_otg *mvotg)
 static void mv_otg_start_host(struct mv_otg *mvotg, int on)
 {
 #ifdef CONFIG_USB
-        struct usb_phy *otg = &mvotg->otg;
+        struct usb_otg *otg = mvotg->phy.otg;
         struct usb_hcd *hcd;
 
         if (!otg->host)
@@ -222,12 +222,12 @@ static void mv_otg_start_host(struct mv_otg *mvotg, int on)
 
 static void mv_otg_start_periphrals(struct mv_otg *mvotg, int on)
 {
-        struct usb_phy *otg = &mvotg->otg;
+        struct usb_otg *otg = mvotg->phy.otg;
 
         if (!otg->gadget)
                 return;
 
-        dev_info(otg->dev, "gadget %s\n", on ? "on" : "off");
+        dev_info(mvotg->phy.dev, "gadget %s\n", on ? "on" : "off");
 
         if (on)
                 usb_gadget_vbus_connect(otg->gadget);
@@ -343,69 +343,69 @@ static void mv_otg_update_inputs(struct mv_otg *mvotg)
 static void mv_otg_update_state(struct mv_otg *mvotg)
 {
         struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl;
-        struct usb_phy *otg = &mvotg->otg;
-        int old_state = otg->state;
+        struct usb_phy *phy = &mvotg->phy;
+        int old_state = phy->state;
 
         switch (old_state) {
         case OTG_STATE_UNDEFINED:
-                otg->state = OTG_STATE_B_IDLE;
+                phy->state = OTG_STATE_B_IDLE;
                 /* FALL THROUGH */
         case OTG_STATE_B_IDLE:
                 if (otg_ctrl->id == 0)
-                        otg->state = OTG_STATE_A_IDLE;
+                        phy->state = OTG_STATE_A_IDLE;
                 else if (otg_ctrl->b_sess_vld)
-                        otg->state = OTG_STATE_B_PERIPHERAL;
+                        phy->state = OTG_STATE_B_PERIPHERAL;
                 break;
         case OTG_STATE_B_PERIPHERAL:
                 if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0)
-                        otg->state = OTG_STATE_B_IDLE;
+                        phy->state = OTG_STATE_B_IDLE;
                 break;
         case OTG_STATE_A_IDLE:
                 if (otg_ctrl->id)
-                        otg->state = OTG_STATE_B_IDLE;
+                        phy->state = OTG_STATE_B_IDLE;
                 else if (!(otg_ctrl->a_bus_drop) &&
                          (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det))
-                        otg->state = OTG_STATE_A_WAIT_VRISE;
+                        phy->state = OTG_STATE_A_WAIT_VRISE;
                 break;
         case OTG_STATE_A_WAIT_VRISE:
                 if (otg_ctrl->a_vbus_vld)
-                        otg->state = OTG_STATE_A_WAIT_BCON;
+                        phy->state = OTG_STATE_A_WAIT_BCON;
                 break;
         case OTG_STATE_A_WAIT_BCON:
                 if (otg_ctrl->id || otg_ctrl->a_bus_drop
                     || otg_ctrl->a_wait_bcon_timeout) {
                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
-                        otg->state = OTG_STATE_A_WAIT_VFALL;
+                        phy->state = OTG_STATE_A_WAIT_VFALL;
                         otg_ctrl->a_bus_req = 0;
                 } else if (!otg_ctrl->a_vbus_vld) {
                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
-                        otg->state = OTG_STATE_A_VBUS_ERR;
+                        phy->state = OTG_STATE_A_VBUS_ERR;
                 } else if (otg_ctrl->b_conn) {
                         mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER);
                         mvotg->otg_ctrl.a_wait_bcon_timeout = 0;
-                        otg->state = OTG_STATE_A_HOST;
+                        phy->state = OTG_STATE_A_HOST;
                 }
                 break;
         case OTG_STATE_A_HOST:
                 if (otg_ctrl->id || !otg_ctrl->b_conn
                     || otg_ctrl->a_bus_drop)
-                        otg->state = OTG_STATE_A_WAIT_BCON;
+                        phy->state = OTG_STATE_A_WAIT_BCON;
                 else if (!otg_ctrl->a_vbus_vld)
-                        otg->state = OTG_STATE_A_VBUS_ERR;
+                        phy->state = OTG_STATE_A_VBUS_ERR;
                 break;
         case OTG_STATE_A_WAIT_VFALL:
                 if (otg_ctrl->id
                     || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld)
                     || otg_ctrl->a_bus_req)
-                        otg->state = OTG_STATE_A_IDLE;
+                        phy->state = OTG_STATE_A_IDLE;
                 break;
         case OTG_STATE_A_VBUS_ERR:
                 if (otg_ctrl->id || otg_ctrl->a_clr_err
                     || otg_ctrl->a_bus_drop) {
                         otg_ctrl->a_clr_err = 0;
-                        otg->state = OTG_STATE_A_WAIT_VFALL;
+                        phy->state = OTG_STATE_A_WAIT_VFALL;
                 }
                 break;
         default:
@@ -416,15 +416,17 @@ static void mv_otg_update_state(struct mv_otg *mvotg)
 static void mv_otg_work(struct work_struct *work)
 {
         struct mv_otg *mvotg;
-        struct usb_phy *otg;
+        struct usb_phy *phy;
+        struct usb_otg *otg;
         int old_state;
 
         mvotg = container_of((struct delayed_work *)work, struct mv_otg, work);
 
 run:
         /* work queue is single thread, or we need spin_lock to protect */
-        otg = &mvotg->otg;
-        old_state = otg->state;
+        phy = &mvotg->phy;
+        otg = phy->otg;
+        old_state = phy->state;
 
         if (!mvotg->active)
                 return;
@@ -432,14 +434,14 @@ run:
         mv_otg_update_inputs(mvotg);
         mv_otg_update_state(mvotg);
 
-        if (old_state != otg->state) {
+        if (old_state != phy->state) {
                 dev_info(&mvotg->pdev->dev, "change from state %s to %s\n",
                          state_string[old_state],
-                         state_string[otg->state]);
+                         state_string[phy->state]);
 
-                switch (otg->state) {
+                switch (phy->state) {
                 case OTG_STATE_B_IDLE:
-                        mvotg->otg.default_a = 0;
+                        otg->default_a = 0;
                         if (old_state == OTG_STATE_B_PERIPHERAL)
                                 mv_otg_start_periphrals(mvotg, 0);
                         mv_otg_reset(mvotg);
@@ -450,14 +452,14 @@ run:
                         mv_otg_start_periphrals(mvotg, 1);
                         break;
                 case OTG_STATE_A_IDLE:
-                        mvotg->otg.default_a = 1;
+                        otg->default_a = 1;
                         mv_otg_enable(mvotg);
                         if (old_state == OTG_STATE_A_WAIT_VFALL)
                                 mv_otg_start_host(mvotg, 0);
                         mv_otg_reset(mvotg);
                         break;
                 case OTG_STATE_A_WAIT_VRISE:
-                        mv_otg_set_vbus(&mvotg->otg, 1);
+                        mv_otg_set_vbus(otg, 1);
                         break;
                 case OTG_STATE_A_WAIT_BCON:
                         if (old_state != OTG_STATE_A_HOST)
@@ -479,7 +481,7 @@ run:
                          * here. In fact, it need host driver to notify us.
                          */
                         mvotg->otg_ctrl.b_conn = 0;
-                        mv_otg_set_vbus(&mvotg->otg, 0);
+                        mv_otg_set_vbus(otg, 0);
                         break;
                 case OTG_STATE_A_VBUS_ERR:
                         break;
@@ -548,8 +550,8 @@ set_a_bus_req(struct device *dev, struct device_attribute *attr,
                 return -1;
 
         /* We will use this interface to change to A device */
-        if (mvotg->otg.state != OTG_STATE_B_IDLE
-            && mvotg->otg.state != OTG_STATE_A_IDLE)
+        if (mvotg->phy.state != OTG_STATE_B_IDLE
+            && mvotg->phy.state != OTG_STATE_A_IDLE)
                 return -1;
 
         /* The clock may disabled and we need to set irq for ID detected */
@@ -579,7 +581,7 @@ set_a_clr_err(struct device *dev, struct device_attribute *attr,
               const char *buf, size_t count)
 {
         struct mv_otg *mvotg = dev_get_drvdata(dev);
-        if (!mvotg->otg.default_a)
+        if (!mvotg->phy.otg->default_a)
                 return -1;
 
         if (count > 2)
@@ -615,7 +617,7 @@ set_a_bus_drop(struct device *dev, struct device_attribute *attr,
                const char *buf, size_t count)
 {
         struct mv_otg *mvotg = dev_get_drvdata(dev);
-        if (!mvotg->otg.default_a)
+        if (!mvotg->phy.otg->default_a)
                 return -1;
 
         if (count > 2)
@@ -688,9 +690,10 @@ int mv_otg_remove(struct platform_device *pdev)
         for (clk_i = 0; clk_i <= mvotg->clknum; clk_i++)
                 clk_put(mvotg->clk[clk_i]);
 
-        otg_set_transceiver(NULL);
+        usb_set_transceiver(NULL);
         platform_set_drvdata(pdev, NULL);
 
+        kfree(mvotg->phy.otg);
         kfree(mvotg);
 
         return 0;
@@ -700,6 +703,7 @@ static int mv_otg_probe(struct platform_device *pdev)
 {
         struct mv_usb_platform_data *pdata = pdev->dev.platform_data;
         struct mv_otg *mvotg;
+        struct usb_otg *otg;
         struct resource *r;
         int retval = 0, clk_i, i;
         size_t size;
@@ -716,6 +720,12 @@ static int mv_otg_probe(struct platform_device *pdev)
                 return -ENOMEM;
         }
 
+        otg = kzalloc(sizeof *otg, GFP_KERNEL);
+        if (!otg) {
+                kfree(mvotg);
+                return -ENOMEM;
+        }
+
         platform_set_drvdata(pdev, mvotg);
 
         mvotg->pdev = pdev;
@@ -741,12 +751,15 @@ static int mv_otg_probe(struct platform_device *pdev)
 
         /* OTG common part */
         mvotg->pdev = pdev;
-        mvotg->otg.dev = &pdev->dev;
-        mvotg->otg.label = driver_name;
-        mvotg->otg.set_host = mv_otg_set_host;
-        mvotg->otg.set_peripheral = mv_otg_set_peripheral;
-        mvotg->otg.set_vbus = mv_otg_set_vbus;
-        mvotg->otg.state = OTG_STATE_UNDEFINED;
+        mvotg->phy.dev = &pdev->dev;
+        mvotg->phy.otg = otg;
+        mvotg->phy.label = driver_name;
+        mvotg->phy.state = OTG_STATE_UNDEFINED;
+
+        otg->phy = &mvotg->phy;
+        otg->set_host = mv_otg_set_host;
+        otg->set_peripheral = mv_otg_set_peripheral;
+        otg->set_vbus = mv_otg_set_vbus;
 
         for (i = 0; i < OTG_TIMER_NUM; i++)
                 init_timer(&mvotg->otg_ctrl.timer[i]);
@@ -840,7 +853,7 @@ static int mv_otg_probe(struct platform_device *pdev)
                 goto err_disable_clk;
         }
 
-        retval = otg_set_transceiver(&mvotg->otg);
+        retval = usb_set_transceiver(&mvotg->phy);
         if (retval < 0) {
                 dev_err(&pdev->dev, "can't register transceiver, %d\n",
                         retval);
@@ -867,7 +880,7 @@ static int mv_otg_probe(struct platform_device *pdev)
         return 0;
 
 err_set_transceiver:
-        otg_set_transceiver(NULL);
+        usb_set_transceiver(NULL);
 err_free_irq:
         free_irq(mvotg->irq, mvotg);
 err_disable_clk:
@@ -888,6 +901,7 @@ err_put_clk:
                 clk_put(mvotg->clk[clk_i]);
 
         platform_set_drvdata(pdev, NULL);
+        kfree(otg);
         kfree(mvotg);
 
         return retval;
@@ -898,10 +912,10 @@ static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state)
 {
         struct mv_otg *mvotg = platform_get_drvdata(pdev);
 
-        if (mvotg->otg.state != OTG_STATE_B_IDLE) {
+        if (mvotg->phy.state != OTG_STATE_B_IDLE) {
                 dev_info(&pdev->dev,
                          "OTG state is not B_IDLE, it is %d!\n",
-                         mvotg->otg.state);
+                         mvotg->phy.state);
                 return -EAGAIN;
         }
 
diff --git a/drivers/usb/otg/mv_otg.h b/drivers/usb/otg/mv_otg.h
index a74ee07a2727..8a9e351b36ba 100644
--- a/drivers/usb/otg/mv_otg.h
+++ b/drivers/usb/otg/mv_otg.h
@@ -136,7 +136,7 @@ struct mv_otg_regs {
 };
 
 struct mv_otg {
-        struct usb_phy otg;
+        struct usb_phy phy;
         struct mv_otg_ctrl otg_ctrl;
 
         /* base address */