1 /* 2 * OHCI HCD (Host Controller Driver) for USB. 3 * 4 * Copyright (C) 2004 SAN People (Pty) Ltd. 5 * Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org> 6 * 7 * AT91 Bus Glue 8 * 9 * Based on fragments of 2.4 driver by Rick Bronson. 10 * Based on ohci-omap.c 11 * 12 * This file is licenced under the GPL. 13 */ 14 15 #include <linux/clk.h> 16 #include <linux/dma-mapping.h> 17 #include <linux/of_platform.h> 18 #include <linux/of_gpio.h> 19 #include <linux/platform_device.h> 20 #include <linux/platform_data/atmel.h> 21 #include <linux/io.h> 22 #include <linux/kernel.h> 23 #include <linux/module.h> 24 #include <linux/usb.h> 25 #include <linux/usb/hcd.h> 26 27 #include "ohci.h" 28 29 #define valid_port(index) ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS) 30 #define at91_for_each_port(index) \ 31 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++) 32 33 /* interface, function and usb clocks; sometimes also an AHB clock */ 34 #define hcd_to_ohci_at91_priv(h) \ 35 ((struct ohci_at91_priv *)hcd_to_ohci(h)->priv) 36 37 #define AT91_MAX_USBH_PORTS 3 38 struct at91_usbh_data { 39 int vbus_pin[AT91_MAX_USBH_PORTS]; /* port power-control pin */ 40 int overcurrent_pin[AT91_MAX_USBH_PORTS]; 41 u8 ports; /* number of ports on root hub */ 42 u8 overcurrent_supported; 43 u8 vbus_pin_active_low[AT91_MAX_USBH_PORTS]; 44 u8 overcurrent_status[AT91_MAX_USBH_PORTS]; 45 u8 overcurrent_changed[AT91_MAX_USBH_PORTS]; 46 }; 47 48 struct ohci_at91_priv { 49 struct clk *iclk; 50 struct clk *fclk; 51 struct clk *hclk; 52 bool clocked; 53 bool wakeup; /* Saved wake-up state for resume */ 54 }; 55 /* interface and function clocks; sometimes also an AHB clock */ 56 57 #define DRIVER_DESC "OHCI Atmel driver" 58 59 static const char hcd_name[] = "ohci-atmel"; 60 61 static struct hc_driver __read_mostly ohci_at91_hc_driver; 62 63 static const struct ohci_driver_overrides ohci_at91_drv_overrides __initconst = { 64 .extra_priv_size = sizeof(struct ohci_at91_priv), 65 }; 66 67 extern int usb_disabled(void); 68 69 /*-------------------------------------------------------------------------*/ 70 71 static void at91_start_clock(struct ohci_at91_priv *ohci_at91) 72 { 73 if (ohci_at91->clocked) 74 return; 75 76 clk_set_rate(ohci_at91->fclk, 48000000); 77 clk_prepare_enable(ohci_at91->hclk); 78 clk_prepare_enable(ohci_at91->iclk); 79 clk_prepare_enable(ohci_at91->fclk); 80 ohci_at91->clocked = true; 81 } 82 83 static void at91_stop_clock(struct ohci_at91_priv *ohci_at91) 84 { 85 if (!ohci_at91->clocked) 86 return; 87 88 clk_disable_unprepare(ohci_at91->fclk); 89 clk_disable_unprepare(ohci_at91->iclk); 90 clk_disable_unprepare(ohci_at91->hclk); 91 ohci_at91->clocked = false; 92 } 93 94 static void at91_start_hc(struct platform_device *pdev) 95 { 96 struct usb_hcd *hcd = platform_get_drvdata(pdev); 97 struct ohci_regs __iomem *regs = hcd->regs; 98 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 99 100 dev_dbg(&pdev->dev, "start\n"); 101 102 /* 103 * Start the USB clocks. 104 */ 105 at91_start_clock(ohci_at91); 106 107 /* 108 * The USB host controller must remain in reset. 109 */ 110 writel(0, ®s->control); 111 } 112 113 static void at91_stop_hc(struct platform_device *pdev) 114 { 115 struct usb_hcd *hcd = platform_get_drvdata(pdev); 116 struct ohci_regs __iomem *regs = hcd->regs; 117 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 118 119 dev_dbg(&pdev->dev, "stop\n"); 120 121 /* 122 * Put the USB host controller into reset. 123 */ 124 writel(0, ®s->control); 125 126 /* 127 * Stop the USB clocks. 128 */ 129 at91_stop_clock(ohci_at91); 130 } 131 132 133 /*-------------------------------------------------------------------------*/ 134 135 static void usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *); 136 137 /* configure so an HC device and id are always provided */ 138 /* always called with process context; sleeping is OK */ 139 140 141 /** 142 * usb_hcd_at91_probe - initialize AT91-based HCDs 143 * Context: !in_interrupt() 144 * 145 * Allocates basic resources for this USB host controller, and 146 * then invokes the start() method for the HCD associated with it 147 * through the hotplug entry's driver_data. 148 */ 149 static int usb_hcd_at91_probe(const struct hc_driver *driver, 150 struct platform_device *pdev) 151 { 152 struct at91_usbh_data *board; 153 struct ohci_hcd *ohci; 154 int retval; 155 struct usb_hcd *hcd; 156 struct ohci_at91_priv *ohci_at91; 157 struct device *dev = &pdev->dev; 158 struct resource *res; 159 int irq; 160 161 irq = platform_get_irq(pdev, 0); 162 if (irq < 0) { 163 dev_dbg(dev, "hcd probe: missing irq resource\n"); 164 return irq; 165 } 166 167 hcd = usb_create_hcd(driver, dev, "at91"); 168 if (!hcd) 169 return -ENOMEM; 170 ohci_at91 = hcd_to_ohci_at91_priv(hcd); 171 172 res = platform_get_resource(pdev, IORESOURCE_MEM, 0); 173 hcd->regs = devm_ioremap_resource(dev, res); 174 if (IS_ERR(hcd->regs)) { 175 retval = PTR_ERR(hcd->regs); 176 goto err; 177 } 178 hcd->rsrc_start = res->start; 179 hcd->rsrc_len = resource_size(res); 180 181 ohci_at91->iclk = devm_clk_get(dev, "ohci_clk"); 182 if (IS_ERR(ohci_at91->iclk)) { 183 dev_err(dev, "failed to get ohci_clk\n"); 184 retval = PTR_ERR(ohci_at91->iclk); 185 goto err; 186 } 187 ohci_at91->fclk = devm_clk_get(dev, "uhpck"); 188 if (IS_ERR(ohci_at91->fclk)) { 189 dev_err(dev, "failed to get uhpck\n"); 190 retval = PTR_ERR(ohci_at91->fclk); 191 goto err; 192 } 193 ohci_at91->hclk = devm_clk_get(dev, "hclk"); 194 if (IS_ERR(ohci_at91->hclk)) { 195 dev_err(dev, "failed to get hclk\n"); 196 retval = PTR_ERR(ohci_at91->hclk); 197 goto err; 198 } 199 200 board = hcd->self.controller->platform_data; 201 ohci = hcd_to_ohci(hcd); 202 ohci->num_ports = board->ports; 203 at91_start_hc(pdev); 204 205 retval = usb_add_hcd(hcd, irq, IRQF_SHARED); 206 if (retval == 0) { 207 device_wakeup_enable(hcd->self.controller); 208 return retval; 209 } 210 211 /* Error handling */ 212 at91_stop_hc(pdev); 213 214 err: 215 usb_put_hcd(hcd); 216 return retval; 217 } 218 219 220 /* may be called with controller, bus, and devices active */ 221 222 /** 223 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs 224 * @dev: USB Host Controller being removed 225 * Context: !in_interrupt() 226 * 227 * Reverses the effect of usb_hcd_at91_probe(), first invoking 228 * the HCD's stop() method. It is always called from a thread 229 * context, "rmmod" or something similar. 230 * 231 */ 232 static void usb_hcd_at91_remove(struct usb_hcd *hcd, 233 struct platform_device *pdev) 234 { 235 usb_remove_hcd(hcd); 236 at91_stop_hc(pdev); 237 usb_put_hcd(hcd); 238 } 239 240 /*-------------------------------------------------------------------------*/ 241 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable) 242 { 243 if (!valid_port(port)) 244 return; 245 246 if (!gpio_is_valid(pdata->vbus_pin[port])) 247 return; 248 249 gpio_set_value(pdata->vbus_pin[port], 250 pdata->vbus_pin_active_low[port] ^ enable); 251 } 252 253 static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port) 254 { 255 if (!valid_port(port)) 256 return -EINVAL; 257 258 if (!gpio_is_valid(pdata->vbus_pin[port])) 259 return -EINVAL; 260 261 return gpio_get_value(pdata->vbus_pin[port]) ^ 262 pdata->vbus_pin_active_low[port]; 263 } 264 265 /* 266 * Update the status data from the hub with the over-current indicator change. 267 */ 268 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf) 269 { 270 struct at91_usbh_data *pdata = hcd->self.controller->platform_data; 271 int length = ohci_hub_status_data(hcd, buf); 272 int port; 273 274 at91_for_each_port(port) { 275 if (pdata->overcurrent_changed[port]) { 276 if (!length) 277 length = 1; 278 buf[0] |= 1 << (port + 1); 279 } 280 } 281 282 return length; 283 } 284 285 /* 286 * Look at the control requests to the root hub and see if we need to override. 287 */ 288 static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 289 u16 wIndex, char *buf, u16 wLength) 290 { 291 struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller); 292 struct usb_hub_descriptor *desc; 293 int ret = -EINVAL; 294 u32 *data = (u32 *)buf; 295 296 dev_dbg(hcd->self.controller, 297 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n", 298 hcd, typeReq, wValue, wIndex, buf, wLength); 299 300 wIndex--; 301 302 switch (typeReq) { 303 case SetPortFeature: 304 if (wValue == USB_PORT_FEAT_POWER) { 305 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n"); 306 if (valid_port(wIndex)) { 307 ohci_at91_usb_set_power(pdata, wIndex, 1); 308 ret = 0; 309 } 310 311 goto out; 312 } 313 break; 314 315 case ClearPortFeature: 316 switch (wValue) { 317 case USB_PORT_FEAT_C_OVER_CURRENT: 318 dev_dbg(hcd->self.controller, 319 "ClearPortFeature: C_OVER_CURRENT\n"); 320 321 if (valid_port(wIndex)) { 322 pdata->overcurrent_changed[wIndex] = 0; 323 pdata->overcurrent_status[wIndex] = 0; 324 } 325 326 goto out; 327 328 case USB_PORT_FEAT_OVER_CURRENT: 329 dev_dbg(hcd->self.controller, 330 "ClearPortFeature: OVER_CURRENT\n"); 331 332 if (valid_port(wIndex)) 333 pdata->overcurrent_status[wIndex] = 0; 334 335 goto out; 336 337 case USB_PORT_FEAT_POWER: 338 dev_dbg(hcd->self.controller, 339 "ClearPortFeature: POWER\n"); 340 341 if (valid_port(wIndex)) { 342 ohci_at91_usb_set_power(pdata, wIndex, 0); 343 return 0; 344 } 345 } 346 break; 347 } 348 349 ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength); 350 if (ret) 351 goto out; 352 353 switch (typeReq) { 354 case GetHubDescriptor: 355 356 /* update the hub's descriptor */ 357 358 desc = (struct usb_hub_descriptor *)buf; 359 360 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n", 361 desc->wHubCharacteristics); 362 363 /* remove the old configurations for power-switching, and 364 * over-current protection, and insert our new configuration 365 */ 366 367 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM); 368 desc->wHubCharacteristics |= 369 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM); 370 371 if (pdata->overcurrent_supported) { 372 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM); 373 desc->wHubCharacteristics |= 374 cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM); 375 } 376 377 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n", 378 desc->wHubCharacteristics); 379 380 return ret; 381 382 case GetPortStatus: 383 /* check port status */ 384 385 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex); 386 387 if (valid_port(wIndex)) { 388 if (!ohci_at91_usb_get_power(pdata, wIndex)) 389 *data &= ~cpu_to_le32(RH_PS_PPS); 390 391 if (pdata->overcurrent_changed[wIndex]) 392 *data |= cpu_to_le32(RH_PS_OCIC); 393 394 if (pdata->overcurrent_status[wIndex]) 395 *data |= cpu_to_le32(RH_PS_POCI); 396 } 397 } 398 399 out: 400 return ret; 401 } 402 403 /*-------------------------------------------------------------------------*/ 404 405 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data) 406 { 407 struct platform_device *pdev = data; 408 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev); 409 int val, gpio, port; 410 411 /* From the GPIO notifying the over-current situation, find 412 * out the corresponding port */ 413 at91_for_each_port(port) { 414 if (gpio_is_valid(pdata->overcurrent_pin[port]) && 415 gpio_to_irq(pdata->overcurrent_pin[port]) == irq) { 416 gpio = pdata->overcurrent_pin[port]; 417 break; 418 } 419 } 420 421 if (port == AT91_MAX_USBH_PORTS) { 422 dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n"); 423 return IRQ_HANDLED; 424 } 425 426 val = gpio_get_value(gpio); 427 428 /* When notified of an over-current situation, disable power 429 on the corresponding port, and mark this port in 430 over-current. */ 431 if (!val) { 432 ohci_at91_usb_set_power(pdata, port, 0); 433 pdata->overcurrent_status[port] = 1; 434 pdata->overcurrent_changed[port] = 1; 435 } 436 437 dev_dbg(& pdev->dev, "overcurrent situation %s\n", 438 val ? "exited" : "notified"); 439 440 return IRQ_HANDLED; 441 } 442 443 static const struct of_device_id at91_ohci_dt_ids[] = { 444 { .compatible = "atmel,at91rm9200-ohci" }, 445 { /* sentinel */ } 446 }; 447 448 MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids); 449 450 /*-------------------------------------------------------------------------*/ 451 452 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) 453 { 454 struct device_node *np = pdev->dev.of_node; 455 struct at91_usbh_data *pdata; 456 int i; 457 int gpio; 458 int ret; 459 enum of_gpio_flags flags; 460 u32 ports; 461 462 /* Right now device-tree probed devices don't get dma_mask set. 463 * Since shared usb code relies on it, set it here for now. 464 * Once we have dma capability bindings this can go away. 465 */ 466 ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 467 if (ret) 468 return ret; 469 470 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 471 if (!pdata) 472 return -ENOMEM; 473 474 pdev->dev.platform_data = pdata; 475 476 if (!of_property_read_u32(np, "num-ports", &ports)) 477 pdata->ports = ports; 478 479 at91_for_each_port(i) { 480 /* 481 * do not configure PIO if not in relation with 482 * real USB port on board 483 */ 484 if (i >= pdata->ports) { 485 pdata->vbus_pin[i] = -EINVAL; 486 pdata->overcurrent_pin[i] = -EINVAL; 487 continue; 488 } 489 490 gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i, 491 &flags); 492 pdata->vbus_pin[i] = gpio; 493 if (!gpio_is_valid(gpio)) 494 continue; 495 pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW; 496 497 ret = gpio_request(gpio, "ohci_vbus"); 498 if (ret) { 499 dev_err(&pdev->dev, 500 "can't request vbus gpio %d\n", gpio); 501 continue; 502 } 503 ret = gpio_direction_output(gpio, 504 !pdata->vbus_pin_active_low[i]); 505 if (ret) { 506 dev_err(&pdev->dev, 507 "can't put vbus gpio %d as output %d\n", 508 gpio, !pdata->vbus_pin_active_low[i]); 509 gpio_free(gpio); 510 continue; 511 } 512 513 ohci_at91_usb_set_power(pdata, i, 1); 514 } 515 516 at91_for_each_port(i) { 517 if (i >= pdata->ports) 518 break; 519 520 pdata->overcurrent_pin[i] = 521 of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags); 522 523 if (!gpio_is_valid(pdata->overcurrent_pin[i])) 524 continue; 525 gpio = pdata->overcurrent_pin[i]; 526 527 ret = gpio_request(gpio, "ohci_overcurrent"); 528 if (ret) { 529 dev_err(&pdev->dev, 530 "can't request overcurrent gpio %d\n", 531 gpio); 532 continue; 533 } 534 535 ret = gpio_direction_input(gpio); 536 if (ret) { 537 dev_err(&pdev->dev, 538 "can't configure overcurrent gpio %d as input\n", 539 gpio); 540 gpio_free(gpio); 541 continue; 542 } 543 544 ret = request_irq(gpio_to_irq(gpio), 545 ohci_hcd_at91_overcurrent_irq, 546 IRQF_SHARED, "ohci_overcurrent", pdev); 547 if (ret) { 548 gpio_free(gpio); 549 dev_err(&pdev->dev, 550 "can't get gpio IRQ for overcurrent\n"); 551 } 552 } 553 554 device_init_wakeup(&pdev->dev, 1); 555 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); 556 } 557 558 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) 559 { 560 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev); 561 int i; 562 563 if (pdata) { 564 at91_for_each_port(i) { 565 if (!gpio_is_valid(pdata->vbus_pin[i])) 566 continue; 567 ohci_at91_usb_set_power(pdata, i, 0); 568 gpio_free(pdata->vbus_pin[i]); 569 } 570 571 at91_for_each_port(i) { 572 if (!gpio_is_valid(pdata->overcurrent_pin[i])) 573 continue; 574 free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev); 575 gpio_free(pdata->overcurrent_pin[i]); 576 } 577 } 578 579 device_init_wakeup(&pdev->dev, 0); 580 usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev); 581 return 0; 582 } 583 584 static int __maybe_unused 585 ohci_hcd_at91_drv_suspend(struct device *dev) 586 { 587 struct usb_hcd *hcd = dev_get_drvdata(dev); 588 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 589 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 590 int ret; 591 592 /* 593 * Disable wakeup if we are going to sleep with slow clock mode 594 * enabled. 595 */ 596 ohci_at91->wakeup = device_may_wakeup(dev) 597 && !at91_suspend_entering_slow_clock(); 598 599 if (ohci_at91->wakeup) 600 enable_irq_wake(hcd->irq); 601 602 ret = ohci_suspend(hcd, ohci_at91->wakeup); 603 if (ret) { 604 if (ohci_at91->wakeup) 605 disable_irq_wake(hcd->irq); 606 return ret; 607 } 608 /* 609 * The integrated transceivers seem unable to notice disconnect, 610 * reconnect, or wakeup without the 48 MHz clock active. so for 611 * correctness, always discard connection state (using reset). 612 * 613 * REVISIT: some boards will be able to turn VBUS off... 614 */ 615 if (!ohci_at91->wakeup) { 616 ohci->hc_control = ohci_readl(ohci, &ohci->regs->control); 617 ohci->hc_control &= OHCI_CTRL_RWC; 618 ohci_writel(ohci, ohci->hc_control, &ohci->regs->control); 619 ohci->rh_state = OHCI_RH_HALTED; 620 621 /* flush the writes */ 622 (void) ohci_readl (ohci, &ohci->regs->control); 623 at91_stop_clock(ohci_at91); 624 } 625 626 return ret; 627 } 628 629 static int __maybe_unused 630 ohci_hcd_at91_drv_resume(struct device *dev) 631 { 632 struct usb_hcd *hcd = dev_get_drvdata(dev); 633 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 634 635 if (ohci_at91->wakeup) 636 disable_irq_wake(hcd->irq); 637 638 at91_start_clock(ohci_at91); 639 640 ohci_resume(hcd, false); 641 return 0; 642 } 643 644 static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops, ohci_hcd_at91_drv_suspend, 645 ohci_hcd_at91_drv_resume); 646 647 static struct platform_driver ohci_hcd_at91_driver = { 648 .probe = ohci_hcd_at91_drv_probe, 649 .remove = ohci_hcd_at91_drv_remove, 650 .shutdown = usb_hcd_platform_shutdown, 651 .driver = { 652 .name = "at91_ohci", 653 .pm = &ohci_hcd_at91_pm_ops, 654 .of_match_table = at91_ohci_dt_ids, 655 }, 656 }; 657 658 static int __init ohci_at91_init(void) 659 { 660 if (usb_disabled()) 661 return -ENODEV; 662 663 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 664 ohci_init_driver(&ohci_at91_hc_driver, &ohci_at91_drv_overrides); 665 666 /* 667 * The Atmel HW has some unusual quirks, which require Atmel-specific 668 * workarounds. We override certain hc_driver functions here to 669 * achieve that. We explicitly do not enhance ohci_driver_overrides to 670 * allow this more easily, since this is an unusual case, and we don't 671 * want to encourage others to override these functions by making it 672 * too easy. 673 */ 674 675 ohci_at91_hc_driver.hub_status_data = ohci_at91_hub_status_data; 676 ohci_at91_hc_driver.hub_control = ohci_at91_hub_control; 677 678 return platform_driver_register(&ohci_hcd_at91_driver); 679 } 680 module_init(ohci_at91_init); 681 682 static void __exit ohci_at91_cleanup(void) 683 { 684 platform_driver_unregister(&ohci_hcd_at91_driver); 685 } 686 module_exit(ohci_at91_cleanup); 687 688 MODULE_DESCRIPTION(DRIVER_DESC); 689 MODULE_LICENSE("GPL"); 690 MODULE_ALIAS("platform:at91_ohci"); 691