1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Cadence USBSS DRD Driver. 4 * 5 * Copyright (C) 2018-2019 Cadence. 6 * Copyright (C) 2017-2018 NXP 7 * Copyright (C) 2019 Texas Instruments 8 * 9 * Author: Peter Chen <peter.chen@nxp.com> 10 * Pawel Laszczak <pawell@cadence.com> 11 * Roger Quadros <rogerq@ti.com> 12 */ 13 14 #include <linux/dma-mapping.h> 15 #include <linux/module.h> 16 #include <linux/kernel.h> 17 #include <linux/platform_device.h> 18 #include <linux/interrupt.h> 19 #include <linux/io.h> 20 #include <linux/pm_runtime.h> 21 22 #include "gadget.h" 23 #include "core.h" 24 #include "host-export.h" 25 #include "gadget-export.h" 26 #include "drd.h" 27 28 static int cdns3_idle_init(struct cdns3 *cdns); 29 30 static int cdns3_role_start(struct cdns3 *cdns, enum usb_role role) 31 { 32 int ret; 33 34 if (WARN_ON(role > USB_ROLE_DEVICE)) 35 return 0; 36 37 mutex_lock(&cdns->mutex); 38 cdns->role = role; 39 mutex_unlock(&cdns->mutex); 40 41 if (!cdns->roles[role]) 42 return -ENXIO; 43 44 if (cdns->roles[role]->state == CDNS3_ROLE_STATE_ACTIVE) 45 return 0; 46 47 mutex_lock(&cdns->mutex); 48 ret = cdns->roles[role]->start(cdns); 49 if (!ret) 50 cdns->roles[role]->state = CDNS3_ROLE_STATE_ACTIVE; 51 mutex_unlock(&cdns->mutex); 52 53 return ret; 54 } 55 56 static void cdns3_role_stop(struct cdns3 *cdns) 57 { 58 enum usb_role role = cdns->role; 59 60 if (WARN_ON(role > USB_ROLE_DEVICE)) 61 return; 62 63 if (cdns->roles[role]->state == CDNS3_ROLE_STATE_INACTIVE) 64 return; 65 66 mutex_lock(&cdns->mutex); 67 cdns->roles[role]->stop(cdns); 68 cdns->roles[role]->state = CDNS3_ROLE_STATE_INACTIVE; 69 mutex_unlock(&cdns->mutex); 70 } 71 72 static void cdns3_exit_roles(struct cdns3 *cdns) 73 { 74 cdns3_role_stop(cdns); 75 cdns3_drd_exit(cdns); 76 } 77 78 /** 79 * cdns3_core_init_role - initialize role of operation 80 * @cdns: Pointer to cdns3 structure 81 * 82 * Returns 0 on success otherwise negative errno 83 */ 84 static int cdns3_core_init_role(struct cdns3 *cdns) 85 { 86 struct device *dev = cdns->dev; 87 enum usb_dr_mode best_dr_mode; 88 enum usb_dr_mode dr_mode; 89 int ret; 90 91 dr_mode = usb_get_dr_mode(dev); 92 cdns->role = USB_ROLE_NONE; 93 94 /* 95 * If driver can't read mode by means of usb_get_dr_mode function then 96 * chooses mode according with Kernel configuration. This setting 97 * can be restricted later depending on strap pin configuration. 98 */ 99 if (dr_mode == USB_DR_MODE_UNKNOWN) { 100 if (IS_ENABLED(CONFIG_USB_CDNS3_HOST) && 101 IS_ENABLED(CONFIG_USB_CDNS3_GADGET)) 102 dr_mode = USB_DR_MODE_OTG; 103 else if (IS_ENABLED(CONFIG_USB_CDNS3_HOST)) 104 dr_mode = USB_DR_MODE_HOST; 105 else if (IS_ENABLED(CONFIG_USB_CDNS3_GADGET)) 106 dr_mode = USB_DR_MODE_PERIPHERAL; 107 } 108 109 /* 110 * At this point cdns->dr_mode contains strap configuration. 111 * Driver try update this setting considering kernel configuration 112 */ 113 best_dr_mode = cdns->dr_mode; 114 115 ret = cdns3_idle_init(cdns); 116 if (ret) 117 return ret; 118 119 if (dr_mode == USB_DR_MODE_OTG) { 120 best_dr_mode = cdns->dr_mode; 121 } else if (cdns->dr_mode == USB_DR_MODE_OTG) { 122 best_dr_mode = dr_mode; 123 } else if (cdns->dr_mode != dr_mode) { 124 dev_err(dev, "Incorrect DRD configuration\n"); 125 return -EINVAL; 126 } 127 128 dr_mode = best_dr_mode; 129 130 if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_HOST) { 131 ret = cdns3_host_init(cdns); 132 if (ret) { 133 dev_err(dev, "Host initialization failed with %d\n", 134 ret); 135 goto err; 136 } 137 } 138 139 if (dr_mode == USB_DR_MODE_OTG || dr_mode == USB_DR_MODE_PERIPHERAL) { 140 ret = cdns3_gadget_init(cdns); 141 if (ret) { 142 dev_err(dev, "Device initialization failed with %d\n", 143 ret); 144 goto err; 145 } 146 } 147 148 cdns->dr_mode = dr_mode; 149 150 ret = cdns3_drd_update_mode(cdns); 151 if (ret) 152 goto err; 153 154 /* Initialize idle role to start with */ 155 ret = cdns3_role_start(cdns, USB_ROLE_NONE); 156 if (ret) 157 goto err; 158 159 switch (cdns->dr_mode) { 160 case USB_DR_MODE_OTG: 161 ret = cdns3_hw_role_switch(cdns); 162 if (ret) 163 goto err; 164 break; 165 case USB_DR_MODE_PERIPHERAL: 166 ret = cdns3_role_start(cdns, USB_ROLE_DEVICE); 167 if (ret) 168 goto err; 169 break; 170 case USB_DR_MODE_HOST: 171 ret = cdns3_role_start(cdns, USB_ROLE_HOST); 172 if (ret) 173 goto err; 174 break; 175 default: 176 ret = -EINVAL; 177 goto err; 178 } 179 180 return 0; 181 err: 182 cdns3_exit_roles(cdns); 183 return ret; 184 } 185 186 /** 187 * cdns3_hw_role_state_machine - role switch state machine based on hw events. 188 * @cdns: Pointer to controller structure. 189 * 190 * Returns next role to be entered based on hw events. 191 */ 192 static enum usb_role cdns3_hw_role_state_machine(struct cdns3 *cdns) 193 { 194 enum usb_role role; 195 int id, vbus; 196 197 if (cdns->dr_mode != USB_DR_MODE_OTG) 198 goto not_otg; 199 200 id = cdns3_get_id(cdns); 201 vbus = cdns3_get_vbus(cdns); 202 203 /* 204 * Role change state machine 205 * Inputs: ID, VBUS 206 * Previous state: cdns->role 207 * Next state: role 208 */ 209 role = cdns->role; 210 211 switch (role) { 212 case USB_ROLE_NONE: 213 /* 214 * Driver treats USB_ROLE_NONE synonymous to IDLE state from 215 * controller specification. 216 */ 217 if (!id) 218 role = USB_ROLE_HOST; 219 else if (vbus) 220 role = USB_ROLE_DEVICE; 221 break; 222 case USB_ROLE_HOST: /* from HOST, we can only change to NONE */ 223 if (id) 224 role = USB_ROLE_NONE; 225 break; 226 case USB_ROLE_DEVICE: /* from GADGET, we can only change to NONE*/ 227 if (!vbus) 228 role = USB_ROLE_NONE; 229 break; 230 } 231 232 dev_dbg(cdns->dev, "role %d -> %d\n", cdns->role, role); 233 234 return role; 235 236 not_otg: 237 if (cdns3_is_host(cdns)) 238 role = USB_ROLE_HOST; 239 if (cdns3_is_device(cdns)) 240 role = USB_ROLE_DEVICE; 241 242 return role; 243 } 244 245 static int cdns3_idle_role_start(struct cdns3 *cdns) 246 { 247 return 0; 248 } 249 250 static void cdns3_idle_role_stop(struct cdns3 *cdns) 251 { 252 /* Program Lane swap and bring PHY out of RESET */ 253 phy_reset(cdns->usb3_phy); 254 } 255 256 static int cdns3_idle_init(struct cdns3 *cdns) 257 { 258 struct cdns3_role_driver *rdrv; 259 260 rdrv = devm_kzalloc(cdns->dev, sizeof(*rdrv), GFP_KERNEL); 261 if (!rdrv) 262 return -ENOMEM; 263 264 rdrv->start = cdns3_idle_role_start; 265 rdrv->stop = cdns3_idle_role_stop; 266 rdrv->state = CDNS3_ROLE_STATE_INACTIVE; 267 rdrv->suspend = NULL; 268 rdrv->resume = NULL; 269 rdrv->name = "idle"; 270 271 cdns->roles[USB_ROLE_NONE] = rdrv; 272 273 return 0; 274 } 275 276 /** 277 * cdns3_hw_role_switch - switch roles based on HW state 278 * @cdns: controller 279 */ 280 int cdns3_hw_role_switch(struct cdns3 *cdns) 281 { 282 enum usb_role real_role, current_role; 283 int ret = 0; 284 285 pm_runtime_get_sync(cdns->dev); 286 287 current_role = cdns->role; 288 real_role = cdns3_hw_role_state_machine(cdns); 289 290 /* Do nothing if nothing changed */ 291 if (current_role == real_role) 292 goto exit; 293 294 cdns3_role_stop(cdns); 295 296 dev_dbg(cdns->dev, "Switching role %d -> %d", current_role, real_role); 297 298 ret = cdns3_role_start(cdns, real_role); 299 if (ret) { 300 /* Back to current role */ 301 dev_err(cdns->dev, "set %d has failed, back to %d\n", 302 real_role, current_role); 303 ret = cdns3_role_start(cdns, current_role); 304 if (ret) 305 dev_err(cdns->dev, "back to %d failed too\n", 306 current_role); 307 } 308 exit: 309 pm_runtime_put_sync(cdns->dev); 310 return ret; 311 } 312 313 /** 314 * cdsn3_role_get - get current role of controller. 315 * 316 * @sw: pointer to USB role switch structure 317 * 318 * Returns role 319 */ 320 static enum usb_role cdns3_role_get(struct usb_role_switch *sw) 321 { 322 struct cdns3 *cdns = usb_role_switch_get_drvdata(sw); 323 324 return cdns->role; 325 } 326 327 /** 328 * cdns3_role_set - set current role of controller. 329 * 330 * @sw: pointer to USB role switch structure 331 * @role: the previous role 332 * Handles below events: 333 * - Role switch for dual-role devices 334 * - USB_ROLE_GADGET <--> USB_ROLE_NONE for peripheral-only devices 335 */ 336 static int cdns3_role_set(struct usb_role_switch *sw, enum usb_role role) 337 { 338 struct cdns3 *cdns = usb_role_switch_get_drvdata(sw); 339 int ret = 0; 340 341 pm_runtime_get_sync(cdns->dev); 342 343 if (cdns->role == role) 344 goto pm_put; 345 346 if (cdns->dr_mode == USB_DR_MODE_HOST) { 347 switch (role) { 348 case USB_ROLE_NONE: 349 case USB_ROLE_HOST: 350 break; 351 default: 352 ret = -EPERM; 353 goto pm_put; 354 } 355 } 356 357 if (cdns->dr_mode == USB_DR_MODE_PERIPHERAL) { 358 switch (role) { 359 case USB_ROLE_NONE: 360 case USB_ROLE_DEVICE: 361 break; 362 default: 363 ret = -EPERM; 364 goto pm_put; 365 } 366 } 367 368 cdns3_role_stop(cdns); 369 ret = cdns3_role_start(cdns, role); 370 if (ret) { 371 dev_err(cdns->dev, "set role %d has failed\n", role); 372 ret = -EPERM; 373 } 374 375 pm_put: 376 pm_runtime_put_sync(cdns->dev); 377 return ret; 378 } 379 380 /** 381 * cdns3_probe - probe for cdns3 core device 382 * @pdev: Pointer to cdns3 core platform device 383 * 384 * Returns 0 on success otherwise negative errno 385 */ 386 static int cdns3_probe(struct platform_device *pdev) 387 { 388 struct usb_role_switch_desc sw_desc = { }; 389 struct device *dev = &pdev->dev; 390 struct resource *res; 391 struct cdns3 *cdns; 392 void __iomem *regs; 393 int ret; 394 395 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32)); 396 if (ret) { 397 dev_err(dev, "error setting dma mask: %d\n", ret); 398 return -ENODEV; 399 } 400 401 cdns = devm_kzalloc(dev, sizeof(*cdns), GFP_KERNEL); 402 if (!cdns) 403 return -ENOMEM; 404 405 cdns->dev = dev; 406 407 platform_set_drvdata(pdev, cdns); 408 409 res = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "host"); 410 if (!res) { 411 dev_err(dev, "missing host IRQ\n"); 412 return -ENODEV; 413 } 414 415 cdns->xhci_res[0] = *res; 416 417 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "xhci"); 418 if (!res) { 419 dev_err(dev, "couldn't get xhci resource\n"); 420 return -ENXIO; 421 } 422 423 cdns->xhci_res[1] = *res; 424 425 cdns->dev_irq = platform_get_irq_byname(pdev, "peripheral"); 426 if (cdns->dev_irq == -EPROBE_DEFER) 427 return cdns->dev_irq; 428 429 if (cdns->dev_irq < 0) 430 dev_err(dev, "couldn't get peripheral irq\n"); 431 432 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "dev"); 433 regs = devm_ioremap_resource(dev, res); 434 if (IS_ERR(regs)) 435 return PTR_ERR(regs); 436 cdns->dev_regs = regs; 437 438 cdns->otg_irq = platform_get_irq_byname(pdev, "otg"); 439 if (cdns->otg_irq == -EPROBE_DEFER) 440 return cdns->otg_irq; 441 442 if (cdns->otg_irq < 0) { 443 dev_err(dev, "couldn't get otg irq\n"); 444 return cdns->otg_irq; 445 } 446 447 res = platform_get_resource_byname(pdev, IORESOURCE_MEM, "otg"); 448 if (!res) { 449 dev_err(dev, "couldn't get otg resource\n"); 450 return -ENXIO; 451 } 452 453 cdns->otg_res = *res; 454 455 mutex_init(&cdns->mutex); 456 457 cdns->usb2_phy = devm_phy_optional_get(dev, "cdns3,usb2-phy"); 458 if (IS_ERR(cdns->usb2_phy)) 459 return PTR_ERR(cdns->usb2_phy); 460 461 ret = phy_init(cdns->usb2_phy); 462 if (ret) 463 return ret; 464 465 cdns->usb3_phy = devm_phy_optional_get(dev, "cdns3,usb3-phy"); 466 if (IS_ERR(cdns->usb3_phy)) 467 return PTR_ERR(cdns->usb3_phy); 468 469 ret = phy_init(cdns->usb3_phy); 470 if (ret) 471 goto err1; 472 473 ret = phy_power_on(cdns->usb2_phy); 474 if (ret) 475 goto err2; 476 477 ret = phy_power_on(cdns->usb3_phy); 478 if (ret) 479 goto err3; 480 481 sw_desc.set = cdns3_role_set; 482 sw_desc.get = cdns3_role_get; 483 sw_desc.allow_userspace_control = true; 484 sw_desc.driver_data = cdns; 485 if (device_property_read_bool(dev, "usb-role-switch")) 486 sw_desc.fwnode = dev->fwnode; 487 488 cdns->role_sw = usb_role_switch_register(dev, &sw_desc); 489 if (IS_ERR(cdns->role_sw)) { 490 ret = PTR_ERR(cdns->role_sw); 491 dev_warn(dev, "Unable to register Role Switch\n"); 492 goto err4; 493 } 494 495 ret = cdns3_drd_init(cdns); 496 if (ret) 497 goto err5; 498 499 ret = cdns3_core_init_role(cdns); 500 if (ret) 501 goto err5; 502 503 device_set_wakeup_capable(dev, true); 504 pm_runtime_set_active(dev); 505 pm_runtime_enable(dev); 506 507 /* 508 * The controller needs less time between bus and controller suspend, 509 * and we also needs a small delay to avoid frequently entering low 510 * power mode. 511 */ 512 pm_runtime_set_autosuspend_delay(dev, 20); 513 pm_runtime_mark_last_busy(dev); 514 pm_runtime_use_autosuspend(dev); 515 dev_dbg(dev, "Cadence USB3 core: probe succeed\n"); 516 517 return 0; 518 err5: 519 cdns3_drd_exit(cdns); 520 usb_role_switch_unregister(cdns->role_sw); 521 err4: 522 phy_power_off(cdns->usb3_phy); 523 524 err3: 525 phy_power_off(cdns->usb2_phy); 526 err2: 527 phy_exit(cdns->usb3_phy); 528 err1: 529 phy_exit(cdns->usb2_phy); 530 531 return ret; 532 } 533 534 /** 535 * cdns3_remove - unbind drd driver and clean up 536 * @pdev: Pointer to Linux platform device 537 * 538 * Returns 0 on success otherwise negative errno 539 */ 540 static int cdns3_remove(struct platform_device *pdev) 541 { 542 struct cdns3 *cdns = platform_get_drvdata(pdev); 543 544 pm_runtime_get_sync(&pdev->dev); 545 pm_runtime_disable(&pdev->dev); 546 pm_runtime_put_noidle(&pdev->dev); 547 cdns3_exit_roles(cdns); 548 usb_role_switch_unregister(cdns->role_sw); 549 phy_power_off(cdns->usb2_phy); 550 phy_power_off(cdns->usb3_phy); 551 phy_exit(cdns->usb2_phy); 552 phy_exit(cdns->usb3_phy); 553 return 0; 554 } 555 556 #ifdef CONFIG_PM_SLEEP 557 558 static int cdns3_suspend(struct device *dev) 559 { 560 struct cdns3 *cdns = dev_get_drvdata(dev); 561 unsigned long flags; 562 563 if (cdns->role == USB_ROLE_HOST) 564 return 0; 565 566 if (pm_runtime_status_suspended(dev)) 567 pm_runtime_resume(dev); 568 569 if (cdns->roles[cdns->role]->suspend) { 570 spin_lock_irqsave(&cdns->gadget_dev->lock, flags); 571 cdns->roles[cdns->role]->suspend(cdns, false); 572 spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags); 573 } 574 575 return 0; 576 } 577 578 static int cdns3_resume(struct device *dev) 579 { 580 struct cdns3 *cdns = dev_get_drvdata(dev); 581 unsigned long flags; 582 583 if (cdns->role == USB_ROLE_HOST) 584 return 0; 585 586 if (cdns->roles[cdns->role]->resume) { 587 spin_lock_irqsave(&cdns->gadget_dev->lock, flags); 588 cdns->roles[cdns->role]->resume(cdns, false); 589 spin_unlock_irqrestore(&cdns->gadget_dev->lock, flags); 590 } 591 592 pm_runtime_disable(dev); 593 pm_runtime_set_active(dev); 594 pm_runtime_enable(dev); 595 596 return 0; 597 } 598 #endif 599 600 static const struct dev_pm_ops cdns3_pm_ops = { 601 SET_SYSTEM_SLEEP_PM_OPS(cdns3_suspend, cdns3_resume) 602 }; 603 604 #ifdef CONFIG_OF 605 static const struct of_device_id of_cdns3_match[] = { 606 { .compatible = "cdns,usb3" }, 607 { }, 608 }; 609 MODULE_DEVICE_TABLE(of, of_cdns3_match); 610 #endif 611 612 static struct platform_driver cdns3_driver = { 613 .probe = cdns3_probe, 614 .remove = cdns3_remove, 615 .driver = { 616 .name = "cdns-usb3", 617 .of_match_table = of_match_ptr(of_cdns3_match), 618 .pm = &cdns3_pm_ops, 619 }, 620 }; 621 622 module_platform_driver(cdns3_driver); 623 624 MODULE_ALIAS("platform:cdns3"); 625 MODULE_AUTHOR("Pawel Laszczak <pawell@cadence.com>"); 626 MODULE_LICENSE("GPL v2"); 627 MODULE_DESCRIPTION("Cadence USB3 DRD Controller Driver"); 628