1 /* 2 * Renesas USB driver 3 * 4 * Copyright (C) 2011 Renesas Solutions Corp. 5 * Kuninori Morimoto <kuninori.morimoto.gx@renesas.com> 6 * 7 * This program is distributed in the hope that it will be useful, 8 * but WITHOUT ANY WARRANTY; without even the implied warranty of 9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 10 * GNU General Public License for more details. 11 * 12 * You should have received a copy of the GNU General Public License 13 * along with this program; if not, write to the Free Software 14 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 15 * 16 */ 17 #include <linux/io.h> 18 #include <linux/module.h> 19 #include <linux/pm_runtime.h> 20 #include <linux/slab.h> 21 #include <linux/sysfs.h> 22 #include "./common.h" 23 24 /* 25 * image of renesas_usbhs 26 * 27 * ex) gadget case 28 29 * mod.c 30 * mod_gadget.c 31 * mod_host.c pipe.c fifo.c 32 * 33 * +-------+ +-----------+ 34 * | pipe0 |------>| fifo pio | 35 * +------------+ +-------+ +-----------+ 36 * | mod_gadget |=====> | pipe1 |--+ 37 * +------------+ +-------+ | +-----------+ 38 * | pipe2 | | +-| fifo dma0 | 39 * +------------+ +-------+ | | +-----------+ 40 * | mod_host | | pipe3 |<-|--+ 41 * +------------+ +-------+ | +-----------+ 42 * | .... | +--->| fifo dma1 | 43 * | .... | +-----------+ 44 */ 45 46 47 #define USBHSF_RUNTIME_PWCTRL (1 << 0) 48 49 /* status */ 50 #define usbhsc_flags_init(p) do {(p)->flags = 0; } while (0) 51 #define usbhsc_flags_set(p, b) ((p)->flags |= (b)) 52 #define usbhsc_flags_clr(p, b) ((p)->flags &= ~(b)) 53 #define usbhsc_flags_has(p, b) ((p)->flags & (b)) 54 55 /* 56 * platform call back 57 * 58 * renesas usb support platform callback function. 59 * Below macro call it. 60 * if platform doesn't have callback, it return 0 (no error) 61 */ 62 #define usbhs_platform_call(priv, func, args...)\ 63 (!(priv) ? -ENODEV : \ 64 !((priv)->pfunc.func) ? 0 : \ 65 (priv)->pfunc.func(args)) 66 67 /* 68 * common functions 69 */ 70 u16 usbhs_read(struct usbhs_priv *priv, u32 reg) 71 { 72 return ioread16(priv->base + reg); 73 } 74 75 void usbhs_write(struct usbhs_priv *priv, u32 reg, u16 data) 76 { 77 iowrite16(data, priv->base + reg); 78 } 79 80 void usbhs_bset(struct usbhs_priv *priv, u32 reg, u16 mask, u16 data) 81 { 82 u16 val = usbhs_read(priv, reg); 83 84 val &= ~mask; 85 val |= data & mask; 86 87 usbhs_write(priv, reg, val); 88 } 89 90 struct usbhs_priv *usbhs_pdev_to_priv(struct platform_device *pdev) 91 { 92 return dev_get_drvdata(&pdev->dev); 93 } 94 95 /* 96 * syscfg functions 97 */ 98 void usbhs_sys_clock_ctrl(struct usbhs_priv *priv, int enable) 99 { 100 usbhs_bset(priv, SYSCFG, SCKE, enable ? SCKE : 0); 101 } 102 103 void usbhs_sys_hispeed_ctrl(struct usbhs_priv *priv, int enable) 104 { 105 usbhs_bset(priv, SYSCFG, HSE, enable ? HSE : 0); 106 } 107 108 void usbhs_sys_usb_ctrl(struct usbhs_priv *priv, int enable) 109 { 110 usbhs_bset(priv, SYSCFG, USBE, enable ? USBE : 0); 111 } 112 113 void usbhs_sys_host_ctrl(struct usbhs_priv *priv, int enable) 114 { 115 u16 mask = DCFM | DRPD | DPRPU; 116 u16 val = DCFM | DRPD; 117 int has_otg = usbhs_get_dparam(priv, has_otg); 118 119 if (has_otg) 120 usbhs_bset(priv, DVSTCTR, (EXTLP | PWEN), (EXTLP | PWEN)); 121 122 /* 123 * if enable 124 * 125 * - select Host mode 126 * - D+ Line/D- Line Pull-down 127 */ 128 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 129 } 130 131 void usbhs_sys_function_ctrl(struct usbhs_priv *priv, int enable) 132 { 133 u16 mask = DCFM | DRPD | DPRPU; 134 u16 val = DPRPU; 135 136 /* 137 * if enable 138 * 139 * - select Function mode 140 * - D+ Line Pull-up 141 */ 142 usbhs_bset(priv, SYSCFG, mask, enable ? val : 0); 143 } 144 145 /* 146 * frame functions 147 */ 148 int usbhs_frame_get_num(struct usbhs_priv *priv) 149 { 150 return usbhs_read(priv, FRMNUM) & FRNM_MASK; 151 } 152 153 /* 154 * usb request functions 155 */ 156 void usbhs_usbreq_get_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 157 { 158 u16 val; 159 160 val = usbhs_read(priv, USBREQ); 161 req->bRequest = (val >> 8) & 0xFF; 162 req->bRequestType = (val >> 0) & 0xFF; 163 164 req->wValue = usbhs_read(priv, USBVAL); 165 req->wIndex = usbhs_read(priv, USBINDX); 166 req->wLength = usbhs_read(priv, USBLENG); 167 } 168 169 void usbhs_usbreq_set_val(struct usbhs_priv *priv, struct usb_ctrlrequest *req) 170 { 171 usbhs_write(priv, USBREQ, (req->bRequest << 8) | req->bRequestType); 172 usbhs_write(priv, USBVAL, req->wValue); 173 usbhs_write(priv, USBINDX, req->wIndex); 174 usbhs_write(priv, USBLENG, req->wLength); 175 176 usbhs_bset(priv, DCPCTR, SUREQ, SUREQ); 177 } 178 179 /* 180 * bus/vbus functions 181 */ 182 void usbhs_bus_send_sof_enable(struct usbhs_priv *priv) 183 { 184 u16 status = usbhs_read(priv, DVSTCTR) & (USBRST | UACT); 185 186 if (status != USBRST) { 187 struct device *dev = usbhs_priv_to_dev(priv); 188 dev_err(dev, "usbhs should be reset\n"); 189 } 190 191 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), UACT); 192 } 193 194 void usbhs_bus_send_reset(struct usbhs_priv *priv) 195 { 196 usbhs_bset(priv, DVSTCTR, (USBRST | UACT), USBRST); 197 } 198 199 int usbhs_bus_get_speed(struct usbhs_priv *priv) 200 { 201 u16 dvstctr = usbhs_read(priv, DVSTCTR); 202 203 switch (RHST & dvstctr) { 204 case RHST_LOW_SPEED: 205 return USB_SPEED_LOW; 206 case RHST_FULL_SPEED: 207 return USB_SPEED_FULL; 208 case RHST_HIGH_SPEED: 209 return USB_SPEED_HIGH; 210 } 211 212 return USB_SPEED_UNKNOWN; 213 } 214 215 int usbhs_vbus_ctrl(struct usbhs_priv *priv, int enable) 216 { 217 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 218 219 return usbhs_platform_call(priv, set_vbus, pdev, enable); 220 } 221 222 static void usbhsc_bus_init(struct usbhs_priv *priv) 223 { 224 usbhs_write(priv, DVSTCTR, 0); 225 226 usbhs_vbus_ctrl(priv, 0); 227 } 228 229 /* 230 * device configuration 231 */ 232 int usbhs_set_device_speed(struct usbhs_priv *priv, int devnum, 233 u16 upphub, u16 hubport, u16 speed) 234 { 235 struct device *dev = usbhs_priv_to_dev(priv); 236 u16 usbspd = 0; 237 u32 reg = DEVADD0 + (2 * devnum); 238 239 if (devnum > 10) { 240 dev_err(dev, "cannot set speed to unknown device %d\n", devnum); 241 return -EIO; 242 } 243 244 if (upphub > 0xA) { 245 dev_err(dev, "unsupported hub number %d\n", upphub); 246 return -EIO; 247 } 248 249 switch (speed) { 250 case USB_SPEED_LOW: 251 usbspd = USBSPD_SPEED_LOW; 252 break; 253 case USB_SPEED_FULL: 254 usbspd = USBSPD_SPEED_FULL; 255 break; 256 case USB_SPEED_HIGH: 257 usbspd = USBSPD_SPEED_HIGH; 258 break; 259 default: 260 dev_err(dev, "unsupported speed %d\n", speed); 261 return -EIO; 262 } 263 264 usbhs_write(priv, reg, UPPHUB(upphub) | 265 HUBPORT(hubport)| 266 USBSPD(usbspd)); 267 268 return 0; 269 } 270 271 /* 272 * local functions 273 */ 274 static void usbhsc_set_buswait(struct usbhs_priv *priv) 275 { 276 int wait = usbhs_get_dparam(priv, buswait_bwait); 277 278 /* set bus wait if platform have */ 279 if (wait) 280 usbhs_bset(priv, BUSWAIT, 0x000F, wait); 281 } 282 283 /* 284 * platform default param 285 */ 286 static u32 usbhsc_default_pipe_type[] = { 287 USB_ENDPOINT_XFER_CONTROL, 288 USB_ENDPOINT_XFER_ISOC, 289 USB_ENDPOINT_XFER_ISOC, 290 USB_ENDPOINT_XFER_BULK, 291 USB_ENDPOINT_XFER_BULK, 292 USB_ENDPOINT_XFER_BULK, 293 USB_ENDPOINT_XFER_INT, 294 USB_ENDPOINT_XFER_INT, 295 USB_ENDPOINT_XFER_INT, 296 USB_ENDPOINT_XFER_INT, 297 }; 298 299 /* 300 * power control 301 */ 302 static void usbhsc_power_ctrl(struct usbhs_priv *priv, int enable) 303 { 304 struct device *dev = usbhs_priv_to_dev(priv); 305 306 if (enable) { 307 /* enable PM */ 308 pm_runtime_get_sync(dev); 309 310 /* USB on */ 311 usbhs_sys_clock_ctrl(priv, enable); 312 } else { 313 /* USB off */ 314 usbhs_sys_clock_ctrl(priv, enable); 315 316 /* disable PM */ 317 pm_runtime_put_sync(dev); 318 } 319 } 320 321 /* 322 * hotplug 323 */ 324 static void usbhsc_hotplug(struct usbhs_priv *priv) 325 { 326 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 327 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 328 int id; 329 int enable; 330 int ret; 331 332 /* 333 * get vbus status from platform 334 */ 335 enable = usbhs_platform_call(priv, get_vbus, pdev); 336 337 /* 338 * get id from platform 339 */ 340 id = usbhs_platform_call(priv, get_id, pdev); 341 342 if (enable && !mod) { 343 ret = usbhs_mod_change(priv, id); 344 if (ret < 0) 345 return; 346 347 dev_dbg(&pdev->dev, "%s enable\n", __func__); 348 349 /* power on */ 350 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 351 usbhsc_power_ctrl(priv, enable); 352 353 /* bus init */ 354 usbhsc_set_buswait(priv); 355 usbhsc_bus_init(priv); 356 357 /* module start */ 358 usbhs_mod_call(priv, start, priv); 359 360 } else if (!enable && mod) { 361 dev_dbg(&pdev->dev, "%s disable\n", __func__); 362 363 /* module stop */ 364 usbhs_mod_call(priv, stop, priv); 365 366 /* bus init */ 367 usbhsc_bus_init(priv); 368 369 /* power off */ 370 if (usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 371 usbhsc_power_ctrl(priv, enable); 372 373 usbhs_mod_change(priv, -1); 374 375 /* reset phy for next connection */ 376 usbhs_platform_call(priv, phy_reset, pdev); 377 } 378 } 379 380 /* 381 * notify hotplug 382 */ 383 static void usbhsc_notify_hotplug(struct work_struct *work) 384 { 385 struct usbhs_priv *priv = container_of(work, 386 struct usbhs_priv, 387 notify_hotplug_work.work); 388 usbhsc_hotplug(priv); 389 } 390 391 int usbhsc_drvcllbck_notify_hotplug(struct platform_device *pdev) 392 { 393 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 394 int delay = usbhs_get_dparam(priv, detection_delay); 395 396 /* 397 * This functions will be called in interrupt. 398 * To make sure safety context, 399 * use workqueue for usbhs_notify_hotplug 400 */ 401 schedule_delayed_work(&priv->notify_hotplug_work, delay); 402 return 0; 403 } 404 405 /* 406 * platform functions 407 */ 408 static int __devinit usbhs_probe(struct platform_device *pdev) 409 { 410 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 411 struct renesas_usbhs_driver_callback *dfunc; 412 struct usbhs_priv *priv; 413 struct resource *res; 414 unsigned int irq; 415 int ret; 416 417 /* check platform information */ 418 if (!info || 419 !info->platform_callback.get_id) { 420 dev_err(&pdev->dev, "no platform information\n"); 421 return -EINVAL; 422 } 423 424 /* platform data */ 425 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 426 irq = platform_get_irq(pdev, 0); 427 if (!res || (int)irq <= 0) { 428 dev_err(&pdev->dev, "Not enough Renesas USB platform resources.\n"); 429 return -ENODEV; 430 } 431 432 /* usb private data */ 433 priv = kzalloc(sizeof(*priv), GFP_KERNEL); 434 if (!priv) { 435 dev_err(&pdev->dev, "Could not allocate priv\n"); 436 return -ENOMEM; 437 } 438 439 priv->base = ioremap_nocache(res->start, resource_size(res)); 440 if (!priv->base) { 441 dev_err(&pdev->dev, "ioremap error.\n"); 442 ret = -ENOMEM; 443 goto probe_end_kfree; 444 } 445 446 /* 447 * care platform info 448 */ 449 memcpy(&priv->pfunc, 450 &info->platform_callback, 451 sizeof(struct renesas_usbhs_platform_callback)); 452 memcpy(&priv->dparam, 453 &info->driver_param, 454 sizeof(struct renesas_usbhs_driver_param)); 455 456 /* set driver callback functions for platform */ 457 dfunc = &info->driver_callback; 458 dfunc->notify_hotplug = usbhsc_drvcllbck_notify_hotplug; 459 460 /* set default param if platform doesn't have */ 461 if (!priv->dparam.pipe_type) { 462 priv->dparam.pipe_type = usbhsc_default_pipe_type; 463 priv->dparam.pipe_size = ARRAY_SIZE(usbhsc_default_pipe_type); 464 } 465 if (!priv->dparam.pio_dma_border) 466 priv->dparam.pio_dma_border = 64; /* 64byte */ 467 468 /* FIXME */ 469 /* runtime power control ? */ 470 if (priv->pfunc.get_vbus) 471 usbhsc_flags_set(priv, USBHSF_RUNTIME_PWCTRL); 472 473 /* 474 * priv settings 475 */ 476 priv->irq = irq; 477 priv->pdev = pdev; 478 INIT_DELAYED_WORK(&priv->notify_hotplug_work, usbhsc_notify_hotplug); 479 spin_lock_init(usbhs_priv_to_lock(priv)); 480 481 /* call pipe and module init */ 482 ret = usbhs_pipe_probe(priv); 483 if (ret < 0) 484 goto probe_end_iounmap; 485 486 ret = usbhs_fifo_probe(priv); 487 if (ret < 0) 488 goto probe_end_pipe_exit; 489 490 ret = usbhs_mod_probe(priv); 491 if (ret < 0) 492 goto probe_end_fifo_exit; 493 494 /* dev_set_drvdata should be called after usbhs_mod_init */ 495 dev_set_drvdata(&pdev->dev, priv); 496 497 /* 498 * deviece reset here because 499 * USB device might be used in boot loader. 500 */ 501 usbhs_sys_clock_ctrl(priv, 0); 502 503 /* 504 * platform call 505 * 506 * USB phy setup might depend on CPU/Board. 507 * If platform has its callback functions, 508 * call it here. 509 */ 510 ret = usbhs_platform_call(priv, hardware_init, pdev); 511 if (ret < 0) { 512 dev_err(&pdev->dev, "platform prove failed.\n"); 513 goto probe_end_mod_exit; 514 } 515 516 /* reset phy for connection */ 517 usbhs_platform_call(priv, phy_reset, pdev); 518 519 /* power control */ 520 pm_runtime_enable(&pdev->dev); 521 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) { 522 usbhsc_power_ctrl(priv, 1); 523 usbhs_mod_autonomy_mode(priv); 524 } 525 526 /* 527 * manual call notify_hotplug for cold plug 528 */ 529 ret = usbhsc_drvcllbck_notify_hotplug(pdev); 530 if (ret < 0) 531 goto probe_end_call_remove; 532 533 dev_info(&pdev->dev, "probed\n"); 534 535 return ret; 536 537 probe_end_call_remove: 538 usbhs_platform_call(priv, hardware_exit, pdev); 539 probe_end_mod_exit: 540 usbhs_mod_remove(priv); 541 probe_end_fifo_exit: 542 usbhs_fifo_remove(priv); 543 probe_end_pipe_exit: 544 usbhs_pipe_remove(priv); 545 probe_end_iounmap: 546 iounmap(priv->base); 547 probe_end_kfree: 548 kfree(priv); 549 550 dev_info(&pdev->dev, "probe failed\n"); 551 552 return ret; 553 } 554 555 static int __devexit usbhs_remove(struct platform_device *pdev) 556 { 557 struct usbhs_priv *priv = usbhs_pdev_to_priv(pdev); 558 struct renesas_usbhs_platform_info *info = pdev->dev.platform_data; 559 struct renesas_usbhs_driver_callback *dfunc = &info->driver_callback; 560 561 dev_dbg(&pdev->dev, "usb remove\n"); 562 563 dfunc->notify_hotplug = NULL; 564 565 /* power off */ 566 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 567 usbhsc_power_ctrl(priv, 0); 568 569 pm_runtime_disable(&pdev->dev); 570 571 usbhs_platform_call(priv, hardware_exit, pdev); 572 usbhs_mod_remove(priv); 573 usbhs_fifo_remove(priv); 574 usbhs_pipe_remove(priv); 575 iounmap(priv->base); 576 kfree(priv); 577 578 return 0; 579 } 580 581 static int usbhsc_suspend(struct device *dev) 582 { 583 struct usbhs_priv *priv = dev_get_drvdata(dev); 584 struct usbhs_mod *mod = usbhs_mod_get_current(priv); 585 586 if (mod) { 587 usbhs_mod_call(priv, stop, priv); 588 usbhs_mod_change(priv, -1); 589 } 590 591 if (mod || !usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 592 usbhsc_power_ctrl(priv, 0); 593 594 return 0; 595 } 596 597 static int usbhsc_resume(struct device *dev) 598 { 599 struct usbhs_priv *priv = dev_get_drvdata(dev); 600 struct platform_device *pdev = usbhs_priv_to_pdev(priv); 601 602 usbhs_platform_call(priv, phy_reset, pdev); 603 604 if (!usbhsc_flags_has(priv, USBHSF_RUNTIME_PWCTRL)) 605 usbhsc_power_ctrl(priv, 1); 606 607 usbhsc_hotplug(priv); 608 609 return 0; 610 } 611 612 static int usbhsc_runtime_nop(struct device *dev) 613 { 614 /* Runtime PM callback shared between ->runtime_suspend() 615 * and ->runtime_resume(). Simply returns success. 616 * 617 * This driver re-initializes all registers after 618 * pm_runtime_get_sync() anyway so there is no need 619 * to save and restore registers here. 620 */ 621 return 0; 622 } 623 624 static const struct dev_pm_ops usbhsc_pm_ops = { 625 .suspend = usbhsc_suspend, 626 .resume = usbhsc_resume, 627 .runtime_suspend = usbhsc_runtime_nop, 628 .runtime_resume = usbhsc_runtime_nop, 629 }; 630 631 static struct platform_driver renesas_usbhs_driver = { 632 .driver = { 633 .name = "renesas_usbhs", 634 .pm = &usbhsc_pm_ops, 635 }, 636 .probe = usbhs_probe, 637 .remove = __devexit_p(usbhs_remove), 638 }; 639 640 static int __init usbhs_init(void) 641 { 642 return platform_driver_register(&renesas_usbhs_driver); 643 } 644 645 static void __exit usbhs_exit(void) 646 { 647 platform_driver_unregister(&renesas_usbhs_driver); 648 } 649 650 module_init(usbhs_init); 651 module_exit(usbhs_exit); 652 653 MODULE_LICENSE("GPL"); 654 MODULE_DESCRIPTION("Renesas USB driver"); 655 MODULE_AUTHOR("Kuninori Morimoto <kuninori.morimoto.gx@renesas.com>"); 656