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/of_platform.h>
18 #include <linux/of_gpio.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/usb.h>
25 #include <linux/usb/hcd.h>
27 #include <mach/hardware.h>
35 #define valid_port(index) ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
36 #define at91_for_each_port(index) \
37 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
39 /* interface, function and usb clocks; sometimes also an AHB clock */
40 static struct clk
*iclk
, *fclk
, *uclk
, *hclk
;
41 /* interface and function clocks; sometimes also an AHB clock */
43 #define DRIVER_DESC "OHCI Atmel driver"
45 static const char hcd_name
[] = "ohci-atmel";
47 static struct hc_driver __read_mostly ohci_at91_hc_driver
;
49 static int (*orig_ohci_hub_control
)(struct usb_hcd
*hcd
, u16 typeReq
,
50 u16 wValue
, u16 wIndex
, char *buf
, u16 wLength
);
51 static int (*orig_ohci_hub_status_data
)(struct usb_hcd
*hcd
, char *buf
);
53 extern int usb_disabled(void);
55 /*-------------------------------------------------------------------------*/
57 static void at91_start_clock(void)
59 if (IS_ENABLED(CONFIG_COMMON_CLK
)) {
60 clk_set_rate(uclk
, 48000000);
61 clk_prepare_enable(uclk
);
63 clk_prepare_enable(hclk
);
64 clk_prepare_enable(iclk
);
65 clk_prepare_enable(fclk
);
69 static void at91_stop_clock(void)
71 clk_disable_unprepare(fclk
);
72 clk_disable_unprepare(iclk
);
73 clk_disable_unprepare(hclk
);
74 if (IS_ENABLED(CONFIG_COMMON_CLK
))
75 clk_disable_unprepare(uclk
);
79 static void at91_start_hc(struct platform_device
*pdev
)
81 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
82 struct ohci_regs __iomem
*regs
= hcd
->regs
;
84 dev_dbg(&pdev
->dev
, "start\n");
87 * Start the USB clocks.
92 * The USB host controller must remain in reset.
94 writel(0, ®s
->control
);
97 static void at91_stop_hc(struct platform_device
*pdev
)
99 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
100 struct ohci_regs __iomem
*regs
= hcd
->regs
;
102 dev_dbg(&pdev
->dev
, "stop\n");
105 * Put the USB host controller into reset.
107 writel(0, ®s
->control
);
110 * Stop the USB clocks.
116 /*-------------------------------------------------------------------------*/
118 static void usb_hcd_at91_remove (struct usb_hcd
*, struct platform_device
*);
120 /* configure so an HC device and id are always provided */
121 /* always called with process context; sleeping is OK */
125 * usb_hcd_at91_probe - initialize AT91-based HCDs
126 * Context: !in_interrupt()
128 * Allocates basic resources for this USB host controller, and
129 * then invokes the start() method for the HCD associated with it
130 * through the hotplug entry's driver_data.
132 static int usb_hcd_at91_probe(const struct hc_driver
*driver
,
133 struct platform_device
*pdev
)
135 struct at91_usbh_data
*board
;
136 struct ohci_hcd
*ohci
;
138 struct usb_hcd
*hcd
= NULL
;
139 struct device
*dev
= &pdev
->dev
;
140 struct resource
*res
;
143 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
145 dev_dbg(dev
, "hcd probe: missing memory resource\n");
149 irq
= platform_get_irq(pdev
, 0);
151 dev_dbg(dev
, "hcd probe: missing irq resource\n");
155 hcd
= usb_create_hcd(driver
, &pdev
->dev
, "at91");
158 hcd
->rsrc_start
= res
->start
;
159 hcd
->rsrc_len
= resource_size(res
);
161 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
, hcd_name
)) {
162 pr_debug("request_mem_region failed\n");
167 hcd
->regs
= ioremap(hcd
->rsrc_start
, hcd
->rsrc_len
);
169 pr_debug("ioremap failed\n");
174 iclk
= clk_get(&pdev
->dev
, "ohci_clk");
176 dev_err(&pdev
->dev
, "failed to get ohci_clk\n");
177 retval
= PTR_ERR(iclk
);
180 fclk
= clk_get(&pdev
->dev
, "uhpck");
182 dev_err(&pdev
->dev
, "failed to get uhpck\n");
183 retval
= PTR_ERR(fclk
);
186 hclk
= clk_get(&pdev
->dev
, "hclk");
188 dev_err(&pdev
->dev
, "failed to get hclk\n");
189 retval
= PTR_ERR(hclk
);
192 if (IS_ENABLED(CONFIG_COMMON_CLK
)) {
193 uclk
= clk_get(&pdev
->dev
, "usb_clk");
195 dev_err(&pdev
->dev
, "failed to get uclk\n");
196 retval
= PTR_ERR(uclk
);
201 board
= hcd
->self
.controller
->platform_data
;
202 ohci
= hcd_to_ohci(hcd
);
203 ohci
->num_ports
= board
->ports
;
206 retval
= usb_add_hcd(hcd
, irq
, IRQF_SHARED
);
213 if (IS_ENABLED(CONFIG_COMMON_CLK
))
226 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
234 /* may be called with controller, bus, and devices active */
237 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
238 * @dev: USB Host Controller being removed
239 * Context: !in_interrupt()
241 * Reverses the effect of usb_hcd_at91_probe(), first invoking
242 * the HCD's stop() method. It is always called from a thread
243 * context, "rmmod" or something similar.
246 static void usb_hcd_at91_remove(struct usb_hcd
*hcd
,
247 struct platform_device
*pdev
)
252 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
255 if (IS_ENABLED(CONFIG_COMMON_CLK
))
260 fclk
= iclk
= hclk
= NULL
;
263 /*-------------------------------------------------------------------------*/
264 static void ohci_at91_usb_set_power(struct at91_usbh_data
*pdata
, int port
, int enable
)
266 if (!valid_port(port
))
269 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
272 gpio_set_value(pdata
->vbus_pin
[port
],
273 pdata
->vbus_pin_active_low
[port
] ^ enable
);
276 static int ohci_at91_usb_get_power(struct at91_usbh_data
*pdata
, int port
)
278 if (!valid_port(port
))
281 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
284 return gpio_get_value(pdata
->vbus_pin
[port
]) ^
285 pdata
->vbus_pin_active_low
[port
];
289 * Update the status data from the hub with the over-current indicator change.
291 static int ohci_at91_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
293 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
294 int length
= orig_ohci_hub_status_data(hcd
, buf
);
297 at91_for_each_port(port
) {
298 if (pdata
->overcurrent_changed
[port
]) {
301 buf
[0] |= 1 << (port
+ 1);
309 * Look at the control requests to the root hub and see if we need to override.
311 static int ohci_at91_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
312 u16 wIndex
, char *buf
, u16 wLength
)
314 struct at91_usbh_data
*pdata
= dev_get_platdata(hcd
->self
.controller
);
315 struct usb_hub_descriptor
*desc
;
317 u32
*data
= (u32
*)buf
;
319 dev_dbg(hcd
->self
.controller
,
320 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
321 hcd
, typeReq
, wValue
, wIndex
, buf
, wLength
);
327 if (wValue
== USB_PORT_FEAT_POWER
) {
328 dev_dbg(hcd
->self
.controller
, "SetPortFeat: POWER\n");
329 if (valid_port(wIndex
)) {
330 ohci_at91_usb_set_power(pdata
, wIndex
, 1);
338 case ClearPortFeature
:
340 case USB_PORT_FEAT_C_OVER_CURRENT
:
341 dev_dbg(hcd
->self
.controller
,
342 "ClearPortFeature: C_OVER_CURRENT\n");
344 if (valid_port(wIndex
)) {
345 pdata
->overcurrent_changed
[wIndex
] = 0;
346 pdata
->overcurrent_status
[wIndex
] = 0;
351 case USB_PORT_FEAT_OVER_CURRENT
:
352 dev_dbg(hcd
->self
.controller
,
353 "ClearPortFeature: OVER_CURRENT\n");
355 if (valid_port(wIndex
))
356 pdata
->overcurrent_status
[wIndex
] = 0;
360 case USB_PORT_FEAT_POWER
:
361 dev_dbg(hcd
->self
.controller
,
362 "ClearPortFeature: POWER\n");
364 if (valid_port(wIndex
)) {
365 ohci_at91_usb_set_power(pdata
, wIndex
, 0);
372 ret
= orig_ohci_hub_control(hcd
, typeReq
, wValue
, wIndex
+ 1,
378 case GetHubDescriptor
:
380 /* update the hub's descriptor */
382 desc
= (struct usb_hub_descriptor
*)buf
;
384 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics 0x%04x\n",
385 desc
->wHubCharacteristics
);
387 /* remove the old configurations for power-switching, and
388 * over-current protection, and insert our new configuration
391 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_LPSM
);
392 desc
->wHubCharacteristics
|= cpu_to_le16(0x0001);
394 if (pdata
->overcurrent_supported
) {
395 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_OCPM
);
396 desc
->wHubCharacteristics
|= cpu_to_le16(0x0008|0x0001);
399 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics after 0x%04x\n",
400 desc
->wHubCharacteristics
);
405 /* check port status */
407 dev_dbg(hcd
->self
.controller
, "GetPortStatus(%d)\n", wIndex
);
409 if (valid_port(wIndex
)) {
410 if (!ohci_at91_usb_get_power(pdata
, wIndex
))
411 *data
&= ~cpu_to_le32(RH_PS_PPS
);
413 if (pdata
->overcurrent_changed
[wIndex
])
414 *data
|= cpu_to_le32(RH_PS_OCIC
);
416 if (pdata
->overcurrent_status
[wIndex
])
417 *data
|= cpu_to_le32(RH_PS_POCI
);
425 /*-------------------------------------------------------------------------*/
427 static irqreturn_t
ohci_hcd_at91_overcurrent_irq(int irq
, void *data
)
429 struct platform_device
*pdev
= data
;
430 struct at91_usbh_data
*pdata
= dev_get_platdata(&pdev
->dev
);
433 /* From the GPIO notifying the over-current situation, find
434 * out the corresponding port */
435 at91_for_each_port(port
) {
436 if (gpio_is_valid(pdata
->overcurrent_pin
[port
]) &&
437 gpio_to_irq(pdata
->overcurrent_pin
[port
]) == irq
) {
438 gpio
= pdata
->overcurrent_pin
[port
];
443 if (port
== AT91_MAX_USBH_PORTS
) {
444 dev_err(& pdev
->dev
, "overcurrent interrupt from unknown GPIO\n");
448 val
= gpio_get_value(gpio
);
450 /* When notified of an over-current situation, disable power
451 on the corresponding port, and mark this port in
454 ohci_at91_usb_set_power(pdata
, port
, 0);
455 pdata
->overcurrent_status
[port
] = 1;
456 pdata
->overcurrent_changed
[port
] = 1;
459 dev_dbg(& pdev
->dev
, "overcurrent situation %s\n",
460 val
? "exited" : "notified");
466 static const struct of_device_id at91_ohci_dt_ids
[] = {
467 { .compatible
= "atmel,at91rm9200-ohci" },
471 MODULE_DEVICE_TABLE(of
, at91_ohci_dt_ids
);
473 static int ohci_at91_of_init(struct platform_device
*pdev
)
475 struct device_node
*np
= pdev
->dev
.of_node
;
477 enum of_gpio_flags flags
;
478 struct at91_usbh_data
*pdata
;
484 /* Right now device-tree probed devices don't get dma_mask set.
485 * Since shared usb code relies on it, set it here for now.
486 * Once we have dma capability bindings this can go away.
488 ret
= dma_coerce_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
492 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
496 if (!of_property_read_u32(np
, "num-ports", &ports
))
497 pdata
->ports
= ports
;
499 at91_for_each_port(i
) {
500 gpio
= of_get_named_gpio_flags(np
, "atmel,vbus-gpio", i
, &flags
);
501 pdata
->vbus_pin
[i
] = gpio
;
502 if (!gpio_is_valid(gpio
))
504 pdata
->vbus_pin_active_low
[i
] = flags
& OF_GPIO_ACTIVE_LOW
;
507 at91_for_each_port(i
)
508 pdata
->overcurrent_pin
[i
] =
509 of_get_named_gpio_flags(np
, "atmel,oc-gpio", i
, &flags
);
511 pdev
->dev
.platform_data
= pdata
;
516 static int ohci_at91_of_init(struct platform_device
*pdev
)
522 /*-------------------------------------------------------------------------*/
524 static int ohci_hcd_at91_drv_probe(struct platform_device
*pdev
)
526 struct at91_usbh_data
*pdata
;
531 ret
= ohci_at91_of_init(pdev
);
535 pdata
= dev_get_platdata(&pdev
->dev
);
538 at91_for_each_port(i
) {
540 * do not configure PIO if not in relation with
541 * real USB port on board
543 if (i
>= pdata
->ports
) {
544 pdata
->vbus_pin
[i
] = -EINVAL
;
545 pdata
->overcurrent_pin
[i
] = -EINVAL
;
549 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
551 gpio
= pdata
->vbus_pin
[i
];
553 ret
= gpio_request(gpio
, "ohci_vbus");
556 "can't request vbus gpio %d\n", gpio
);
559 ret
= gpio_direction_output(gpio
,
560 !pdata
->vbus_pin_active_low
[i
]);
563 "can't put vbus gpio %d as output %d\n",
564 gpio
, !pdata
->vbus_pin_active_low
[i
]);
569 ohci_at91_usb_set_power(pdata
, i
, 1);
572 at91_for_each_port(i
) {
573 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
575 gpio
= pdata
->overcurrent_pin
[i
];
577 ret
= gpio_request(gpio
, "ohci_overcurrent");
580 "can't request overcurrent gpio %d\n",
585 ret
= gpio_direction_input(gpio
);
588 "can't configure overcurrent gpio %d as input\n",
594 ret
= request_irq(gpio_to_irq(gpio
),
595 ohci_hcd_at91_overcurrent_irq
,
596 IRQF_SHARED
, "ohci_overcurrent", pdev
);
600 "can't get gpio IRQ for overcurrent\n");
605 device_init_wakeup(&pdev
->dev
, 1);
606 return usb_hcd_at91_probe(&ohci_at91_hc_driver
, pdev
);
609 static int ohci_hcd_at91_drv_remove(struct platform_device
*pdev
)
611 struct at91_usbh_data
*pdata
= dev_get_platdata(&pdev
->dev
);
615 at91_for_each_port(i
) {
616 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
618 ohci_at91_usb_set_power(pdata
, i
, 0);
619 gpio_free(pdata
->vbus_pin
[i
]);
622 at91_for_each_port(i
) {
623 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
625 free_irq(gpio_to_irq(pdata
->overcurrent_pin
[i
]), pdev
);
626 gpio_free(pdata
->overcurrent_pin
[i
]);
630 device_init_wakeup(&pdev
->dev
, 0);
631 usb_hcd_at91_remove(platform_get_drvdata(pdev
), pdev
);
638 ohci_hcd_at91_drv_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
640 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
641 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
643 if (device_may_wakeup(&pdev
->dev
))
644 enable_irq_wake(hcd
->irq
);
647 * The integrated transceivers seem unable to notice disconnect,
648 * reconnect, or wakeup without the 48 MHz clock active. so for
649 * correctness, always discard connection state (using reset).
651 * REVISIT: some boards will be able to turn VBUS off...
653 if (at91_suspend_entering_slow_clock()) {
654 ohci
->hc_control
= ohci_readl(ohci
, &ohci
->regs
->control
);
655 ohci
->hc_control
&= OHCI_CTRL_RWC
;
656 ohci_writel(ohci
, ohci
->hc_control
, &ohci
->regs
->control
);
657 ohci
->rh_state
= OHCI_RH_HALTED
;
659 /* flush the writes */
660 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
667 static int ohci_hcd_at91_drv_resume(struct platform_device
*pdev
)
669 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
671 if (device_may_wakeup(&pdev
->dev
))
672 disable_irq_wake(hcd
->irq
);
677 ohci_resume(hcd
, false);
681 #define ohci_hcd_at91_drv_suspend NULL
682 #define ohci_hcd_at91_drv_resume NULL
685 static struct platform_driver ohci_hcd_at91_driver
= {
686 .probe
= ohci_hcd_at91_drv_probe
,
687 .remove
= ohci_hcd_at91_drv_remove
,
688 .shutdown
= usb_hcd_platform_shutdown
,
689 .suspend
= ohci_hcd_at91_drv_suspend
,
690 .resume
= ohci_hcd_at91_drv_resume
,
693 .owner
= THIS_MODULE
,
694 .of_match_table
= of_match_ptr(at91_ohci_dt_ids
),
698 static int __init
ohci_at91_init(void)
703 pr_info("%s: " DRIVER_DESC
"\n", hcd_name
);
704 ohci_init_driver(&ohci_at91_hc_driver
, NULL
);
707 * The Atmel HW has some unusual quirks, which require Atmel-specific
708 * workarounds. We override certain hc_driver functions here to
709 * achieve that. We explicitly do not enhance ohci_driver_overrides to
710 * allow this more easily, since this is an unusual case, and we don't
711 * want to encourage others to override these functions by making it
715 orig_ohci_hub_control
= ohci_at91_hc_driver
.hub_control
;
716 orig_ohci_hub_status_data
= ohci_at91_hc_driver
.hub_status_data
;
718 ohci_at91_hc_driver
.hub_status_data
= ohci_at91_hub_status_data
;
719 ohci_at91_hc_driver
.hub_control
= ohci_at91_hub_control
;
721 return platform_driver_register(&ohci_hcd_at91_driver
);
723 module_init(ohci_at91_init
);
725 static void __exit
ohci_at91_cleanup(void)
727 platform_driver_unregister(&ohci_hcd_at91_driver
);
729 module_exit(ohci_at91_cleanup
);
731 MODULE_DESCRIPTION(DRIVER_DESC
);
732 MODULE_LICENSE("GPL");
733 MODULE_ALIAS("platform:at91_ohci");