Commit | Line | Data |
---|---|---|
236dd4d1 AV |
1 | /* |
2 | * Freescale QUICC Engine USB Host Controller Driver | |
3 | * | |
4 | * Copyright (c) Freescale Semicondutor, Inc. 2006. | |
5 | * Shlomi Gridish <gridish@freescale.com> | |
6 | * Jerry Huang <Chang-Ming.Huang@freescale.com> | |
7 | * Copyright (c) Logic Product Development, Inc. 2007 | |
8 | * Peter Barada <peterb@logicpd.com> | |
9 | * Copyright (c) MontaVista Software, Inc. 2008. | |
10 | * Anton Vorontsov <avorontsov@ru.mvista.com> | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the | |
14 | * Free Software Foundation; either version 2 of the License, or (at your | |
15 | * option) any later version. | |
16 | */ | |
17 | ||
18 | #include <linux/kernel.h> | |
19 | #include <linux/types.h> | |
20 | #include <linux/spinlock.h> | |
21 | #include <linux/delay.h> | |
22 | #include <linux/errno.h> | |
23 | #include <linux/io.h> | |
24 | #include <linux/usb.h> | |
27729aad | 25 | #include <linux/usb/hcd.h> |
236dd4d1 AV |
26 | #include <linux/gpio.h> |
27 | #include <asm/qe.h> | |
236dd4d1 AV |
28 | #include "fhci.h" |
29 | ||
30 | /* virtual root hub specific descriptor */ | |
31 | static u8 root_hub_des[] = { | |
32 | 0x09, /* blength */ | |
51a114bc | 33 | USB_DT_HUB, /* bDescriptorType;hub-descriptor */ |
236dd4d1 | 34 | 0x01, /* bNbrPorts */ |
14de3a30 | 35 | HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM, /* wHubCharacteristics */ |
368fbc34 | 36 | 0x00, /* per-port power, no overcurrent */ |
236dd4d1 AV |
37 | 0x01, /* bPwrOn2pwrGood;2ms */ |
38 | 0x00, /* bHubContrCurrent;0mA */ | |
39 | 0x00, /* DeviceRemoveable */ | |
40 | 0xff, /* PortPwrCtrlMask */ | |
41 | }; | |
42 | ||
43 | static void fhci_gpio_set_value(struct fhci_hcd *fhci, int gpio_nr, bool on) | |
44 | { | |
45 | int gpio = fhci->gpios[gpio_nr]; | |
46 | bool alow = fhci->alow_gpios[gpio_nr]; | |
47 | ||
48 | if (!gpio_is_valid(gpio)) | |
49 | return; | |
50 | ||
51 | gpio_set_value(gpio, on ^ alow); | |
52 | mdelay(5); | |
53 | } | |
54 | ||
55 | void fhci_config_transceiver(struct fhci_hcd *fhci, | |
56 | enum fhci_port_status status) | |
57 | { | |
58 | fhci_dbg(fhci, "-> %s: %d\n", __func__, status); | |
59 | ||
60 | switch (status) { | |
61 | case FHCI_PORT_POWER_OFF: | |
62 | fhci_gpio_set_value(fhci, GPIO_POWER, false); | |
63 | break; | |
64 | case FHCI_PORT_DISABLED: | |
65 | case FHCI_PORT_WAITING: | |
66 | fhci_gpio_set_value(fhci, GPIO_POWER, true); | |
67 | break; | |
68 | case FHCI_PORT_LOW: | |
69 | fhci_gpio_set_value(fhci, GPIO_SPEED, false); | |
70 | break; | |
71 | case FHCI_PORT_FULL: | |
72 | fhci_gpio_set_value(fhci, GPIO_SPEED, true); | |
73 | break; | |
74 | default: | |
75 | WARN_ON(1); | |
76 | break; | |
77 | } | |
78 | ||
79 | fhci_dbg(fhci, "<- %s: %d\n", __func__, status); | |
80 | } | |
81 | ||
82 | /* disable the USB port by clearing the EN bit in the USBMOD register */ | |
83 | void fhci_port_disable(struct fhci_hcd *fhci) | |
84 | { | |
85 | struct fhci_usb *usb = (struct fhci_usb *)fhci->usb_lld; | |
86 | enum fhci_port_status port_status; | |
87 | ||
88 | fhci_dbg(fhci, "-> %s\n", __func__); | |
89 | ||
90 | fhci_stop_sof_timer(fhci); | |
91 | ||
92 | fhci_flush_all_transmissions(usb); | |
93 | ||
94 | fhci_usb_disable_interrupt((struct fhci_usb *)fhci->usb_lld); | |
95 | port_status = usb->port_status; | |
96 | usb->port_status = FHCI_PORT_DISABLED; | |
97 | ||
98 | /* Enable IDLE since we want to know if something comes along */ | |
99 | usb->saved_msk |= USB_E_IDLE_MASK; | |
cf61fdb9 | 100 | out_be16(&usb->fhci->regs->usb_usbmr, usb->saved_msk); |
236dd4d1 AV |
101 | |
102 | /* check if during the disconnection process attached new device */ | |
103 | if (port_status == FHCI_PORT_WAITING) | |
104 | fhci_device_connected_interrupt(fhci); | |
105 | usb->vroot_hub->port.wPortStatus &= ~USB_PORT_STAT_ENABLE; | |
106 | usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_ENABLE; | |
107 | fhci_usb_enable_interrupt((struct fhci_usb *)fhci->usb_lld); | |
108 | ||
109 | fhci_dbg(fhci, "<- %s\n", __func__); | |
110 | } | |
111 | ||
112 | /* enable the USB port by setting the EN bit in the USBMOD register */ | |
113 | void fhci_port_enable(void *lld) | |
114 | { | |
115 | struct fhci_usb *usb = (struct fhci_usb *)lld; | |
116 | struct fhci_hcd *fhci = usb->fhci; | |
117 | ||
118 | fhci_dbg(fhci, "-> %s\n", __func__); | |
119 | ||
120 | fhci_config_transceiver(fhci, usb->port_status); | |
121 | ||
122 | if ((usb->port_status != FHCI_PORT_FULL) && | |
123 | (usb->port_status != FHCI_PORT_LOW)) | |
124 | fhci_start_sof_timer(fhci); | |
125 | ||
126 | usb->vroot_hub->port.wPortStatus |= USB_PORT_STAT_ENABLE; | |
127 | usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_ENABLE; | |
128 | ||
129 | fhci_dbg(fhci, "<- %s\n", __func__); | |
130 | } | |
131 | ||
132 | void fhci_io_port_generate_reset(struct fhci_hcd *fhci) | |
133 | { | |
134 | fhci_dbg(fhci, "-> %s\n", __func__); | |
135 | ||
136 | gpio_direction_output(fhci->gpios[GPIO_USBOE], 0); | |
137 | gpio_direction_output(fhci->gpios[GPIO_USBTP], 0); | |
138 | gpio_direction_output(fhci->gpios[GPIO_USBTN], 0); | |
139 | ||
140 | mdelay(5); | |
141 | ||
142 | qe_pin_set_dedicated(fhci->pins[PIN_USBOE]); | |
143 | qe_pin_set_dedicated(fhci->pins[PIN_USBTP]); | |
144 | qe_pin_set_dedicated(fhci->pins[PIN_USBTN]); | |
145 | ||
146 | fhci_dbg(fhci, "<- %s\n", __func__); | |
147 | } | |
148 | ||
149 | /* generate the RESET condition on the bus */ | |
150 | void fhci_port_reset(void *lld) | |
151 | { | |
152 | struct fhci_usb *usb = (struct fhci_usb *)lld; | |
153 | struct fhci_hcd *fhci = usb->fhci; | |
154 | u8 mode; | |
155 | u16 mask; | |
156 | ||
157 | fhci_dbg(fhci, "-> %s\n", __func__); | |
158 | ||
159 | fhci_stop_sof_timer(fhci); | |
160 | /* disable the USB controller */ | |
cf61fdb9 GMF |
161 | mode = in_8(&fhci->regs->usb_usmod); |
162 | out_8(&fhci->regs->usb_usmod, mode & (~USB_MODE_EN)); | |
236dd4d1 AV |
163 | |
164 | /* disable idle interrupts */ | |
cf61fdb9 GMF |
165 | mask = in_be16(&fhci->regs->usb_usbmr); |
166 | out_be16(&fhci->regs->usb_usbmr, mask & (~USB_E_IDLE_MASK)); | |
236dd4d1 AV |
167 | |
168 | fhci_io_port_generate_reset(fhci); | |
169 | ||
170 | /* enable interrupt on this endpoint */ | |
cf61fdb9 | 171 | out_be16(&fhci->regs->usb_usbmr, mask); |
236dd4d1 AV |
172 | |
173 | /* enable the USB controller */ | |
cf61fdb9 GMF |
174 | mode = in_8(&fhci->regs->usb_usmod); |
175 | out_8(&fhci->regs->usb_usmod, mode | USB_MODE_EN); | |
236dd4d1 AV |
176 | fhci_start_sof_timer(fhci); |
177 | ||
178 | fhci_dbg(fhci, "<- %s\n", __func__); | |
179 | } | |
180 | ||
181 | int fhci_hub_status_data(struct usb_hcd *hcd, char *buf) | |
182 | { | |
183 | struct fhci_hcd *fhci = hcd_to_fhci(hcd); | |
184 | int ret = 0; | |
185 | unsigned long flags; | |
186 | ||
187 | fhci_dbg(fhci, "-> %s\n", __func__); | |
188 | ||
189 | spin_lock_irqsave(&fhci->lock, flags); | |
190 | ||
191 | if (fhci->vroot_hub->port.wPortChange & (USB_PORT_STAT_C_CONNECTION | | |
192 | USB_PORT_STAT_C_ENABLE | USB_PORT_STAT_C_SUSPEND | | |
193 | USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_OVERCURRENT)) { | |
194 | *buf = 1 << 1; | |
195 | ret = 1; | |
196 | fhci_dbg(fhci, "-- %s\n", __func__); | |
197 | } | |
198 | ||
199 | spin_unlock_irqrestore(&fhci->lock, flags); | |
200 | ||
201 | fhci_dbg(fhci, "<- %s\n", __func__); | |
202 | ||
203 | return ret; | |
204 | } | |
205 | ||
206 | int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, | |
207 | u16 wIndex, char *buf, u16 wLength) | |
208 | { | |
209 | struct fhci_hcd *fhci = hcd_to_fhci(hcd); | |
210 | int retval = 0; | |
236dd4d1 AV |
211 | struct usb_hub_status *hub_status; |
212 | struct usb_port_status *port_status; | |
213 | unsigned long flags; | |
214 | ||
215 | spin_lock_irqsave(&fhci->lock, flags); | |
216 | ||
217 | fhci_dbg(fhci, "-> %s\n", __func__); | |
218 | ||
219 | switch (typeReq) { | |
220 | case ClearHubFeature: | |
221 | switch (wValue) { | |
222 | case C_HUB_LOCAL_POWER: | |
223 | case C_HUB_OVER_CURRENT: | |
224 | break; | |
225 | default: | |
226 | goto error; | |
227 | } | |
228 | break; | |
229 | case ClearPortFeature: | |
230 | fhci->vroot_hub->feature &= (1 << wValue); | |
231 | ||
232 | switch (wValue) { | |
233 | case USB_PORT_FEAT_ENABLE: | |
234 | fhci->vroot_hub->port.wPortStatus &= | |
235 | ~USB_PORT_STAT_ENABLE; | |
236 | fhci_port_disable(fhci); | |
237 | break; | |
238 | case USB_PORT_FEAT_C_ENABLE: | |
239 | fhci->vroot_hub->port.wPortChange &= | |
240 | ~USB_PORT_STAT_C_ENABLE; | |
241 | break; | |
242 | case USB_PORT_FEAT_SUSPEND: | |
243 | fhci->vroot_hub->port.wPortStatus &= | |
244 | ~USB_PORT_STAT_SUSPEND; | |
245 | fhci_stop_sof_timer(fhci); | |
246 | break; | |
247 | case USB_PORT_FEAT_C_SUSPEND: | |
248 | fhci->vroot_hub->port.wPortChange &= | |
249 | ~USB_PORT_STAT_C_SUSPEND; | |
250 | break; | |
251 | case USB_PORT_FEAT_POWER: | |
252 | fhci->vroot_hub->port.wPortStatus &= | |
253 | ~USB_PORT_STAT_POWER; | |
254 | fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF); | |
255 | break; | |
256 | case USB_PORT_FEAT_C_CONNECTION: | |
257 | fhci->vroot_hub->port.wPortChange &= | |
258 | ~USB_PORT_STAT_C_CONNECTION; | |
259 | break; | |
260 | case USB_PORT_FEAT_C_OVER_CURRENT: | |
261 | fhci->vroot_hub->port.wPortChange &= | |
262 | ~USB_PORT_STAT_C_OVERCURRENT; | |
263 | break; | |
264 | case USB_PORT_FEAT_C_RESET: | |
265 | fhci->vroot_hub->port.wPortChange &= | |
266 | ~USB_PORT_STAT_C_RESET; | |
267 | break; | |
268 | default: | |
269 | goto error; | |
270 | } | |
271 | break; | |
272 | case GetHubDescriptor: | |
273 | memcpy(buf, root_hub_des, sizeof(root_hub_des)); | |
236dd4d1 AV |
274 | break; |
275 | case GetHubStatus: | |
276 | hub_status = (struct usb_hub_status *)buf; | |
277 | hub_status->wHubStatus = | |
278 | cpu_to_le16(fhci->vroot_hub->hub.wHubStatus); | |
279 | hub_status->wHubChange = | |
280 | cpu_to_le16(fhci->vroot_hub->hub.wHubChange); | |
236dd4d1 AV |
281 | break; |
282 | case GetPortStatus: | |
283 | port_status = (struct usb_port_status *)buf; | |
284 | port_status->wPortStatus = | |
285 | cpu_to_le16(fhci->vroot_hub->port.wPortStatus); | |
286 | port_status->wPortChange = | |
287 | cpu_to_le16(fhci->vroot_hub->port.wPortChange); | |
236dd4d1 AV |
288 | break; |
289 | case SetHubFeature: | |
290 | switch (wValue) { | |
291 | case C_HUB_OVER_CURRENT: | |
292 | case C_HUB_LOCAL_POWER: | |
293 | break; | |
294 | default: | |
295 | goto error; | |
296 | } | |
297 | break; | |
298 | case SetPortFeature: | |
299 | fhci->vroot_hub->feature |= (1 << wValue); | |
300 | ||
301 | switch (wValue) { | |
302 | case USB_PORT_FEAT_ENABLE: | |
303 | fhci->vroot_hub->port.wPortStatus |= | |
304 | USB_PORT_STAT_ENABLE; | |
305 | fhci_port_enable(fhci->usb_lld); | |
306 | break; | |
307 | case USB_PORT_FEAT_SUSPEND: | |
308 | fhci->vroot_hub->port.wPortStatus |= | |
309 | USB_PORT_STAT_SUSPEND; | |
310 | fhci_stop_sof_timer(fhci); | |
311 | break; | |
312 | case USB_PORT_FEAT_RESET: | |
313 | fhci->vroot_hub->port.wPortStatus |= | |
314 | USB_PORT_STAT_RESET; | |
315 | fhci_port_reset(fhci->usb_lld); | |
316 | fhci->vroot_hub->port.wPortStatus |= | |
317 | USB_PORT_STAT_ENABLE; | |
318 | fhci->vroot_hub->port.wPortStatus &= | |
319 | ~USB_PORT_STAT_RESET; | |
320 | break; | |
321 | case USB_PORT_FEAT_POWER: | |
322 | fhci->vroot_hub->port.wPortStatus |= | |
323 | USB_PORT_STAT_POWER; | |
324 | fhci_config_transceiver(fhci, FHCI_PORT_WAITING); | |
325 | break; | |
326 | default: | |
327 | goto error; | |
328 | } | |
329 | break; | |
330 | default: | |
331 | error: | |
332 | retval = -EPIPE; | |
333 | } | |
334 | ||
335 | fhci_dbg(fhci, "<- %s\n", __func__); | |
336 | ||
337 | spin_unlock_irqrestore(&fhci->lock, flags); | |
338 | ||
339 | return retval; | |
340 | } |