2 * OHCI HCD (Host Controller Driver) for USB.
4 * Copyright (C) 2004 SAN People (Pty) Ltd.
5 * Copyright (C) 2005 Thibaut VARENE <varenet@parisc-linux.org>
9 * Based on fragments of 2.4 driver by Rick Bronson.
10 * Based on ohci-omap.c
12 * This file is licenced under the GPL.
15 #include <linux/clk.h>
16 #include <linux/dma-mapping.h>
17 #include <linux/gpio/consumer.h>
18 #include <linux/of_platform.h>
19 #include <linux/platform_device.h>
20 #include <linux/platform_data/atmel.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>
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)++)
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)
40 #define AT91_MAX_USBH_PORTS 3
41 struct at91_usbh_data
{
42 struct gpio_desc
*vbus_pin
[AT91_MAX_USBH_PORTS
];
43 struct gpio_desc
*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
];
51 struct ohci_at91_priv
{
56 bool wakeup
; /* Saved wake-up state for resume */
57 struct regmap
*sfr_regmap
;
59 /* interface and function clocks; sometimes also an AHB clock */
61 #define DRIVER_DESC "OHCI Atmel driver"
63 static const char hcd_name
[] = "ohci-atmel";
65 static struct hc_driver __read_mostly ohci_at91_hc_driver
;
67 static const struct ohci_driver_overrides ohci_at91_drv_overrides __initconst
= {
68 .extra_priv_size
= sizeof(struct ohci_at91_priv
),
71 /*-------------------------------------------------------------------------*/
73 static void at91_start_clock(struct ohci_at91_priv
*ohci_at91
)
75 if (ohci_at91
->clocked
)
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;
85 static void at91_stop_clock(struct ohci_at91_priv
*ohci_at91
)
87 if (!ohci_at91
->clocked
)
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;
96 static void at91_start_hc(struct platform_device
*pdev
)
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
);
102 dev_dbg(&pdev
->dev
, "start\n");
105 * Start the USB clocks.
107 at91_start_clock(ohci_at91
);
110 * The USB host controller must remain in reset.
112 writel(0, ®s
->control
);
115 static void at91_stop_hc(struct platform_device
*pdev
)
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
);
121 dev_dbg(&pdev
->dev
, "stop\n");
124 * Put the USB host controller into reset.
126 writel(0, ®s
->control
);
129 * Stop the USB clocks.
131 at91_stop_clock(ohci_at91
);
135 /*-------------------------------------------------------------------------*/
137 static void usb_hcd_at91_remove (struct usb_hcd
*, struct platform_device
*);
139 static struct regmap
*at91_dt_syscon_sfr(void)
141 struct regmap
*regmap
;
143 regmap
= syscon_regmap_lookup_by_compatible("atmel,sama5d2-sfr");
150 /* configure so an HC device and id are always provided */
151 /* always called with process context; sleeping is OK */
155 * usb_hcd_at91_probe - initialize AT91-based HCDs
156 * Context: !in_interrupt()
158 * Allocates basic resources for this USB host controller, and
159 * then invokes the start() method for the HCD associated with it
160 * through the hotplug entry's driver_data.
162 static int usb_hcd_at91_probe(const struct hc_driver
*driver
,
163 struct platform_device
*pdev
)
165 struct at91_usbh_data
*board
;
166 struct ohci_hcd
*ohci
;
169 struct ohci_at91_priv
*ohci_at91
;
170 struct device
*dev
= &pdev
->dev
;
171 struct resource
*res
;
174 irq
= platform_get_irq(pdev
, 0);
176 dev_dbg(dev
, "hcd probe: missing irq resource\n");
180 hcd
= usb_create_hcd(driver
, dev
, "at91");
183 ohci_at91
= hcd_to_ohci_at91_priv(hcd
);
185 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
186 hcd
->regs
= devm_ioremap_resource(dev
, res
);
187 if (IS_ERR(hcd
->regs
)) {
188 retval
= PTR_ERR(hcd
->regs
);
191 hcd
->rsrc_start
= res
->start
;
192 hcd
->rsrc_len
= resource_size(res
);
194 ohci_at91
->iclk
= devm_clk_get(dev
, "ohci_clk");
195 if (IS_ERR(ohci_at91
->iclk
)) {
196 dev_err(dev
, "failed to get ohci_clk\n");
197 retval
= PTR_ERR(ohci_at91
->iclk
);
200 ohci_at91
->fclk
= devm_clk_get(dev
, "uhpck");
201 if (IS_ERR(ohci_at91
->fclk
)) {
202 dev_err(dev
, "failed to get uhpck\n");
203 retval
= PTR_ERR(ohci_at91
->fclk
);
206 ohci_at91
->hclk
= devm_clk_get(dev
, "hclk");
207 if (IS_ERR(ohci_at91
->hclk
)) {
208 dev_err(dev
, "failed to get hclk\n");
209 retval
= PTR_ERR(ohci_at91
->hclk
);
213 ohci_at91
->sfr_regmap
= at91_dt_syscon_sfr();
214 if (!ohci_at91
->sfr_regmap
)
215 dev_warn(dev
, "failed to find sfr node\n");
217 board
= hcd
->self
.controller
->platform_data
;
218 ohci
= hcd_to_ohci(hcd
);
219 ohci
->num_ports
= board
->ports
;
223 * The RemoteWakeupConnected bit has to be set explicitly
224 * before calling ohci_run. The reset value of this bit is 0.
226 ohci
->hc_control
= OHCI_CTRL_RWC
;
228 retval
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
230 device_wakeup_enable(hcd
->self
.controller
);
243 /* may be called with controller, bus, and devices active */
246 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
247 * @dev: USB Host Controller being removed
248 * Context: !in_interrupt()
250 * Reverses the effect of usb_hcd_at91_probe(), first invoking
251 * the HCD's stop() method. It is always called from a thread
252 * context, "rmmod" or something similar.
255 static void usb_hcd_at91_remove(struct usb_hcd
*hcd
,
256 struct platform_device
*pdev
)
263 /*-------------------------------------------------------------------------*/
264 static void ohci_at91_usb_set_power(struct at91_usbh_data
*pdata
, int port
, int enable
)
266 if (!valid_port(port
))
269 gpiod_set_value(pdata
->vbus_pin
[port
],
270 pdata
->vbus_pin_active_low
[port
] ^ enable
);
273 static int ohci_at91_usb_get_power(struct at91_usbh_data
*pdata
, int port
)
275 if (!valid_port(port
))
278 return gpiod_get_value(pdata
->vbus_pin
[port
]) ^
279 pdata
->vbus_pin_active_low
[port
];
283 * Update the status data from the hub with the over-current indicator change.
285 static int ohci_at91_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
287 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
288 int length
= ohci_hub_status_data(hcd
, buf
);
291 at91_for_each_port(port
) {
292 if (pdata
->overcurrent_changed
[port
]) {
295 buf
[0] |= 1 << (port
+ 1);
302 static int ohci_at91_port_suspend(struct regmap
*regmap
, u8 set
)
310 ret
= regmap_read(regmap
, AT91_SFR_OHCIICR
, ®val
);
315 regval
|= AT91_OHCIICR_USB_SUSPEND
;
317 regval
&= ~AT91_OHCIICR_USB_SUSPEND
;
319 regmap_write(regmap
, AT91_SFR_OHCIICR
, regval
);
325 * Look at the control requests to the root hub and see if we need to override.
327 static int ohci_at91_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
328 u16 wIndex
, char *buf
, u16 wLength
)
330 struct at91_usbh_data
*pdata
= dev_get_platdata(hcd
->self
.controller
);
331 struct ohci_at91_priv
*ohci_at91
= hcd_to_ohci_at91_priv(hcd
);
332 struct usb_hub_descriptor
*desc
;
334 u32
*data
= (u32
*)buf
;
336 dev_dbg(hcd
->self
.controller
,
337 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
338 hcd
, typeReq
, wValue
, wIndex
, buf
, wLength
);
345 case USB_PORT_FEAT_POWER
:
346 dev_dbg(hcd
->self
.controller
, "SetPortFeat: POWER\n");
347 if (valid_port(wIndex
)) {
348 ohci_at91_usb_set_power(pdata
, wIndex
, 1);
354 case USB_PORT_FEAT_SUSPEND
:
355 dev_dbg(hcd
->self
.controller
, "SetPortFeat: SUSPEND\n");
356 if (valid_port(wIndex
)) {
357 ohci_at91_port_suspend(ohci_at91
->sfr_regmap
,
365 case ClearPortFeature
:
367 case USB_PORT_FEAT_C_OVER_CURRENT
:
368 dev_dbg(hcd
->self
.controller
,
369 "ClearPortFeature: C_OVER_CURRENT\n");
371 if (valid_port(wIndex
)) {
372 pdata
->overcurrent_changed
[wIndex
] = 0;
373 pdata
->overcurrent_status
[wIndex
] = 0;
378 case USB_PORT_FEAT_OVER_CURRENT
:
379 dev_dbg(hcd
->self
.controller
,
380 "ClearPortFeature: OVER_CURRENT\n");
382 if (valid_port(wIndex
))
383 pdata
->overcurrent_status
[wIndex
] = 0;
387 case USB_PORT_FEAT_POWER
:
388 dev_dbg(hcd
->self
.controller
,
389 "ClearPortFeature: POWER\n");
391 if (valid_port(wIndex
)) {
392 ohci_at91_usb_set_power(pdata
, wIndex
, 0);
397 case USB_PORT_FEAT_SUSPEND
:
398 dev_dbg(hcd
->self
.controller
, "ClearPortFeature: SUSPEND\n");
399 if (valid_port(wIndex
)) {
400 ohci_at91_port_suspend(ohci_at91
->sfr_regmap
,
409 ret
= ohci_hub_control(hcd
, typeReq
, wValue
, wIndex
+ 1, buf
, wLength
);
414 case GetHubDescriptor
:
416 /* update the hub's descriptor */
418 desc
= (struct usb_hub_descriptor
*)buf
;
420 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics 0x%04x\n",
421 desc
->wHubCharacteristics
);
423 /* remove the old configurations for power-switching, and
424 * over-current protection, and insert our new configuration
427 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_LPSM
);
428 desc
->wHubCharacteristics
|=
429 cpu_to_le16(HUB_CHAR_INDV_PORT_LPSM
);
431 if (pdata
->overcurrent_supported
) {
432 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_OCPM
);
433 desc
->wHubCharacteristics
|=
434 cpu_to_le16(HUB_CHAR_INDV_PORT_OCPM
);
437 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics after 0x%04x\n",
438 desc
->wHubCharacteristics
);
443 /* check port status */
445 dev_dbg(hcd
->self
.controller
, "GetPortStatus(%d)\n", wIndex
);
447 if (valid_port(wIndex
)) {
448 if (!ohci_at91_usb_get_power(pdata
, wIndex
))
449 *data
&= ~cpu_to_le32(RH_PS_PPS
);
451 if (pdata
->overcurrent_changed
[wIndex
])
452 *data
|= cpu_to_le32(RH_PS_OCIC
);
454 if (pdata
->overcurrent_status
[wIndex
])
455 *data
|= cpu_to_le32(RH_PS_POCI
);
463 /*-------------------------------------------------------------------------*/
465 static irqreturn_t
ohci_hcd_at91_overcurrent_irq(int irq
, void *data
)
467 struct platform_device
*pdev
= data
;
468 struct at91_usbh_data
*pdata
= dev_get_platdata(&pdev
->dev
);
471 /* From the GPIO notifying the over-current situation, find
472 * out the corresponding port */
473 at91_for_each_port(port
) {
474 if (gpiod_to_irq(pdata
->overcurrent_pin
[port
]) == irq
)
478 if (port
== AT91_MAX_USBH_PORTS
) {
479 dev_err(& pdev
->dev
, "overcurrent interrupt from unknown GPIO\n");
483 val
= gpiod_get_value(pdata
->overcurrent_pin
[port
]);
485 /* When notified of an over-current situation, disable power
486 on the corresponding port, and mark this port in
489 ohci_at91_usb_set_power(pdata
, port
, 0);
490 pdata
->overcurrent_status
[port
] = 1;
491 pdata
->overcurrent_changed
[port
] = 1;
494 dev_dbg(& pdev
->dev
, "overcurrent situation %s\n",
495 val
? "exited" : "notified");
500 static const struct of_device_id at91_ohci_dt_ids
[] = {
501 { .compatible
= "atmel,at91rm9200-ohci" },
505 MODULE_DEVICE_TABLE(of
, at91_ohci_dt_ids
);
507 /*-------------------------------------------------------------------------*/
509 static int ohci_hcd_at91_drv_probe(struct platform_device
*pdev
)
511 struct device_node
*np
= pdev
->dev
.of_node
;
512 struct at91_usbh_data
*pdata
;
518 /* Right now device-tree probed devices don't get dma_mask set.
519 * Since shared usb code relies on it, set it here for now.
520 * Once we have dma capability bindings this can go away.
522 ret
= dma_coerce_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
526 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
530 pdev
->dev
.platform_data
= pdata
;
532 if (!of_property_read_u32(np
, "num-ports", &ports
))
533 pdata
->ports
= ports
;
535 at91_for_each_port(i
) {
536 pdata
->vbus_pin
[i
] = devm_gpiod_get_optional(&pdev
->dev
,
539 if (IS_ERR(pdata
->vbus_pin
[i
])) {
540 err
= PTR_ERR(pdata
->vbus_pin
[i
]);
541 dev_err(&pdev
->dev
, "unable to claim gpio \"vbus\": %d\n", err
);
545 pdata
->vbus_pin_active_low
[i
] = gpiod_get_value(pdata
->vbus_pin
[i
]);
547 ohci_at91_usb_set_power(pdata
, i
, 1);
550 at91_for_each_port(i
) {
551 if (i
>= pdata
->ports
)
554 pdata
->overcurrent_pin
[i
] =
555 devm_gpiod_get_optional(&pdev
->dev
,
556 "atmel,oc-gpio", GPIOD_IN
);
557 if (IS_ERR(pdata
->overcurrent_pin
[i
])) {
558 err
= PTR_ERR(pdata
->overcurrent_pin
[i
]);
559 dev_err(&pdev
->dev
, "unable to claim gpio \"overcurrent\": %d\n", err
);
563 ret
= devm_request_irq(&pdev
->dev
,
564 gpiod_to_irq(pdata
->overcurrent_pin
[i
]),
565 ohci_hcd_at91_overcurrent_irq
,
567 "ohci_overcurrent", pdev
);
569 dev_info(&pdev
->dev
, "failed to request gpio \"overcurrent\" IRQ\n");
572 device_init_wakeup(&pdev
->dev
, 1);
573 return usb_hcd_at91_probe(&ohci_at91_hc_driver
, pdev
);
576 static int ohci_hcd_at91_drv_remove(struct platform_device
*pdev
)
578 struct at91_usbh_data
*pdata
= dev_get_platdata(&pdev
->dev
);
582 at91_for_each_port(i
)
583 ohci_at91_usb_set_power(pdata
, i
, 0);
586 device_init_wakeup(&pdev
->dev
, 0);
587 usb_hcd_at91_remove(platform_get_drvdata(pdev
), pdev
);
591 static int __maybe_unused
592 ohci_hcd_at91_drv_suspend(struct device
*dev
)
594 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
595 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
596 struct ohci_at91_priv
*ohci_at91
= hcd_to_ohci_at91_priv(hcd
);
600 * Disable wakeup if we are going to sleep with slow clock mode
603 ohci_at91
->wakeup
= device_may_wakeup(dev
)
604 && !at91_suspend_entering_slow_clock();
606 if (ohci_at91
->wakeup
)
607 enable_irq_wake(hcd
->irq
);
609 ohci_at91_port_suspend(ohci_at91
->sfr_regmap
, 1);
611 ret
= ohci_suspend(hcd
, ohci_at91
->wakeup
);
613 if (ohci_at91
->wakeup
)
614 disable_irq_wake(hcd
->irq
);
618 * The integrated transceivers seem unable to notice disconnect,
619 * reconnect, or wakeup without the 48 MHz clock active. so for
620 * correctness, always discard connection state (using reset).
622 * REVISIT: some boards will be able to turn VBUS off...
624 if (!ohci_at91
->wakeup
) {
625 ohci
->rh_state
= OHCI_RH_HALTED
;
627 /* flush the writes */
628 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
629 at91_stop_clock(ohci_at91
);
635 static int __maybe_unused
636 ohci_hcd_at91_drv_resume(struct device
*dev
)
638 struct usb_hcd
*hcd
= dev_get_drvdata(dev
);
639 struct ohci_at91_priv
*ohci_at91
= hcd_to_ohci_at91_priv(hcd
);
641 if (ohci_at91
->wakeup
)
642 disable_irq_wake(hcd
->irq
);
644 at91_start_clock(ohci_at91
);
646 ohci_resume(hcd
, false);
648 ohci_at91_port_suspend(ohci_at91
->sfr_regmap
, 0);
653 static SIMPLE_DEV_PM_OPS(ohci_hcd_at91_pm_ops
, ohci_hcd_at91_drv_suspend
,
654 ohci_hcd_at91_drv_resume
);
656 static struct platform_driver ohci_hcd_at91_driver
= {
657 .probe
= ohci_hcd_at91_drv_probe
,
658 .remove
= ohci_hcd_at91_drv_remove
,
659 .shutdown
= usb_hcd_platform_shutdown
,
662 .pm
= &ohci_hcd_at91_pm_ops
,
663 .of_match_table
= at91_ohci_dt_ids
,
667 static int __init
ohci_at91_init(void)
672 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
673 ohci_init_driver(&ohci_at91_hc_driver
, &ohci_at91_drv_overrides
);
676 * The Atmel HW has some unusual quirks, which require Atmel-specific
677 * workarounds. We override certain hc_driver functions here to
678 * achieve that. We explicitly do not enhance ohci_driver_overrides to
679 * allow this more easily, since this is an unusual case, and we don't
680 * want to encourage others to override these functions by making it
684 ohci_at91_hc_driver
.hub_status_data
= ohci_at91_hub_status_data
;
685 ohci_at91_hc_driver
.hub_control
= ohci_at91_hub_control
;
687 return platform_driver_register(&ohci_hcd_at91_driver
);
689 module_init(ohci_at91_init
);
691 static void __exit
ohci_at91_cleanup(void)
693 platform_driver_unregister(&ohci_hcd_at91_driver
);
695 module_exit(ohci_at91_cleanup
);
697 MODULE_DESCRIPTION(DRIVER_DESC
);
698 MODULE_LICENSE("GPL");
699 MODULE_ALIAS("platform:at91_ohci");