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