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; 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 if (!pdev->dev.dma_mask) 485 pdev->dev.dma_mask = &pdev->dev.coherent_dma_mask; 486 if (!pdev->dev.coherent_dma_mask) 487 pdev->dev.coherent_dma_mask = DMA_BIT_MASK(32); 488 489 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 490 if (!pdata) 491 return -ENOMEM; 492 493 if (!of_property_read_u32(np, "num-ports", &ports)) 494 pdata->ports = ports; 495 496 at91_for_each_port(i) { 497 gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i, &flags); 498 pdata->vbus_pin[i] = gpio; 499 if (!gpio_is_valid(gpio)) 500 continue; 501 pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW; 502 } 503 504 at91_for_each_port(i) 505 pdata->overcurrent_pin[i] = 506 of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags); 507 508 pdev->dev.platform_data = pdata; 509 510 return 0; 511 } 512 #else 513 static int ohci_at91_of_init(struct platform_device *pdev) 514 { 515 return 0; 516 } 517 #endif 518 519 /*-------------------------------------------------------------------------*/ 520 521 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev) 522 { 523 struct at91_usbh_data *pdata; 524 int i; 525 int gpio; 526 int ret; 527 528 ret = ohci_at91_of_init(pdev); 529 if (ret) 530 return ret; 531 532 pdata = dev_get_platdata(&pdev->dev); 533 534 if (pdata) { 535 at91_for_each_port(i) { 536 /* 537 * do not configure PIO if not in relation with 538 * real USB port on board 539 */ 540 if (i >= pdata->ports) { 541 pdata->vbus_pin[i] = -EINVAL; 542 pdata->overcurrent_pin[i] = -EINVAL; 543 break; 544 } 545 546 if (!gpio_is_valid(pdata->vbus_pin[i])) 547 continue; 548 gpio = pdata->vbus_pin[i]; 549 550 ret = gpio_request(gpio, "ohci_vbus"); 551 if (ret) { 552 dev_err(&pdev->dev, 553 "can't request vbus gpio %d\n", gpio); 554 continue; 555 } 556 ret = gpio_direction_output(gpio, 557 !pdata->vbus_pin_active_low[i]); 558 if (ret) { 559 dev_err(&pdev->dev, 560 "can't put vbus gpio %d as output %d\n", 561 gpio, !pdata->vbus_pin_active_low[i]); 562 gpio_free(gpio); 563 continue; 564 } 565 566 ohci_at91_usb_set_power(pdata, i, 1); 567 } 568 569 at91_for_each_port(i) { 570 if (!gpio_is_valid(pdata->overcurrent_pin[i])) 571 continue; 572 gpio = pdata->overcurrent_pin[i]; 573 574 ret = gpio_request(gpio, "ohci_overcurrent"); 575 if (ret) { 576 dev_err(&pdev->dev, 577 "can't request overcurrent gpio %d\n", 578 gpio); 579 continue; 580 } 581 582 ret = gpio_direction_input(gpio); 583 if (ret) { 584 dev_err(&pdev->dev, 585 "can't configure overcurrent gpio %d as input\n", 586 gpio); 587 gpio_free(gpio); 588 continue; 589 } 590 591 ret = request_irq(gpio_to_irq(gpio), 592 ohci_hcd_at91_overcurrent_irq, 593 IRQF_SHARED, "ohci_overcurrent", pdev); 594 if (ret) { 595 gpio_free(gpio); 596 dev_err(&pdev->dev, 597 "can't get gpio IRQ for overcurrent\n"); 598 } 599 } 600 } 601 602 device_init_wakeup(&pdev->dev, 1); 603 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev); 604 } 605 606 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev) 607 { 608 struct at91_usbh_data *pdata = dev_get_platdata(&pdev->dev); 609 int i; 610 611 if (pdata) { 612 at91_for_each_port(i) { 613 if (!gpio_is_valid(pdata->vbus_pin[i])) 614 continue; 615 ohci_at91_usb_set_power(pdata, i, 0); 616 gpio_free(pdata->vbus_pin[i]); 617 } 618 619 at91_for_each_port(i) { 620 if (!gpio_is_valid(pdata->overcurrent_pin[i])) 621 continue; 622 free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev); 623 gpio_free(pdata->overcurrent_pin[i]); 624 } 625 } 626 627 device_init_wakeup(&pdev->dev, 0); 628 usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev); 629 return 0; 630 } 631 632 #ifdef CONFIG_PM 633 634 static int 635 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg) 636 { 637 struct usb_hcd *hcd = platform_get_drvdata(pdev); 638 struct ohci_hcd *ohci = hcd_to_ohci(hcd); 639 640 if (device_may_wakeup(&pdev->dev)) 641 enable_irq_wake(hcd->irq); 642 643 /* 644 * The integrated transceivers seem unable to notice disconnect, 645 * reconnect, or wakeup without the 48 MHz clock active. so for 646 * correctness, always discard connection state (using reset). 647 * 648 * REVISIT: some boards will be able to turn VBUS off... 649 */ 650 if (at91_suspend_entering_slow_clock()) { 651 ohci->hc_control = ohci_readl(ohci, &ohci->regs->control); 652 ohci->hc_control &= OHCI_CTRL_RWC; 653 ohci_writel(ohci, ohci->hc_control, &ohci->regs->control); 654 ohci->rh_state = OHCI_RH_HALTED; 655 656 /* flush the writes */ 657 (void) ohci_readl (ohci, &ohci->regs->control); 658 at91_stop_clock(); 659 } 660 661 return 0; 662 } 663 664 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev) 665 { 666 struct usb_hcd *hcd = platform_get_drvdata(pdev); 667 668 if (device_may_wakeup(&pdev->dev)) 669 disable_irq_wake(hcd->irq); 670 671 if (!clocked) 672 at91_start_clock(); 673 674 ohci_resume(hcd, false); 675 return 0; 676 } 677 #else 678 #define ohci_hcd_at91_drv_suspend NULL 679 #define ohci_hcd_at91_drv_resume NULL 680 #endif 681 682 static struct platform_driver ohci_hcd_at91_driver = { 683 .probe = ohci_hcd_at91_drv_probe, 684 .remove = ohci_hcd_at91_drv_remove, 685 .shutdown = usb_hcd_platform_shutdown, 686 .suspend = ohci_hcd_at91_drv_suspend, 687 .resume = ohci_hcd_at91_drv_resume, 688 .driver = { 689 .name = "at91_ohci", 690 .owner = THIS_MODULE, 691 .of_match_table = of_match_ptr(at91_ohci_dt_ids), 692 }, 693 }; 694 695 static int __init ohci_at91_init(void) 696 { 697 if (usb_disabled()) 698 return -ENODEV; 699 700 pr_info("%s: " DRIVER_DESC "\n", hcd_name); 701 ohci_init_driver(&ohci_at91_hc_driver, NULL); 702 703 /* 704 * The Atmel HW has some unusual quirks, which require Atmel-specific 705 * workarounds. We override certain hc_driver functions here to 706 * achieve that. We explicitly do not enhance ohci_driver_overrides to 707 * allow this more easily, since this is an unusual case, and we don't 708 * want to encourage others to override these functions by making it 709 * too easy. 710 */ 711 712 orig_ohci_hub_control = ohci_at91_hc_driver.hub_control; 713 orig_ohci_hub_status_data = ohci_at91_hc_driver.hub_status_data; 714 715 ohci_at91_hc_driver.hub_status_data = ohci_at91_hub_status_data; 716 ohci_at91_hc_driver.hub_control = ohci_at91_hub_control; 717 718 return platform_driver_register(&ohci_hcd_at91_driver); 719 } 720 module_init(ohci_at91_init); 721 722 static void __exit ohci_at91_cleanup(void) 723 { 724 platform_driver_unregister(&ohci_hcd_at91_driver); 725 } 726 module_exit(ohci_at91_cleanup); 727 728 MODULE_DESCRIPTION(DRIVER_DESC); 729 MODULE_LICENSE("GPL"); 730 MODULE_ALIAS("platform:at91_ohci"); 731