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