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/platform_device.h>
17
18 #include <asm/mach-types.h>
19 #include <asm/hardware.h>
20 #include <asm/gpio.h>
21
22 #include <asm/arch/board.h>
23 #include <asm/arch/cpu.h>
24
25 #ifndef CONFIG_ARCH_AT91
26 #error "CONFIG_ARCH_AT91 must be defined."
27 #endif
28
29 /* interface and function clocks; sometimes also an AHB clock */
30 static struct clk *iclk, *fclk, *hclk;
31 static int clocked;
32
33 extern int usb_disabled(void);
34
35 /*-------------------------------------------------------------------------*/
36
37 static void at91_start_clock(void)
38 {
39 if (cpu_is_at91sam9261())
40 clk_enable(hclk);
41 clk_enable(iclk);
42 clk_enable(fclk);
43 clocked = 1;
44 }
45
46 static void at91_stop_clock(void)
47 {
48 clk_disable(fclk);
49 clk_disable(iclk);
50 if (cpu_is_at91sam9261())
51 clk_disable(hclk);
52 clocked = 0;
53 }
54
55 static void at91_start_hc(struct platform_device *pdev)
56 {
57 struct usb_hcd *hcd = platform_get_drvdata(pdev);
58 struct ohci_regs __iomem *regs = hcd->regs;
59
60 dev_dbg(&pdev->dev, "start\n");
61
62 /*
63 * Start the USB clocks.
64 */
65 at91_start_clock();
66
67 /*
68 * The USB host controller must remain in reset.
69 */
70 writel(0, ®s->control);
71 }
72
73 static void at91_stop_hc(struct platform_device *pdev)
74 {
75 struct usb_hcd *hcd = platform_get_drvdata(pdev);
76 struct ohci_regs __iomem *regs = hcd->regs;
77
78 dev_dbg(&pdev->dev, "stop\n");
79
80 /*
81 * Put the USB host controller into reset.
82 */
83 writel(0, ®s->control);
84
85 /*
86 * Stop the USB clocks.
87 */
88 at91_stop_clock();
89 }
90
91
92 /*-------------------------------------------------------------------------*/
93
94 static int usb_hcd_at91_remove (struct usb_hcd *, struct platform_device *);
95
96 /* configure so an HC device and id are always provided */
97 /* always called with process context; sleeping is OK */
98
99
100 /**
101 * usb_hcd_at91_probe - initialize AT91-based HCDs
102 * Context: !in_interrupt()
103 *
104 * Allocates basic resources for this USB host controller, and
105 * then invokes the start() method for the HCD associated with it
106 * through the hotplug entry's driver_data.
107 */
108 static int usb_hcd_at91_probe(const struct hc_driver *driver,
109 struct platform_device *pdev)
110 {
111 int retval;
112 struct usb_hcd *hcd = NULL;
113
114 if (pdev->num_resources != 2) {
115 pr_debug("hcd probe: invalid num_resources");
116 return -ENODEV;
117 }
118
119 if ((pdev->resource[0].flags != IORESOURCE_MEM)
120 || (pdev->resource[1].flags != IORESOURCE_IRQ)) {
121 pr_debug("hcd probe: invalid resource type\n");
122 return -ENODEV;
123 }
124
125 hcd = usb_create_hcd(driver, &pdev->dev, "at91");
126 if (!hcd)
127 return -ENOMEM;
128 hcd->rsrc_start = pdev->resource[0].start;
129 hcd->rsrc_len = pdev->resource[0].end - pdev->resource[0].start + 1;
130
131 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, hcd_name)) {
132 pr_debug("request_mem_region failed\n");
133 retval = -EBUSY;
134 goto err1;
135 }
136
137 hcd->regs = ioremap(hcd->rsrc_start, hcd->rsrc_len);
138 if (!hcd->regs) {
139 pr_debug("ioremap failed\n");
140 retval = -EIO;
141 goto err2;
142 }
143
144 iclk = clk_get(&pdev->dev, "ohci_clk");
145 fclk = clk_get(&pdev->dev, "uhpck");
146 if (cpu_is_at91sam9261())
147 hclk = clk_get(&pdev->dev, "hck0");
148
149 at91_start_hc(pdev);
150 ohci_hcd_init(hcd_to_ohci(hcd));
151
152 retval = usb_add_hcd(hcd, pdev->resource[1].start, IRQF_DISABLED);
153 if (retval == 0)
154 return retval;
155
156 /* Error handling */
157 at91_stop_hc(pdev);
158
159 if (cpu_is_at91sam9261())
160 clk_put(hclk);
161 clk_put(fclk);
162 clk_put(iclk);
163
164 iounmap(hcd->regs);
165
166 err2:
167 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
168
169 err1:
170 usb_put_hcd(hcd);
171 return retval;
172 }
173
174
175 /* may be called with controller, bus, and devices active */
176
177 /**
178 * usb_hcd_at91_remove - shutdown processing for AT91-based HCDs
179 * @dev: USB Host Controller being removed
180 * Context: !in_interrupt()
181 *
182 * Reverses the effect of usb_hcd_at91_probe(), first invoking
183 * the HCD's stop() method. It is always called from a thread
184 * context, "rmmod" or something similar.
185 *
186 */
187 static int usb_hcd_at91_remove(struct usb_hcd *hcd,
188 struct platform_device *pdev)
189 {
190 usb_remove_hcd(hcd);
191 at91_stop_hc(pdev);
192 iounmap(hcd->regs);
193 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
194
195 if (cpu_is_at91sam9261())
196 clk_put(hclk);
197 clk_put(fclk);
198 clk_put(iclk);
199 fclk = iclk = hclk = NULL;
200
201 dev_set_drvdata(&pdev->dev, NULL);
202 return 0;
203 }
204
205 /*-------------------------------------------------------------------------*/
206
207 static int __devinit
208 ohci_at91_start (struct usb_hcd *hcd)
209 {
210 struct at91_usbh_data *board = hcd->self.controller->platform_data;
211 struct ohci_hcd *ohci = hcd_to_ohci (hcd);
212 int ret;
213
214 if ((ret = ohci_init(ohci)) < 0)
215 return ret;
216
217 ohci->num_ports = board->ports;
218
219 if ((ret = ohci_run(ohci)) < 0) {
220 err("can't start %s", hcd->self.bus_name);
221 ohci_stop(hcd);
222 return ret;
223 }
224 return 0;
225 }
226
227 /*-------------------------------------------------------------------------*/
228
229 static const struct hc_driver ohci_at91_hc_driver = {
230 .description = hcd_name,
231 .product_desc = "AT91 OHCI",
232 .hcd_priv_size = sizeof(struct ohci_hcd),
233
234 /*
235 * generic hardware linkage
236 */
237 .irq = ohci_irq,
238 .flags = HCD_USB11 | HCD_MEMORY,
239
240 /*
241 * basic lifecycle operations
242 */
243 .start = ohci_at91_start,
244 .stop = ohci_stop,
245 .shutdown = ohci_shutdown,
246
247 /*
248 * managing i/o requests and associated device resources
249 */
250 .urb_enqueue = ohci_urb_enqueue,
251 .urb_dequeue = ohci_urb_dequeue,
252 .endpoint_disable = ohci_endpoint_disable,
253
254 /*
255 * scheduling support
256 */
257 .get_frame_number = ohci_get_frame,
258
259 /*
260 * root hub support
261 */
262 .hub_status_data = ohci_hub_status_data,
263 .hub_control = ohci_hub_control,
264 .hub_irq_enable = ohci_rhsc_enable,
265 #ifdef CONFIG_PM
266 .bus_suspend = ohci_bus_suspend,
267 .bus_resume = ohci_bus_resume,
268 #endif
269 .start_port_reset = ohci_start_port_reset,
270 };
271
272 /*-------------------------------------------------------------------------*/
273
274 static int ohci_hcd_at91_drv_probe(struct platform_device *pdev)
275 {
276 struct at91_usbh_data *pdata = pdev->dev.platform_data;
277 int i;
278
279 if (pdata) {
280 /* REVISIT make the driver support per-port power switching,
281 * and also overcurrent detection. Here we assume the ports
282 * are always powered while this driver is active, and use
283 * active-low power switches.
284 */
285 for (i = 0; i < pdata->ports; i++) {
286 if (pdata->vbus_pin[i] <= 0)
287 continue;
288 gpio_request(pdata->vbus_pin[i], "ohci_vbus");
289 gpio_direction_output(pdata->vbus_pin[i], 0);
290 }
291 }
292
293 device_init_wakeup(&pdev->dev, 1);
294 return usb_hcd_at91_probe(&ohci_at91_hc_driver, pdev);
295 }
296
297 static int ohci_hcd_at91_drv_remove(struct platform_device *pdev)
298 {
299 struct at91_usbh_data *pdata = pdev->dev.platform_data;
300 int i;
301
302 if (pdata) {
303 for (i = 0; i < pdata->ports; i++) {
304 if (pdata->vbus_pin[i] <= 0)
305 continue;
306 gpio_direction_output(pdata->vbus_pin[i], 1);
307 gpio_free(pdata->vbus_pin[i]);
308 }
309 }
310
311 device_init_wakeup(&pdev->dev, 0);
312 return usb_hcd_at91_remove(platform_get_drvdata(pdev), pdev);
313 }
314
315 #ifdef CONFIG_PM
316
317 static int
318 ohci_hcd_at91_drv_suspend(struct platform_device *pdev, pm_message_t mesg)
319 {
320 struct usb_hcd *hcd = platform_get_drvdata(pdev);
321 struct ohci_hcd *ohci = hcd_to_ohci(hcd);
322
323 if (device_may_wakeup(&pdev->dev))
324 enable_irq_wake(hcd->irq);
325
326 /*
327 * The integrated transceivers seem unable to notice disconnect,
328 * reconnect, or wakeup without the 48 MHz clock active. so for
329 * correctness, always discard connection state (using reset).
330 *
331 * REVISIT: some boards will be able to turn VBUS off...
332 */
333 if (at91_suspend_entering_slow_clock()) {
334 ohci_usb_reset (ohci);
335 at91_stop_clock();
336 }
337
338 return 0;
339 }
340
341 static int ohci_hcd_at91_drv_resume(struct platform_device *pdev)
342 {
343 struct usb_hcd *hcd = platform_get_drvdata(pdev);
344
345 if (device_may_wakeup(&pdev->dev))
346 disable_irq_wake(hcd->irq);
347
348 if (!clocked)
349 at91_start_clock();
350
351 return 0;
352 }
353 #else
354 #define ohci_hcd_at91_drv_suspend NULL
355 #define ohci_hcd_at91_drv_resume NULL
356 #endif
357
358 MODULE_ALIAS("platform:at91_ohci");
359
360 static struct platform_driver ohci_hcd_at91_driver = {
361 .probe = ohci_hcd_at91_drv_probe,
362 .remove = ohci_hcd_at91_drv_remove,
363 .shutdown = usb_hcd_platform_shutdown,
364 .suspend = ohci_hcd_at91_drv_suspend,
365 .resume = ohci_hcd_at91_drv_resume,
366 .driver = {
367 .name = "at91_ohci",
368 .owner = THIS_MODULE,
369 },
370 };
371
|
This page was automatically generated by the
LXR engine.
|