git.oblomov.eu Git - linux-2.6/blob - drivers/usb/wusbcore/rh.c

   1 /*
   2  * Wireless USB Host Controller
   3  * Root Hub operations
   4  *
   5  *
   6  * Copyright (C) 2005-2006 Intel Corporation
   7  * Inaky Perez-Gonzalez <inaky.perez-gonzalez@intel.com>
   8  *
   9  * This program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License version
  11  * 2 as published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21  * 02110-1301, USA.
  22  *
  23  *
  24  * We fake a root hub that has fake ports (as many as simultaneous
  25  * devices the Wireless USB Host Controller can deal with). For each
  26  * port we keep an state in @wusbhc->port[index] identical to the one
  27  * specified in the USB2.0[ch11] spec and some extra device
  28  * information that complements the one in 'struct usb_device' (as
  29  * this lacs a hcpriv pointer).
  30  *
  31  * Note this is common to WHCI and HWA host controllers.
  32  *
  33  * Through here we enable most of the state changes that the USB stack
  34  * will use to connect or disconnect devices. We need to do some
  35  * forced adaptation of Wireless USB device states vs. wired:
  36  *
  37  *        USB:                 WUSB:
  38  *
  39  * Port   Powered-off          port slot n/a
  40  *        Powered-on           port slot available
  41  *        Disconnected         port slot available
  42  *        Connected            port slot assigned device
  43  *                             device sent DN_Connect
  44  *                             device was authenticated
  45  *        Enabled              device is authenticated, transitioned
  46  *                             from unauth -> auth -> default address
  47  *                             -> enabled
  48  *        Reset                disconnect
  49  *        Disable              disconnect
  50  *
  51  * This maps the standard USB port states with the WUSB device states
  52  * so we can fake ports without having to modify the USB stack.
  53  *
  54  * FIXME: this process will change in the future
  55  *
  56  *
  57  * ENTRY POINTS
  58  *
  59  * Our entry points into here are, as in hcd.c, the USB stack root hub
  60  * ops defined in the usb_hcd struct:
  61  *
  62  * wusbhc_rh_status_data()      Provide hub and port status data bitmap
  63  *
  64  * wusbhc_rh_control()          Execution of all the major requests
  65  *                              you can do to a hub (Set|Clear
  66  *                              features, get descriptors, status, etc).
  67  *
  68  * wusbhc_rh_[suspend|resume]() That
  69  *
  70  * wusbhc_rh_start_port_reset() ??? unimplemented
  71  */
  72 #include "wusbhc.h"
  73
  74 /*
  75  * Reset a fake port
  76  *
  77  * Using a Reset Device IE is too heavyweight as it causes the device
  78  * to enter the UnConnected state and leave the cluster, this can mean
  79  * that when the device reconnects it is connected to a different fake
  80  * port.
  81  *
  82  * Instead, reset authenticated devices with a SetAddress(0), followed
  83  * by a SetAddresss(AuthAddr).
  84  *
  85  * For unauthenticated devices just pretend to reset but do nothing.
  86  * If the device initialization continues to fail it will eventually
  87  * time out after TrustTimeout and enter the UnConnected state.
  88  *
  89  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
  90  *
  91  * Supposedly we are the only thread accesing @wusbhc->port; in any
  92  * case, maybe we should move the mutex locking from
  93  * wusbhc_devconnect_auth() to here.
  94  *
  95  * @port_idx refers to the wusbhc's port index, not the USB port number
  96  */
  97 static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx)
  98 {
  99         int result = 0;
 100         struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx);
 101         struct wusb_dev *wusb_dev = port->wusb_dev;
 102
 103         port->status |= USB_PORT_STAT_RESET;
 104         port->change |= USB_PORT_STAT_C_RESET;
 105
 106         if (wusb_dev->addr & WUSB_DEV_ADDR_UNAUTH)
 107                 result = 0;
 108         else
 109                 result = wusb_dev_update_address(wusbhc, wusb_dev);
 110
 111         port->status &= ~USB_PORT_STAT_RESET;
 112         port->status |= USB_PORT_STAT_ENABLE;
 113         port->change |= USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_ENABLE;
 114
 115         return result;
 116 }
 117
 118 /*
 119  * Return the hub change status bitmap
 120  *
 121  * The bits in the change status bitmap are cleared when a
 122  * ClearPortFeature request is issued (USB2.0[11.12.3,11.12.4].
 123  *
 124  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 125  *
 126  * WARNING!! This gets called from atomic context; we cannot get the
 127  *           mutex--the only race condition we can find is some bit
 128  *           changing just after we copy it, which shouldn't be too
 129  *           big of a problem [and we can't make it an spinlock
 130  *           because other parts need to take it and sleep] .
 131  *
 132  *           @usb_hcd is refcounted, so it won't dissapear under us
 133  *           and before killing a host, the polling of the root hub
 134  *           would be stopped anyway.
 135  */
 136 int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf)
 137 {
 138         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
 139         size_t cnt, size;
 140         unsigned long *buf = (unsigned long *) _buf;
 141
 142         /* WE DON'T LOCK, see comment */
 143         size = wusbhc->ports_max + 1 /* hub bit */;
 144         size = (size + 8 - 1) / 8;      /* round to bytes */
 145         for (cnt = 0; cnt < wusbhc->ports_max; cnt++)
 146                 if (wusb_port_by_idx(wusbhc, cnt)->change)
 147                         set_bit(cnt + 1, buf);
 148                 else
 149                         clear_bit(cnt + 1, buf);
 150         return size;
 151 }
 152 EXPORT_SYMBOL_GPL(wusbhc_rh_status_data);
 153
 154 /*
 155  * Return the hub's desciptor
 156  *
 157  * NOTE: almost cut and paste from ehci-hub.c
 158  *
 159  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked
 160  */
 161 static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue,
 162                                    u16 wIndex,
 163                                    struct usb_hub_descriptor *descr,
 164                                    u16 wLength)
 165 {
 166         u16 temp = 1 + (wusbhc->ports_max / 8);
 167         u8 length = 7 + 2 * temp;
 168
 169         if (wLength < length)
 170                 return -ENOSPC;
 171         descr->bDescLength = 7 + 2 * temp;
 172         descr->bDescriptorType = 0x29;  /* HUB type */
 173         descr->bNbrPorts = wusbhc->ports_max;
 174         descr->wHubCharacteristics = cpu_to_le16(
 175                 0x00                    /* All ports power at once */
 176                 | 0x00                  /* not part of compound device */
 177                 | 0x10                  /* No overcurrent protection */
 178                 | 0x00                  /* 8 FS think time FIXME ?? */
 179                 | 0x00);                /* No port indicators */
 180         descr->bPwrOn2PwrGood = 0;
 181         descr->bHubContrCurrent = 0;
 182         /* two bitmaps:  ports removable, and usb 1.0 legacy PortPwrCtrlMask */
 183         memset(&descr->bitmap[0], 0, temp);
 184         memset(&descr->bitmap[temp], 0xff, temp);
 185         return 0;
 186 }
 187
 188 /*
 189  * Clear a hub feature
 190  *
 191  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 192  *
 193  * Nothing to do, so no locking needed ;)
 194  */
 195 static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature)
 196 {
 197         int result;
 198
 199         switch (feature) {
 200         case C_HUB_LOCAL_POWER:
 201                 /* FIXME: maybe plug bit 0 to the power input status,
 202                  * if any?
 203                  * see wusbhc_rh_get_hub_status() */
 204         case C_HUB_OVER_CURRENT:
 205                 result = 0;
 206                 break;
 207         default:
 208                 result = -EPIPE;
 209         }
 210         return result;
 211 }
 212
 213 /*
 214  * Return hub status (it is always zero...)
 215  *
 216  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 217  *
 218  * Nothing to do, so no locking needed ;)
 219  */
 220 static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf,
 221                                     u16 wLength)
 222 {
 223         /* FIXME: maybe plug bit 0 to the power input status (if any)? */
 224         *buf = 0;
 225         return 0;
 226 }
 227
 228 /*
 229  * Set a port feature
 230  *
 231  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 232  */
 233 static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature,
 234                                    u8 selector, u8 port_idx)
 235 {
 236         struct device *dev = wusbhc->dev;
 237
 238         if (port_idx > wusbhc->ports_max)
 239                 return -EINVAL;
 240
 241         switch (feature) {
 242                 /* According to USB2.0[11.24.2.13]p2, these features
 243                  * are not required to be implemented. */
 244         case USB_PORT_FEAT_C_OVER_CURRENT:
 245         case USB_PORT_FEAT_C_ENABLE:
 246         case USB_PORT_FEAT_C_SUSPEND:
 247         case USB_PORT_FEAT_C_CONNECTION:
 248         case USB_PORT_FEAT_C_RESET:
 249                 return 0;
 250         case USB_PORT_FEAT_POWER:
 251                 /* No such thing, but we fake it works */
 252                 mutex_lock(&wusbhc->mutex);
 253                 wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER;
 254                 mutex_unlock(&wusbhc->mutex);
 255                 return 0;
 256         case USB_PORT_FEAT_RESET:
 257                 return wusbhc_rh_port_reset(wusbhc, port_idx);
 258         case USB_PORT_FEAT_ENABLE:
 259         case USB_PORT_FEAT_SUSPEND:
 260                 dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n",
 261                         port_idx, feature, selector);
 262                 return -ENOSYS;
 263         default:
 264                 dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n",
 265                         port_idx, feature, selector);
 266                 return -EPIPE;
 267         }
 268
 269         return 0;
 270 }
 271
 272 /*
 273  * Clear a port feature...
 274  *
 275  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 276  */
 277 static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature,
 278                                      u8 selector, u8 port_idx)
 279 {
 280         int result = 0;
 281         struct device *dev = wusbhc->dev;
 282
 283         if (port_idx > wusbhc->ports_max)
 284                 return -EINVAL;
 285
 286         mutex_lock(&wusbhc->mutex);
 287         switch (feature) {
 288         case USB_PORT_FEAT_POWER:       /* fake port always on */
 289                 /* According to USB2.0[11.24.2.7.1.4], no need to implement? */
 290         case USB_PORT_FEAT_C_OVER_CURRENT:
 291                 break;
 292         case USB_PORT_FEAT_C_RESET:
 293                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET;
 294                 break;
 295         case USB_PORT_FEAT_C_CONNECTION:
 296                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION;
 297                 break;
 298         case USB_PORT_FEAT_ENABLE:
 299                 __wusbhc_dev_disable(wusbhc, port_idx);
 300                 break;
 301         case USB_PORT_FEAT_C_ENABLE:
 302                 wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE;
 303                 break;
 304         case USB_PORT_FEAT_SUSPEND:
 305         case USB_PORT_FEAT_C_SUSPEND:
 306                 dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n",
 307                         port_idx, feature, selector);
 308                 result = -ENOSYS;
 309                 break;
 310         default:
 311                 dev_err(dev, "(port_idx %d) Clear feat %d/%d UNKNOWN\n",
 312                         port_idx, feature, selector);
 313                 result = -EPIPE;
 314                 break;
 315         }
 316         mutex_unlock(&wusbhc->mutex);
 317
 318         return result;
 319 }
 320
 321 /*
 322  * Return the port's status
 323  *
 324  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 325  */
 326 static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx,
 327                                      u32 *_buf, u16 wLength)
 328 {
 329         __le16 *buf = (__le16 *)_buf;
 330
 331         if (port_idx > wusbhc->ports_max)
 332                 return -EINVAL;
 333
 334         mutex_lock(&wusbhc->mutex);
 335         buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status);
 336         buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change);
 337         mutex_unlock(&wusbhc->mutex);
 338
 339         return 0;
 340 }
 341
 342 /*
 343  * Entry point for Root Hub operations
 344  *
 345  * @wusbhc is assumed referenced and @wusbhc->mutex unlocked.
 346  */
 347 int wusbhc_rh_control(struct usb_hcd *usb_hcd, u16 reqntype, u16 wValue,
 348                       u16 wIndex, char *buf, u16 wLength)
 349 {
 350         int result = -ENOSYS;
 351         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
 352
 353         switch (reqntype) {
 354         case GetHubDescriptor:
 355                 result = wusbhc_rh_get_hub_descr(
 356                         wusbhc, wValue, wIndex,
 357                         (struct usb_hub_descriptor *) buf, wLength);
 358                 break;
 359         case ClearHubFeature:
 360                 result = wusbhc_rh_clear_hub_feat(wusbhc, wValue);
 361                 break;
 362         case GetHubStatus:
 363                 result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength);
 364                 break;
 365
 366         case SetPortFeature:
 367                 result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8,
 368                                                  (wIndex & 0xff) - 1);
 369                 break;
 370         case ClearPortFeature:
 371                 result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8,
 372                                                    (wIndex & 0xff) - 1);
 373                 break;
 374         case GetPortStatus:
 375                 result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1,
 376                                                    (u32 *)buf, wLength);
 377                 break;
 378
 379         case SetHubFeature:
 380         default:
 381                 dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) "
 382                         "UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype,
 383                         wValue, wIndex, buf, wLength);
 384                 /* dump_stack(); */
 385                 result = -ENOSYS;
 386         }
 387         return result;
 388 }
 389 EXPORT_SYMBOL_GPL(wusbhc_rh_control);
 390
 391 int wusbhc_rh_suspend(struct usb_hcd *usb_hcd)
 392 {
 393         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
 394         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
 395                 usb_hcd, wusbhc);
 396         /* dump_stack(); */
 397         return -ENOSYS;
 398 }
 399 EXPORT_SYMBOL_GPL(wusbhc_rh_suspend);
 400
 401 int wusbhc_rh_resume(struct usb_hcd *usb_hcd)
 402 {
 403         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
 404         dev_err(wusbhc->dev, "%s (%p [%p]) UNIMPLEMENTED\n", __func__,
 405                 usb_hcd, wusbhc);
 406         /* dump_stack(); */
 407         return -ENOSYS;
 408 }
 409 EXPORT_SYMBOL_GPL(wusbhc_rh_resume);
 410
 411 int wusbhc_rh_start_port_reset(struct usb_hcd *usb_hcd, unsigned port_idx)
 412 {
 413         struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd);
 414         dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n",
 415                 __func__, usb_hcd, wusbhc, port_idx);
 416         WARN_ON(1);
 417         return -ENOSYS;
 418 }
 419 EXPORT_SYMBOL_GPL(wusbhc_rh_start_port_reset);
 420
 421 static void wusb_port_init(struct wusb_port *port)
 422 {
 423         port->status |= USB_PORT_STAT_HIGH_SPEED;
 424 }
 425
 426 /*
 427  * Alloc fake port specific fields and status.
 428  */
 429 int wusbhc_rh_create(struct wusbhc *wusbhc)
 430 {
 431         int result = -ENOMEM;
 432         size_t port_size, itr;
 433         port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]);
 434         wusbhc->port = kzalloc(port_size, GFP_KERNEL);
 435         if (wusbhc->port == NULL)
 436                 goto error_port_alloc;
 437         for (itr = 0; itr < wusbhc->ports_max; itr++)
 438                 wusb_port_init(&wusbhc->port[itr]);
 439         result = 0;
 440 error_port_alloc:
 441         return result;
 442 }
 443
 444 void wusbhc_rh_destroy(struct wusbhc *wusbhc)
 445 {
 446         kfree(wusbhc->port);
 447 }