/* * Wireless USB Host Controller * Root Hub operations * * * Copyright (C) 2005-2006 Intel Corporation * Inaky Perez-Gonzalez * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License version * 2 as published by the Free Software Foundation. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA * 02110-1301, USA. * * * We fake a root hub that has fake ports (as many as simultaneous * devices the Wireless USB Host Controller can deal with). For each * port we keep an state in @wusbhc->port[index] identical to the one * specified in the USB2.0[ch11] spec and some extra device * information that complements the one in 'struct usb_device' (as * this lacs a hcpriv pointer). * * Note this is common to WHCI and HWA host controllers. * * Through here we enable most of the state changes that the USB stack * will use to connect or disconnect devices. We need to do some * forced adaptation of Wireless USB device states vs. wired: * * USB: WUSB: * * Port Powered-off port slot n/a * Powered-on port slot available * Disconnected port slot available * Connected port slot assigned device * device sent DN_Connect * device was authenticated * Enabled device is authenticated, transitioned * from unauth -> auth -> default address * -> enabled * Reset disconnect * Disable disconnect * * This maps the standard USB port states with the WUSB device states * so we can fake ports without having to modify the USB stack. * * FIXME: this process will change in the future * * * ENTRY POINTS * * Our entry points into here are, as in hcd.c, the USB stack root hub * ops defined in the usb_hcd struct: * * wusbhc_rh_status_data() Provide hub and port status data bitmap * * wusbhc_rh_control() Execution of all the major requests * you can do to a hub (Set|Clear * features, get descriptors, status, etc). * * wusbhc_rh_[suspend|resume]() That * * wusbhc_rh_start_port_reset() ??? unimplemented */ #include #include #include "wusbhc.h" /* * Reset a fake port * * Using a Reset Device IE is too heavyweight as it causes the device * to enter the UnConnected state and leave the cluster, this can mean * that when the device reconnects it is connected to a different fake * port. * * Instead, reset authenticated devices with a SetAddress(0), followed * by a SetAddresss(AuthAddr). * * For unauthenticated devices just pretend to reset but do nothing. * If the device initialization continues to fail it will eventually * time out after TrustTimeout and enter the UnConnected state. * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. * * Supposedly we are the only thread accesing @wusbhc->port; in any * case, maybe we should move the mutex locking from * wusbhc_devconnect_auth() to here. * * @port_idx refers to the wusbhc's port index, not the USB port number */ static int wusbhc_rh_port_reset(struct wusbhc *wusbhc, u8 port_idx) { int result = 0; struct wusb_port *port = wusb_port_by_idx(wusbhc, port_idx); struct wusb_dev *wusb_dev = port->wusb_dev; if (wusb_dev == NULL) return -ENOTCONN; port->status |= USB_PORT_STAT_RESET; port->change |= USB_PORT_STAT_C_RESET; if (wusb_dev->addr & WUSB_DEV_ADDR_UNAUTH) result = 0; else result = wusb_dev_update_address(wusbhc, wusb_dev); port->status &= ~USB_PORT_STAT_RESET; port->status |= USB_PORT_STAT_ENABLE; port->change |= USB_PORT_STAT_C_RESET | USB_PORT_STAT_C_ENABLE; return result; } /* * Return the hub change status bitmap * * The bits in the change status bitmap are cleared when a * ClearPortFeature request is issued (USB2.0[11.12.3,11.12.4]. * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. * * WARNING!! This gets called from atomic context; we cannot get the * mutex--the only race condition we can find is some bit * changing just after we copy it, which shouldn't be too * big of a problem [and we can't make it an spinlock * because other parts need to take it and sleep] . * * @usb_hcd is refcounted, so it won't disappear under us * and before killing a host, the polling of the root hub * would be stopped anyway. */ int wusbhc_rh_status_data(struct usb_hcd *usb_hcd, char *_buf) { struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); size_t cnt, size, bits_set = 0; /* WE DON'T LOCK, see comment */ /* round up to bytes. Hub bit is bit 0 so add 1. */ size = DIV_ROUND_UP(wusbhc->ports_max + 1, 8); /* clear the output buffer. */ memset(_buf, 0, size); /* set the bit for each changed port. */ for (cnt = 0; cnt < wusbhc->ports_max; cnt++) { if (wusb_port_by_idx(wusbhc, cnt)->change) { const int bitpos = cnt+1; _buf[bitpos/8] |= (1 << (bitpos % 8)); bits_set++; } } return bits_set ? size : 0; } EXPORT_SYMBOL_GPL(wusbhc_rh_status_data); /* * Return the hub's descriptor * * NOTE: almost cut and paste from ehci-hub.c * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked */ static int wusbhc_rh_get_hub_descr(struct wusbhc *wusbhc, u16 wValue, u16 wIndex, struct usb_hub_descriptor *descr, u16 wLength) { u16 temp = 1 + (wusbhc->ports_max / 8); u8 length = 7 + 2 * temp; if (wLength < length) return -ENOSPC; descr->bDescLength = 7 + 2 * temp; descr->bDescriptorType = 0x29; /* HUB type */ descr->bNbrPorts = wusbhc->ports_max; descr->wHubCharacteristics = cpu_to_le16( 0x00 /* All ports power at once */ | 0x00 /* not part of compound device */ | 0x10 /* No overcurrent protection */ | 0x00 /* 8 FS think time FIXME ?? */ | 0x00); /* No port indicators */ descr->bPwrOn2PwrGood = 0; descr->bHubContrCurrent = 0; /* two bitmaps: ports removable, and usb 1.0 legacy PortPwrCtrlMask */ memset(&descr->u.hs.DeviceRemovable[0], 0, temp); memset(&descr->u.hs.DeviceRemovable[temp], 0xff, temp); return 0; } /* * Clear a hub feature * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. * * Nothing to do, so no locking needed ;) */ static int wusbhc_rh_clear_hub_feat(struct wusbhc *wusbhc, u16 feature) { int result; switch (feature) { case C_HUB_LOCAL_POWER: /* FIXME: maybe plug bit 0 to the power input status, * if any? * see wusbhc_rh_get_hub_status() */ case C_HUB_OVER_CURRENT: result = 0; break; default: result = -EPIPE; } return result; } /* * Return hub status (it is always zero...) * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. * * Nothing to do, so no locking needed ;) */ static int wusbhc_rh_get_hub_status(struct wusbhc *wusbhc, u32 *buf, u16 wLength) { /* FIXME: maybe plug bit 0 to the power input status (if any)? */ *buf = 0; return 0; } /* * Set a port feature * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. */ static int wusbhc_rh_set_port_feat(struct wusbhc *wusbhc, u16 feature, u8 selector, u8 port_idx) { struct device *dev = wusbhc->dev; if (port_idx > wusbhc->ports_max) return -EINVAL; switch (feature) { /* According to USB2.0[11.24.2.13]p2, these features * are not required to be implemented. */ case USB_PORT_FEAT_C_OVER_CURRENT: case USB_PORT_FEAT_C_ENABLE: case USB_PORT_FEAT_C_SUSPEND: case USB_PORT_FEAT_C_CONNECTION: case USB_PORT_FEAT_C_RESET: return 0; case USB_PORT_FEAT_POWER: /* No such thing, but we fake it works */ mutex_lock(&wusbhc->mutex); wusb_port_by_idx(wusbhc, port_idx)->status |= USB_PORT_STAT_POWER; mutex_unlock(&wusbhc->mutex); return 0; case USB_PORT_FEAT_RESET: return wusbhc_rh_port_reset(wusbhc, port_idx); case USB_PORT_FEAT_ENABLE: case USB_PORT_FEAT_SUSPEND: dev_err(dev, "(port_idx %d) set feat %d/%d UNIMPLEMENTED\n", port_idx, feature, selector); return -ENOSYS; default: dev_err(dev, "(port_idx %d) set feat %d/%d UNKNOWN\n", port_idx, feature, selector); return -EPIPE; } return 0; } /* * Clear a port feature... * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. */ static int wusbhc_rh_clear_port_feat(struct wusbhc *wusbhc, u16 feature, u8 selector, u8 port_idx) { int result = 0; struct device *dev = wusbhc->dev; if (port_idx > wusbhc->ports_max) return -EINVAL; mutex_lock(&wusbhc->mutex); switch (feature) { case USB_PORT_FEAT_POWER: /* fake port always on */ /* According to USB2.0[11.24.2.7.1.4], no need to implement? */ case USB_PORT_FEAT_C_OVER_CURRENT: break; case USB_PORT_FEAT_C_RESET: wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_RESET; break; case USB_PORT_FEAT_C_CONNECTION: wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_CONNECTION; break; case USB_PORT_FEAT_ENABLE: __wusbhc_dev_disable(wusbhc, port_idx); break; case USB_PORT_FEAT_C_ENABLE: wusb_port_by_idx(wusbhc, port_idx)->change &= ~USB_PORT_STAT_C_ENABLE; break; case USB_PORT_FEAT_SUSPEND: case USB_PORT_FEAT_C_SUSPEND: dev_err(dev, "(port_idx %d) Clear feat %d/%d UNIMPLEMENTED\n", port_idx, feature, selector); result = -ENOSYS; break; default: dev_err(dev, "(port_idx %d) Clear feat %d/%d UNKNOWN\n", port_idx, feature, selector); result = -EPIPE; break; } mutex_unlock(&wusbhc->mutex); return result; } /* * Return the port's status * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. */ static int wusbhc_rh_get_port_status(struct wusbhc *wusbhc, u16 port_idx, u32 *_buf, u16 wLength) { __le16 *buf = (__le16 *)_buf; if (port_idx > wusbhc->ports_max) return -EINVAL; mutex_lock(&wusbhc->mutex); buf[0] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->status); buf[1] = cpu_to_le16(wusb_port_by_idx(wusbhc, port_idx)->change); mutex_unlock(&wusbhc->mutex); return 0; } /* * Entry point for Root Hub operations * * @wusbhc is assumed referenced and @wusbhc->mutex unlocked. */ int wusbhc_rh_control(struct usb_hcd *usb_hcd, u16 reqntype, u16 wValue, u16 wIndex, char *buf, u16 wLength) { int result = -ENOSYS; struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); switch (reqntype) { case GetHubDescriptor: result = wusbhc_rh_get_hub_descr( wusbhc, wValue, wIndex, (struct usb_hub_descriptor *) buf, wLength); break; case ClearHubFeature: result = wusbhc_rh_clear_hub_feat(wusbhc, wValue); break; case GetHubStatus: result = wusbhc_rh_get_hub_status(wusbhc, (u32 *)buf, wLength); break; case SetPortFeature: result = wusbhc_rh_set_port_feat(wusbhc, wValue, wIndex >> 8, (wIndex & 0xff) - 1); break; case ClearPortFeature: result = wusbhc_rh_clear_port_feat(wusbhc, wValue, wIndex >> 8, (wIndex & 0xff) - 1); break; case GetPortStatus: result = wusbhc_rh_get_port_status(wusbhc, wIndex - 1, (u32 *)buf, wLength); break; case SetHubFeature: default: dev_err(wusbhc->dev, "%s (%p [%p], %x, %x, %x, %p, %x) " "UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, reqntype, wValue, wIndex, buf, wLength); /* dump_stack(); */ result = -ENOSYS; } return result; } EXPORT_SYMBOL_GPL(wusbhc_rh_control); int wusbhc_rh_start_port_reset(struct usb_hcd *usb_hcd, unsigned port_idx) { struct wusbhc *wusbhc = usb_hcd_to_wusbhc(usb_hcd); dev_err(wusbhc->dev, "%s (%p [%p], port_idx %u) UNIMPLEMENTED\n", __func__, usb_hcd, wusbhc, port_idx); WARN_ON(1); return -ENOSYS; } EXPORT_SYMBOL_GPL(wusbhc_rh_start_port_reset); static void wusb_port_init(struct wusb_port *port) { port->status |= USB_PORT_STAT_HIGH_SPEED; } /* * Alloc fake port specific fields and status. */ int wusbhc_rh_create(struct wusbhc *wusbhc) { int result = -ENOMEM; size_t port_size, itr; port_size = wusbhc->ports_max * sizeof(wusbhc->port[0]); wusbhc->port = kzalloc(port_size, GFP_KERNEL); if (wusbhc->port == NULL) goto error_port_alloc; for (itr = 0; itr < wusbhc->ports_max; itr++) wusb_port_init(&wusbhc->port[itr]); result = 0; error_port_alloc: return result; } void wusbhc_rh_destroy(struct wusbhc *wusbhc) { kfree(wusbhc->port); }