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