Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/usb/host/ohci-at91.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us