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/platform_device.h>
17 #include <linux/of_platform.h>
18 #include <linux/of_gpio.h>
19
20 #include <mach/hardware.h>
21 #include <asm/gpio.h>
22
23 #include <mach/board.h>
24 #include <mach/cpu.h>
25
26 #ifndef CONFIG_ARCH_AT91
27 #error "CONFIG_ARCH_AT91 must be defined."
28 #endif
29
30 #define valid_port(index) ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
31 #define at91_for_each_port(index) \
32 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
33
34 /* interface and function clocks; sometimes also an AHB clock */
35 static struct clk *iclk, *fclk, *hclk;
36 static int clocked;
37
38 extern int usb_disabled(void);
39
40 /*-------------------------------------------------------------------------*/
41
at91_start_clock(void)42 static void at91_start_clock(void)
43 {
44 clk_enable(hclk);
45 clk_enable(iclk);
46 clk_enable(fclk);
47 clocked = 1;
48 }
49
at91_stop_clock(void)50 static void at91_stop_clock(void)
51 {
52 clk_disable(fclk);
53 clk_disable(iclk);
54 clk_disable(hclk);
55 clocked = 0;
56 }
57
at91_start_hc(struct platform_device * pdev)58 static void at91_start_hc(struct platform_device *pdev)
59 {
60 struct usb_hcd *hcd = platform_get_drvdata(pdev);
61 struct ohci_regs __iomem *regs = hcd->regs;
62
63 dev_dbg(&pdev->dev, "start\n");
64
65 /*
66 * Start the USB clocks.
67 */
68 at91_start_clock();
69
70 /*
71 * The USB host controller must remain in reset.
72 */
73 writel(0, ®s->control);
74 }
75
at91_stop_hc(struct platform_device * pdev)76 static void at91_stop_hc(struct platform_device *pdev)
77 {
78 struct usb_hcd *hcd = platform_get_drvdata(pdev);
79 struct ohci_regs __iomem *regs = hcd->regs;
80
81 dev_dbg(&pdev->dev, "stop\n");
82
83 /*
84 * Put the USB host controller into reset.
85 */
86 writel(0, ®s->control);
87
88 /*
89 * Stop the USB clocks.
90 */
91 at91_stop_clock();
92 }
93
94
95 /*-------------------------------------------------------------------------*/
96
97 static void __devexit usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
98
99 /* configure so an HC device and id are always provided */
100 /* always called with process context; sleeping is OK */
101
102
103 /**
104 * usb_hcd_at91_probe - initialize AT91-based HCDs
105 * Context: !in_interrupt()
106 *
107 * Allocates basic resources for this USB host controller, and
108 * then invokes the start() method for the HCD associated with it
109 * through the hotplug entry's driver_data.
110 */
usb_hcd_at91_probe(const struct hc_driver * driver,struct platform_device * pdev)111 static int __devinit usb_hcd_at91_probe(const struct hc_driver *driver,
112 struct platform_device *pdev)
113 {
114 int retval;
115 struct usb_hcd *hcd = NULL;
116
117 if (pdev->num_resources != 2) {
118 pr_debug("hcd probe: invalid num_resources");
119 return -ENODEV;
120 }
121
122 if ((pdev->resource[0].flags != IORESOURCE_MEM)
123 || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
124 pr_debug("hcd probe: invalid resource type\n");
125 return -ENODEV;
126 }
127
128 hcd = usb_create_hcd(driver, &pdev->dev, "at91");
129 if (!hcd)
130 return -ENOMEM;
131 hcd->rsrc_start = pdev->resource[0].start;
132 hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
133
134 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
135 pr_debug("request_mem_region failed\n");
136 retval = -EBUSY;
137 goto err1;
138 }
139
140 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
141 if (!hcd->regs) {
142 pr_debug("ioremap failed\n");
143 retval = -EIO;
144 goto err2;
145 }
146
147 iclk = clk_get(&pdev->dev, "ohci_clk");
148 if (IS_ERR(iclk)) {
149 dev_err(&pdev->dev, "failed to get ohci_clk\n");
150 retval = PTR_ERR(iclk);
151 goto err3;
152 }
153 fclk = clk_get(&pdev->dev, "uhpck");
154 if (IS_ERR(fclk)) {
155 dev_err(&pdev->dev, "failed to get uhpck\n");
156 retval = PTR_ERR(fclk);
157 goto err4;
158 }
159 hclk = clk_get(&pdev->dev, "hclk");
160 if (IS_ERR(hclk)) {
161 dev_err(&pdev->dev, "failed to get hclk\n");
162 retval = PTR_ERR(hclk);
163 goto err5;
164 }
165
166 at91_start_hc(pdev);
167 ohci_hcd_init(hcd_to_ohci(hcd));
168
169 retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_SHARED);
170 if (retval == 0)
171 return retval;
172
173 /* Error handling */
174 at91_stop_hc(pdev);
175
176 clk_put(hclk);
177 err5:
178 clk_put(fclk);
179 err4:
180 clk_put(iclk);
181
182 err3:
183 iounmap(hcd->regs);
184
185 err2:
186 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
187
188 err1:
189 usb_put_hcd(hcd);
190 return retval;
191 }
192
193
194 /* may be called with controller, bus, and devices active */
195
196 /**
197 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
198 * @dev: USB Host Controller being removed
199 * Context: !in_interrupt()
200 *
201 * Reverses the effect of usb_hcd_at91_probe(), first invoking
202 * the HCD's stop() method. It is always called from a thread
203 * context, "rmmod" or something similar.
204 *
205 */
usb_hcd_at91_remove(struct usb_hcd * hcd,struct platform_device * pdev)206 static void __devexit usb_hcd_at91_remove(struct usb_hcd *hcd,
207 struct platform_device *pdev)
208 {
209 usb_remove_hcd(hcd);
210 at91_stop_hc(pdev);
211 iounmap(hcd->regs);
212 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
213 usb_put_hcd(hcd);
214
215 clk_put(hclk);
216 clk_put(fclk);
217 clk_put(iclk);
218 fclk = iclk = hclk = NULL;
219
220 dev_set_drvdata(&pdev->dev, NULL);
221 }
222
223 /*-------------------------------------------------------------------------*/
224
225 static int __devinit
ohci_at91_reset(struct usb_hcd * hcd)226 ohci_at91_reset (struct usb_hcd *hcd)
227 {
228 struct at91_usbh_data *board = hcd->self.controller->platform_data;
229 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
230 int ret;
231
232 if ((ret = ohci_init(ohci)) < 0)
233 return ret;
234
235 ohci->num_ports = board->ports;
236 return 0;
237 }
238
239 static int __devinit
ohci_at91_start(struct usb_hcd * hcd)240 ohci_at91_start (struct usb_hcd *hcd)
241 {
242 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
243 int ret;
244
245 if ((ret = ohci_run(ohci)) < 0) {
246 err("can't start %s", hcd->self.bus_name);
247 ohci_stop(hcd);
248 return ret;
249 }
250 return 0;
251 }
252
ohci_at91_usb_set_power(struct at91_usbh_data * pdata,int port,int enable)253 static void ohci_at91_usb_set_power(struct at91_usbh_data *pdata, int port, int enable)
254 {
255 if (!valid_port(port))
256 return;
257
258 if (!gpio_is_valid(pdata->vbus_pin[port]))
259 return;
260
261 gpio_set_value(pdata->vbus_pin[port],
262 pdata->vbus_pin_active_low[port] ^ enable);
263 }
264
ohci_at91_usb_get_power(struct at91_usbh_data * pdata,int port)265 static int ohci_at91_usb_get_power(struct at91_usbh_data *pdata, int port)
266 {
267 if (!valid_port(port))
268 return -EINVAL;
269
270 if (!gpio_is_valid(pdata->vbus_pin[port]))
271 return -EINVAL;
272
273 return gpio_get_value(pdata->vbus_pin[port]) ^
274 pdata->vbus_pin_active_low[port];
275 }
276
277 /*
278 * Update the status data from the hub with the over-current indicator change.
279 */
ohci_at91_hub_status_data(struct usb_hcd * hcd,char * buf)280 static int ohci_at91_hub_status_data(struct usb_hcd *hcd, char *buf)
281 {
282 struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
283 int length = ohci_hub_status_data(hcd, buf);
284 int port;
285
286 at91_for_each_port(port) {
287 if (pdata->overcurrent_changed[port]) {
288 if (!length)
289 length = 1;
290 buf[0] |= 1 << (port + 1);
291 }
292 }
293
294 return length;
295 }
296
297 /*
298 * Look at the control requests to the root hub and see if we need to override.
299 */
ohci_at91_hub_control(struct usb_hcd * hcd,u16 typeReq,u16 wValue,u16 wIndex,char * buf,u16 wLength)300 static int ohci_at91_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue,
301 u16 wIndex, char *buf, u16 wLength)
302 {
303 struct at91_usbh_data *pdata = hcd->self.controller->platform_data;
304 struct usb_hub_descriptor *desc;
305 int ret = -EINVAL;
306 u32 *data = (u32 *)buf;
307
308 dev_dbg(hcd->self.controller,
309 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
310 hcd, typeReq, wValue, wIndex, buf, wLength);
311
312 wIndex--;
313
314 switch (typeReq) {
315 case SetPortFeature:
316 if (wValue == USB_PORT_FEAT_POWER) {
317 dev_dbg(hcd->self.controller, "SetPortFeat: POWER\n");
318 if (valid_port(wIndex)) {
319 ohci_at91_usb_set_power(pdata, wIndex, 1);
320 ret = 0;
321 }
322
323 goto out;
324 }
325 break;
326
327 case ClearPortFeature:
328 switch (wValue) {
329 case USB_PORT_FEAT_C_OVER_CURRENT:
330 dev_dbg(hcd->self.controller,
331 "ClearPortFeature: C_OVER_CURRENT\n");
332
333 if (valid_port(wIndex)) {
334 pdata->overcurrent_changed[wIndex] = 0;
335 pdata->overcurrent_status[wIndex] = 0;
336 }
337
338 goto out;
339
340 case USB_PORT_FEAT_OVER_CURRENT:
341 dev_dbg(hcd->self.controller,
342 "ClearPortFeature: OVER_CURRENT\n");
343
344 if (valid_port(wIndex))
345 pdata->overcurrent_status[wIndex] = 0;
346
347 goto out;
348
349 case USB_PORT_FEAT_POWER:
350 dev_dbg(hcd->self.controller,
351 "ClearPortFeature: POWER\n");
352
353 if (valid_port(wIndex)) {
354 ohci_at91_usb_set_power(pdata, wIndex, 0);
355 return 0;
356 }
357 }
358 break;
359 }
360
361 ret = ohci_hub_control(hcd, typeReq, wValue, wIndex + 1, buf, wLength);
362 if (ret)
363 goto out;
364
365 switch (typeReq) {
366 case GetHubDescriptor:
367
368 /* update the hub's descriptor */
369
370 desc = (struct usb_hub_descriptor *)buf;
371
372 dev_dbg(hcd->self.controller, "wHubCharacteristics 0x%04x\n",
373 desc->wHubCharacteristics);
374
375 /* remove the old configurations for power-switching, and
376 * over-current protection, and insert our new configuration
377 */
378
379 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_LPSM);
380 desc->wHubCharacteristics |= cpu_to_le16(0x0001);
381
382 if (pdata->overcurrent_supported) {
383 desc->wHubCharacteristics &= ~cpu_to_le16(HUB_CHAR_OCPM);
384 desc->wHubCharacteristics |= cpu_to_le16(0x0008|0x0001);
385 }
386
387 dev_dbg(hcd->self.controller, "wHubCharacteristics after 0x%04x\n",
388 desc->wHubCharacteristics);
389
390 return ret;
391
392 case GetPortStatus:
393 /* check port status */
394
395 dev_dbg(hcd->self.controller, "GetPortStatus(%d)\n", wIndex);
396
397 if (valid_port(wIndex)) {
398 if (!ohci_at91_usb_get_power(pdata, wIndex))
399 *data &= ~cpu_to_le32(RH_PS_PPS);
400
401 if (pdata->overcurrent_changed[wIndex])
402 *data |= cpu_to_le32(RH_PS_OCIC);
403
404 if (pdata->overcurrent_status[wIndex])
405 *data |= cpu_to_le32(RH_PS_POCI);
406 }
407 }
408
409 out:
410 return ret;
411 }
412
413 /*-------------------------------------------------------------------------*/
414
415 static const struct hc_driver ohci_at91_hc_driver = {
416 .description = hcd_name,
417 .product_desc = "AT91 OHCI",
418 .hcd_priv_size = sizeof(struct ohci_hcd),
419
420 /*
421 * generic hardware linkage
422 */
423 .irq = ohci_irq,
424 .flags = HCD_USB11 | HCD_MEMORY,
425
426 /*
427 * basic lifecycle operations
428 */
429 .reset = ohci_at91_reset,
430 .start = ohci_at91_start,
431 .stop = ohci_stop,
432 .shutdown = ohci_shutdown,
433
434 /*
435 * managing i/o requests and associated device resources
436 */
437 .urb_enqueue = ohci_urb_enqueue,
438 .urb_dequeue = ohci_urb_dequeue,
439 .endpoint_disable = ohci_endpoint_disable,
440
441 /*
442 * scheduling support
443 */
444 .get_frame_number = ohci_get_frame,
445
446 /*
447 * root hub support
448 */
449 .hub_status_data = ohci_at91_hub_status_data,
450 .hub_control = ohci_at91_hub_control,
451 #ifdef CONFIG_PM
452 .bus_suspend = ohci_bus_suspend,
453 .bus_resume = ohci_bus_resume,
454 #endif
455 .start_port_reset = ohci_start_port_reset,
456 };
457
458 /*-------------------------------------------------------------------------*/
459
ohci_hcd_at91_overcurrent_irq(int irq,void * data)460 static irqreturn_t ohci_hcd_at91_overcurrent_irq(int irq, void *data)
461 {
462 struct platform_device *pdev = data;
463 struct at91_usbh_data *pdata = pdev->dev.platform_data;
464 int val, gpio, port;
465
466 /* From the GPIO notifying the over-current situation, find
467 * out the corresponding port */
468 at91_for_each_port(port) {
469 if (gpio_is_valid(pdata->overcurrent_pin[port]) &&
470 gpio_to_irq(pdata->overcurrent_pin[port]) == irq) {
471 gpio = pdata->overcurrent_pin[port];
472 break;
473 }
474 }
475
476 if (port == AT91_MAX_USBH_PORTS) {
477 dev_err(& pdev->dev, "overcurrent interrupt from unknown GPIO\n");
478 return IRQ_HANDLED;
479 }
480
481 val = gpio_get_value(gpio);
482
483 /* When notified of an over-current situation, disable power
484 on the corresponding port, and mark this port in
485 over-current. */
486 if (!val) {
487 ohci_at91_usb_set_power(pdata, port, 0);
488 pdata->overcurrent_status[port] = 1;
489 pdata->overcurrent_changed[port] = 1;
490 }
491
492 dev_dbg(& pdev->dev, "overcurrent situation %s\n",
493 val ? "exited" : "notified");
494
495 return IRQ_HANDLED;
496 }
497
498 #ifdef CONFIG_OF
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 static u64 at91_ohci_dma_mask = DMA_BIT_MASK(32);
507
ohci_at91_of_init(struct platform_device * pdev)508 static int __devinit ohci_at91_of_init(struct platform_device *pdev)
509 {
510 struct device_node *np = pdev->dev.of_node;
511 int i, gpio;
512 enum of_gpio_flags flags;
513 struct at91_usbh_data *pdata;
514 u32 ports;
515
516 if (!np)
517 return 0;
518
519 /* Right now device-tree probed devices don't get dma_mask set.
520 * Since shared usb code relies on it, set it here for now.
521 * Once we have dma capability bindings this can go away.
522 */
523 if (!pdev->dev.dma_mask)
524 pdev->dev.dma_mask = &at91_ohci_dma_mask;
525
526 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
527 if (!pdata)
528 return -ENOMEM;
529
530 if (!of_property_read_u32(np, "num-ports", &ports))
531 pdata->ports = ports;
532
533 at91_for_each_port(i) {
534 gpio = of_get_named_gpio_flags(np, "atmel,vbus-gpio", i, &flags);
535 pdata->vbus_pin[i] = gpio;
536 if (!gpio_is_valid(gpio))
537 continue;
538 pdata->vbus_pin_active_low[i] = flags & OF_GPIO_ACTIVE_LOW;
539 }
540
541 at91_for_each_port(i)
542 pdata->overcurrent_pin[i] =
543 of_get_named_gpio_flags(np, "atmel,oc-gpio", i, &flags);
544
545 pdev->dev.platform_data = pdata;
546
547 return 0;
548 }
549 #else
ohci_at91_of_init(struct platform_device * pdev)550 static int __devinit ohci_at91_of_init(struct platform_device *pdev)
551 {
552 return 0;
553 }
554 #endif
555
556 /*-------------------------------------------------------------------------*/
557
ohci_hcd_at91_drv_probe(struct platform_device * pdev)558 static int __devinit ohci_hcd_at91_drv_probe(struct platform_device *pdev)
559 {
560 struct at91_usbh_data *pdata;
561 int i;
562 int gpio;
563 int ret;
564
565 ret = ohci_at91_of_init(pdev);
566 if (ret)
567 return ret;
568
569 pdata = pdev->dev.platform_data;
570
571 if (pdata) {
572 at91_for_each_port(i) {
573 /*
574 * do not configure PIO if not in relation with
575 * real USB port on board
576 */
577 if (i >= pdata->ports) {
578 pdata->vbus_pin[i] = -EINVAL;
579 pdata->overcurrent_pin[i] = -EINVAL;
580 break;
581 }
582
583 if (!gpio_is_valid(pdata->vbus_pin[i]))
584 continue;
585 gpio = pdata->vbus_pin[i];
586
587 ret = gpio_request(gpio, "ohci_vbus");
588 if (ret) {
589 dev_err(&pdev->dev,
590 "can't request vbus gpio %d\n", gpio);
591 continue;
592 }
593 ret = gpio_direction_output(gpio,
594 !pdata->vbus_pin_active_low[i]);
595 if (ret) {
596 dev_err(&pdev->dev,
597 "can't put vbus gpio %d as output %d\n",
598 gpio, !pdata->vbus_pin_active_low[i]);
599 gpio_free(gpio);
600 continue;
601 }
602
603 ohci_at91_usb_set_power(pdata, i, 1);
604 }
605
606 at91_for_each_port(i) {
607 if (!gpio_is_valid(pdata->overcurrent_pin[i]))
608 continue;
609 gpio = pdata->overcurrent_pin[i];
610
611 ret = gpio_request(gpio, "ohci_overcurrent");
612 if (ret) {
613 dev_err(&pdev->dev,
614 "can't request overcurrent gpio %d\n",
615 gpio);
616 continue;
617 }
618
619 ret = gpio_direction_input(gpio);
620 if (ret) {
621 dev_err(&pdev->dev,
622 "can't configure overcurrent gpio %d as input\n",
623 gpio);
624 gpio_free(gpio);
625 continue;
626 }
627
628 ret = request_irq(gpio_to_irq(gpio),
629 ohci_hcd_at91_overcurrent_irq,
630 IRQF_SHARED, "ohci_overcurrent", pdev);
631 if (ret) {
632 gpio_free(gpio);
633 dev_err(&pdev->dev,
634 "can't get gpio IRQ for overcurrent\n");
635 }
636 }
637 }
638
639 device_init_wakeup(&pdev->dev, 1);
640 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
641 }
642
ohci_hcd_at91_drv_remove(struct platform_device * pdev)643 static int __devexit ohci_hcd_at91_drv_remove(struct platform_device *pdev)
644 {
645 struct at91_usbh_data *pdata = pdev->dev.platform_data;
646 int i;
647
648 if (pdata) {
649 at91_for_each_port(i) {
650 if (!gpio_is_valid(pdata->vbus_pin[i]))
651 continue;
652 ohci_at91_usb_set_power(pdata, i, 0);
653 gpio_free(pdata->vbus_pin[i]);
654 }
655
656 at91_for_each_port(i) {
657 if (!gpio_is_valid(pdata->overcurrent_pin[i]))
658 continue;
659 free_irq(gpio_to_irq(pdata->overcurrent_pin[i]), pdev);
660 gpio_free(pdata->overcurrent_pin[i]);
661 }
662 }
663
664 device_init_wakeup(&pdev->dev, 0);
665 usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
666 return 0;
667 }
668
669 #ifdef CONFIG_PM
670
671 static int
ohci_hcd_at91_drv_suspend(struct platform_device * pdev,pm_message_t mesg)672 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
673 {
674 struct usb_hcd *hcd = platform_get_drvdata(pdev);
675 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
676
677 if (device_may_wakeup(&pdev->dev))
678 enable_irq_wake(hcd->irq);
679
680 /*
681 * The integrated transceivers seem unable to notice disconnect,
682 * reconnect, or wakeup without the 48 MHz clock active. so for
683 * correctness, always discard connection state (using reset).
684 *
685 * REVISIT: some boards will be able to turn VBUS off...
686 */
687 if (at91_suspend_entering_slow_clock()) {
688 ohci_usb_reset (ohci);
689 /* flush the writes */
690 (void) ohci_readl (ohci, &ohci->regs->control);
691 at91_stop_clock();
692 }
693
694 return 0;
695 }
696
ohci_hcd_at91_drv_resume(struct platform_device * pdev)697 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
698 {
699 struct usb_hcd *hcd = platform_get_drvdata(pdev);
700
701 if (device_may_wakeup(&pdev->dev))
702 disable_irq_wake(hcd->irq);
703
704 if (!clocked)
705 at91_start_clock();
706
707 ohci_finish_controller_resume(hcd);
708 return 0;
709 }
710 #else
711 #define ohci_hcd_at91_drv_suspend NULL
712 #define ohci_hcd_at91_drv_resume NULL
713 #endif
714
715 MODULE_ALIAS("platform:at91_ohci");
716
717 static struct platform_driver ohci_hcd_at91_driver = {
718 .probe = ohci_hcd_at91_drv_probe,
719 .remove = __devexit_p(ohci_hcd_at91_drv_remove),
720 .shutdown = usb_hcd_platform_shutdown,
721 .suspend = ohci_hcd_at91_drv_suspend,
722 .resume = ohci_hcd_at91_drv_resume,
723 .driver = {
724 .name = "at91_ohci",
725 .owner = THIS_MODULE,
726 .of_match_table = of_match_ptr(at91_ohci_dt_ids),
727 },
728 };
729