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