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 * Context: !in_interrupt() 250 * 251 * Reverses the effect of usb_hcd_at91_probe(), first invoking 252 * the HCD's stop() method. It is always called from a thread 253 * context, "rmmod" or something similar. 254 * 255 */ 256 static void usb_hcd_at91_remove(struct usb_hcd *hcd, 257 struct platform_device *pdev) 258 { 259 usb_remove_hcd(hcd); 260 at91_stop_hc(pdev); 261 usb_put_hcd(hcd); 262 } 263 264 /*-------------------------------------------------------------------------*/ 265 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable) 266 { 267 if (!valid_port(port)) 268 return; 269 270 gpiod_set_value(pdata->vbus_pin[port], enable); 271 } 272 273 static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port) 274 { 275 if (!valid_port(port)) 276 return -EINVAL; 277 278 return gpiod_get_value(pdata->vbus_pin[port]); 279 } 280 281 /* 282 * Update the status data from the hub with the over-current indicator change. 283 */ 284 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf) 285 { 286 struct at91_usbh_data *pdata = hcd->self.controller->platform_data; 287 int length = ohci_hub_status_data(hcd, buf); 288 int port; 289 290 at91_for_each_port(port) { 291 if (pdata->overcurrent_changed[port]) { 292 if (!length) 293 length = 1; 294 buf[0] |= 1 << (port + 1); 295 } 296 } 297 298 return length; 299 } 300 301 static int ohci_at91_port_suspend(struct regmap *regmap, u8 set) 302 { 303 u32 regval; 304 int ret; 305 306 if (!regmap) 307 return 0; 308 309 ret = regmap_read(regmap, AT91_SFR_OHCIICR, ®val); 310 if (ret) 311 return ret; 312 313 if (set) 314 regval |= AT91_OHCIICR_USB_SUSPEND; 315 else 316 regval &= ~AT91_OHCIICR_USB_SUSPEND; 317 318 regmap_write(regmap, AT91_SFR_OHCIICR, regval); 319 320 return 0; 321 } 322 323 /* 324 * Look at the control requests to the root hub and see if we need to override. 325 */ 326 static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 327 u16 wIndex, char *buf, u16 wLength) 328 { 329 struct at91_usbh_data *pdata = dev_get_platdata(hcd->self.controller); 330 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 331 struct usb_hub_descriptor *desc; 332 int ret = -EINVAL; 333 u32 *data = (u32 *)buf; 334 335 dev_dbg(hcd->self.controller, 336 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n", 337 hcd, typeReq, wValue, wIndex, buf, wLength); 338 339 wIndex--; 340 341 switch (typeReq) { 342 case SetPortFeature: 343 switch (wValue) { 344 case USB_PORT_FEAT_POWER: 345 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n"); 346 if (valid_port(wIndex)) { 347 ohci_at91_usb_set_power(pdata, wIndex, 1); 348 ret = 0; 349 } 350 351 goto out; 352 353 case USB_PORT_FEAT_SUSPEND: 354 dev_dbg(hcd->self.controller, "SetPortFeat: SUSPEND\n"); 355 if (valid_port(wIndex) && ohci_at91->sfr_regmap) { 356 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 357 1); 358 return 0; 359 } 360 break; 361 } 362 break; 363 364 case ClearPortFeature: 365 switch (wValue) { 366 case USB_PORT_FEAT_C_OVER_CURRENT: 367 dev_dbg(hcd->self.controller, 368 "ClearPortFeature: C_OVER_CURRENT\n"); 369 370 if (valid_port(wIndex)) { 371 pdata->overcurrent_changed[wIndex] = 0; 372 pdata->overcurrent_status[wIndex] = 0; 373 } 374 375 goto out; 376 377 case USB_PORT_FEAT_OVER_CURRENT: 378 dev_dbg(hcd->self.controller, 379 "ClearPortFeature: OVER_CURRENT\n"); 380 381 if (valid_port(wIndex)) 382 pdata->overcurrent_status[wIndex] = 0; 383 384 goto out; 385 386 case USB_PORT_FEAT_POWER: 387 dev_dbg(hcd->self.controller, 388 "ClearPortFeature: POWER\n"); 389 390 if (valid_port(wIndex)) { 391 ohci_at91_usb_set_power(pdata, wIndex, 0); 392 return 0; 393 } 394 break; 395 396 case USB_PORT_FEAT_SUSPEND: 397 dev_dbg(hcd->self.controller, "ClearPortFeature: SUSPEND\n"); 398 if (valid_port(wIndex) && ohci_at91->sfr_regmap) { 399 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 400 0); 401 return 0; 402 } 403 break; 404 } 405 break; 406 } 407 408 ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength); 409 if (ret) 410 goto out; 411 412 switch (typeReq) { 413 case GetHubDescriptor: 414 415 /* update the hub's descriptor */ 416 417 desc = (struct usb_hub_descriptor *)buf; 418 419 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n", 420 desc->wHubCharacteristics); 421 422 /* remove the old configurations for power-switching, and 423 * over-current protection, and insert our new configuration 424 */ 425 426 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM); 427 desc->wHubCharacteristics |= 428 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM); 429 430 if (pdata->overcurrent_supported) { 431 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM); 432 desc->wHubCharacteristics |= 433 cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM); 434 } 435 436 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n", 437 desc->wHubCharacteristics); 438 439 return ret; 440 441 case GetPortStatus: 442 /* check port status */ 443 444 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex); 445 446 if (valid_port(wIndex)) { 447 if (!ohci_at91_usb_get_power(pdata, wIndex)) 448 *data &= ~cpu_to_le32(RH_PS_PPS); 449 450 if (pdata->overcurrent_changed[wIndex]) 451 *data |= cpu_to_le32(RH_PS_OCIC); 452 453 if (pdata->overcurrent_status[wIndex]) 454 *data |= cpu_to_le32(RH_PS_POCI); 455 } 456 } 457 458 out: 459 return ret; 460 } 461 462 /*-------------------------------------------------------------------------*/ 463 464 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data) 465 { 466 struct platform_device *pdev = data; 467 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev); 468 int val, port; 469 470 /* From the GPIO notifying the over-current situation, find 471 * out the corresponding port */ 472 at91_for_each_port(port) { 473 if (gpiod_to_irq(pdata->overcurrent_pin[port]) == irq) 474 break; 475 } 476 477 if (port == AT91_MAX_USBH_PORTS) { 478 dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n"); 479 return IRQ_HANDLED; 480 } 481 482 val = gpiod_get_value(pdata->overcurrent_pin[port]); 483 484 /* When notified of an over-current situation, disable power 485 on the corresponding port, and mark this port in 486 over-current. */ 487 if (!val) { 488 ohci_at91_usb_set_power(pdata, port, 0); 489 pdata->overcurrent_status[port] = 1; 490 pdata->overcurrent_changed[port] = 1; 491 } 492 493 dev_dbg(& pdev->dev, "overcurrent situation %s\n", 494 val ? "exited" : "notified"); 495 496 return IRQ_HANDLED; 497 } 498 499 static const struct of_device_id at91_ohci_dt_ids[] = { 500 { .compatible = "atmel,at91rm9200-ohci" }, 501 { /* sentinel */ } 502 }; 503 504 MODULE_DEVICE_TABLE(of, at91_ohci_dt_ids); 505 506 /*-------------------------------------------------------------------------*/ 507 508 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) 509 { 510 struct device_node *np = pdev->dev.of_node; 511 struct at91_usbh_data *pdata; 512 int i; 513 int ret; 514 int err; 515 u32 ports; 516 517 /* Right now device-tree probed devices don't get dma_mask set. 518 * Since shared usb code relies on it, set it here for now. 519 * Once we have dma capability bindings this can go away. 520 */ 521 ret = dma_coerce_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 522 if (ret) 523 return ret; 524 525 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 526 if (!pdata) 527 return -ENOMEM; 528 529 pdev->dev.platform_data = pdata; 530 531 if (!of_property_read_u32(np, "num-ports", &ports)) 532 pdata->ports = ports; 533 534 at91_for_each_port(i) { 535 if (i >= pdata->ports) 536 break; 537 538 pdata->vbus_pin[i] = 539 devm_gpiod_get_index_optional(&pdev->dev, "atmel,vbus", 540 i, GPIOD_OUT_HIGH); 541 if (IS_ERR(pdata->vbus_pin[i])) { 542 err = PTR_ERR(pdata->vbus_pin[i]); 543 dev_err(&pdev->dev, "unable to claim gpio \"vbus\": %d\n", err); 544 continue; 545 } 546 } 547 548 at91_for_each_port(i) { 549 if (i >= pdata->ports) 550 break; 551 552 pdata->overcurrent_pin[i] = 553 devm_gpiod_get_index_optional(&pdev->dev, "atmel,oc", 554 i, GPIOD_IN); 555 if (!pdata->overcurrent_pin[i]) 556 continue; 557 if (IS_ERR(pdata->overcurrent_pin[i])) { 558 err = PTR_ERR(pdata->overcurrent_pin[i]); 559 dev_err(&pdev->dev, "unable to claim gpio \"overcurrent\": %d\n", err); 560 continue; 561 } 562 563 ret = devm_request_irq(&pdev->dev, 564 gpiod_to_irq(pdata->overcurrent_pin[i]), 565 ohci_hcd_at91_overcurrent_irq, 566 IRQF_SHARED, 567 "ohci_overcurrent", pdev); 568 if (ret) 569 dev_info(&pdev->dev, "failed to request gpio \"overcurrent\" IRQ\n"); 570 } 571 572 device_init_wakeup(&pdev->dev, 1); 573 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); 574 } 575 576 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) 577 { 578 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev); 579 int i; 580 581 if (pdata) { 582 at91_for_each_port(i) 583 ohci_at91_usb_set_power(pdata, i, 0); 584 } 585 586 device_init_wakeup(&pdev->dev, 0); 587 usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev); 588 return 0; 589 } 590 591 static int __maybe_unused 592 ohci_hcd_at91_drv_suspend(struct device *dev) 593 { 594 struct usb_hcd *hcd = dev_get_drvdata(dev); 595 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 596 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 597 int ret; 598 599 /* 600 * Disable wakeup if we are going to sleep with slow clock mode 601 * enabled. 602 */ 603 ohci_at91->wakeup = device_may_wakeup(dev) 604 && !at91_suspend_entering_slow_clock(); 605 606 if (ohci_at91->wakeup) 607 enable_irq_wake(hcd->irq); 608 609 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 1); 610 611 ret = ohci_suspend(hcd, ohci_at91->wakeup); 612 if (ret) { 613 if (ohci_at91->wakeup) 614 disable_irq_wake(hcd->irq); 615 return ret; 616 } 617 /* 618 * The integrated transceivers seem unable to notice disconnect, 619 * reconnect, or wakeup without the 48 MHz clock active. so for 620 * correctness, always discard connection state (using reset). 621 * 622 * REVISIT: some boards will be able to turn VBUS off... 623 */ 624 if (!ohci_at91->wakeup) { 625 ohci->rh_state = OHCI_RH_HALTED; 626 627 /* flush the writes */ 628 (void) ohci_readl (ohci, &ohci->regs->control); 629 msleep(1); 630 at91_stop_clock(ohci_at91); 631 } 632 633 return ret; 634 } 635 636 static int __maybe_unused 637 ohci_hcd_at91_drv_resume(struct device *dev) 638 { 639 struct usb_hcd *hcd = dev_get_drvdata(dev); 640 struct ohci_at91_priv *ohci_at91 = hcd_to_ohci_at91_priv(hcd); 641 642 if (ohci_at91->wakeup) 643 disable_irq_wake(hcd->irq); 644 else 645 at91_start_clock(ohci_at91); 646 647 ohci_resume(hcd, false); 648 649 ohci_at91_port_suspend(ohci_at91->sfr_regmap, 0); 650 651 return 0; 652 } 653 654 static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops, ohci_hcd_at91_drv_suspend, 655 ohci_hcd_at91_drv_resume); 656 657 static struct platform_driver ohci_hcd_at91_driver = { 658 .probe = ohci_hcd_at91_drv_probe, 659 .remove = ohci_hcd_at91_drv_remove, 660 .shutdown = usb_hcd_platform_shutdown, 661 .driver = { 662 .name = "at91_ohci", 663 .pm = &ohci_hcd_at91_pm_ops, 664 .of_match_table = at91_ohci_dt_ids, 665 }, 666 }; 667 668 static int __init ohci_at91_init(void) 669 { 670 if (usb_disabled()) 671 return -ENODEV; 672 673 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 674 ohci_init_driver(&ohci_at91_hc_driver, &ohci_at91_drv_overrides); 675 676 /* 677 * The Atmel HW has some unusual quirks, which require Atmel-specific 678 * workarounds. We override certain hc_driver functions here to 679 * achieve that. We explicitly do not enhance ohci_driver_overrides to 680 * allow this more easily, since this is an unusual case, and we don't 681 * want to encourage others to override these functions by making it 682 * too easy. 683 */ 684 685 ohci_at91_hc_driver.hub_status_data = ohci_at91_hub_status_data; 686 ohci_at91_hc_driver.hub_control = ohci_at91_hub_control; 687 688 return platform_driver_register(&ohci_hcd_at91_driver); 689 } 690 module_init(ohci_at91_init); 691 692 static void __exit ohci_at91_cleanup(void) 693 { 694 platform_driver_unregister(&ohci_hcd_at91_driver); 695 } 696 module_exit(ohci_at91_cleanup); 697 698 MODULE_DESCRIPTION(DRIVER_DESC); 699 MODULE_LICENSE("GPL"); 700 MODULE_ALIAS("platform:at91_ohci"); 701