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