Version:  2.0.40 2.2.26 2.4.37 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 4.5 4.6 4.7 4.8 4.9

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

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