drivers/usb/host/fhci-hub.c

   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>
  25 #include <linux/usb/hcd.h>
  26 #include <linux/gpio.h>
  27 #include <soc/fsl/qe/qe.h>
  28 #include "fhci.h"
  29
  30 /* virtual root hub specific descriptor */
  31 static u8 root_hub_des[] = {
  32         0x09, /* blength */
  33         USB_DT_HUB, /* bDescriptorType;hub-descriptor */
  34         0x01, /* bNbrPorts */
  35         HUB_CHAR_INDV_PORT_LPSM | HUB_CHAR_NO_OCPM, /* wHubCharacteristics */
  36         0x00, /* per-port power, no overcurrent */
  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;
 100         out_be16(&usb->fhci->regs->usb_usbmr, usb->saved_msk);
 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 */
 161         mode = in_8(&fhci->regs->usb_usmod);
 162         out_8(&fhci->regs->usb_usmod, mode & (~USB_MODE_EN));
 163
 164         /* disable idle interrupts */
 165         mask = in_be16(&fhci->regs->usb_usbmr);
 166         out_be16(&fhci->regs->usb_usbmr, mask & (~USB_E_IDLE_MASK));
 167
 168         fhci_io_port_generate_reset(fhci);
 169
 170         /* enable interrupt on this endpoint */
 171         out_be16(&fhci->regs->usb_usbmr, mask);
 172
 173         /* enable the USB controller */
 174         mode = in_8(&fhci->regs->usb_usmod);
 175         out_8(&fhci->regs->usb_usmod, mode | USB_MODE_EN);
 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;
 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));
 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);
 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);
 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 }