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