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