tjh.dev
Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
1/*
2 * PMC MSP EHCI (Host Controller Driver) for USB.
3 *
4 * (C) Copyright 2006-2010 PMC-Sierra Inc
5 *
6 * This file is subject to the terms and conditions of the GNU General Public
7 * License. See the file "COPYING" in the main directory of this archive
8 * for more details.
9 *
10 */
11
12/* includes */
13#include <linux/platform_device.h>
14#include <linux/gpio.h>
15#include <linux/usb.h>
16#include <msp_usb.h>
17
18/* stream disable*/
19#define USB_CTRL_MODE_STREAM_DISABLE 0x10
20
21/* threshold */
22#define USB_CTRL_FIFO_THRESH 0x00300000
23
24/* register offset for usb_mode */
25#define USB_EHCI_REG_USB_MODE 0x68
26
27/* register offset for usb fifo */
28#define USB_EHCI_REG_USB_FIFO 0x24
29
30/* register offset for usb status */
31#define USB_EHCI_REG_USB_STATUS 0x44
32
33/* serial/parallel transceiver */
34#define USB_EHCI_REG_BIT_STAT_STS (1<<29)
35
36/* TWI USB0 host device pin */
37#define MSP_PIN_USB0_HOST_DEV 49
38
39/* TWI USB1 host device pin */
40#define MSP_PIN_USB1_HOST_DEV 50
41
42
43static void usb_hcd_tdi_set_mode(struct ehci_hcd *ehci)
44{
45 u8 *base;
46 u8 *statreg;
47 u8 *fiforeg;
48 u32 val;
49 struct ehci_regs *reg_base = ehci->regs;
50
51 /* get register base */
52 base = (u8 *)reg_base + USB_EHCI_REG_USB_MODE;
53 statreg = (u8 *)reg_base + USB_EHCI_REG_USB_STATUS;
54 fiforeg = (u8 *)reg_base + USB_EHCI_REG_USB_FIFO;
55
56 /* Disable controller mode stream */
57 val = ehci_readl(ehci, (u32 *)base);
58 ehci_writel(ehci, (val | USB_CTRL_MODE_STREAM_DISABLE),
59 (u32 *)base);
60
61 /* clear STS to select parallel transceiver interface */
62 val = ehci_readl(ehci, (u32 *)statreg);
63 val = val & ~USB_EHCI_REG_BIT_STAT_STS;
64 ehci_writel(ehci, val, (u32 *)statreg);
65
66 /* write to set the proper fifo threshold */
67 ehci_writel(ehci, USB_CTRL_FIFO_THRESH, (u32 *)fiforeg);
68
69 /* set TWI GPIO USB_HOST_DEV pin high */
70 gpio_direction_output(MSP_PIN_USB0_HOST_DEV, 1);
71#ifdef CONFIG_MSP_HAS_DUAL_USB
72 gpio_direction_output(MSP_PIN_USB1_HOST_DEV, 1);
73#endif
74}
75
76/* called during probe() after chip reset completes */
77static int ehci_msp_setup(struct usb_hcd *hcd)
78{
79 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
80 int retval;
81
82 ehci->big_endian_mmio = 1;
83 ehci->big_endian_desc = 1;
84
85 ehci->caps = hcd->regs;
86 hcd->has_tt = 1;
87
88 retval = ehci_setup(hcd);
89 if (retval)
90 return retval;
91
92 usb_hcd_tdi_set_mode(ehci);
93
94 return retval;
95}
96
97
98/* configure so an HC device and id are always provided
99 * always called with process context; sleeping is OK
100 */
101
102static int usb_hcd_msp_map_regs(struct mspusb_device *dev)
103{
104 struct resource *res;
105 struct platform_device *pdev = &dev->dev;
106 u32 res_len;
107 int retval;
108
109 /* MAB register space */
110 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
111 if (res == NULL)
112 return -ENOMEM;
113 res_len = resource_size(res);
114 if (!request_mem_region(res->start, res_len, "mab regs"))
115 return -EBUSY;
116
117 dev->mab_regs = ioremap_nocache(res->start, res_len);
118 if (dev->mab_regs == NULL) {
119 retval = -ENOMEM;
120 goto err1;
121 }
122
123 /* MSP USB register space */
124 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
125 if (res == NULL) {
126 retval = -ENOMEM;
127 goto err2;
128 }
129 res_len = resource_size(res);
130 if (!request_mem_region(res->start, res_len, "usbid regs")) {
131 retval = -EBUSY;
132 goto err2;
133 }
134 dev->usbid_regs = ioremap_nocache(res->start, res_len);
135 if (dev->usbid_regs == NULL) {
136 retval = -ENOMEM;
137 goto err3;
138 }
139
140 return 0;
141err3:
142 res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
143 res_len = resource_size(res);
144 release_mem_region(res->start, res_len);
145err2:
146 iounmap(dev->mab_regs);
147err1:
148 res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
149 res_len = resource_size(res);
150 release_mem_region(res->start, res_len);
151 dev_err(&pdev->dev, "Failed to map non-EHCI regs.\n");
152 return retval;
153}
154
155/**
156 * usb_hcd_msp_probe - initialize PMC MSP-based HCDs
157 * Context: !in_interrupt()
158 *
159 * Allocates basic resources for this USB host controller, and
160 * then invokes the start() method for the HCD associated with it
161 * through the hotplug entry's driver_data.
162 *
163 */
164int usb_hcd_msp_probe(const struct hc_driver *driver,
165 struct platform_device *dev)
166{
167 int retval;
168 struct usb_hcd *hcd;
169 struct resource *res;
170 struct ehci_hcd *ehci ;
171
172 hcd = usb_create_hcd(driver, &dev->dev, "pmcmsp");
173 if (!hcd)
174 return -ENOMEM;
175
176 res = platform_get_resource(dev, IORESOURCE_MEM, 0);
177 if (res == NULL) {
178 pr_debug("No IOMEM resource info for %s.\n", dev->name);
179 retval = -ENOMEM;
180 goto err1;
181 }
182 hcd->rsrc_start = res->start;
183 hcd->rsrc_len = resource_size(res);
184 if (!request_mem_region(hcd->rsrc_start, hcd->rsrc_len, dev->name)) {
185 retval = -EBUSY;
186 goto err1;
187 }
188 hcd->regs = ioremap_nocache(hcd->rsrc_start, hcd->rsrc_len);
189 if (!hcd->regs) {
190 pr_debug("ioremap failed");
191 retval = -ENOMEM;
192 goto err2;
193 }
194
195 res = platform_get_resource(dev, IORESOURCE_IRQ, 0);
196 if (res == NULL) {
197 dev_err(&dev->dev, "No IRQ resource info for %s.\n", dev->name);
198 retval = -ENOMEM;
199 goto err3;
200 }
201
202 /* Map non-EHCI register spaces */
203 retval = usb_hcd_msp_map_regs(to_mspusb_device(dev));
204 if (retval != 0)
205 goto err3;
206
207 ehci = hcd_to_ehci(hcd);
208 ehci->big_endian_mmio = 1;
209 ehci->big_endian_desc = 1;
210
211
212 retval = usb_add_hcd(hcd, res->start, IRQF_SHARED);
213 if (retval == 0)
214 return 0;
215
216 usb_remove_hcd(hcd);
217err3:
218 iounmap(hcd->regs);
219err2:
220 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
221err1:
222 usb_put_hcd(hcd);
223
224 return retval;
225}
226
227
228
229/**
230 * usb_hcd_msp_remove - shutdown processing for PMC MSP-based HCDs
231 * @dev: USB Host Controller being removed
232 * Context: !in_interrupt()
233 *
234 * Reverses the effect of usb_hcd_msp_probe(), first invoking
235 * the HCD's stop() method. It is always called from a thread
236 * context, normally "rmmod", "apmd", or something similar.
237 *
238 * may be called without controller electrically present
239 * may be called with controller, bus, and devices active
240 */
241void usb_hcd_msp_remove(struct usb_hcd *hcd, struct platform_device *dev)
242{
243 usb_remove_hcd(hcd);
244 iounmap(hcd->regs);
245 release_mem_region(hcd->rsrc_start, hcd->rsrc_len);
246 usb_put_hcd(hcd);
247}
248
249#ifdef CONFIG_MSP_HAS_DUAL_USB
250/*
251 * Wrapper around the main ehci_irq. Since both USB host controllers are
252 * sharing the same IRQ, need to first determine whether we're the intended
253 * recipient of this interrupt.
254 */
255static irqreturn_t ehci_msp_irq(struct usb_hcd *hcd)
256{
257 u32 int_src;
258 struct device *dev = hcd->self.controller;
259 struct platform_device *pdev;
260 struct mspusb_device *mdev;
261 struct ehci_hcd *ehci = hcd_to_ehci(hcd);
262 /* need to reverse-map a couple of containers to get our device */
263 pdev = to_platform_device(dev);
264 mdev = to_mspusb_device(pdev);
265
266 /* Check to see if this interrupt is for this host controller */
267 int_src = ehci_readl(ehci, &mdev->mab_regs->int_stat);
268 if (int_src & (1 << pdev->id))
269 return ehci_irq(hcd);
270
271 /* Not for this device */
272 return IRQ_NONE;
273}
274#endif /* DUAL_USB */
275
276static const struct hc_driver ehci_msp_hc_driver = {
277 .description = hcd_name,
278 .product_desc = "PMC MSP EHCI",
279 .hcd_priv_size = sizeof(struct ehci_hcd),
280
281 /*
282 * generic hardware linkage
283 */
284#ifdef CONFIG_MSP_HAS_DUAL_USB
285 .irq = ehci_msp_irq,
286#else
287 .irq = ehci_irq,
288#endif
289 .flags = HCD_MEMORY | HCD_USB2,
290
291 /*
292 * basic lifecycle operations
293 */
294 .reset = ehci_msp_setup,
295 .start = ehci_run,
296 .shutdown = ehci_shutdown,
297 .start = ehci_run,
298 .stop = ehci_stop,
299
300 /*
301 * managing i/o requests and associated device resources
302 */
303 .urb_enqueue = ehci_urb_enqueue,
304 .urb_dequeue = ehci_urb_dequeue,
305 .endpoint_disable = ehci_endpoint_disable,
306 .endpoint_reset = ehci_endpoint_reset,
307
308 /*
309 * scheduling support
310 */
311 .get_frame_number = ehci_get_frame,
312
313 /*
314 * root hub support
315 */
316 .hub_status_data = ehci_hub_status_data,
317 .hub_control = ehci_hub_control,
318 .bus_suspend = ehci_bus_suspend,
319 .bus_resume = ehci_bus_resume,
320 .relinquish_port = ehci_relinquish_port,
321 .port_handed_over = ehci_port_handed_over,
322
323 .clear_tt_buffer_complete = ehci_clear_tt_buffer_complete,
324};
325
326static int ehci_hcd_msp_drv_probe(struct platform_device *pdev)
327{
328 int ret;
329
330 pr_debug("In ehci_hcd_msp_drv_probe");
331
332 if (usb_disabled())
333 return -ENODEV;
334
335 gpio_request(MSP_PIN_USB0_HOST_DEV, "USB0_HOST_DEV_GPIO");
336#ifdef CONFIG_MSP_HAS_DUAL_USB
337 gpio_request(MSP_PIN_USB1_HOST_DEV, "USB1_HOST_DEV_GPIO");
338#endif
339
340 ret = usb_hcd_msp_probe(&ehci_msp_hc_driver, pdev);
341
342 return ret;
343}
344
345static int ehci_hcd_msp_drv_remove(struct platform_device *pdev)
346{
347 struct usb_hcd *hcd = platform_get_drvdata(pdev);
348
349 usb_hcd_msp_remove(hcd, pdev);
350
351 /* free TWI GPIO USB_HOST_DEV pin */
352 gpio_free(MSP_PIN_USB0_HOST_DEV);
353#ifdef CONFIG_MSP_HAS_DUAL_USB
354 gpio_free(MSP_PIN_USB1_HOST_DEV);
355#endif
356
357 return 0;
358}
359
360MODULE_ALIAS("pmcmsp-ehci");
361
362static struct platform_driver ehci_hcd_msp_driver = {
363 .probe = ehci_hcd_msp_drv_probe,
364 .remove = ehci_hcd_msp_drv_remove,
365 .driver = {
366 .name = "pmcmsp-ehci",
367 .owner = THIS_MODULE,
368 },
369};