?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
of: MSI: Simplify irqdomain lookup
[linux/fpc-iii.git] / drivers / usb / host / ohci-at91.c
blob8c6e15bd6ff0b27ce2e8cb22c2fe03e9866f1768
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");
Linux with added FPC-III support