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/platform_device.h>
18 #include <mach/hardware.h>
21 #include <mach/board.h>
24 #ifndef CONFIG_ARCH_AT91
25 #error "CONFIG_ARCH_AT91 must be defined."
28 /* interface and function clocks; sometimes also an AHB clock */
29 static struct clk
*iclk
, *fclk
, *hclk
;
32 extern int usb_disabled(void);
34 /*-------------------------------------------------------------------------*/
36 static void at91_start_clock(void)
44 static void at91_stop_clock(void)
52 static void at91_start_hc(struct platform_device
*pdev
)
54 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
55 struct ohci_regs __iomem
*regs
= hcd
->regs
;
57 dev_dbg(&pdev
->dev
, "start\n");
60 * Start the USB clocks.
65 * The USB host controller must remain in reset.
67 writel(0, ®s
->control
);
70 static void at91_stop_hc(struct platform_device
*pdev
)
72 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
73 struct ohci_regs __iomem
*regs
= hcd
->regs
;
75 dev_dbg(&pdev
->dev
, "stop\n");
78 * Put the USB host controller into reset.
80 writel(0, ®s
->control
);
83 * Stop the USB clocks.
89 /*-------------------------------------------------------------------------*/
91 static void usb_hcd_at91_remove (struct usb_hcd
*, struct platform_device
*);
93 /* configure so an HC device and id are always provided */
94 /* always called with process context; sleeping is OK */
98 * usb_hcd_at91_probe - initialize AT91-based HCDs
99 * Context: !in_interrupt()
101 * Allocates basic resources for this USB host controller, and
102 * then invokes the start() method for the HCD associated with it
103 * through the hotplug entry's driver_data.
105 static int usb_hcd_at91_probe(const struct hc_driver
*driver
,
106 struct platform_device
*pdev
)
109 struct usb_hcd
*hcd
= NULL
;
111 if (pdev
->num_resources
!= 2) {
112 pr_debug("hcd probe: invalid num_resources");
116 if ((pdev
->resource
[0].flags
!= IORESOURCE_MEM
)
117 || (pdev
->resource
[1].flags
!= IORESOURCE_IRQ
)) {
118 pr_debug("hcd probe: invalid resource type\n");
122 hcd
= usb_create_hcd(driver
, &pdev
->dev
, "at91");
125 hcd
->rsrc_start
= pdev
->resource
[0].start
;
126 hcd
->rsrc_len
= pdev
->resource
[0].end
- pdev
->resource
[0].start
+ 1;
128 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
, hcd_name
)) {
129 pr_debug("request_mem_region failed\n");
134 hcd
->regs
= ioremap(hcd
->rsrc_start
, hcd
->rsrc_len
);
136 pr_debug("ioremap failed\n");
141 iclk
= clk_get(&pdev
->dev
, "ohci_clk");
143 dev_err(&pdev
->dev
, "failed to get ohci_clk\n");
144 retval
= PTR_ERR(iclk
);
147 fclk
= clk_get(&pdev
->dev
, "uhpck");
149 dev_err(&pdev
->dev
, "failed to get uhpck\n");
150 retval
= PTR_ERR(fclk
);
153 hclk
= clk_get(&pdev
->dev
, "hclk");
155 dev_err(&pdev
->dev
, "failed to get hclk\n");
156 retval
= PTR_ERR(hclk
);
161 ohci_hcd_init(hcd_to_ohci(hcd
));
163 retval
= usb_add_hcd(hcd
, pdev
->resource
[1].start
, IRQF_SHARED
);
180 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
188 /* may be called with controller, bus, and devices active */
191 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
192 * @dev: USB Host Controller being removed
193 * Context: !in_interrupt()
195 * Reverses the effect of usb_hcd_at91_probe(), first invoking
196 * the HCD's stop() method. It is always called from a thread
197 * context, "rmmod" or something similar.
200 static void usb_hcd_at91_remove(struct usb_hcd
*hcd
,
201 struct platform_device
*pdev
)
206 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
212 fclk
= iclk
= hclk
= NULL
;
214 dev_set_drvdata(&pdev
->dev
, NULL
);
217 /*-------------------------------------------------------------------------*/
220 ohci_at91_start (struct usb_hcd
*hcd
)
222 struct at91_usbh_data
*board
= hcd
->self
.controller
->platform_data
;
223 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
226 if ((ret
= ohci_init(ohci
)) < 0)
229 ohci
->num_ports
= board
->ports
;
231 if ((ret
= ohci_run(ohci
)) < 0) {
232 err("can't start %s", hcd
->self
.bus_name
);
239 static void ohci_at91_usb_set_power(struct at91_usbh_data
*pdata
, int port
, int enable
)
241 if (port
< 0 || port
>= 2)
244 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
247 gpio_set_value(pdata
->vbus_pin
[port
],
248 !pdata
->vbus_pin_active_low
[port
] ^ enable
);
251 static int ohci_at91_usb_get_power(struct at91_usbh_data
*pdata
, int port
)
253 if (port
< 0 || port
>= 2)
256 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
259 return gpio_get_value(pdata
->vbus_pin
[port
]) ^
260 !pdata
->vbus_pin_active_low
[port
];
264 * Update the status data from the hub with the over-current indicator change.
266 static int ohci_at91_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
268 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
269 int length
= ohci_hub_status_data(hcd
, buf
);
272 for (port
= 0; port
< ARRAY_SIZE(pdata
->overcurrent_pin
); port
++) {
273 if (pdata
->overcurrent_changed
[port
]) {
276 buf
[0] |= 1 << (port
+ 1);
284 * Look at the control requests to the root hub and see if we need to override.
286 static int ohci_at91_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
287 u16 wIndex
, char *buf
, u16 wLength
)
289 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
290 struct usb_hub_descriptor
*desc
;
292 u32
*data
= (u32
*)buf
;
294 dev_dbg(hcd
->self
.controller
,
295 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
296 hcd
, typeReq
, wValue
, wIndex
, buf
, wLength
);
300 if (wValue
== USB_PORT_FEAT_POWER
) {
301 dev_dbg(hcd
->self
.controller
, "SetPortFeat: POWER\n");
302 ohci_at91_usb_set_power(pdata
, wIndex
- 1, 1);
307 case ClearPortFeature
:
309 case USB_PORT_FEAT_C_OVER_CURRENT
:
310 dev_dbg(hcd
->self
.controller
,
311 "ClearPortFeature: C_OVER_CURRENT\n");
313 if (wIndex
== 1 || wIndex
== 2) {
314 pdata
->overcurrent_changed
[wIndex
-1] = 0;
315 pdata
->overcurrent_status
[wIndex
-1] = 0;
320 case USB_PORT_FEAT_OVER_CURRENT
:
321 dev_dbg(hcd
->self
.controller
,
322 "ClearPortFeature: OVER_CURRENT\n");
324 if (wIndex
== 1 || wIndex
== 2) {
325 pdata
->overcurrent_status
[wIndex
-1] = 0;
330 case USB_PORT_FEAT_POWER
:
331 dev_dbg(hcd
->self
.controller
,
332 "ClearPortFeature: POWER\n");
334 if (wIndex
== 1 || wIndex
== 2) {
335 ohci_at91_usb_set_power(pdata
, wIndex
- 1, 0);
342 ret
= ohci_hub_control(hcd
, typeReq
, wValue
, wIndex
, buf
, wLength
);
347 case GetHubDescriptor
:
349 /* update the hub's descriptor */
351 desc
= (struct usb_hub_descriptor
*)buf
;
353 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics 0x%04x\n",
354 desc
->wHubCharacteristics
);
356 /* remove the old configurations for power-switching, and
357 * over-current protection, and insert our new configuration
360 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_LPSM
);
361 desc
->wHubCharacteristics
|= cpu_to_le16(0x0001);
363 if (pdata
->overcurrent_supported
) {
364 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_OCPM
);
365 desc
->wHubCharacteristics
|= cpu_to_le16(0x0008|0x0001);
368 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics after 0x%04x\n",
369 desc
->wHubCharacteristics
);
374 /* check port status */
376 dev_dbg(hcd
->self
.controller
, "GetPortStatus(%d)\n", wIndex
);
378 if (wIndex
== 1 || wIndex
== 2) {
379 if (! ohci_at91_usb_get_power(pdata
, wIndex
-1)) {
380 *data
&= ~cpu_to_le32(RH_PS_PPS
);
383 if (pdata
->overcurrent_changed
[wIndex
-1]) {
384 *data
|= cpu_to_le32(RH_PS_OCIC
);
387 if (pdata
->overcurrent_status
[wIndex
-1]) {
388 *data
|= cpu_to_le32(RH_PS_POCI
);
397 /*-------------------------------------------------------------------------*/
399 static const struct hc_driver ohci_at91_hc_driver
= {
400 .description
= hcd_name
,
401 .product_desc
= "AT91 OHCI",
402 .hcd_priv_size
= sizeof(struct ohci_hcd
),
405 * generic hardware linkage
408 .flags
= HCD_USB11
| HCD_MEMORY
,
411 * basic lifecycle operations
413 .start
= ohci_at91_start
,
415 .shutdown
= ohci_shutdown
,
418 * managing i/o requests and associated device resources
420 .urb_enqueue
= ohci_urb_enqueue
,
421 .urb_dequeue
= ohci_urb_dequeue
,
422 .endpoint_disable
= ohci_endpoint_disable
,
427 .get_frame_number
= ohci_get_frame
,
432 .hub_status_data
= ohci_at91_hub_status_data
,
433 .hub_control
= ohci_at91_hub_control
,
435 .bus_suspend
= ohci_bus_suspend
,
436 .bus_resume
= ohci_bus_resume
,
438 .start_port_reset
= ohci_start_port_reset
,
441 /*-------------------------------------------------------------------------*/
443 static irqreturn_t
ohci_hcd_at91_overcurrent_irq(int irq
, void *data
)
445 struct platform_device
*pdev
= data
;
446 struct at91_usbh_data
*pdata
= pdev
->dev
.platform_data
;
449 /* From the GPIO notifying the over-current situation, find
450 * out the corresponding port */
451 gpio
= irq_to_gpio(irq
);
452 for (port
= 0; port
< ARRAY_SIZE(pdata
->overcurrent_pin
); port
++) {
453 if (pdata
->overcurrent_pin
[port
] == gpio
)
457 if (port
== ARRAY_SIZE(pdata
->overcurrent_pin
)) {
458 dev_err(& pdev
->dev
, "overcurrent interrupt from unknown GPIO\n");
462 val
= gpio_get_value(gpio
);
464 /* When notified of an over-current situation, disable power
465 on the corresponding port, and mark this port in
468 ohci_at91_usb_set_power(pdata
, port
, 0);
469 pdata
->overcurrent_status
[port
] = 1;
470 pdata
->overcurrent_changed
[port
] = 1;
473 dev_dbg(& pdev
->dev
, "overcurrent situation %s\n",
474 val
? "exited" : "notified");
479 /*-------------------------------------------------------------------------*/
481 static int ohci_hcd_at91_drv_probe(struct platform_device
*pdev
)
483 struct at91_usbh_data
*pdata
= pdev
->dev
.platform_data
;
487 for (i
= 0; i
< ARRAY_SIZE(pdata
->vbus_pin
); i
++) {
488 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
490 gpio_request(pdata
->vbus_pin
[i
], "ohci_vbus");
491 ohci_at91_usb_set_power(pdata
, i
, 1);
494 for (i
= 0; i
< ARRAY_SIZE(pdata
->overcurrent_pin
); i
++) {
497 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
499 gpio_request(pdata
->overcurrent_pin
[i
], "ohci_overcurrent");
501 ret
= request_irq(gpio_to_irq(pdata
->overcurrent_pin
[i
]),
502 ohci_hcd_at91_overcurrent_irq
,
503 IRQF_SHARED
, "ohci_overcurrent", pdev
);
505 gpio_free(pdata
->overcurrent_pin
[i
]);
506 dev_warn(& pdev
->dev
, "cannot get GPIO IRQ for overcurrent\n");
511 device_init_wakeup(&pdev
->dev
, 1);
512 return usb_hcd_at91_probe(&ohci_at91_hc_driver
, pdev
);
515 static int ohci_hcd_at91_drv_remove(struct platform_device
*pdev
)
517 struct at91_usbh_data
*pdata
= pdev
->dev
.platform_data
;
521 for (i
= 0; i
< ARRAY_SIZE(pdata
->vbus_pin
); i
++) {
522 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
524 ohci_at91_usb_set_power(pdata
, i
, 0);
525 gpio_free(pdata
->vbus_pin
[i
]);
528 for (i
= 0; i
< ARRAY_SIZE(pdata
->overcurrent_pin
); i
++) {
529 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
531 free_irq(gpio_to_irq(pdata
->overcurrent_pin
[i
]), pdev
);
532 gpio_free(pdata
->overcurrent_pin
[i
]);
536 device_init_wakeup(&pdev
->dev
, 0);
537 usb_hcd_at91_remove(platform_get_drvdata(pdev
), pdev
);
544 ohci_hcd_at91_drv_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
546 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
547 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
549 if (device_may_wakeup(&pdev
->dev
))
550 enable_irq_wake(hcd
->irq
);
553 * The integrated transceivers seem unable to notice disconnect,
554 * reconnect, or wakeup without the 48 MHz clock active. so for
555 * correctness, always discard connection state (using reset).
557 * REVISIT: some boards will be able to turn VBUS off...
559 if (at91_suspend_entering_slow_clock()) {
560 ohci_usb_reset (ohci
);
561 /* flush the writes */
562 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
569 static int ohci_hcd_at91_drv_resume(struct platform_device
*pdev
)
571 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
573 if (device_may_wakeup(&pdev
->dev
))
574 disable_irq_wake(hcd
->irq
);
579 ohci_finish_controller_resume(hcd
);
583 #define ohci_hcd_at91_drv_suspend NULL
584 #define ohci_hcd_at91_drv_resume NULL
587 MODULE_ALIAS("platform:at91_ohci");
589 static struct platform_driver ohci_hcd_at91_driver
= {
590 .probe
= ohci_hcd_at91_drv_probe
,
591 .remove
= ohci_hcd_at91_drv_remove
,
592 .shutdown
= usb_hcd_platform_shutdown
,
593 .suspend
= ohci_hcd_at91_drv_suspend
,
594 .resume
= ohci_hcd_at91_drv_resume
,
597 .owner
= THIS_MODULE
,