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> 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 29 #include "phy-mv-usb.h" 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 57 static int mv_otg_set_vbus(struct usb_otg *otg, bool on) 58 { 59 struct mv_otg *mvotg = container_of(otg->usb_phy, struct mv_otg, phy); 60 if (mvotg->pdata->set_vbus == NULL) 61 return -ENODEV; 62 63 return mvotg->pdata->set_vbus(on); 64 } 65 66 static int mv_otg_set_host(struct usb_otg *otg, 67 struct usb_bus *host) 68 { 69 otg->host = host; 70 71 return 0; 72 } 73 74 static int mv_otg_set_peripheral(struct usb_otg *otg, 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 { 204 #ifdef CONFIG_USB 205 struct usb_otg *otg = mvotg->phy.otg; 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 215 if (on) { 216 usb_add_hcd(hcd, hcd->irq, IRQF_SHARED); 217 device_wakeup_enable(hcd->self.controller); 218 } else { 219 usb_remove_hcd(hcd); 220 } 221 #endif /* CONFIG_USB */ 222 } 223 224 static void mv_otg_start_periphrals(struct mv_otg *mvotg, int on) 225 { 226 struct usb_otg *otg = mvotg->phy.otg; 227 228 if (!otg->gadget) 229 return; 230 231 dev_info(mvotg->phy.dev, "gadget %s\n", on ? "on" : "off"); 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 { 241 clk_prepare_enable(mvotg->clk); 242 } 243 244 static void otg_clock_disable(struct mv_otg *mvotg) 245 { 246 clk_disable_unprepare(mvotg->clk); 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; 341 struct usb_phy *phy = &mvotg->phy; 342 int old_state = mvotg->phy.otg->state; 343 344 switch (old_state) { 345 case OTG_STATE_UNDEFINED: 346 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 347 /* FALL THROUGH */ 348 case OTG_STATE_B_IDLE: 349 if (otg_ctrl->id == 0) 350 mvotg->phy.otg->state = OTG_STATE_A_IDLE; 351 else if (otg_ctrl->b_sess_vld) 352 mvotg->phy.otg->state = OTG_STATE_B_PERIPHERAL; 353 break; 354 case OTG_STATE_B_PERIPHERAL: 355 if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0) 356 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 357 break; 358 case OTG_STATE_A_IDLE: 359 if (otg_ctrl->id) 360 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 361 else if (!(otg_ctrl->a_bus_drop) && 362 (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det)) 363 mvotg->phy.otg->state = OTG_STATE_A_WAIT_VRISE; 364 break; 365 case OTG_STATE_A_WAIT_VRISE: 366 if (otg_ctrl->a_vbus_vld) 367 mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; 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; 374 mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; 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; 379 mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; 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; 383 mvotg->phy.otg->state = OTG_STATE_A_HOST; 384 } 385 break; 386 case OTG_STATE_A_HOST: 387 if (otg_ctrl->id || !otg_ctrl->b_conn 388 || otg_ctrl->a_bus_drop) 389 mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; 390 else if (!otg_ctrl->a_vbus_vld) 391 mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; 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) 397 mvotg->phy.otg->state = OTG_STATE_A_IDLE; 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; 403 mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; 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; 414 struct usb_phy *phy; 415 struct usb_otg *otg; 416 int old_state; 417 418 mvotg = container_of(to_delayed_work(work), struct mv_otg, work); 419 420 run: 421 /* work queue is single thread, or we need spin_lock to protect */ 422 phy = &mvotg->phy; 423 otg = mvotg->phy.otg; 424 old_state = otg->state; 425 426 if (!mvotg->active) 427 return; 428 429 mv_otg_update_inputs(mvotg); 430 mv_otg_update_state(mvotg); 431 432 if (old_state != mvotg->phy.otg->state) { 433 dev_info(&mvotg->pdev->dev, "change from state %s to %s\n", 434 state_string[old_state], 435 state_string[mvotg->phy.otg->state]); 436 437 switch (mvotg->phy.otg->state) { 438 case OTG_STATE_B_IDLE: 439 otg->default_a = 0; 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); 444 usb_phy_set_event(&mvotg->phy, USB_EVENT_NONE); 445 break; 446 case OTG_STATE_B_PERIPHERAL: 447 mv_otg_enable(mvotg); 448 mv_otg_start_periphrals(mvotg, 1); 449 usb_phy_set_event(&mvotg->phy, USB_EVENT_ENUMERATED); 450 break; 451 case OTG_STATE_A_IDLE: 452 otg->default_a = 1; 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: 459 mv_otg_set_vbus(otg, 1); 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; 481 mv_otg_set_vbus(otg, 0); 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 */ 550 if (mvotg->phy.otg->state != OTG_STATE_B_IDLE 551 && mvotg->phy.otg->state != OTG_STATE_A_IDLE) 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); 581 if (!mvotg->phy.otg->default_a) 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); 617 if (!mvotg->phy.otg->default_a) 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 659 static int mv_otg_remove(struct platform_device *pdev) 660 { 661 struct mv_otg *mvotg = platform_get_drvdata(pdev); 662 663 sysfs_remove_group(&mvotg->pdev->dev.kobj, &inputs_attr_group); 664 665 if (mvotg->qwork) { 666 flush_workqueue(mvotg->qwork); 667 destroy_workqueue(mvotg->qwork); 668 } 669 670 mv_otg_disable(mvotg); 671 672 usb_remove_phy(&mvotg->phy); 673 674 return 0; 675 } 676 677 static int mv_otg_probe(struct platform_device *pdev) 678 { 679 struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev); 680 struct mv_otg *mvotg; 681 struct usb_otg *otg; 682 struct resource *r; 683 int retval = 0, i; 684 685 if (pdata == NULL) { 686 dev_err(&pdev->dev, "failed to get platform data\n"); 687 return -ENODEV; 688 } 689 690 mvotg = devm_kzalloc(&pdev->dev, sizeof(*mvotg), GFP_KERNEL); 691 if (!mvotg) 692 return -ENOMEM; 693 694 otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL); 695 if (!otg) 696 return -ENOMEM; 697 698 platform_set_drvdata(pdev, mvotg); 699 700 mvotg->pdev = pdev; 701 mvotg->pdata = pdata; 702 703 mvotg->clk = devm_clk_get(&pdev->dev, NULL); 704 if (IS_ERR(mvotg->clk)) 705 return PTR_ERR(mvotg->clk); 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"); 710 return -ENOMEM; 711 } 712 713 INIT_DELAYED_WORK(&mvotg->work, mv_otg_work); 714 715 /* OTG common part */ 716 mvotg->pdev = pdev; 717 mvotg->phy.dev = &pdev->dev; 718 mvotg->phy.otg = otg; 719 mvotg->phy.label = driver_name; 720 721 otg->state = OTG_STATE_UNDEFINED; 722 otg->usb_phy = &mvotg->phy; 723 otg->set_host = mv_otg_set_host; 724 otg->set_peripheral = mv_otg_set_peripheral; 725 otg->set_vbus = mv_otg_set_vbus; 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 738 mvotg->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 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; 750 goto err_destroy_workqueue; 751 } 752 753 mvotg->cap_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 754 if (mvotg->cap_regs == NULL) { 755 dev_err(&pdev->dev, "failed to map I/O memory\n"); 756 retval = -EFAULT; 757 goto err_destroy_workqueue; 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); 764 goto err_destroy_workqueue; 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) { 772 retval = devm_request_threaded_irq(&pdev->dev, pdata->id->irq, 773 NULL, mv_otg_inputs_irq, 774 IRQF_ONESHOT, "id", mvotg); 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; 784 retval = devm_request_threaded_irq(&pdev->dev, pdata->vbus->irq, 785 NULL, mv_otg_inputs_irq, 786 IRQF_ONESHOT, "vbus", mvotg); 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; 810 if (devm_request_irq(&pdev->dev, mvotg->irq, mv_otg_irq, IRQF_SHARED, 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 819 retval = usb_add_phy(&mvotg->phy, USB_PHY_TYPE_USB2); 820 if (retval < 0) { 821 dev_err(&pdev->dev, "can't register transceiver, %d\n", 822 retval); 823 goto err_disable_clk; 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); 830 goto err_remove_phy; 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 845 err_remove_phy: 846 usb_remove_phy(&mvotg->phy); 847 err_disable_clk: 848 mv_otg_disable_internal(mvotg); 849 err_destroy_workqueue: 850 flush_workqueue(mvotg->qwork); 851 destroy_workqueue(mvotg->qwork); 852 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 861 if (mvotg->phy.state != OTG_STATE_B_IDLE) { 862 dev_info(&pdev->dev, 863 "OTG state is not B_IDLE, it is %d!\n", 864 mvotg->phy.state); 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, 897 .remove = mv_otg_remove, 898 .driver = { 899 .name = driver_name, 900 }, 901 #ifdef CONFIG_PM 902 .suspend = mv_otg_suspend, 903 .resume = mv_otg_resume, 904 #endif 905 }; 906 module_platform_driver(mv_otg_driver); 907