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.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 int gpio = fhci->gpios[gpio_nr]; 42 bool alow = fhci->alow_gpios[gpio_nr]; 43 44 if (!gpio_is_valid(gpio)) 45 return; 46 47 gpio_set_value(gpio, on ^ alow); 48 mdelay(5); 49 } 50 51 void fhci_config_transceiver(struct fhci_hcd *fhci, 52 enum fhci_port_status status) 53 { 54 fhci_dbg(fhci, "-> %s: %d\n", __func__, status); 55 56 switch (status) { 57 case FHCI_PORT_POWER_OFF: 58 fhci_gpio_set_value(fhci, GPIO_POWER, false); 59 break; 60 case FHCI_PORT_DISABLED: 61 case FHCI_PORT_WAITING: 62 fhci_gpio_set_value(fhci, GPIO_POWER, true); 63 break; 64 case FHCI_PORT_LOW: 65 fhci_gpio_set_value(fhci, GPIO_SPEED, false); 66 break; 67 case FHCI_PORT_FULL: 68 fhci_gpio_set_value(fhci, GPIO_SPEED, true); 69 break; 70 default: 71 WARN_ON(1); 72 break; 73 } 74 75 fhci_dbg(fhci, "<- %s: %d\n", __func__, status); 76 } 77 78 /* disable the USB port by clearing the EN bit in the USBMOD register */ 79 void fhci_port_disable(struct fhci_hcd *fhci) 80 { 81 struct fhci_usb *usb = (struct fhci_usb *)fhci->usb_lld; 82 enum fhci_port_status port_status; 83 84 fhci_dbg(fhci, "-> %s\n", __func__); 85 86 fhci_stop_sof_timer(fhci); 87 88 fhci_flush_all_transmissions(usb); 89 90 fhci_usb_disable_interrupt((struct fhci_usb *)fhci->usb_lld); 91 port_status = usb->port_status; 92 usb->port_status = FHCI_PORT_DISABLED; 93 94 /* Enable IDLE since we want to know if something comes along */ 95 usb->saved_msk |= USB_E_IDLE_MASK; 96 out_be16(&usb->fhci->regs->usb_usbmr, usb->saved_msk); 97 98 /* check if during the disconnection process attached new device */ 99 if (port_status == FHCI_PORT_WAITING) 100 fhci_device_connected_interrupt(fhci); 101 usb->vroot_hub->port.wPortStatus &= ~USB_PORT_STAT_ENABLE; 102 usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_ENABLE; 103 fhci_usb_enable_interrupt((struct fhci_usb *)fhci->usb_lld); 104 105 fhci_dbg(fhci, "<- %s\n", __func__); 106 } 107 108 /* enable the USB port by setting the EN bit in the USBMOD register */ 109 void fhci_port_enable(void *lld) 110 { 111 struct fhci_usb *usb = (struct fhci_usb *)lld; 112 struct fhci_hcd *fhci = usb->fhci; 113 114 fhci_dbg(fhci, "-> %s\n", __func__); 115 116 fhci_config_transceiver(fhci, usb->port_status); 117 118 if ((usb->port_status != FHCI_PORT_FULL) && 119 (usb->port_status != FHCI_PORT_LOW)) 120 fhci_start_sof_timer(fhci); 121 122 usb->vroot_hub->port.wPortStatus |= USB_PORT_STAT_ENABLE; 123 usb->vroot_hub->port.wPortChange |= USB_PORT_STAT_C_ENABLE; 124 125 fhci_dbg(fhci, "<- %s\n", __func__); 126 } 127 128 void fhci_io_port_generate_reset(struct fhci_hcd *fhci) 129 { 130 fhci_dbg(fhci, "-> %s\n", __func__); 131 132 gpio_direction_output(fhci->gpios[GPIO_USBOE], 0); 133 gpio_direction_output(fhci->gpios[GPIO_USBTP], 0); 134 gpio_direction_output(fhci->gpios[GPIO_USBTN], 0); 135 136 mdelay(5); 137 138 qe_pin_set_dedicated(fhci->pins[PIN_USBOE]); 139 qe_pin_set_dedicated(fhci->pins[PIN_USBTP]); 140 qe_pin_set_dedicated(fhci->pins[PIN_USBTN]); 141 142 fhci_dbg(fhci, "<- %s\n", __func__); 143 } 144 145 /* generate the RESET condition on the bus */ 146 void fhci_port_reset(void *lld) 147 { 148 struct fhci_usb *usb = (struct fhci_usb *)lld; 149 struct fhci_hcd *fhci = usb->fhci; 150 u8 mode; 151 u16 mask; 152 153 fhci_dbg(fhci, "-> %s\n", __func__); 154 155 fhci_stop_sof_timer(fhci); 156 /* disable the USB controller */ 157 mode = in_8(&fhci->regs->usb_usmod); 158 out_8(&fhci->regs->usb_usmod, mode & (~USB_MODE_EN)); 159 160 /* disable idle interrupts */ 161 mask = in_be16(&fhci->regs->usb_usbmr); 162 out_be16(&fhci->regs->usb_usbmr, mask & (~USB_E_IDLE_MASK)); 163 164 fhci_io_port_generate_reset(fhci); 165 166 /* enable interrupt on this endpoint */ 167 out_be16(&fhci->regs->usb_usbmr, mask); 168 169 /* enable the USB controller */ 170 mode = in_8(&fhci->regs->usb_usmod); 171 out_8(&fhci->regs->usb_usmod, mode | USB_MODE_EN); 172 fhci_start_sof_timer(fhci); 173 174 fhci_dbg(fhci, "<- %s\n", __func__); 175 } 176 177 int fhci_hub_status_data(struct usb_hcd *hcd, char *buf) 178 { 179 struct fhci_hcd *fhci = hcd_to_fhci(hcd); 180 int ret = 0; 181 unsigned long flags; 182 183 fhci_dbg(fhci, "-> %s\n", __func__); 184 185 spin_lock_irqsave(&fhci->lock, flags); 186 187 if (fhci->vroot_hub->port.wPortChange & (USB_PORT_STAT_C_CONNECTION | 188 USB_PORT_STAT_C_ENABLE | USB_PORT_STAT_C_SUSPEND | 189 USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_OVERCURRENT)) { 190 *buf = 1 << 1; 191 ret = 1; 192 fhci_dbg(fhci, "-- %s\n", __func__); 193 } 194 195 spin_unlock_irqrestore(&fhci->lock, flags); 196 197 fhci_dbg(fhci, "<- %s\n", __func__); 198 199 return ret; 200 } 201 202 int fhci_hub_control(struct usb_hcd *hcd, u16 typeReq, u16 wValue, 203 u16 wIndex, char *buf, u16 wLength) 204 { 205 struct fhci_hcd *fhci = hcd_to_fhci(hcd); 206 int retval = 0; 207 struct usb_hub_status *hub_status; 208 struct usb_port_status *port_status; 209 unsigned long flags; 210 211 spin_lock_irqsave(&fhci->lock, flags); 212 213 fhci_dbg(fhci, "-> %s\n", __func__); 214 215 switch (typeReq) { 216 case ClearHubFeature: 217 switch (wValue) { 218 case C_HUB_LOCAL_POWER: 219 case C_HUB_OVER_CURRENT: 220 break; 221 default: 222 goto error; 223 } 224 break; 225 case ClearPortFeature: 226 fhci->vroot_hub->feature &= (1 << wValue); 227 228 switch (wValue) { 229 case USB_PORT_FEAT_ENABLE: 230 fhci->vroot_hub->port.wPortStatus &= 231 ~USB_PORT_STAT_ENABLE; 232 fhci_port_disable(fhci); 233 break; 234 case USB_PORT_FEAT_C_ENABLE: 235 fhci->vroot_hub->port.wPortChange &= 236 ~USB_PORT_STAT_C_ENABLE; 237 break; 238 case USB_PORT_FEAT_SUSPEND: 239 fhci->vroot_hub->port.wPortStatus &= 240 ~USB_PORT_STAT_SUSPEND; 241 fhci_stop_sof_timer(fhci); 242 break; 243 case USB_PORT_FEAT_C_SUSPEND: 244 fhci->vroot_hub->port.wPortChange &= 245 ~USB_PORT_STAT_C_SUSPEND; 246 break; 247 case USB_PORT_FEAT_POWER: 248 fhci->vroot_hub->port.wPortStatus &= 249 ~USB_PORT_STAT_POWER; 250 fhci_config_transceiver(fhci, FHCI_PORT_POWER_OFF); 251 break; 252 case USB_PORT_FEAT_C_CONNECTION: 253 fhci->vroot_hub->port.wPortChange &= 254 ~USB_PORT_STAT_C_CONNECTION; 255 break; 256 case USB_PORT_FEAT_C_OVER_CURRENT: 257 fhci->vroot_hub->port.wPortChange &= 258 ~USB_PORT_STAT_C_OVERCURRENT; 259 break; 260 case USB_PORT_FEAT_C_RESET: 261 fhci->vroot_hub->port.wPortChange &= 262 ~USB_PORT_STAT_C_RESET; 263 break; 264 default: 265 goto error; 266 } 267 break; 268 case GetHubDescriptor: 269 memcpy(buf, root_hub_des, sizeof(root_hub_des)); 270 break; 271 case GetHubStatus: 272 hub_status = (struct usb_hub_status *)buf; 273 hub_status->wHubStatus = 274 cpu_to_le16(fhci->vroot_hub->hub.wHubStatus); 275 hub_status->wHubChange = 276 cpu_to_le16(fhci->vroot_hub->hub.wHubChange); 277 break; 278 case GetPortStatus: 279 port_status = (struct usb_port_status *)buf; 280 port_status->wPortStatus = 281 cpu_to_le16(fhci->vroot_hub->port.wPortStatus); 282 port_status->wPortChange = 283 cpu_to_le16(fhci->vroot_hub->port.wPortChange); 284 break; 285 case SetHubFeature: 286 switch (wValue) { 287 case C_HUB_OVER_CURRENT: 288 case C_HUB_LOCAL_POWER: 289 break; 290 default: 291 goto error; 292 } 293 break; 294 case SetPortFeature: 295 fhci->vroot_hub->feature |= (1 << wValue); 296 297 switch (wValue) { 298 case USB_PORT_FEAT_ENABLE: 299 fhci->vroot_hub->port.wPortStatus |= 300 USB_PORT_STAT_ENABLE; 301 fhci_port_enable(fhci->usb_lld); 302 break; 303 case USB_PORT_FEAT_SUSPEND: 304 fhci->vroot_hub->port.wPortStatus |= 305 USB_PORT_STAT_SUSPEND; 306 fhci_stop_sof_timer(fhci); 307 break; 308 case USB_PORT_FEAT_RESET: 309 fhci->vroot_hub->port.wPortStatus |= 310 USB_PORT_STAT_RESET; 311 fhci_port_reset(fhci->usb_lld); 312 fhci->vroot_hub->port.wPortStatus |= 313 USB_PORT_STAT_ENABLE; 314 fhci->vroot_hub->port.wPortStatus &= 315 ~USB_PORT_STAT_RESET; 316 break; 317 case USB_PORT_FEAT_POWER: 318 fhci->vroot_hub->port.wPortStatus |= 319 USB_PORT_STAT_POWER; 320 fhci_config_transceiver(fhci, FHCI_PORT_WAITING); 321 break; 322 default: 323 goto error; 324 } 325 break; 326 default: 327 error: 328 retval = -EPIPE; 329 } 330 331 fhci_dbg(fhci, "<- %s\n", __func__); 332 333 spin_unlock_irqrestore(&fhci->lock, flags); 334 335 return retval; 336 } 337