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>
17 #include <linux/of_platform.h>
18 #include <linux/of_gpio.h>
20 #include <mach/hardware.h>
23 #include <mach/board.h>
26 #ifndef CONFIG_ARCH_AT91
27 #error "CONFIG_ARCH_AT91 must be defined."
30 #define valid_port(index) ((index) >= 0 && (index) < AT91_MAX_USBH_PORTS)
31 #define at91_for_each_port(index) \
32 for ((index) = 0; (index) < AT91_MAX_USBH_PORTS; (index)++)
34 /* interface and function clocks; sometimes also an AHB clock */
35 static struct clk
*iclk
, *fclk
, *hclk
;
38 extern int usb_disabled(void);
40 /*-------------------------------------------------------------------------*/
42 static void at91_start_clock(void)
50 static void at91_stop_clock(void)
58 static void at91_start_hc(struct platform_device
*pdev
)
60 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
61 struct ohci_regs __iomem
*regs
= hcd
->regs
;
63 dev_dbg(&pdev
->dev
, "start\n");
66 * Start the USB clocks.
71 * The USB host controller must remain in reset.
73 writel(0, ®s
->control
);
76 static void at91_stop_hc(struct platform_device
*pdev
)
78 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
79 struct ohci_regs __iomem
*regs
= hcd
->regs
;
81 dev_dbg(&pdev
->dev
, "stop\n");
84 * Put the USB host controller into reset.
86 writel(0, ®s
->control
);
89 * Stop the USB clocks.
95 /*-------------------------------------------------------------------------*/
97 static void __devexit
usb_hcd_at91_remove (struct usb_hcd
*, struct platform_device
*);
99 /* configure so an HC device and id are always provided */
100 /* always called with process context; sleeping is OK */
104 * usb_hcd_at91_probe - initialize AT91-based HCDs
105 * Context: !in_interrupt()
107 * Allocates basic resources for this USB host controller, and
108 * then invokes the start() method for the HCD associated with it
109 * through the hotplug entry's driver_data.
111 static int __devinit
usb_hcd_at91_probe(const struct hc_driver
*driver
,
112 struct platform_device
*pdev
)
115 struct usb_hcd
*hcd
= NULL
;
117 if (pdev
->num_resources
!= 2) {
118 pr_debug("hcd probe: invalid num_resources");
122 if ((pdev
->resource
[0].flags
!= IORESOURCE_MEM
)
123 || (pdev
->resource
[1].flags
!= IORESOURCE_IRQ
)) {
124 pr_debug("hcd probe: invalid resource type\n");
128 hcd
= usb_create_hcd(driver
, &pdev
->dev
, "at91");
131 hcd
->rsrc_start
= pdev
->resource
[0].start
;
132 hcd
->rsrc_len
= resource_size(&pdev
->resource
[0]);
134 if (!request_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
, hcd_name
)) {
135 pr_debug("request_mem_region failed\n");
140 hcd
->regs
= ioremap(hcd
->rsrc_start
, hcd
->rsrc_len
);
142 pr_debug("ioremap failed\n");
147 iclk
= clk_get(&pdev
->dev
, "ohci_clk");
149 dev_err(&pdev
->dev
, "failed to get ohci_clk\n");
150 retval
= PTR_ERR(iclk
);
153 fclk
= clk_get(&pdev
->dev
, "uhpck");
155 dev_err(&pdev
->dev
, "failed to get uhpck\n");
156 retval
= PTR_ERR(fclk
);
159 hclk
= clk_get(&pdev
->dev
, "hclk");
161 dev_err(&pdev
->dev
, "failed to get hclk\n");
162 retval
= PTR_ERR(hclk
);
167 ohci_hcd_init(hcd_to_ohci(hcd
));
169 retval
= usb_add_hcd(hcd
, pdev
->resource
[1].start
, IRQF_SHARED
);
186 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
194 /* may be called with controller, bus, and devices active */
197 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
198 * @dev: USB Host Controller being removed
199 * Context: !in_interrupt()
201 * Reverses the effect of usb_hcd_at91_probe(), first invoking
202 * the HCD's stop() method. It is always called from a thread
203 * context, "rmmod" or something similar.
206 static void __devexit
usb_hcd_at91_remove(struct usb_hcd
*hcd
,
207 struct platform_device
*pdev
)
212 release_mem_region(hcd
->rsrc_start
, hcd
->rsrc_len
);
218 fclk
= iclk
= hclk
= NULL
;
220 dev_set_drvdata(&pdev
->dev
, NULL
);
223 /*-------------------------------------------------------------------------*/
226 ohci_at91_reset (struct usb_hcd
*hcd
)
228 struct at91_usbh_data
*board
= hcd
->self
.controller
->platform_data
;
229 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
232 if ((ret
= ohci_init(ohci
)) < 0)
235 ohci
->num_ports
= board
->ports
;
240 ohci_at91_start (struct usb_hcd
*hcd
)
242 struct ohci_hcd
*ohci
= hcd_to_ohci (hcd
);
245 if ((ret
= ohci_run(ohci
)) < 0) {
246 dev_err(hcd
->self
.controller
, "can't start %s\n",
254 static void ohci_at91_usb_set_power(struct at91_usbh_data
*pdata
, int port
, int enable
)
256 if (!valid_port(port
))
259 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
262 gpio_set_value(pdata
->vbus_pin
[port
],
263 pdata
->vbus_pin_active_low
[port
] ^ enable
);
266 static int ohci_at91_usb_get_power(struct at91_usbh_data
*pdata
, int port
)
268 if (!valid_port(port
))
271 if (!gpio_is_valid(pdata
->vbus_pin
[port
]))
274 return gpio_get_value(pdata
->vbus_pin
[port
]) ^
275 pdata
->vbus_pin_active_low
[port
];
279 * Update the status data from the hub with the over-current indicator change.
281 static int ohci_at91_hub_status_data(struct usb_hcd
*hcd
, char *buf
)
283 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
284 int length
= ohci_hub_status_data(hcd
, buf
);
287 at91_for_each_port(port
) {
288 if (pdata
->overcurrent_changed
[port
]) {
291 buf
[0] |= 1 << (port
+ 1);
299 * Look at the control requests to the root hub and see if we need to override.
301 static int ohci_at91_hub_control(struct usb_hcd
*hcd
, u16 typeReq
, u16 wValue
,
302 u16 wIndex
, char *buf
, u16 wLength
)
304 struct at91_usbh_data
*pdata
= hcd
->self
.controller
->platform_data
;
305 struct usb_hub_descriptor
*desc
;
307 u32
*data
= (u32
*)buf
;
309 dev_dbg(hcd
->self
.controller
,
310 "ohci_at91_hub_control(%p,0x%04x,0x%04x,0x%04x,%p,%04x)\n",
311 hcd
, typeReq
, wValue
, wIndex
, buf
, wLength
);
317 if (wValue
== USB_PORT_FEAT_POWER
) {
318 dev_dbg(hcd
->self
.controller
, "SetPortFeat: POWER\n");
319 if (valid_port(wIndex
)) {
320 ohci_at91_usb_set_power(pdata
, wIndex
, 1);
328 case ClearPortFeature
:
330 case USB_PORT_FEAT_C_OVER_CURRENT
:
331 dev_dbg(hcd
->self
.controller
,
332 "ClearPortFeature: C_OVER_CURRENT\n");
334 if (valid_port(wIndex
)) {
335 pdata
->overcurrent_changed
[wIndex
] = 0;
336 pdata
->overcurrent_status
[wIndex
] = 0;
341 case USB_PORT_FEAT_OVER_CURRENT
:
342 dev_dbg(hcd
->self
.controller
,
343 "ClearPortFeature: OVER_CURRENT\n");
345 if (valid_port(wIndex
))
346 pdata
->overcurrent_status
[wIndex
] = 0;
350 case USB_PORT_FEAT_POWER
:
351 dev_dbg(hcd
->self
.controller
,
352 "ClearPortFeature: POWER\n");
354 if (valid_port(wIndex
)) {
355 ohci_at91_usb_set_power(pdata
, wIndex
, 0);
362 ret
= ohci_hub_control(hcd
, typeReq
, wValue
, wIndex
+ 1, buf
, wLength
);
367 case GetHubDescriptor
:
369 /* update the hub's descriptor */
371 desc
= (struct usb_hub_descriptor
*)buf
;
373 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics 0x%04x\n",
374 desc
->wHubCharacteristics
);
376 /* remove the old configurations for power-switching, and
377 * over-current protection, and insert our new configuration
380 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_LPSM
);
381 desc
->wHubCharacteristics
|= cpu_to_le16(0x0001);
383 if (pdata
->overcurrent_supported
) {
384 desc
->wHubCharacteristics
&= ~cpu_to_le16(HUB_CHAR_OCPM
);
385 desc
->wHubCharacteristics
|= cpu_to_le16(0x0008|0x0001);
388 dev_dbg(hcd
->self
.controller
, "wHubCharacteristics after 0x%04x\n",
389 desc
->wHubCharacteristics
);
394 /* check port status */
396 dev_dbg(hcd
->self
.controller
, "GetPortStatus(%d)\n", wIndex
);
398 if (valid_port(wIndex
)) {
399 if (!ohci_at91_usb_get_power(pdata
, wIndex
))
400 *data
&= ~cpu_to_le32(RH_PS_PPS
);
402 if (pdata
->overcurrent_changed
[wIndex
])
403 *data
|= cpu_to_le32(RH_PS_OCIC
);
405 if (pdata
->overcurrent_status
[wIndex
])
406 *data
|= cpu_to_le32(RH_PS_POCI
);
414 /*-------------------------------------------------------------------------*/
416 static const struct hc_driver ohci_at91_hc_driver
= {
417 .description
= hcd_name
,
418 .product_desc
= "AT91 OHCI",
419 .hcd_priv_size
= sizeof(struct ohci_hcd
),
422 * generic hardware linkage
425 .flags
= HCD_USB11
| HCD_MEMORY
,
428 * basic lifecycle operations
430 .reset
= ohci_at91_reset
,
431 .start
= ohci_at91_start
,
433 .shutdown
= ohci_shutdown
,
436 * managing i/o requests and associated device resources
438 .urb_enqueue
= ohci_urb_enqueue
,
439 .urb_dequeue
= ohci_urb_dequeue
,
440 .endpoint_disable
= ohci_endpoint_disable
,
445 .get_frame_number
= ohci_get_frame
,
450 .hub_status_data
= ohci_at91_hub_status_data
,
451 .hub_control
= ohci_at91_hub_control
,
453 .bus_suspend
= ohci_bus_suspend
,
454 .bus_resume
= ohci_bus_resume
,
456 .start_port_reset
= ohci_start_port_reset
,
459 /*-------------------------------------------------------------------------*/
461 static irqreturn_t
ohci_hcd_at91_overcurrent_irq(int irq
, void *data
)
463 struct platform_device
*pdev
= data
;
464 struct at91_usbh_data
*pdata
= pdev
->dev
.platform_data
;
467 /* From the GPIO notifying the over-current situation, find
468 * out the corresponding port */
469 at91_for_each_port(port
) {
470 if (gpio_to_irq(pdata
->overcurrent_pin
[port
]) == irq
) {
471 gpio
= pdata
->overcurrent_pin
[port
];
476 if (port
== AT91_MAX_USBH_PORTS
) {
477 dev_err(& pdev
->dev
, "overcurrent interrupt from unknown GPIO\n");
481 val
= gpio_get_value(gpio
);
483 /* When notified of an over-current situation, disable power
484 on the corresponding port, and mark this port in
487 ohci_at91_usb_set_power(pdata
, port
, 0);
488 pdata
->overcurrent_status
[port
] = 1;
489 pdata
->overcurrent_changed
[port
] = 1;
492 dev_dbg(& pdev
->dev
, "overcurrent situation %s\n",
493 val
? "exited" : "notified");
499 static const struct of_device_id at91_ohci_dt_ids
[] = {
500 { .compatible
= "atmel,at91rm9200-ohci" },
504 MODULE_DEVICE_TABLE(of
, at91_ohci_dt_ids
);
506 static u64 at91_ohci_dma_mask
= DMA_BIT_MASK(32);
508 static int __devinit
ohci_at91_of_init(struct platform_device
*pdev
)
510 struct device_node
*np
= pdev
->dev
.of_node
;
512 enum of_gpio_flags flags
;
513 struct at91_usbh_data
*pdata
;
519 /* Right now device-tree probed devices don't get dma_mask set.
520 * Since shared usb code relies on it, set it here for now.
521 * Once we have dma capability bindings this can go away.
523 if (!pdev
->dev
.dma_mask
)
524 pdev
->dev
.dma_mask
= &at91_ohci_dma_mask
;
526 pdata
= devm_kzalloc(&pdev
->dev
, sizeof(*pdata
), GFP_KERNEL
);
530 if (!of_property_read_u32(np
, "num-ports", &ports
))
531 pdata
->ports
= ports
;
533 at91_for_each_port(i
) {
534 gpio
= of_get_named_gpio_flags(np
, "atmel,vbus-gpio", i
, &flags
);
535 pdata
->vbus_pin
[i
] = gpio
;
536 if (!gpio_is_valid(gpio
))
538 pdata
->vbus_pin_active_low
[i
] = flags
& OF_GPIO_ACTIVE_LOW
;
541 at91_for_each_port(i
)
542 pdata
->overcurrent_pin
[i
] =
543 of_get_named_gpio_flags(np
, "atmel,oc-gpio", i
, &flags
);
545 pdev
->dev
.platform_data
= pdata
;
550 static int __devinit
ohci_at91_of_init(struct platform_device
*pdev
)
556 /*-------------------------------------------------------------------------*/
558 static int __devinit
ohci_hcd_at91_drv_probe(struct platform_device
*pdev
)
560 struct at91_usbh_data
*pdata
;
565 ret
= ohci_at91_of_init(pdev
);
569 pdata
= pdev
->dev
.platform_data
;
572 at91_for_each_port(i
) {
573 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
575 gpio
= pdata
->vbus_pin
[i
];
577 ret
= gpio_request(gpio
, "ohci_vbus");
580 "can't request vbus gpio %d\n", gpio
);
583 ret
= gpio_direction_output(gpio
,
584 !pdata
->vbus_pin_active_low
[i
]);
587 "can't put vbus gpio %d as output %d\n",
588 gpio
, !pdata
->vbus_pin_active_low
[i
]);
593 ohci_at91_usb_set_power(pdata
, i
, 1);
596 at91_for_each_port(i
) {
597 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
599 gpio
= pdata
->overcurrent_pin
[i
];
601 ret
= gpio_request(gpio
, "ohci_overcurrent");
604 "can't request overcurrent gpio %d\n",
609 ret
= gpio_direction_input(gpio
);
612 "can't configure overcurrent gpio %d as input\n",
618 ret
= request_irq(gpio_to_irq(gpio
),
619 ohci_hcd_at91_overcurrent_irq
,
620 IRQF_SHARED
, "ohci_overcurrent", pdev
);
624 "can't get gpio IRQ for overcurrent\n");
629 device_init_wakeup(&pdev
->dev
, 1);
630 return usb_hcd_at91_probe(&ohci_at91_hc_driver
, pdev
);
633 static int __devexit
ohci_hcd_at91_drv_remove(struct platform_device
*pdev
)
635 struct at91_usbh_data
*pdata
= pdev
->dev
.platform_data
;
639 at91_for_each_port(i
) {
640 if (!gpio_is_valid(pdata
->vbus_pin
[i
]))
642 ohci_at91_usb_set_power(pdata
, i
, 0);
643 gpio_free(pdata
->vbus_pin
[i
]);
646 at91_for_each_port(i
) {
647 if (!gpio_is_valid(pdata
->overcurrent_pin
[i
]))
649 free_irq(gpio_to_irq(pdata
->overcurrent_pin
[i
]), pdev
);
650 gpio_free(pdata
->overcurrent_pin
[i
]);
654 device_init_wakeup(&pdev
->dev
, 0);
655 usb_hcd_at91_remove(platform_get_drvdata(pdev
), pdev
);
662 ohci_hcd_at91_drv_suspend(struct platform_device
*pdev
, pm_message_t mesg
)
664 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
665 struct ohci_hcd
*ohci
= hcd_to_ohci(hcd
);
667 if (device_may_wakeup(&pdev
->dev
))
668 enable_irq_wake(hcd
->irq
);
671 * The integrated transceivers seem unable to notice disconnect,
672 * reconnect, or wakeup without the 48 MHz clock active. so for
673 * correctness, always discard connection state (using reset).
675 * REVISIT: some boards will be able to turn VBUS off...
677 if (at91_suspend_entering_slow_clock()) {
678 ohci_usb_reset (ohci
);
679 /* flush the writes */
680 (void) ohci_readl (ohci
, &ohci
->regs
->control
);
687 static int ohci_hcd_at91_drv_resume(struct platform_device
*pdev
)
689 struct usb_hcd
*hcd
= platform_get_drvdata(pdev
);
691 if (device_may_wakeup(&pdev
->dev
))
692 disable_irq_wake(hcd
->irq
);
697 ohci_finish_controller_resume(hcd
);
701 #define ohci_hcd_at91_drv_suspend NULL
702 #define ohci_hcd_at91_drv_resume NULL
705 MODULE_ALIAS("platform:at91_ohci");
707 static struct platform_driver ohci_hcd_at91_driver
= {
708 .probe
= ohci_hcd_at91_drv_probe
,
709 .remove
= __devexit_p(ohci_hcd_at91_drv_remove
),
710 .shutdown
= usb_hcd_platform_shutdown
,
711 .suspend
= ohci_hcd_at91_drv_suspend
,
712 .resume
= ohci_hcd_at91_drv_resume
,
715 .owner
= THIS_MODULE
,
716 .of_match_table
= of_match_ptr(at91_ohci_dt_ids
),