Version:  2.0.40 2.2.26 2.4.37 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 4.2 4.3 4.4

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

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