1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * OHCI HCD (Host Controller Driver) for USB. 4 * 5 * TI DA8xx (OMAP-L1x) Bus Glue 6 * 7 * Derived from: ohci-omap.c and ohci-s3c2410.c 8 * Copyright (C) 2008-2009 MontaVista Software, Inc. <source@mvista.com> 9 */ 10 11 #include <linux/clk.h> 12 #include <linux/gpio/consumer.h> 13 #include <linux/io.h> 14 #include <linux/interrupt.h> 15 #include <linux/jiffies.h> 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/platform_device.h> 20 #include <linux/phy/phy.h> 21 #include <linux/platform_data/usb-davinci.h> 22 #include <linux/regulator/consumer.h> 23 #include <linux/usb.h> 24 #include <linux/usb/hcd.h> 25 #include <asm/unaligned.h> 26 27 #include "ohci.h" 28 29 #define DRIVER_DESC "DA8XX" 30 #define DRV_NAME "ohci-da8xx" 31 32 static struct hc_driver __read_mostly ohci_da8xx_hc_driver; 33 34 static int (*orig_ohci_hub_control)(struct usb_hcd *hcd, u16 typeReq, 35 u16 wValue, u16 wIndex, char *buf, u16 wLength); 36 static int (*orig_ohci_hub_status_data)(struct usb_hcd *hcd, char *buf); 37 38 struct da8xx_ohci_hcd { 39 struct usb_hcd *hcd; 40 struct clk *usb11_clk; 41 struct phy *usb11_phy; 42 struct regulator *vbus_reg; 43 struct notifier_block nb; 44 struct gpio_desc *oc_gpio; 45 }; 46 47 #define to_da8xx_ohci(hcd) (struct da8xx_ohci_hcd *)(hcd_to_ohci(hcd)->priv) 48 49 /* Over-current indicator change bitmask */ 50 static volatile u16 ocic_mask; 51 52 static int ohci_da8xx_enable(struct usb_hcd *hcd) 53 { 54 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 55 int ret; 56 57 ret = clk_prepare_enable(da8xx_ohci->usb11_clk); 58 if (ret) 59 return ret; 60 61 ret = phy_init(da8xx_ohci->usb11_phy); 62 if (ret) 63 goto err_phy_init; 64 65 ret = phy_power_on(da8xx_ohci->usb11_phy); 66 if (ret) 67 goto err_phy_power_on; 68 69 return 0; 70 71 err_phy_power_on: 72 phy_exit(da8xx_ohci->usb11_phy); 73 err_phy_init: 74 clk_disable_unprepare(da8xx_ohci->usb11_clk); 75 76 return ret; 77 } 78 79 static void ohci_da8xx_disable(struct usb_hcd *hcd) 80 { 81 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 82 83 phy_power_off(da8xx_ohci->usb11_phy); 84 phy_exit(da8xx_ohci->usb11_phy); 85 clk_disable_unprepare(da8xx_ohci->usb11_clk); 86 } 87 88 static int ohci_da8xx_set_power(struct usb_hcd *hcd, int on) 89 { 90 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 91 struct device *dev = hcd->self.controller; 92 int ret; 93 94 if (!da8xx_ohci->vbus_reg) 95 return 0; 96 97 if (on) { 98 ret = regulator_enable(da8xx_ohci->vbus_reg); 99 if (ret) { 100 dev_err(dev, "Failed to enable regulator: %d\n", ret); 101 return ret; 102 } 103 } else { 104 ret = regulator_disable(da8xx_ohci->vbus_reg); 105 if (ret) { 106 dev_err(dev, "Failed to disable regulator: %d\n", ret); 107 return ret; 108 } 109 } 110 111 return 0; 112 } 113 114 static int ohci_da8xx_get_power(struct usb_hcd *hcd) 115 { 116 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 117 118 if (da8xx_ohci->vbus_reg) 119 return regulator_is_enabled(da8xx_ohci->vbus_reg); 120 121 return 1; 122 } 123 124 static int ohci_da8xx_get_oci(struct usb_hcd *hcd) 125 { 126 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 127 unsigned int flags; 128 int ret; 129 130 if (da8xx_ohci->oc_gpio) 131 return gpiod_get_value_cansleep(da8xx_ohci->oc_gpio); 132 133 if (!da8xx_ohci->vbus_reg) 134 return 0; 135 136 ret = regulator_get_error_flags(da8xx_ohci->vbus_reg, &flags); 137 if (ret) 138 return ret; 139 140 if (flags & REGULATOR_ERROR_OVER_CURRENT) 141 return 1; 142 143 return 0; 144 } 145 146 static int ohci_da8xx_has_set_power(struct usb_hcd *hcd) 147 { 148 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 149 150 if (da8xx_ohci->vbus_reg) 151 return 1; 152 153 return 0; 154 } 155 156 static int ohci_da8xx_has_oci(struct usb_hcd *hcd) 157 { 158 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 159 160 if (da8xx_ohci->oc_gpio) 161 return 1; 162 163 if (da8xx_ohci->vbus_reg) 164 return 1; 165 166 return 0; 167 } 168 169 static int ohci_da8xx_has_potpgt(struct usb_hcd *hcd) 170 { 171 struct device *dev = hcd->self.controller; 172 struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev); 173 174 if (hub && hub->potpgt) 175 return 1; 176 177 return 0; 178 } 179 180 static int ohci_da8xx_regulator_event(struct notifier_block *nb, 181 unsigned long event, void *data) 182 { 183 struct da8xx_ohci_hcd *da8xx_ohci = 184 container_of(nb, struct da8xx_ohci_hcd, nb); 185 186 if (event & REGULATOR_EVENT_OVER_CURRENT) { 187 ocic_mask |= 1 << 1; 188 ohci_da8xx_set_power(da8xx_ohci->hcd, 0); 189 } 190 191 return 0; 192 } 193 194 static irqreturn_t ohci_da8xx_oc_thread(int irq, void *data) 195 { 196 struct da8xx_ohci_hcd *da8xx_ohci = data; 197 struct device *dev = da8xx_ohci->hcd->self.controller; 198 int ret; 199 200 if (gpiod_get_value_cansleep(da8xx_ohci->oc_gpio) && 201 da8xx_ohci->vbus_reg) { 202 ret = regulator_disable(da8xx_ohci->vbus_reg); 203 if (ret) 204 dev_err(dev, "Failed to disable regulator: %d\n", ret); 205 } 206 207 return IRQ_HANDLED; 208 } 209 210 static int ohci_da8xx_register_notify(struct usb_hcd *hcd) 211 { 212 struct da8xx_ohci_hcd *da8xx_ohci = to_da8xx_ohci(hcd); 213 struct device *dev = hcd->self.controller; 214 int ret = 0; 215 216 if (!da8xx_ohci->oc_gpio && da8xx_ohci->vbus_reg) { 217 da8xx_ohci->nb.notifier_call = ohci_da8xx_regulator_event; 218 ret = devm_regulator_register_notifier(da8xx_ohci->vbus_reg, 219 &da8xx_ohci->nb); 220 } 221 222 if (ret) 223 dev_err(dev, "Failed to register notifier: %d\n", ret); 224 225 return ret; 226 } 227 228 static int ohci_da8xx_reset(struct usb_hcd *hcd) 229 { 230 struct device *dev = hcd->self.controller; 231 struct da8xx_ohci_root_hub *hub = dev_get_platdata(dev); 232 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 233 int result; 234 u32 rh_a; 235 236 dev_dbg(dev, "starting USB controller\n"); 237 238 result = ohci_da8xx_enable(hcd); 239 if (result < 0) 240 return result; 241 242 /* 243 * DA8xx only have 1 port connected to the pins but the HC root hub 244 * register A reports 2 ports, thus we'll have to override it... 245 */ 246 ohci->num_ports = 1; 247 248 result = ohci_setup(hcd); 249 if (result < 0) { 250 ohci_da8xx_disable(hcd); 251 return result; 252 } 253 254 /* 255 * Since we're providing a board-specific root hub port power control 256 * and over-current reporting, we have to override the HC root hub A 257 * register's default value, so that ohci_hub_control() could return 258 * the correct hub descriptor... 259 */ 260 rh_a = ohci_readl(ohci, &ohci->regs->roothub.a); 261 if (ohci_da8xx_has_set_power(hcd)) { 262 rh_a &= ~RH_A_NPS; 263 rh_a |= RH_A_PSM; 264 } 265 if (ohci_da8xx_has_oci(hcd)) { 266 rh_a &= ~RH_A_NOCP; 267 rh_a |= RH_A_OCPM; 268 } 269 if (ohci_da8xx_has_potpgt(hcd)) { 270 rh_a &= ~RH_A_POTPGT; 271 rh_a |= hub->potpgt << 24; 272 } 273 ohci_writel(ohci, rh_a, &ohci->regs->roothub.a); 274 275 return result; 276 } 277 278 /* 279 * Update the status data from the hub with the over-current indicator change. 280 */ 281 static int ohci_da8xx_hub_status_data(struct usb_hcd *hcd, char *buf) 282 { 283 int length = orig_ohci_hub_status_data(hcd, buf); 284 285 /* See if we have OCIC bit set on port 1 */ 286 if (ocic_mask & (1 << 1)) { 287 dev_dbg(hcd->self.controller, "over-current indicator change " 288 "on port 1\n"); 289 290 if (!length) 291 length = 1; 292 293 buf[0] |= 1 << 1; 294 } 295 return length; 296 } 297 298 /* 299 * Look at the control requests to the root hub and see if we need to override. 300 */ 301 static int ohci_da8xx_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 302 u16 wIndex, char *buf, u16 wLength) 303 { 304 struct device *dev = hcd->self.controller; 305 int temp; 306 307 switch (typeReq) { 308 case GetPortStatus: 309 /* Check the port number */ 310 if (wIndex != 1) 311 break; 312 313 dev_dbg(dev, "GetPortStatus(%u)\n", wIndex); 314 315 temp = roothub_portstatus(hcd_to_ohci(hcd), wIndex - 1); 316 317 /* The port power status (PPS) bit defaults to 1 */ 318 if (!ohci_da8xx_get_power(hcd)) 319 temp &= ~RH_PS_PPS; 320 321 /* The port over-current indicator (POCI) bit is always 0 */ 322 if (ohci_da8xx_get_oci(hcd) > 0) 323 temp |= RH_PS_POCI; 324 325 /* The over-current indicator change (OCIC) bit is 0 too */ 326 if (ocic_mask & (1 << wIndex)) 327 temp |= RH_PS_OCIC; 328 329 put_unaligned(cpu_to_le32(temp), (__le32 *)buf); 330 return 0; 331 case SetPortFeature: 332 temp = 1; 333 goto check_port; 334 case ClearPortFeature: 335 temp = 0; 336 337 check_port: 338 /* Check the port number */ 339 if (wIndex != 1) 340 break; 341 342 switch (wValue) { 343 case USB_PORT_FEAT_POWER: 344 dev_dbg(dev, "%sPortFeature(%u): %s\n", 345 temp ? "Set" : "Clear", wIndex, "POWER"); 346 347 return ohci_da8xx_set_power(hcd, temp) ? -EPIPE : 0; 348 case USB_PORT_FEAT_C_OVER_CURRENT: 349 dev_dbg(dev, "%sPortFeature(%u): %s\n", 350 temp ? "Set" : "Clear", wIndex, 351 "C_OVER_CURRENT"); 352 353 if (temp) 354 ocic_mask |= 1 << wIndex; 355 else 356 ocic_mask &= ~(1 << wIndex); 357 return 0; 358 } 359 } 360 361 return orig_ohci_hub_control(hcd, typeReq, wValue, 362 wIndex, buf, wLength); 363 } 364 365 /*-------------------------------------------------------------------------*/ 366 #ifdef CONFIG_OF 367 static const struct of_device_id da8xx_ohci_ids[] = { 368 { .compatible = "ti,da830-ohci" }, 369 { } 370 }; 371 MODULE_DEVICE_TABLE(of, da8xx_ohci_ids); 372 #endif 373 374 static int ohci_da8xx_probe(struct platform_device *pdev) 375 { 376 struct da8xx_ohci_hcd *da8xx_ohci; 377 struct device *dev = &pdev->dev; 378 int error, hcd_irq, oc_irq; 379 struct usb_hcd *hcd; 380 struct resource *mem; 381 382 hcd = usb_create_hcd(&ohci_da8xx_hc_driver, dev, dev_name(dev)); 383 if (!hcd) 384 return -ENOMEM; 385 386 da8xx_ohci = to_da8xx_ohci(hcd); 387 da8xx_ohci->hcd = hcd; 388 389 da8xx_ohci->usb11_clk = devm_clk_get(dev, NULL); 390 if (IS_ERR(da8xx_ohci->usb11_clk)) { 391 error = PTR_ERR(da8xx_ohci->usb11_clk); 392 if (error != -EPROBE_DEFER) 393 dev_err(dev, "Failed to get clock.\n"); 394 goto err; 395 } 396 397 da8xx_ohci->usb11_phy = devm_phy_get(dev, "usb-phy"); 398 if (IS_ERR(da8xx_ohci->usb11_phy)) { 399 error = PTR_ERR(da8xx_ohci->usb11_phy); 400 if (error != -EPROBE_DEFER) 401 dev_err(dev, "Failed to get phy.\n"); 402 goto err; 403 } 404 405 da8xx_ohci->vbus_reg = devm_regulator_get_optional(dev, "vbus"); 406 if (IS_ERR(da8xx_ohci->vbus_reg)) { 407 error = PTR_ERR(da8xx_ohci->vbus_reg); 408 if (error == -ENODEV) { 409 da8xx_ohci->vbus_reg = NULL; 410 } else if (error == -EPROBE_DEFER) { 411 goto err; 412 } else { 413 dev_err(dev, "Failed to get regulator\n"); 414 goto err; 415 } 416 } 417 418 da8xx_ohci->oc_gpio = devm_gpiod_get_optional(dev, "oc", GPIOD_IN); 419 if (IS_ERR(da8xx_ohci->oc_gpio)) { 420 error = PTR_ERR(da8xx_ohci->oc_gpio); 421 goto err; 422 } 423 424 if (da8xx_ohci->oc_gpio) { 425 oc_irq = gpiod_to_irq(da8xx_ohci->oc_gpio); 426 if (oc_irq < 0) { 427 error = oc_irq; 428 goto err; 429 } 430 431 error = devm_request_threaded_irq(dev, oc_irq, NULL, 432 ohci_da8xx_oc_thread, IRQF_TRIGGER_RISING | 433 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 434 "OHCI over-current indicator", da8xx_ohci); 435 if (error) 436 goto err; 437 } 438 439 hcd->regs = devm_platform_get_and_ioremap_resource(pdev, 0, &mem); 440 if (IS_ERR(hcd->regs)) { 441 error = PTR_ERR(hcd->regs); 442 goto err; 443 } 444 hcd->rsrc_start = mem->start; 445 hcd->rsrc_len = resource_size(mem); 446 447 hcd_irq = platform_get_irq(pdev, 0); 448 if (hcd_irq < 0) { 449 error = -ENODEV; 450 goto err; 451 } 452 453 error = usb_add_hcd(hcd, hcd_irq, 0); 454 if (error) 455 goto err; 456 457 device_wakeup_enable(hcd->self.controller); 458 459 error = ohci_da8xx_register_notify(hcd); 460 if (error) 461 goto err_remove_hcd; 462 463 return 0; 464 465 err_remove_hcd: 466 usb_remove_hcd(hcd); 467 err: 468 usb_put_hcd(hcd); 469 return error; 470 } 471 472 static void ohci_da8xx_remove(struct platform_device *pdev) 473 { 474 struct usb_hcd *hcd = platform_get_drvdata(pdev); 475 476 usb_remove_hcd(hcd); 477 usb_put_hcd(hcd); 478 } 479 480 #ifdef CONFIG_PM 481 static int ohci_da8xx_suspend(struct platform_device *pdev, 482 pm_message_t message) 483 { 484 struct usb_hcd *hcd = platform_get_drvdata(pdev); 485 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 486 bool do_wakeup = device_may_wakeup(&pdev->dev); 487 int ret; 488 489 490 if (time_before(jiffies, ohci->next_statechange)) 491 msleep(5); 492 ohci->next_statechange = jiffies; 493 494 ret = ohci_suspend(hcd, do_wakeup); 495 if (ret) 496 return ret; 497 498 ohci_da8xx_disable(hcd); 499 hcd->state = HC_STATE_SUSPENDED; 500 501 return ret; 502 } 503 504 static int ohci_da8xx_resume(struct platform_device *dev) 505 { 506 struct usb_hcd *hcd = platform_get_drvdata(dev); 507 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 508 int ret; 509 510 if (time_before(jiffies, ohci->next_statechange)) 511 msleep(5); 512 ohci->next_statechange = jiffies; 513 514 ret = ohci_da8xx_enable(hcd); 515 if (ret) 516 return ret; 517 518 ohci_resume(hcd, false); 519 520 return 0; 521 } 522 #endif 523 524 static const struct ohci_driver_overrides da8xx_overrides __initconst = { 525 .reset = ohci_da8xx_reset, 526 .extra_priv_size = sizeof(struct da8xx_ohci_hcd), 527 }; 528 529 /* 530 * Driver definition to register with platform structure. 531 */ 532 static struct platform_driver ohci_hcd_da8xx_driver = { 533 .probe = ohci_da8xx_probe, 534 .remove_new = ohci_da8xx_remove, 535 .shutdown = usb_hcd_platform_shutdown, 536 #ifdef CONFIG_PM 537 .suspend = ohci_da8xx_suspend, 538 .resume = ohci_da8xx_resume, 539 #endif 540 .driver = { 541 .name = DRV_NAME, 542 .of_match_table = of_match_ptr(da8xx_ohci_ids), 543 }, 544 }; 545 546 static int __init ohci_da8xx_init(void) 547 { 548 549 if (usb_disabled()) 550 return -ENODEV; 551 552 ohci_init_driver(&ohci_da8xx_hc_driver, &da8xx_overrides); 553 554 /* 555 * The Davinci da8xx HW has some unusual quirks, which require 556 * da8xx-specific workarounds. We override certain hc_driver 557 * functions here to achieve that. We explicitly do not enhance 558 * ohci_driver_overrides to allow this more easily, since this 559 * is an unusual case, and we don't want to encourage others to 560 * override these functions by making it too easy. 561 */ 562 563 orig_ohci_hub_control = ohci_da8xx_hc_driver.hub_control; 564 orig_ohci_hub_status_data = ohci_da8xx_hc_driver.hub_status_data; 565 566 ohci_da8xx_hc_driver.hub_status_data = ohci_da8xx_hub_status_data; 567 ohci_da8xx_hc_driver.hub_control = ohci_da8xx_hub_control; 568 569 return platform_driver_register(&ohci_hcd_da8xx_driver); 570 } 571 module_init(ohci_da8xx_init); 572 573 static void __exit ohci_da8xx_exit(void) 574 { 575 platform_driver_unregister(&ohci_hcd_da8xx_driver); 576 } 577 module_exit(ohci_da8xx_exit); 578 MODULE_DESCRIPTION(DRIVER_DESC); 579 MODULE_LICENSE("GPL"); 580 MODULE_ALIAS("platform:" DRV_NAME); 581