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 int old_state = mvotg->phy.otg->state; 342 343 switch (old_state) { 344 case OTG_STATE_UNDEFINED: 345 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 346 /* FALL THROUGH */ 347 case OTG_STATE_B_IDLE: 348 if (otg_ctrl->id == 0) 349 mvotg->phy.otg->state = OTG_STATE_A_IDLE; 350 else if (otg_ctrl->b_sess_vld) 351 mvotg->phy.otg->state = OTG_STATE_B_PERIPHERAL; 352 break; 353 case OTG_STATE_B_PERIPHERAL: 354 if (!otg_ctrl->b_sess_vld || otg_ctrl->id == 0) 355 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 356 break; 357 case OTG_STATE_A_IDLE: 358 if (otg_ctrl->id) 359 mvotg->phy.otg->state = OTG_STATE_B_IDLE; 360 else if (!(otg_ctrl->a_bus_drop) && 361 (otg_ctrl->a_bus_req || otg_ctrl->a_srp_det)) 362 mvotg->phy.otg->state = OTG_STATE_A_WAIT_VRISE; 363 break; 364 case OTG_STATE_A_WAIT_VRISE: 365 if (otg_ctrl->a_vbus_vld) 366 mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; 367 break; 368 case OTG_STATE_A_WAIT_BCON: 369 if (otg_ctrl->id || otg_ctrl->a_bus_drop 370 || otg_ctrl->a_wait_bcon_timeout) { 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_WAIT_VFALL; 374 otg_ctrl->a_bus_req = 0; 375 } else if (!otg_ctrl->a_vbus_vld) { 376 mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); 377 mvotg->otg_ctrl.a_wait_bcon_timeout = 0; 378 mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; 379 } else if (otg_ctrl->b_conn) { 380 mv_otg_cancel_timer(mvotg, A_WAIT_BCON_TIMER); 381 mvotg->otg_ctrl.a_wait_bcon_timeout = 0; 382 mvotg->phy.otg->state = OTG_STATE_A_HOST; 383 } 384 break; 385 case OTG_STATE_A_HOST: 386 if (otg_ctrl->id || !otg_ctrl->b_conn 387 || otg_ctrl->a_bus_drop) 388 mvotg->phy.otg->state = OTG_STATE_A_WAIT_BCON; 389 else if (!otg_ctrl->a_vbus_vld) 390 mvotg->phy.otg->state = OTG_STATE_A_VBUS_ERR; 391 break; 392 case OTG_STATE_A_WAIT_VFALL: 393 if (otg_ctrl->id 394 || (!otg_ctrl->b_conn && otg_ctrl->a_sess_vld) 395 || otg_ctrl->a_bus_req) 396 mvotg->phy.otg->state = OTG_STATE_A_IDLE; 397 break; 398 case OTG_STATE_A_VBUS_ERR: 399 if (otg_ctrl->id || otg_ctrl->a_clr_err 400 || otg_ctrl->a_bus_drop) { 401 otg_ctrl->a_clr_err = 0; 402 mvotg->phy.otg->state = OTG_STATE_A_WAIT_VFALL; 403 } 404 break; 405 default: 406 break; 407 } 408 } 409 410 static void mv_otg_work(struct work_struct *work) 411 { 412 struct mv_otg *mvotg; 413 struct usb_phy *phy; 414 struct usb_otg *otg; 415 int old_state; 416 417 mvotg = container_of(to_delayed_work(work), struct mv_otg, work); 418 419 run: 420 /* work queue is single thread, or we need spin_lock to protect */ 421 phy = &mvotg->phy; 422 otg = mvotg->phy.otg; 423 old_state = otg->state; 424 425 if (!mvotg->active) 426 return; 427 428 mv_otg_update_inputs(mvotg); 429 mv_otg_update_state(mvotg); 430 431 if (old_state != mvotg->phy.otg->state) { 432 dev_info(&mvotg->pdev->dev, "change from state %s to %s\n", 433 state_string[old_state], 434 state_string[mvotg->phy.otg->state]); 435 436 switch (mvotg->phy.otg->state) { 437 case OTG_STATE_B_IDLE: 438 otg->default_a = 0; 439 if (old_state == OTG_STATE_B_PERIPHERAL) 440 mv_otg_start_periphrals(mvotg, 0); 441 mv_otg_reset(mvotg); 442 mv_otg_disable(mvotg); 443 usb_phy_set_event(&mvotg->phy, USB_EVENT_NONE); 444 break; 445 case OTG_STATE_B_PERIPHERAL: 446 mv_otg_enable(mvotg); 447 mv_otg_start_periphrals(mvotg, 1); 448 usb_phy_set_event(&mvotg->phy, USB_EVENT_ENUMERATED); 449 break; 450 case OTG_STATE_A_IDLE: 451 otg->default_a = 1; 452 mv_otg_enable(mvotg); 453 if (old_state == OTG_STATE_A_WAIT_VFALL) 454 mv_otg_start_host(mvotg, 0); 455 mv_otg_reset(mvotg); 456 break; 457 case OTG_STATE_A_WAIT_VRISE: 458 mv_otg_set_vbus(otg, 1); 459 break; 460 case OTG_STATE_A_WAIT_BCON: 461 if (old_state != OTG_STATE_A_HOST) 462 mv_otg_start_host(mvotg, 1); 463 mv_otg_set_timer(mvotg, A_WAIT_BCON_TIMER, 464 T_A_WAIT_BCON, 465 mv_otg_timer_await_bcon); 466 /* 467 * Now, we directly enter A_HOST. So set b_conn = 1 468 * here. In fact, it need host driver to notify us. 469 */ 470 mvotg->otg_ctrl.b_conn = 1; 471 break; 472 case OTG_STATE_A_HOST: 473 break; 474 case OTG_STATE_A_WAIT_VFALL: 475 /* 476 * Now, we has exited A_HOST. So set b_conn = 0 477 * here. In fact, it need host driver to notify us. 478 */ 479 mvotg->otg_ctrl.b_conn = 0; 480 mv_otg_set_vbus(otg, 0); 481 break; 482 case OTG_STATE_A_VBUS_ERR: 483 break; 484 default: 485 break; 486 } 487 goto run; 488 } 489 } 490 491 static irqreturn_t mv_otg_irq(int irq, void *dev) 492 { 493 struct mv_otg *mvotg = dev; 494 u32 otgsc; 495 496 otgsc = readl(&mvotg->op_regs->otgsc); 497 writel(otgsc, &mvotg->op_regs->otgsc); 498 499 /* 500 * if we have vbus, then the vbus detection for B-device 501 * will be done by mv_otg_inputs_irq(). 502 */ 503 if (mvotg->pdata->vbus) 504 if ((otgsc & OTGSC_STS_USB_ID) && 505 !(otgsc & OTGSC_INTSTS_USB_ID)) 506 return IRQ_NONE; 507 508 if ((otgsc & mvotg->irq_status) == 0) 509 return IRQ_NONE; 510 511 mv_otg_run_state_machine(mvotg, 0); 512 513 return IRQ_HANDLED; 514 } 515 516 static irqreturn_t mv_otg_inputs_irq(int irq, void *dev) 517 { 518 struct mv_otg *mvotg = dev; 519 520 /* The clock may disabled at this time */ 521 if (!mvotg->active) { 522 mv_otg_enable(mvotg); 523 mv_otg_init_irq(mvotg); 524 } 525 526 mv_otg_run_state_machine(mvotg, 0); 527 528 return IRQ_HANDLED; 529 } 530 531 static ssize_t 532 get_a_bus_req(struct device *dev, struct device_attribute *attr, char *buf) 533 { 534 struct mv_otg *mvotg = dev_get_drvdata(dev); 535 return scnprintf(buf, PAGE_SIZE, "%d\n", 536 mvotg->otg_ctrl.a_bus_req); 537 } 538 539 static ssize_t 540 set_a_bus_req(struct device *dev, struct device_attribute *attr, 541 const char *buf, size_t count) 542 { 543 struct mv_otg *mvotg = dev_get_drvdata(dev); 544 545 if (count > 2) 546 return -1; 547 548 /* We will use this interface to change to A device */ 549 if (mvotg->phy.otg->state != OTG_STATE_B_IDLE 550 && mvotg->phy.otg->state != OTG_STATE_A_IDLE) 551 return -1; 552 553 /* The clock may disabled and we need to set irq for ID detected */ 554 mv_otg_enable(mvotg); 555 mv_otg_init_irq(mvotg); 556 557 if (buf[0] == '1') { 558 mvotg->otg_ctrl.a_bus_req = 1; 559 mvotg->otg_ctrl.a_bus_drop = 0; 560 dev_dbg(&mvotg->pdev->dev, 561 "User request: a_bus_req = 1\n"); 562 563 if (spin_trylock(&mvotg->wq_lock)) { 564 mv_otg_run_state_machine(mvotg, 0); 565 spin_unlock(&mvotg->wq_lock); 566 } 567 } 568 569 return count; 570 } 571 572 static DEVICE_ATTR(a_bus_req, S_IRUGO | S_IWUSR, get_a_bus_req, 573 set_a_bus_req); 574 575 static ssize_t 576 set_a_clr_err(struct device *dev, struct device_attribute *attr, 577 const char *buf, size_t count) 578 { 579 struct mv_otg *mvotg = dev_get_drvdata(dev); 580 if (!mvotg->phy.otg->default_a) 581 return -1; 582 583 if (count > 2) 584 return -1; 585 586 if (buf[0] == '1') { 587 mvotg->otg_ctrl.a_clr_err = 1; 588 dev_dbg(&mvotg->pdev->dev, 589 "User request: a_clr_err = 1\n"); 590 } 591 592 if (spin_trylock(&mvotg->wq_lock)) { 593 mv_otg_run_state_machine(mvotg, 0); 594 spin_unlock(&mvotg->wq_lock); 595 } 596 597 return count; 598 } 599 600 static DEVICE_ATTR(a_clr_err, S_IWUSR, NULL, set_a_clr_err); 601 602 static ssize_t 603 get_a_bus_drop(struct device *dev, struct device_attribute *attr, 604 char *buf) 605 { 606 struct mv_otg *mvotg = dev_get_drvdata(dev); 607 return scnprintf(buf, PAGE_SIZE, "%d\n", 608 mvotg->otg_ctrl.a_bus_drop); 609 } 610 611 static ssize_t 612 set_a_bus_drop(struct device *dev, struct device_attribute *attr, 613 const char *buf, size_t count) 614 { 615 struct mv_otg *mvotg = dev_get_drvdata(dev); 616 if (!mvotg->phy.otg->default_a) 617 return -1; 618 619 if (count > 2) 620 return -1; 621 622 if (buf[0] == '0') { 623 mvotg->otg_ctrl.a_bus_drop = 0; 624 dev_dbg(&mvotg->pdev->dev, 625 "User request: a_bus_drop = 0\n"); 626 } else if (buf[0] == '1') { 627 mvotg->otg_ctrl.a_bus_drop = 1; 628 mvotg->otg_ctrl.a_bus_req = 0; 629 dev_dbg(&mvotg->pdev->dev, 630 "User request: a_bus_drop = 1\n"); 631 dev_dbg(&mvotg->pdev->dev, 632 "User request: and a_bus_req = 0\n"); 633 } 634 635 if (spin_trylock(&mvotg->wq_lock)) { 636 mv_otg_run_state_machine(mvotg, 0); 637 spin_unlock(&mvotg->wq_lock); 638 } 639 640 return count; 641 } 642 643 static DEVICE_ATTR(a_bus_drop, S_IRUGO | S_IWUSR, 644 get_a_bus_drop, set_a_bus_drop); 645 646 static struct attribute *inputs_attrs[] = { 647 &dev_attr_a_bus_req.attr, 648 &dev_attr_a_clr_err.attr, 649 &dev_attr_a_bus_drop.attr, 650 NULL, 651 }; 652 653 static struct attribute_group inputs_attr_group = { 654 .name = "inputs", 655 .attrs = inputs_attrs, 656 }; 657 658 static int mv_otg_remove(struct platform_device *pdev) 659 { 660 struct mv_otg *mvotg = platform_get_drvdata(pdev); 661 662 sysfs_remove_group(&mvotg->pdev->dev.kobj, &inputs_attr_group); 663 664 if (mvotg->qwork) { 665 flush_workqueue(mvotg->qwork); 666 destroy_workqueue(mvotg->qwork); 667 } 668 669 mv_otg_disable(mvotg); 670 671 usb_remove_phy(&mvotg->phy); 672 673 return 0; 674 } 675 676 static int mv_otg_probe(struct platform_device *pdev) 677 { 678 struct mv_usb_platform_data *pdata = dev_get_platdata(&pdev->dev); 679 struct mv_otg *mvotg; 680 struct usb_otg *otg; 681 struct resource *r; 682 int retval = 0, i; 683 684 if (pdata == NULL) { 685 dev_err(&pdev->dev, "failed to get platform data\n"); 686 return -ENODEV; 687 } 688 689 mvotg = devm_kzalloc(&pdev->dev, sizeof(*mvotg), GFP_KERNEL); 690 if (!mvotg) 691 return -ENOMEM; 692 693 otg = devm_kzalloc(&pdev->dev, sizeof(*otg), GFP_KERNEL); 694 if (!otg) 695 return -ENOMEM; 696 697 platform_set_drvdata(pdev, mvotg); 698 699 mvotg->pdev = pdev; 700 mvotg->pdata = pdata; 701 702 mvotg->clk = devm_clk_get(&pdev->dev, NULL); 703 if (IS_ERR(mvotg->clk)) 704 return PTR_ERR(mvotg->clk); 705 706 mvotg->qwork = create_singlethread_workqueue("mv_otg_queue"); 707 if (!mvotg->qwork) { 708 dev_dbg(&pdev->dev, "cannot create workqueue for OTG\n"); 709 return -ENOMEM; 710 } 711 712 INIT_DELAYED_WORK(&mvotg->work, mv_otg_work); 713 714 /* OTG common part */ 715 mvotg->pdev = pdev; 716 mvotg->phy.dev = &pdev->dev; 717 mvotg->phy.otg = otg; 718 mvotg->phy.label = driver_name; 719 720 otg->state = OTG_STATE_UNDEFINED; 721 otg->usb_phy = &mvotg->phy; 722 otg->set_host = mv_otg_set_host; 723 otg->set_peripheral = mv_otg_set_peripheral; 724 otg->set_vbus = mv_otg_set_vbus; 725 726 for (i = 0; i < OTG_TIMER_NUM; i++) 727 init_timer(&mvotg->otg_ctrl.timer[i]); 728 729 r = platform_get_resource_byname(mvotg->pdev, 730 IORESOURCE_MEM, "phyregs"); 731 if (r == NULL) { 732 dev_err(&pdev->dev, "no phy I/O memory resource defined\n"); 733 retval = -ENODEV; 734 goto err_destroy_workqueue; 735 } 736 737 mvotg->phy_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 738 if (mvotg->phy_regs == NULL) { 739 dev_err(&pdev->dev, "failed to map phy I/O memory\n"); 740 retval = -EFAULT; 741 goto err_destroy_workqueue; 742 } 743 744 r = platform_get_resource_byname(mvotg->pdev, 745 IORESOURCE_MEM, "capregs"); 746 if (r == NULL) { 747 dev_err(&pdev->dev, "no I/O memory resource defined\n"); 748 retval = -ENODEV; 749 goto err_destroy_workqueue; 750 } 751 752 mvotg->cap_regs = devm_ioremap(&pdev->dev, r->start, resource_size(r)); 753 if (mvotg->cap_regs == NULL) { 754 dev_err(&pdev->dev, "failed to map I/O memory\n"); 755 retval = -EFAULT; 756 goto err_destroy_workqueue; 757 } 758 759 /* we will acces controller register, so enable the udc controller */ 760 retval = mv_otg_enable_internal(mvotg); 761 if (retval) { 762 dev_err(&pdev->dev, "mv otg enable error %d\n", retval); 763 goto err_destroy_workqueue; 764 } 765 766 mvotg->op_regs = 767 (struct mv_otg_regs __iomem *) ((unsigned long) mvotg->cap_regs 768 + (readl(mvotg->cap_regs) & CAPLENGTH_MASK)); 769 770 if (pdata->id) { 771 retval = devm_request_threaded_irq(&pdev->dev, pdata->id->irq, 772 NULL, mv_otg_inputs_irq, 773 IRQF_ONESHOT, "id", mvotg); 774 if (retval) { 775 dev_info(&pdev->dev, 776 "Failed to request irq for ID\n"); 777 pdata->id = NULL; 778 } 779 } 780 781 if (pdata->vbus) { 782 mvotg->clock_gating = 1; 783 retval = devm_request_threaded_irq(&pdev->dev, pdata->vbus->irq, 784 NULL, mv_otg_inputs_irq, 785 IRQF_ONESHOT, "vbus", mvotg); 786 if (retval) { 787 dev_info(&pdev->dev, 788 "Failed to request irq for VBUS, " 789 "disable clock gating\n"); 790 mvotg->clock_gating = 0; 791 pdata->vbus = NULL; 792 } 793 } 794 795 if (pdata->disable_otg_clock_gating) 796 mvotg->clock_gating = 0; 797 798 mv_otg_reset(mvotg); 799 mv_otg_init_irq(mvotg); 800 801 r = platform_get_resource(mvotg->pdev, IORESOURCE_IRQ, 0); 802 if (r == NULL) { 803 dev_err(&pdev->dev, "no IRQ resource defined\n"); 804 retval = -ENODEV; 805 goto err_disable_clk; 806 } 807 808 mvotg->irq = r->start; 809 if (devm_request_irq(&pdev->dev, mvotg->irq, mv_otg_irq, IRQF_SHARED, 810 driver_name, mvotg)) { 811 dev_err(&pdev->dev, "Request irq %d for OTG failed\n", 812 mvotg->irq); 813 mvotg->irq = 0; 814 retval = -ENODEV; 815 goto err_disable_clk; 816 } 817 818 retval = usb_add_phy(&mvotg->phy, USB_PHY_TYPE_USB2); 819 if (retval < 0) { 820 dev_err(&pdev->dev, "can't register transceiver, %d\n", 821 retval); 822 goto err_disable_clk; 823 } 824 825 retval = sysfs_create_group(&pdev->dev.kobj, &inputs_attr_group); 826 if (retval < 0) { 827 dev_dbg(&pdev->dev, 828 "Can't register sysfs attr group: %d\n", retval); 829 goto err_remove_phy; 830 } 831 832 spin_lock_init(&mvotg->wq_lock); 833 if (spin_trylock(&mvotg->wq_lock)) { 834 mv_otg_run_state_machine(mvotg, 2 * HZ); 835 spin_unlock(&mvotg->wq_lock); 836 } 837 838 dev_info(&pdev->dev, 839 "successful probe OTG device %s clock gating.\n", 840 mvotg->clock_gating ? "with" : "without"); 841 842 return 0; 843 844 err_remove_phy: 845 usb_remove_phy(&mvotg->phy); 846 err_disable_clk: 847 mv_otg_disable_internal(mvotg); 848 err_destroy_workqueue: 849 flush_workqueue(mvotg->qwork); 850 destroy_workqueue(mvotg->qwork); 851 852 return retval; 853 } 854 855 #ifdef CONFIG_PM 856 static int mv_otg_suspend(struct platform_device *pdev, pm_message_t state) 857 { 858 struct mv_otg *mvotg = platform_get_drvdata(pdev); 859 860 if (mvotg->phy.otg->state != OTG_STATE_B_IDLE) { 861 dev_info(&pdev->dev, 862 "OTG state is not B_IDLE, it is %d!\n", 863 mvotg->phy.otg->state); 864 return -EAGAIN; 865 } 866 867 if (!mvotg->clock_gating) 868 mv_otg_disable_internal(mvotg); 869 870 return 0; 871 } 872 873 static int mv_otg_resume(struct platform_device *pdev) 874 { 875 struct mv_otg *mvotg = platform_get_drvdata(pdev); 876 u32 otgsc; 877 878 if (!mvotg->clock_gating) { 879 mv_otg_enable_internal(mvotg); 880 881 otgsc = readl(&mvotg->op_regs->otgsc); 882 otgsc |= mvotg->irq_en; 883 writel(otgsc, &mvotg->op_regs->otgsc); 884 885 if (spin_trylock(&mvotg->wq_lock)) { 886 mv_otg_run_state_machine(mvotg, 0); 887 spin_unlock(&mvotg->wq_lock); 888 } 889 } 890 return 0; 891 } 892 #endif 893 894 static struct platform_driver mv_otg_driver = { 895 .probe = mv_otg_probe, 896 .remove = mv_otg_remove, 897 .driver = { 898 .name = driver_name, 899 }, 900 #ifdef CONFIG_PM 901 .suspend = mv_otg_suspend, 902 .resume = mv_otg_resume, 903 #endif 904 }; 905 module_platform_driver(mv_otg_driver); 906