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