5f48660ebdfa299d0c51a8b1f3aa1303f3b69d18
[releases.git] / fhci-hub.c
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
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
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 */
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 */
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
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 */
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
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
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 }