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