Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 Marvell International Ltd. All rights reserved. |
| 3 | * Author: Chao Xie <chao.xie@marvell.com> |
| 4 | * Neil Zhang <zhangwm@marvell.com> |
| 5 | * |
| 6 | * This program is free software; you can redistribute it and/or modify it |
| 7 | * under the terms of the GNU General Public License as published by the |
| 8 | * Free Software Foundation; either version 2 of the License, or (at your |
| 9 | * option) any later version. |
| 10 | */ |
| 11 | |
| 12 | #include <linux/module.h> |
| 13 | #include <linux/kernel.h> |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 14 | #include <linux/io.h> |
| 15 | #include <linux/uaccess.h> |
| 16 | #include <linux/device.h> |
| 17 | #include <linux/proc_fs.h> |
| 18 | #include <linux/clk.h> |
| 19 | #include <linux/workqueue.h> |
| 20 | #include <linux/platform_device.h> |
| 21 | |
| 22 | #include <linux/usb.h> |
| 23 | #include <linux/usb/ch9.h> |
| 24 | #include <linux/usb/otg.h> |
| 25 | #include <linux/usb/gadget.h> |
| 26 | #include <linux/usb/hcd.h> |
| 27 | #include <linux/platform_data/mv_usb.h> |
| 28 | |
Felipe Balbi | 94ae984 | 2013-03-07 17:37:59 +0200 | [diff] [blame] | 29 | #include "phy-mv-usb.h" |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 30 | |
| 31 | #define DRIVER_DESC "Marvell USB OTG transceiver driver" |
| 32 | #define DRIVER_VERSION "Jan 20, 2010" |
| 33 | |
| 34 | MODULE_DESCRIPTION(DRIVER_DESC); |
| 35 | MODULE_VERSION(DRIVER_VERSION); |
| 36 | MODULE_LICENSE("GPL"); |
| 37 | |
| 38 | static const char driver_name[] = "mv-otg"; |
| 39 | |
| 40 | static char *state_string[] = { |
| 41 | "undefined", |
| 42 | "b_idle", |
| 43 | "b_srp_init", |
| 44 | "b_peripheral", |
| 45 | "b_wait_acon", |
| 46 | "b_host", |
| 47 | "a_idle", |
| 48 | "a_wait_vrise", |
| 49 | "a_wait_bcon", |
| 50 | "a_host", |
| 51 | "a_suspend", |
| 52 | "a_peripheral", |
| 53 | "a_wait_vfall", |
| 54 | "a_vbus_err" |
| 55 | }; |
| 56 | |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 57 | static int mv_otg_set_vbus(struct usb_otg *otg, bool on) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 58 | { |
Antoine Tenart | 19c1eac | 2014-10-30 18:41:14 +0100 | [diff] [blame] | 59 | struct mv_otg *mvotg = container_of(otg->usb_phy, struct mv_otg, phy); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 60 | if (mvotg->pdata->set_vbus == NULL) |
| 61 | return -ENODEV; |
| 62 | |
| 63 | return mvotg->pdata->set_vbus(on); |
| 64 | } |
| 65 | |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 66 | static int mv_otg_set_host(struct usb_otg *otg, |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 67 | struct usb_bus *host) |
| 68 | { |
| 69 | otg->host = host; |
| 70 | |
| 71 | return 0; |
| 72 | } |
| 73 | |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 74 | static int mv_otg_set_peripheral(struct usb_otg *otg, |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 75 | struct usb_gadget *gadget) |
| 76 | { |
| 77 | otg->gadget = gadget; |
| 78 | |
| 79 | return 0; |
| 80 | } |
| 81 | |
| 82 | static void mv_otg_run_state_machine(struct mv_otg *mvotg, |
| 83 | unsigned long delay) |
| 84 | { |
| 85 | dev_dbg(&mvotg->pdev->dev, "transceiver is updated\n"); |
| 86 | if (!mvotg->qwork) |
| 87 | return; |
| 88 | |
| 89 | queue_delayed_work(mvotg->qwork, &mvotg->work, delay); |
| 90 | } |
| 91 | |
| 92 | static void mv_otg_timer_await_bcon(unsigned long data) |
| 93 | { |
| 94 | struct mv_otg *mvotg = (struct mv_otg *) data; |
| 95 | |
| 96 | mvotg->otg_ctrl.a_wait_bcon_timeout = 1; |
| 97 | |
| 98 | dev_info(&mvotg->pdev->dev, "B Device No Response!\n"); |
| 99 | |
| 100 | if (spin_trylock(&mvotg->wq_lock)) { |
| 101 | mv_otg_run_state_machine(mvotg, 0); |
| 102 | spin_unlock(&mvotg->wq_lock); |
| 103 | } |
| 104 | } |
| 105 | |
| 106 | static int mv_otg_cancel_timer(struct mv_otg *mvotg, unsigned int id) |
| 107 | { |
| 108 | struct timer_list *timer; |
| 109 | |
| 110 | if (id >= OTG_TIMER_NUM) |
| 111 | return -EINVAL; |
| 112 | |
| 113 | timer = &mvotg->otg_ctrl.timer[id]; |
| 114 | |
| 115 | if (timer_pending(timer)) |
| 116 | del_timer(timer); |
| 117 | |
| 118 | return 0; |
| 119 | } |
| 120 | |
| 121 | static int mv_otg_set_timer(struct mv_otg *mvotg, unsigned int id, |
| 122 | unsigned long interval, |
| 123 | void (*callback) (unsigned long)) |
| 124 | { |
| 125 | struct timer_list *timer; |
| 126 | |
| 127 | if (id >= OTG_TIMER_NUM) |
| 128 | return -EINVAL; |
| 129 | |
| 130 | timer = &mvotg->otg_ctrl.timer[id]; |
| 131 | if (timer_pending(timer)) { |
| 132 | dev_err(&mvotg->pdev->dev, "Timer%d is already running\n", id); |
| 133 | return -EBUSY; |
| 134 | } |
| 135 | |
| 136 | init_timer(timer); |
| 137 | timer->data = (unsigned long) mvotg; |
| 138 | timer->function = callback; |
| 139 | timer->expires = jiffies + interval; |
| 140 | add_timer(timer); |
| 141 | |
| 142 | return 0; |
| 143 | } |
| 144 | |
| 145 | static int mv_otg_reset(struct mv_otg *mvotg) |
| 146 | { |
| 147 | unsigned int loops; |
| 148 | u32 tmp; |
| 149 | |
| 150 | /* Stop the controller */ |
| 151 | tmp = readl(&mvotg->op_regs->usbcmd); |
| 152 | tmp &= ~USBCMD_RUN_STOP; |
| 153 | writel(tmp, &mvotg->op_regs->usbcmd); |
| 154 | |
| 155 | /* Reset the controller to get default values */ |
| 156 | writel(USBCMD_CTRL_RESET, &mvotg->op_regs->usbcmd); |
| 157 | |
| 158 | loops = 500; |
| 159 | while (readl(&mvotg->op_regs->usbcmd) & USBCMD_CTRL_RESET) { |
| 160 | if (loops == 0) { |
| 161 | dev_err(&mvotg->pdev->dev, |
| 162 | "Wait for RESET completed TIMEOUT\n"); |
| 163 | return -ETIMEDOUT; |
| 164 | } |
| 165 | loops--; |
| 166 | udelay(20); |
| 167 | } |
| 168 | |
| 169 | writel(0x0, &mvotg->op_regs->usbintr); |
| 170 | tmp = readl(&mvotg->op_regs->usbsts); |
| 171 | writel(tmp, &mvotg->op_regs->usbsts); |
| 172 | |
| 173 | return 0; |
| 174 | } |
| 175 | |
| 176 | static void mv_otg_init_irq(struct mv_otg *mvotg) |
| 177 | { |
| 178 | u32 otgsc; |
| 179 | |
| 180 | mvotg->irq_en = OTGSC_INTR_A_SESSION_VALID |
| 181 | | OTGSC_INTR_A_VBUS_VALID; |
| 182 | mvotg->irq_status = OTGSC_INTSTS_A_SESSION_VALID |
| 183 | | OTGSC_INTSTS_A_VBUS_VALID; |
| 184 | |
| 185 | if (mvotg->pdata->vbus == NULL) { |
| 186 | mvotg->irq_en |= OTGSC_INTR_B_SESSION_VALID |
| 187 | | OTGSC_INTR_B_SESSION_END; |
| 188 | mvotg->irq_status |= OTGSC_INTSTS_B_SESSION_VALID |
| 189 | | OTGSC_INTSTS_B_SESSION_END; |
| 190 | } |
| 191 | |
| 192 | if (mvotg->pdata->id == NULL) { |
| 193 | mvotg->irq_en |= OTGSC_INTR_USB_ID; |
| 194 | mvotg->irq_status |= OTGSC_INTSTS_USB_ID; |
| 195 | } |
| 196 | |
| 197 | otgsc = readl(&mvotg->op_regs->otgsc); |
| 198 | otgsc |= mvotg->irq_en; |
| 199 | writel(otgsc, &mvotg->op_regs->otgsc); |
| 200 | } |
| 201 | |
| 202 | static void mv_otg_start_host(struct mv_otg *mvotg, int on) |
| 203 | { |
Geert Uytterhoeven | 2053c2d | 2012-01-15 12:36:16 +0100 | [diff] [blame] | 204 | #ifdef CONFIG_USB |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 205 | struct usb_otg *otg = mvotg->phy.otg; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 206 | struct usb_hcd *hcd; |
| 207 | |
| 208 | if (!otg->host) |
| 209 | return; |
| 210 | |
| 211 | dev_info(&mvotg->pdev->dev, "%s host\n", on ? "start" : "stop"); |
| 212 | |
| 213 | hcd = bus_to_hcd(otg->host); |
| 214 | |
Peter Chen | 3c9740a | 2013-11-05 10:46:02 +0800 | [diff] [blame] | 215 | if (on) { |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 216 | usb_add_hcd(hcd, hcd->irq, IRQF_SHARED); |
Peter Chen | 3c9740a | 2013-11-05 10:46:02 +0800 | [diff] [blame] | 217 | device_wakeup_enable(hcd->self.controller); |
| 218 | } else { |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 219 | usb_remove_hcd(hcd); |
Peter Chen | 3c9740a | 2013-11-05 10:46:02 +0800 | [diff] [blame] | 220 | } |
Geert Uytterhoeven | 2053c2d | 2012-01-15 12:36:16 +0100 | [diff] [blame] | 221 | #endif /* CONFIG_USB */ |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 222 | } |
| 223 | |
| 224 | static void mv_otg_start_periphrals(struct mv_otg *mvotg, int on) |
| 225 | { |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 226 | struct usb_otg *otg = mvotg->phy.otg; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 227 | |
| 228 | if (!otg->gadget) |
| 229 | return; |
| 230 | |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 231 | dev_info(mvotg->phy.dev, "gadget %s\n", on ? "on" : "off"); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 232 | |
| 233 | if (on) |
| 234 | usb_gadget_vbus_connect(otg->gadget); |
| 235 | else |
| 236 | usb_gadget_vbus_disconnect(otg->gadget); |
| 237 | } |
| 238 | |
| 239 | static void otg_clock_enable(struct mv_otg *mvotg) |
| 240 | { |
Chao Xie | df18fed | 2013-03-25 03:06:53 -0400 | [diff] [blame] | 241 | clk_prepare_enable(mvotg->clk); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 242 | } |
| 243 | |
| 244 | static void otg_clock_disable(struct mv_otg *mvotg) |
| 245 | { |
Chao Xie | df18fed | 2013-03-25 03:06:53 -0400 | [diff] [blame] | 246 | clk_disable_unprepare(mvotg->clk); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | static int mv_otg_enable_internal(struct mv_otg *mvotg) |
| 250 | { |
| 251 | int retval = 0; |
| 252 | |
| 253 | if (mvotg->active) |
| 254 | return 0; |
| 255 | |
| 256 | dev_dbg(&mvotg->pdev->dev, "otg enabled\n"); |
| 257 | |
| 258 | otg_clock_enable(mvotg); |
| 259 | if (mvotg->pdata->phy_init) { |
| 260 | retval = mvotg->pdata->phy_init(mvotg->phy_regs); |
| 261 | if (retval) { |
| 262 | dev_err(&mvotg->pdev->dev, |
| 263 | "init phy error %d\n", retval); |
| 264 | otg_clock_disable(mvotg); |
| 265 | return retval; |
| 266 | } |
| 267 | } |
| 268 | mvotg->active = 1; |
| 269 | |
| 270 | return 0; |
| 271 | |
| 272 | } |
| 273 | |
| 274 | static int mv_otg_enable(struct mv_otg *mvotg) |
| 275 | { |
| 276 | if (mvotg->clock_gating) |
| 277 | return mv_otg_enable_internal(mvotg); |
| 278 | |
| 279 | return 0; |
| 280 | } |
| 281 | |
| 282 | static void mv_otg_disable_internal(struct mv_otg *mvotg) |
| 283 | { |
| 284 | if (mvotg->active) { |
| 285 | dev_dbg(&mvotg->pdev->dev, "otg disabled\n"); |
| 286 | if (mvotg->pdata->phy_deinit) |
| 287 | mvotg->pdata->phy_deinit(mvotg->phy_regs); |
| 288 | otg_clock_disable(mvotg); |
| 289 | mvotg->active = 0; |
| 290 | } |
| 291 | } |
| 292 | |
| 293 | static void mv_otg_disable(struct mv_otg *mvotg) |
| 294 | { |
| 295 | if (mvotg->clock_gating) |
| 296 | mv_otg_disable_internal(mvotg); |
| 297 | } |
| 298 | |
| 299 | static void mv_otg_update_inputs(struct mv_otg *mvotg) |
| 300 | { |
| 301 | struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl; |
| 302 | u32 otgsc; |
| 303 | |
| 304 | otgsc = readl(&mvotg->op_regs->otgsc); |
| 305 | |
| 306 | if (mvotg->pdata->vbus) { |
| 307 | if (mvotg->pdata->vbus->poll() == VBUS_HIGH) { |
| 308 | otg_ctrl->b_sess_vld = 1; |
| 309 | otg_ctrl->b_sess_end = 0; |
| 310 | } else { |
| 311 | otg_ctrl->b_sess_vld = 0; |
| 312 | otg_ctrl->b_sess_end = 1; |
| 313 | } |
| 314 | } else { |
| 315 | otg_ctrl->b_sess_vld = !!(otgsc & OTGSC_STS_B_SESSION_VALID); |
| 316 | otg_ctrl->b_sess_end = !!(otgsc & OTGSC_STS_B_SESSION_END); |
| 317 | } |
| 318 | |
| 319 | if (mvotg->pdata->id) |
| 320 | otg_ctrl->id = !!mvotg->pdata->id->poll(); |
| 321 | else |
| 322 | otg_ctrl->id = !!(otgsc & OTGSC_STS_USB_ID); |
| 323 | |
| 324 | if (mvotg->pdata->otg_force_a_bus_req && !otg_ctrl->id) |
| 325 | otg_ctrl->a_bus_req = 1; |
| 326 | |
| 327 | otg_ctrl->a_sess_vld = !!(otgsc & OTGSC_STS_A_SESSION_VALID); |
| 328 | otg_ctrl->a_vbus_vld = !!(otgsc & OTGSC_STS_A_VBUS_VALID); |
| 329 | |
| 330 | dev_dbg(&mvotg->pdev->dev, "%s: ", __func__); |
| 331 | dev_dbg(&mvotg->pdev->dev, "id %d\n", otg_ctrl->id); |
| 332 | dev_dbg(&mvotg->pdev->dev, "b_sess_vld %d\n", otg_ctrl->b_sess_vld); |
| 333 | dev_dbg(&mvotg->pdev->dev, "b_sess_end %d\n", otg_ctrl->b_sess_end); |
| 334 | dev_dbg(&mvotg->pdev->dev, "a_vbus_vld %d\n", otg_ctrl->a_vbus_vld); |
| 335 | dev_dbg(&mvotg->pdev->dev, "a_sess_vld %d\n", otg_ctrl->a_sess_vld); |
| 336 | } |
| 337 | |
| 338 | static void mv_otg_update_state(struct mv_otg *mvotg) |
| 339 | { |
| 340 | struct mv_otg_ctrl *otg_ctrl = &mvotg->otg_ctrl; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 341 | struct usb_phy *phy = &mvotg->phy; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 342 | int old_state = mvotg->phy.otg->state; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 343 | |
| 344 | switch (old_state) { |
| 345 | case OTG_STATE_UNDEFINED: |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 346 | mvotg->phy.otg->state = OTG_STATE_B_IDLE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 347 | /* FALL THROUGH */ |
| 348 | case OTG_STATE_B_IDLE: |
| 349 | if (otg_ctrl->id == 0) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 350 | mvotg->phy.otg->state = OTG_STATE_A_IDLE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 351 | else if (otg_ctrl->b_sess_vld) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 352 | mvotg->phy.otg->state = OTG_STATE_B_PERIPHERAL; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 353 | break; |
| 354 | case OTG_STATE_B_PERIPHERAL: |
| 355 | if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 356 | mvotg->phy.otg->state = OTG_STATE_B_IDLE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 357 | break; |
| 358 | case OTG_STATE_A_IDLE: |
| 359 | if (otg_ctrl->id) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 360 | mvotg->phy.otg->state = OTG_STATE_B_IDLE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 361 | else if (!(otg_ctrl->a_bus_drop) && |
| 362 | (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det)) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 363 | mvotg->phy.otg->state = OTG_STATE_A_WAIT_VRISE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 364 | break; |
| 365 | case OTG_STATE_A_WAIT_VRISE: |
| 366 | if (otg_ctrl->a_vbus_vld) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 367 | mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 368 | break; |
| 369 | case OTG_STATE_A_WAIT_BCON: |
| 370 | if (otg_ctrl->id || otg_ctrl->a_bus_drop |
| 371 | || otg_ctrl->a_wait_bcon_timeout) { |
| 372 | mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); |
| 373 | mvotg->otg_ctrl.a_wait_bcon_timeout = 0; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 374 | mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 375 | otg_ctrl->a_bus_req = 0; |
| 376 | } else if (!otg_ctrl->a_vbus_vld) { |
| 377 | mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); |
| 378 | mvotg->otg_ctrl.a_wait_bcon_timeout = 0; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 379 | mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 380 | } else if (otg_ctrl->b_conn) { |
| 381 | mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); |
| 382 | mvotg->otg_ctrl.a_wait_bcon_timeout = 0; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 383 | mvotg->phy.otg->state = OTG_STATE_A_HOST; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 384 | } |
| 385 | break; |
| 386 | case OTG_STATE_A_HOST: |
| 387 | if (otg_ctrl->id || !otg_ctrl->b_conn |
| 388 | || otg_ctrl->a_bus_drop) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 389 | mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 390 | else if (!otg_ctrl->a_vbus_vld) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 391 | mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 392 | break; |
| 393 | case OTG_STATE_A_WAIT_VFALL: |
| 394 | if (otg_ctrl->id |
| 395 | || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld) |
| 396 | || otg_ctrl->a_bus_req) |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 397 | mvotg->phy.otg->state = OTG_STATE_A_IDLE; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 398 | break; |
| 399 | case OTG_STATE_A_VBUS_ERR: |
| 400 | if (otg_ctrl->id || otg_ctrl->a_clr_err |
| 401 | || otg_ctrl->a_bus_drop) { |
| 402 | otg_ctrl->a_clr_err = 0; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 403 | mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 404 | } |
| 405 | break; |
| 406 | default: |
| 407 | break; |
| 408 | } |
| 409 | } |
| 410 | |
| 411 | static void mv_otg_work(struct work_struct *work) |
| 412 | { |
| 413 | struct mv_otg *mvotg; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 414 | struct usb_phy *phy; |
| 415 | struct usb_otg *otg; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 416 | int old_state; |
| 417 | |
Cesar Eduardo Barros | 63a1307 | 2012-12-04 20:21:12 -0200 | [diff] [blame] | 418 | mvotg = container_of(to_delayed_work(work), struct mv_otg, work); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 419 | |
| 420 | run: |
| 421 | /* work queue is single thread, or we need spin_lock to protect */ |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 422 | phy = &mvotg->phy; |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 423 | otg = mvotg->phy.otg; |
| 424 | old_state = otg->state; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 425 | |
| 426 | if (!mvotg->active) |
| 427 | return; |
| 428 | |
| 429 | mv_otg_update_inputs(mvotg); |
| 430 | mv_otg_update_state(mvotg); |
| 431 | |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 432 | if (old_state != mvotg->phy.otg->state) { |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 433 | dev_info(&mvotg->pdev->dev, "change from state %s to %s\n", |
| 434 | state_string[old_state], |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 435 | state_string[mvotg->phy.otg->state]); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 436 | |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 437 | switch (mvotg->phy.otg->state) { |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 438 | case OTG_STATE_B_IDLE: |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 439 | otg->default_a = 0; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 440 | if (old_state == OTG_STATE_B_PERIPHERAL) |
| 441 | mv_otg_start_periphrals(mvotg, 0); |
| 442 | mv_otg_reset(mvotg); |
| 443 | mv_otg_disable(mvotg); |
Kiran Raparthy | b20f3f9 | 2014-11-24 22:54:59 +0530 | [diff] [blame^] | 444 | usb_phy_set_event(&mvotg->phy, USB_EVENT_NONE); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 445 | break; |
| 446 | case OTG_STATE_B_PERIPHERAL: |
| 447 | mv_otg_enable(mvotg); |
| 448 | mv_otg_start_periphrals(mvotg, 1); |
Kiran Raparthy | b20f3f9 | 2014-11-24 22:54:59 +0530 | [diff] [blame^] | 449 | usb_phy_set_event(&mvotg->phy, USB_EVENT_ENUMERATED); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 450 | break; |
| 451 | case OTG_STATE_A_IDLE: |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 452 | otg->default_a = 1; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 453 | mv_otg_enable(mvotg); |
| 454 | if (old_state == OTG_STATE_A_WAIT_VFALL) |
| 455 | mv_otg_start_host(mvotg, 0); |
| 456 | mv_otg_reset(mvotg); |
| 457 | break; |
| 458 | case OTG_STATE_A_WAIT_VRISE: |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 459 | mv_otg_set_vbus(otg, 1); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 460 | break; |
| 461 | case OTG_STATE_A_WAIT_BCON: |
| 462 | if (old_state != OTG_STATE_A_HOST) |
| 463 | mv_otg_start_host(mvotg, 1); |
| 464 | mv_otg_set_timer(mvotg, A_WAIT_BCON_TIMER, |
| 465 | T_A_WAIT_BCON, |
| 466 | mv_otg_timer_await_bcon); |
| 467 | /* |
| 468 | * Now, we directly enter A_HOST. So set b_conn = 1 |
| 469 | * here. In fact, it need host driver to notify us. |
| 470 | */ |
| 471 | mvotg->otg_ctrl.b_conn = 1; |
| 472 | break; |
| 473 | case OTG_STATE_A_HOST: |
| 474 | break; |
| 475 | case OTG_STATE_A_WAIT_VFALL: |
| 476 | /* |
| 477 | * Now, we has exited A_HOST. So set b_conn = 0 |
| 478 | * here. In fact, it need host driver to notify us. |
| 479 | */ |
| 480 | mvotg->otg_ctrl.b_conn = 0; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 481 | mv_otg_set_vbus(otg, 0); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 482 | break; |
| 483 | case OTG_STATE_A_VBUS_ERR: |
| 484 | break; |
| 485 | default: |
| 486 | break; |
| 487 | } |
| 488 | goto run; |
| 489 | } |
| 490 | } |
| 491 | |
| 492 | static irqreturn_t mv_otg_irq(int irq, void *dev) |
| 493 | { |
| 494 | struct mv_otg *mvotg = dev; |
| 495 | u32 otgsc; |
| 496 | |
| 497 | otgsc = readl(&mvotg->op_regs->otgsc); |
| 498 | writel(otgsc, &mvotg->op_regs->otgsc); |
| 499 | |
| 500 | /* |
| 501 | * if we have vbus, then the vbus detection for B-device |
| 502 | * will be done by mv_otg_inputs_irq(). |
| 503 | */ |
| 504 | if (mvotg->pdata->vbus) |
| 505 | if ((otgsc & OTGSC_STS_USB_ID) && |
| 506 | !(otgsc & OTGSC_INTSTS_USB_ID)) |
| 507 | return IRQ_NONE; |
| 508 | |
| 509 | if ((otgsc & mvotg->irq_status) == 0) |
| 510 | return IRQ_NONE; |
| 511 | |
| 512 | mv_otg_run_state_machine(mvotg, 0); |
| 513 | |
| 514 | return IRQ_HANDLED; |
| 515 | } |
| 516 | |
| 517 | static irqreturn_t mv_otg_inputs_irq(int irq, void *dev) |
| 518 | { |
| 519 | struct mv_otg *mvotg = dev; |
| 520 | |
| 521 | /* The clock may disabled at this time */ |
| 522 | if (!mvotg->active) { |
| 523 | mv_otg_enable(mvotg); |
| 524 | mv_otg_init_irq(mvotg); |
| 525 | } |
| 526 | |
| 527 | mv_otg_run_state_machine(mvotg, 0); |
| 528 | |
| 529 | return IRQ_HANDLED; |
| 530 | } |
| 531 | |
| 532 | static ssize_t |
| 533 | get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf) |
| 534 | { |
| 535 | struct mv_otg *mvotg = dev_get_drvdata(dev); |
| 536 | return scnprintf(buf, PAGE_SIZE, "%d\n", |
| 537 | mvotg->otg_ctrl.a_bus_req); |
| 538 | } |
| 539 | |
| 540 | static ssize_t |
| 541 | set_a_bus_req(struct device *dev, struct device_attribute *attr, |
| 542 | const char *buf, size_t count) |
| 543 | { |
| 544 | struct mv_otg *mvotg = dev_get_drvdata(dev); |
| 545 | |
| 546 | if (count > 2) |
| 547 | return -1; |
| 548 | |
| 549 | /* We will use this interface to change to A device */ |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 550 | if (mvotg->phy.otg->state != OTG_STATE_B_IDLE |
| 551 | && mvotg->phy.otg->state != OTG_STATE_A_IDLE) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 552 | return -1; |
| 553 | |
| 554 | /* The clock may disabled and we need to set irq for ID detected */ |
| 555 | mv_otg_enable(mvotg); |
| 556 | mv_otg_init_irq(mvotg); |
| 557 | |
| 558 | if (buf[0] == '1') { |
| 559 | mvotg->otg_ctrl.a_bus_req = 1; |
| 560 | mvotg->otg_ctrl.a_bus_drop = 0; |
| 561 | dev_dbg(&mvotg->pdev->dev, |
| 562 | "User request: a_bus_req = 1\n"); |
| 563 | |
| 564 | if (spin_trylock(&mvotg->wq_lock)) { |
| 565 | mv_otg_run_state_machine(mvotg, 0); |
| 566 | spin_unlock(&mvotg->wq_lock); |
| 567 | } |
| 568 | } |
| 569 | |
| 570 | return count; |
| 571 | } |
| 572 | |
| 573 | static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, |
| 574 | set_a_bus_req); |
| 575 | |
| 576 | static ssize_t |
| 577 | set_a_clr_err(struct device *dev, struct device_attribute *attr, |
| 578 | const char *buf, size_t count) |
| 579 | { |
| 580 | struct mv_otg *mvotg = dev_get_drvdata(dev); |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 581 | if (!mvotg->phy.otg->default_a) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 582 | return -1; |
| 583 | |
| 584 | if (count > 2) |
| 585 | return -1; |
| 586 | |
| 587 | if (buf[0] == '1') { |
| 588 | mvotg->otg_ctrl.a_clr_err = 1; |
| 589 | dev_dbg(&mvotg->pdev->dev, |
| 590 | "User request: a_clr_err = 1\n"); |
| 591 | } |
| 592 | |
| 593 | if (spin_trylock(&mvotg->wq_lock)) { |
| 594 | mv_otg_run_state_machine(mvotg, 0); |
| 595 | spin_unlock(&mvotg->wq_lock); |
| 596 | } |
| 597 | |
| 598 | return count; |
| 599 | } |
| 600 | |
| 601 | static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err); |
| 602 | |
| 603 | static ssize_t |
| 604 | get_a_bus_drop(struct device *dev, struct device_attribute *attr, |
| 605 | char *buf) |
| 606 | { |
| 607 | struct mv_otg *mvotg = dev_get_drvdata(dev); |
| 608 | return scnprintf(buf, PAGE_SIZE, "%d\n", |
| 609 | mvotg->otg_ctrl.a_bus_drop); |
| 610 | } |
| 611 | |
| 612 | static ssize_t |
| 613 | set_a_bus_drop(struct device *dev, struct device_attribute *attr, |
| 614 | const char *buf, size_t count) |
| 615 | { |
| 616 | struct mv_otg *mvotg = dev_get_drvdata(dev); |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 617 | if (!mvotg->phy.otg->default_a) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 618 | return -1; |
| 619 | |
| 620 | if (count > 2) |
| 621 | return -1; |
| 622 | |
| 623 | if (buf[0] == '0') { |
| 624 | mvotg->otg_ctrl.a_bus_drop = 0; |
| 625 | dev_dbg(&mvotg->pdev->dev, |
| 626 | "User request: a_bus_drop = 0\n"); |
| 627 | } else if (buf[0] == '1') { |
| 628 | mvotg->otg_ctrl.a_bus_drop = 1; |
| 629 | mvotg->otg_ctrl.a_bus_req = 0; |
| 630 | dev_dbg(&mvotg->pdev->dev, |
| 631 | "User request: a_bus_drop = 1\n"); |
| 632 | dev_dbg(&mvotg->pdev->dev, |
| 633 | "User request: and a_bus_req = 0\n"); |
| 634 | } |
| 635 | |
| 636 | if (spin_trylock(&mvotg->wq_lock)) { |
| 637 | mv_otg_run_state_machine(mvotg, 0); |
| 638 | spin_unlock(&mvotg->wq_lock); |
| 639 | } |
| 640 | |
| 641 | return count; |
| 642 | } |
| 643 | |
| 644 | static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, |
| 645 | get_a_bus_drop, set_a_bus_drop); |
| 646 | |
| 647 | static struct attribute *inputs_attrs[] = { |
| 648 | &dev_attr_a_bus_req.attr, |
| 649 | &dev_attr_a_clr_err.attr, |
| 650 | &dev_attr_a_bus_drop.attr, |
| 651 | NULL, |
| 652 | }; |
| 653 | |
| 654 | static struct attribute_group inputs_attr_group = { |
| 655 | .name = "inputs", |
| 656 | .attrs = inputs_attrs, |
| 657 | }; |
| 658 | |
Jingoo Han | d07f4a8 | 2013-08-05 14:17:53 +0900 | [diff] [blame] | 659 | static int mv_otg_remove(struct platform_device *pdev) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 660 | { |
| 661 | struct mv_otg *mvotg = platform_get_drvdata(pdev); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 662 | |
| 663 | sysfs_remove_group(&mvotg->pdev->dev.kobj, &inputs_attr_group); |
| 664 | |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 665 | if (mvotg->qwork) { |
| 666 | flush_workqueue(mvotg->qwork); |
| 667 | destroy_workqueue(mvotg->qwork); |
| 668 | } |
| 669 | |
| 670 | mv_otg_disable(mvotg); |
| 671 | |
Kishon Vijay Abraham I | 662dca5 | 2012-06-22 17:02:46 +0530 | [diff] [blame] | 672 | usb_remove_phy(&mvotg->phy); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 673 | |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 674 | return 0; |
| 675 | } |
| 676 | |
| 677 | static int mv_otg_probe(struct platform_device *pdev) |
| 678 | { |
Jingoo Han | 19f9e18 | 2013-07-30 17:02:13 +0900 | [diff] [blame] | 679 | struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 680 | struct mv_otg *mvotg; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 681 | struct usb_otg *otg; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 682 | struct resource *r; |
Chao Xie | df18fed | 2013-03-25 03:06:53 -0400 | [diff] [blame] | 683 | int retval = 0, i; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 684 | |
| 685 | if (pdata == NULL) { |
| 686 | dev_err(&pdev->dev, "failed to get platform data\n"); |
| 687 | return -ENODEV; |
| 688 | } |
| 689 | |
Chao Xie | df18fed | 2013-03-25 03:06:53 -0400 | [diff] [blame] | 690 | mvotg = devm_kzalloc(&pdev->dev, sizeof(*mvotg), GFP_KERNEL); |
Peter Chen | aa10c7b | 2014-10-14 15:56:18 +0800 | [diff] [blame] | 691 | if (!mvotg) |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 692 | return -ENOMEM; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 693 | |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 694 | otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL); |
| 695 | if (!otg) |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 696 | return -ENOMEM; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 697 | |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 698 | platform_set_drvdata(pdev, mvotg); |
| 699 | |
| 700 | mvotg->pdev = pdev; |
| 701 | mvotg->pdata = pdata; |
| 702 | |
Chao Xie | df18fed | 2013-03-25 03:06:53 -0400 | [diff] [blame] | 703 | mvotg->clk = devm_clk_get(&pdev->dev, NULL); |
| 704 | if (IS_ERR(mvotg->clk)) |
| 705 | return PTR_ERR(mvotg->clk); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 706 | |
| 707 | mvotg->qwork = create_singlethread_workqueue("mv_otg_queue"); |
| 708 | if (!mvotg->qwork) { |
| 709 | dev_dbg(&pdev->dev, "cannot create workqueue for OTG\n"); |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 710 | return -ENOMEM; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 711 | } |
| 712 | |
| 713 | INIT_DELAYED_WORK(&mvotg->work, mv_otg_work); |
| 714 | |
| 715 | /* OTG common part */ |
| 716 | mvotg->pdev = pdev; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 717 | mvotg->phy.dev = &pdev->dev; |
| 718 | mvotg->phy.otg = otg; |
| 719 | mvotg->phy.label = driver_name; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 720 | |
Antoine Tenart | e47d925 | 2014-10-30 18:41:13 +0100 | [diff] [blame] | 721 | otg->state = OTG_STATE_UNDEFINED; |
Antoine Tenart | 19c1eac | 2014-10-30 18:41:14 +0100 | [diff] [blame] | 722 | otg->usb_phy = &mvotg->phy; |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 723 | otg->set_host = mv_otg_set_host; |
| 724 | otg->set_peripheral = mv_otg_set_peripheral; |
| 725 | otg->set_vbus = mv_otg_set_vbus; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 726 | |
| 727 | for (i = 0; i < OTG_TIMER_NUM; i++) |
| 728 | init_timer(&mvotg->otg_ctrl.timer[i]); |
| 729 | |
| 730 | r = platform_get_resource_byname(mvotg->pdev, |
| 731 | IORESOURCE_MEM, "phyregs"); |
| 732 | if (r == NULL) { |
| 733 | dev_err(&pdev->dev, "no phy I/O memory resource defined\n"); |
| 734 | retval = -ENODEV; |
| 735 | goto err_destroy_workqueue; |
| 736 | } |
| 737 | |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 738 | mvotg->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 739 | if (mvotg->phy_regs == NULL) { |
| 740 | dev_err(&pdev->dev, "failed to map phy I/O memory\n"); |
| 741 | retval = -EFAULT; |
| 742 | goto err_destroy_workqueue; |
| 743 | } |
| 744 | |
| 745 | r = platform_get_resource_byname(mvotg->pdev, |
| 746 | IORESOURCE_MEM, "capregs"); |
| 747 | if (r == NULL) { |
| 748 | dev_err(&pdev->dev, "no I/O memory resource defined\n"); |
| 749 | retval = -ENODEV; |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 750 | goto err_destroy_workqueue; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 751 | } |
| 752 | |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 753 | mvotg->cap_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 754 | if (mvotg->cap_regs == NULL) { |
| 755 | dev_err(&pdev->dev, "failed to map I/O memory\n"); |
| 756 | retval = -EFAULT; |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 757 | goto err_destroy_workqueue; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 758 | } |
| 759 | |
| 760 | /* we will acces controller register, so enable the udc controller */ |
| 761 | retval = mv_otg_enable_internal(mvotg); |
| 762 | if (retval) { |
| 763 | dev_err(&pdev->dev, "mv otg enable error %d\n", retval); |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 764 | goto err_destroy_workqueue; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 765 | } |
| 766 | |
| 767 | mvotg->op_regs = |
| 768 | (struct mv_otg_regs __iomem *) ((unsigned long) mvotg->cap_regs |
| 769 | + (readl(mvotg->cap_regs) & CAPLENGTH_MASK)); |
| 770 | |
| 771 | if (pdata->id) { |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 772 | retval = devm_request_threaded_irq(&pdev->dev, pdata->id->irq, |
| 773 | NULL, mv_otg_inputs_irq, |
| 774 | IRQF_ONESHOT, "id", mvotg); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 775 | if (retval) { |
| 776 | dev_info(&pdev->dev, |
| 777 | "Failed to request irq for ID\n"); |
| 778 | pdata->id = NULL; |
| 779 | } |
| 780 | } |
| 781 | |
| 782 | if (pdata->vbus) { |
| 783 | mvotg->clock_gating = 1; |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 784 | retval = devm_request_threaded_irq(&pdev->dev, pdata->vbus->irq, |
| 785 | NULL, mv_otg_inputs_irq, |
| 786 | IRQF_ONESHOT, "vbus", mvotg); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 787 | if (retval) { |
| 788 | dev_info(&pdev->dev, |
| 789 | "Failed to request irq for VBUS, " |
| 790 | "disable clock gating\n"); |
| 791 | mvotg->clock_gating = 0; |
| 792 | pdata->vbus = NULL; |
| 793 | } |
| 794 | } |
| 795 | |
| 796 | if (pdata->disable_otg_clock_gating) |
| 797 | mvotg->clock_gating = 0; |
| 798 | |
| 799 | mv_otg_reset(mvotg); |
| 800 | mv_otg_init_irq(mvotg); |
| 801 | |
| 802 | r = platform_get_resource(mvotg->pdev, IORESOURCE_IRQ, 0); |
| 803 | if (r == NULL) { |
| 804 | dev_err(&pdev->dev, "no IRQ resource defined\n"); |
| 805 | retval = -ENODEV; |
| 806 | goto err_disable_clk; |
| 807 | } |
| 808 | |
| 809 | mvotg->irq = r->start; |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 810 | if (devm_request_irq(&pdev->dev, mvotg->irq, mv_otg_irq, IRQF_SHARED, |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 811 | driver_name, mvotg)) { |
| 812 | dev_err(&pdev->dev, "Request irq %d for OTG failed\n", |
| 813 | mvotg->irq); |
| 814 | mvotg->irq = 0; |
| 815 | retval = -ENODEV; |
| 816 | goto err_disable_clk; |
| 817 | } |
| 818 | |
Kishon Vijay Abraham I | 662dca5 | 2012-06-22 17:02:46 +0530 | [diff] [blame] | 819 | retval = usb_add_phy(&mvotg->phy, USB_PHY_TYPE_USB2); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 820 | if (retval < 0) { |
| 821 | dev_err(&pdev->dev, "can't register transceiver, %d\n", |
| 822 | retval); |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 823 | goto err_disable_clk; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 824 | } |
| 825 | |
| 826 | retval = sysfs_create_group(&pdev->dev.kobj, &inputs_attr_group); |
| 827 | if (retval < 0) { |
| 828 | dev_dbg(&pdev->dev, |
| 829 | "Can't register sysfs attr group: %d\n", retval); |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 830 | goto err_remove_phy; |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 831 | } |
| 832 | |
| 833 | spin_lock_init(&mvotg->wq_lock); |
| 834 | if (spin_trylock(&mvotg->wq_lock)) { |
| 835 | mv_otg_run_state_machine(mvotg, 2 * HZ); |
| 836 | spin_unlock(&mvotg->wq_lock); |
| 837 | } |
| 838 | |
| 839 | dev_info(&pdev->dev, |
| 840 | "successful probe OTG device %s clock gating.\n", |
| 841 | mvotg->clock_gating ? "with" : "without"); |
| 842 | |
| 843 | return 0; |
| 844 | |
Chao Xie | fb3dfe1 | 2013-01-24 01:38:28 -0500 | [diff] [blame] | 845 | err_remove_phy: |
Kishon Vijay Abraham I | 662dca5 | 2012-06-22 17:02:46 +0530 | [diff] [blame] | 846 | usb_remove_phy(&mvotg->phy); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 847 | err_disable_clk: |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 848 | mv_otg_disable_internal(mvotg); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 849 | err_destroy_workqueue: |
| 850 | flush_workqueue(mvotg->qwork); |
| 851 | destroy_workqueue(mvotg->qwork); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 852 | |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 853 | return retval; |
| 854 | } |
| 855 | |
| 856 | #ifdef CONFIG_PM |
| 857 | static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state) |
| 858 | { |
| 859 | struct mv_otg *mvotg = platform_get_drvdata(pdev); |
| 860 | |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 861 | if (mvotg->phy.state != OTG_STATE_B_IDLE) { |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 862 | dev_info(&pdev->dev, |
| 863 | "OTG state is not B_IDLE, it is %d!\n", |
Heikki Krogerus | b1c711d | 2012-02-13 13:24:17 +0200 | [diff] [blame] | 864 | mvotg->phy.state); |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 865 | return -EAGAIN; |
| 866 | } |
| 867 | |
| 868 | if (!mvotg->clock_gating) |
| 869 | mv_otg_disable_internal(mvotg); |
| 870 | |
| 871 | return 0; |
| 872 | } |
| 873 | |
| 874 | static int mv_otg_resume(struct platform_device *pdev) |
| 875 | { |
| 876 | struct mv_otg *mvotg = platform_get_drvdata(pdev); |
| 877 | u32 otgsc; |
| 878 | |
| 879 | if (!mvotg->clock_gating) { |
| 880 | mv_otg_enable_internal(mvotg); |
| 881 | |
| 882 | otgsc = readl(&mvotg->op_regs->otgsc); |
| 883 | otgsc |= mvotg->irq_en; |
| 884 | writel(otgsc, &mvotg->op_regs->otgsc); |
| 885 | |
| 886 | if (spin_trylock(&mvotg->wq_lock)) { |
| 887 | mv_otg_run_state_machine(mvotg, 0); |
| 888 | spin_unlock(&mvotg->wq_lock); |
| 889 | } |
| 890 | } |
| 891 | return 0; |
| 892 | } |
| 893 | #endif |
| 894 | |
| 895 | static struct platform_driver mv_otg_driver = { |
| 896 | .probe = mv_otg_probe, |
Jingoo Han | d07f4a8 | 2013-08-05 14:17:53 +0900 | [diff] [blame] | 897 | .remove = mv_otg_remove, |
Neil Zhang | 277164f | 2011-12-20 13:20:22 +0800 | [diff] [blame] | 898 | .driver = { |
| 899 | .owner = THIS_MODULE, |
| 900 | .name = driver_name, |
| 901 | }, |
| 902 | #ifdef CONFIG_PM |
| 903 | .suspend = mv_otg_suspend, |
| 904 | .resume = mv_otg_resume, |
| 905 | #endif |
| 906 | }; |
Srinivas Kandagatla | ca21dda | 2012-10-10 19:37:28 +0100 | [diff] [blame] | 907 | module_platform_driver(mv_otg_driver); |