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