Adding David Vrabel to review from a WUSB point of view. > From: Tatyana Linder <[email protected]> > > This patch adds the SuperSpeed functionality to the gadget framework. > In order not to force all the FDs to supply SuperSpeed descriptors when > operating in SuperSpeed mode the following approach was taken: > If we're operating in SuperSpeed mode and the FD didn't supply SuperSpeed > descriptors, the composite layer will automatically create SuperSpeed > descriptors with default values. > Support for new SuperSpeed BOS descriptor was added. > Support for SET_FEATURE and GET_STATUS requests in SuperSpeed mode was > added. > > Signed-off-by: Tatyana Linder <[email protected]> > --- > This patch was verified by USBCV 3.0 and 2.0. > > drivers/usb/gadget/Kconfig | 20 ++- > drivers/usb/gadget/composite.c | 319 > +++++++++++++++++++++++++++++++++++++--- > include/linux/usb/ch9.h | 54 +++++++- > include/linux/usb/composite.h | 24 +++ > include/linux/usb/gadget.h | 19 +++ > 5 files changed, 407 insertions(+), 29 deletions(-) > > diff --git a/drivers/usb/gadget/Kconfig b/drivers/usb/gadget/Kconfig > index cd27f9b..9afdd08 100644 > --- a/drivers/usb/gadget/Kconfig > +++ b/drivers/usb/gadget/Kconfig > @@ -520,11 +520,11 @@ config USB_GADGET_DUMMY_HCD > side is the master; the gadget side is the slave. Gadget drivers > can be high, full, or low speed; and they have access to endpoints > like those from NET2280, PXA2xx, or SA1100 hardware. > - > + > This may help in some stages of creating a driver to embed in a > Linux device, since it lets you debug several parts of the gadget > driver without its hardware or drivers being involved. > - > + > Since such a gadget side driver needs to interoperate with a host > side Linux-USB device driver, this may help to debug both sides > of a USB protocol stack. > @@ -552,6 +552,18 @@ config USB_GADGET_DUALSPEED > Means that gadget drivers should include extra descriptors > and code to handle dual-speed controllers. > > +config USB_GADGET_SUPERSPEED > + boolean "Gadget opperating in Super Speed" > + depends on USB_GADGET > + depends on USB_GADGET_DUALSPEED > + default n > + help > + Enabling this feature enables Super Speed support in the Gadget > + driver. It means that gadget drivers should include extra (SuperSpeed) > + descriptors. > + For composite devices: if SupeSpeed descriptors weren't supplied by > + the FD, they will be automatically generated with default values. > + > # > # USB Gadget Drivers > # > @@ -633,7 +645,7 @@ config USB_ETH > help > This driver implements Ethernet style communication, in one of > several ways: > - > + > - The "Communication Device Class" (CDC) Ethernet Control Model. > That protocol is often avoided with pure Ethernet adapters, in > favor of simpler vendor-specific hardware, but is widely > @@ -673,7 +685,7 @@ config USB_ETH_RNDIS > If you say "y" here, the Ethernet gadget driver will try to provide > a second device configuration, supporting RNDIS to talk to such > Microsoft USB hosts. > - > + > To make MS-Windows work with this, use Documentation/usb/linux.inf > as the "driver info file". For versions of MS-Windows older than > XP, you'll need to download drivers from Microsoft's website; a URL > diff --git a/drivers/usb/gadget/composite.c > b/drivers/usb/gadget/composite.c > index c619c80..a5dcfe1 100644 > --- a/drivers/usb/gadget/composite.c > +++ b/drivers/usb/gadget/composite.c > @@ -70,6 +70,102 @@ static char *iSerialNumber; > module_param(iSerialNumber, charp, 0); > MODULE_PARM_DESC(iSerialNumber, "SerialNumber string"); > > +/** Default endpoint companion descriptor */ > +static struct usb_ss_ep_comp_descriptor ep_comp_desc = { > + .bDescriptorType = USB_DT_SS_ENDPOINT_COMP, > + .bLength = 0x06, > + .bMaxBurst = 0, /*the default is we don't support bursting*/ > + .bmAttributes = 0, /*2^0 streams supported*/ > + .wBytesPerInterval = 0, > +}; > + > +/**This function receives a pointer to usb_function and adds > + * missing super speed descriptors in the ss_descriptor field > + * according to its hs_descriptors field. > + * > + * In more details: this function copies f->hs_descriptors while > + * updating the endpoint descriptor and adding endpoint > + * companion descriptor > + */ > +static void create_ss_descriptors(struct usb_function *f) > +{ > + unsigned bytes; /*number of bytes to allocate*/ > + unsigned n_desc; /* number of descriptors*/ > + void *mem; /*allocated memory to copy to*/ > + struct usb_descriptor_header **tmp; > + struct usb_endpoint_descriptor *ep_desc ; > + struct usb_descriptor_header **src = f->hs_descriptors; > + > + if (!f->hs_descriptors) > + return; > + > + /* Count number of EPs (in order to know how many SS_EP_COMPANION > + descriptors to add), the total number of descriptors and the sum of > + each descriptor bLength field in order to know how much memory to > + allocate*/ > + for (bytes = 0, n_desc = 0, tmp = src; *tmp; tmp++, n_desc++) { > + if ((*tmp)->bDescriptorType == USB_DT_ENDPOINT) { > + bytes += ep_comp_desc.bLength; > + n_desc++; > + } > + bytes += (*tmp)->bLength; > + } > + > + bytes += (n_desc + 1) * sizeof(*tmp); > + mem = kmalloc(bytes, GFP_KERNEL); > + if (!mem) > + return; > + > + /* fill in pointers starting at "tmp", > + * to descriptors copied starting at "mem"; > + * and return "ret" > + */ > + tmp = mem; > + f->ss_descriptors = mem; > + mem += (n_desc + 1) * sizeof(*tmp); > + while (*src) { > + /*Copy the original descriptor*/ > + memcpy(mem, *src, (*src)->bLength); > + switch ((*src)->bDescriptorType) { > + case USB_DT_ENDPOINT: > + /*update ep descriptor*/ > + ep_desc = (struct usb_endpoint_descriptor *)mem; > + switch (ep_desc->bmAttributes & > + USB_ENDPOINT_XFERTYPE_MASK) { > + case USB_ENDPOINT_XFER_CONTROL: > + ep_desc->wMaxPacketSize = 512; > + ep_desc->bInterval = 0; > + break; > + case USB_ENDPOINT_XFER_BULK: > + ep_desc->wMaxPacketSize = 1024; > + ep_desc->bInterval = 0; > + break; > + case USB_ENDPOINT_XFER_INT: > + case USB_ENDPOINT_XFER_ISOC: > + break; > + } > + *tmp = mem; > + tmp++; > + mem += (*src)->bLength; > + /*add ep companion descriptor*/ > + memcpy(mem, &ep_comp_desc, ep_comp_desc.bLength); > + *tmp = mem; > + tmp++; > + mem += ep_comp_desc.bLength; > + break; > + default: > + *tmp = mem; > + tmp++; > + mem += (*src)->bLength; > + break; > + } > + src++; > + } > + *tmp = NULL; /*The last (struct usb_descriptor_header *) in the > + descriptors vector is NULL*/ > + f->ss_desc_allocated = true; > +} > + > /*-------------------------------------------------------------------------*/ > /** > * next_ep_desc - advance to the next EP descriptor > @@ -110,6 +206,9 @@ int ep_choose(struct usb_gadget *g, struct > usb_function *f, struct usb_ep *_ep) > struct usb_endpoint_descriptor *chosen_desc = NULL; > struct usb_descriptor_header **speed_desc = NULL; > > + struct usb_ss_ep_comp_descriptor *comp_desc = NULL; > + int want_comp_desc = 0; > + > struct usb_descriptor_header **d_spd; /* cursor for speed desc */ > > if (!g || !f || !_ep) > @@ -117,6 +216,13 @@ int ep_choose(struct usb_gadget *g, struct > usb_function *f, struct usb_ep *_ep) > > /* select desired speed */ > switch (g->speed) { > + case USB_SPEED_SUPER: > + if (gadget_is_superspeed(g)) { > + speed_desc = f->ss_descriptors; > + want_comp_desc = 1; > + break; > + } > + /*else: Fall trough*/ > case USB_SPEED_HIGH: > if (gadget_is_dualspeed(g)) { > speed_desc = f->hs_descriptors; > @@ -143,7 +249,18 @@ ep_found: > /* commit results */ > _ep->maxpacket = chosen_desc->wMaxPacketSize; > _ep->desc = chosen_desc; > - > + _ep->comp_desc = NULL; > + if (want_comp_desc) { > + /** > + * Companion descriptor should follow EP descriptor > + * USB 3.0 spec, #9.6.7 > + */ > + comp_desc = (struct usb_ss_ep_comp_descriptor *)*(++d_spd); > + if (!comp_desc || > + (comp_desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP)) > + return -EIO; > + _ep->comp_desc = comp_desc; > + } > return 0; > } > > @@ -185,6 +302,12 @@ int usb_add_function(struct usb_configuration > *config, > list_del(&function->list); > function->config = NULL; > } > + /*Add SS descriptors if there are any. This has to be done > + after the bind since we need the hs_descriptors to be set in > + usb_function and some of the FDs does it in the bind. */ > + if ((gadget_is_superspeed(config->cdev->gadget)) && > + (!function->ss_not_capable) && (!function->ss_descriptors)) > + create_ss_descriptors(function); > } else > value = 0; > > @@ -197,6 +320,8 @@ int usb_add_function(struct usb_configuration *config, > config->fullspeed = true; > if (!config->highspeed && function->hs_descriptors) > config->highspeed = true; > + if (!config->superspeed && function->ss_descriptors) > + config->superspeed = true; > > done: > if (value) > @@ -340,7 +465,9 @@ static int config_buf(struct usb_configuration > *config, > list_for_each_entry(f, &config->functions, list) { > struct usb_descriptor_header **descriptors; > > - if (speed == USB_SPEED_HIGH) > + if (speed == USB_SPEED_SUPER) > + descriptors = f->ss_descriptors; > + else if (speed == USB_SPEED_HIGH) > descriptors = f->hs_descriptors; > else > descriptors = f->descriptors; > @@ -366,23 +493,26 @@ static int config_desc(struct usb_composite_dev > *cdev, unsigned w_value) > u8 type = w_value >> 8; > enum usb_device_speed speed = USB_SPEED_UNKNOWN; > > - if (gadget_is_dualspeed(gadget)) { > - int hs = 0; > - > + if (gadget->speed == USB_SPEED_SUPER) > + speed = gadget->speed; > + else if (gadget_is_dualspeed(gadget)) { > + int hs = 0; > if (gadget->speed == USB_SPEED_HIGH) > hs = 1; > if (type == USB_DT_OTHER_SPEED_CONFIG) > hs = !hs; > if (hs) > speed = USB_SPEED_HIGH; > - > } > > /* This is a lookup by config *INDEX* */ > w_value &= 0xff; > list_for_each_entry(c, &cdev->configs, list) { > /* ignore configs that won't work at this speed */ > - if (speed == USB_SPEED_HIGH) { > + if (speed == USB_SPEED_SUPER) { > + if (!c->superspeed) > + continue; > + } else if (speed == USB_SPEED_HIGH) { > if (!c->highspeed) > continue; > } else { > @@ -402,16 +532,22 @@ static int count_configs(struct usb_composite_dev > *cdev, unsigned type) > struct usb_configuration *c; > unsigned count = 0; > int hs = 0; > + int ss = 0; > > if (gadget_is_dualspeed(gadget)) { > if (gadget->speed == USB_SPEED_HIGH) > hs = 1; > + if (gadget->speed == USB_SPEED_SUPER) > + ss = 1; > if (type == USB_DT_DEVICE_QUALIFIER) > hs = !hs; > } > list_for_each_entry(c, &cdev->configs, list) { > /* ignore configs that won't work at this speed */ > - if (hs) { > + if (ss) { > + if (!c->superspeed) > + continue; > + } else if (hs) { > if (!c->highspeed) > continue; > } else { > @@ -423,6 +559,55 @@ static int count_configs(struct usb_composite_dev > *cdev, unsigned type) > return count; > } > > +/** > + * bos() - prepares the BOS (Binary Device Object) descriptor > + * and its device capabilities descriptors. The bos descriptor > + * should be supported by a Superspeed device. > + */ > +static int bos(struct usb_composite_dev *cdev) > +{ > + struct usb_bos_descriptor *bos = cdev->req->buf; > + struct usb_ext_cap_descriptor *usb_ext = NULL; > + struct ss_usb_cap_descriptor *ss_cap = NULL; > + > + bos->bLength = USB_DT_BOS_SIZE; > + bos->bDescriptorType = USB_DT_BOS; > + > + bos->wTotalLength = USB_DT_BOS_SIZE; > + bos->bNumDeviceCaps = 0; > + > + /* A SuperSpeed device shall include the USB2.0 extension descriptor and > + shall support LPM when operating in USB2.0 HS mode.*/ > + usb_ext = (struct usb_ext_cap_descriptor *) > + (cdev->req->buf+bos->wTotalLength); > + bos->bNumDeviceCaps++; > + bos->wTotalLength += USB_DT_USB_EXT_CAP_SIZE; > + usb_ext->bLength = USB_DT_USB_EXT_CAP_SIZE; > + usb_ext->bDescriptorType = USB_DT_DEVICE_CAPABILITY; > + usb_ext->bDevCapabilityType = USB_CAP_TYPE_EXT; > + usb_ext->bmAttributes = USB_LPM_SUPPORT; > + > + /* The Superspeed USB Capability descriptor shall be implemented by all > + Superspeed devices. */ > + ss_cap = (struct ss_usb_cap_descriptor *) > + (cdev->req->buf+bos->wTotalLength); > + bos->bNumDeviceCaps++; > + bos->wTotalLength += USB_DT_SS_USB_CAP_SIZE; > + ss_cap->bLength = USB_DT_SS_USB_CAP_SIZE; > + ss_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY; > + ss_cap->bDevCapabilityType = SS_USB_CAP_TYPE; > + ss_cap->bmAttributes = 0; /*LTM is not supported yet*/ > + ss_cap->wSpeedSupported = USB_LOW_SPEED_OPERATION | > + USB_FULL_SPEED_OPERATION | > + USB_HIGH_SPEED_OPERATION | > + USB_5GBPS_OPERATION; > + ss_cap->bFunctionalitySupport = USB_LOW_SPEED_OPERATION; > + ss_cap->bU1devExitLat = 0; > + ss_cap->bU2DevExitLat = 0; > + > + return bos->wTotalLength; > +} > + > static void device_qual(struct usb_composite_dev *cdev) > { > struct usb_qualifier_descriptor *qual = cdev->req->buf; > @@ -466,27 +651,40 @@ static int set_config(struct usb_composite_dev > *cdev, > unsigned power = gadget_is_otg(gadget) ? 8 : 100; > int tmp; > > - if (cdev->config) > - reset_config(cdev); > - > if (number) { > list_for_each_entry(c, &cdev->configs, list) { > if (c->bConfigurationValue == number) { > + /* Need to disable the FDs of the previous > + configuration */ > + if (cdev->config) > + reset_config(cdev); > result = 0; > break; > } > } > if (result < 0) > goto done; > - } else > + } else { /* Zero configuration value - need to reset the config */ > + if (cdev->config) > + reset_config(cdev); > result = 0; > + } > > INFO(cdev, "%s speed config #%d: %s\n", > ({ char *speed; > switch (gadget->speed) { > - case USB_SPEED_LOW: speed = "low"; break; > - case USB_SPEED_FULL: speed = "full"; break; > - case USB_SPEED_HIGH: speed = "high"; break; > + case USB_SPEED_LOW: > + speed = "low"; > + break; > + case USB_SPEED_FULL: > + speed = "full"; > + break; > + case USB_SPEED_HIGH: > + speed = "high"; > + break; > + case USB_SPEED_SUPER: > + speed = "super"; > + break; > default: speed = "?"; break; > } ; speed; }), number, c ? c->label : "unconfigured"); > > @@ -509,7 +707,9 @@ static int set_config(struct usb_composite_dev *cdev, > * function's setup callback instead of the current > * configuration's setup callback. > */ > - if (gadget->speed == USB_SPEED_HIGH) > + if (gadget->speed == USB_SPEED_SUPER) > + descriptors = f->ss_descriptors; > + else if (gadget->speed == USB_SPEED_HIGH) > descriptors = f->hs_descriptors; > else > descriptors = f->descriptors; > @@ -592,14 +792,14 @@ int usb_add_config(struct usb_composite_dev *cdev, > } else { > unsigned i; > > - DBG(cdev, "cfg %d/%p speeds:%s%s\n", > + DBG(cdev, "cfg %d/%p speeds:%s%s%s\n", > config->bConfigurationValue, config, > + config->superspeed ? " super" : "", > config->highspeed ? " high" : "", > config->fullspeed > ? (gadget_is_dualspeed(cdev->gadget) > ? " full" > - : " full/low") > - : ""); > + : " full/low") : ""); > > for (i = 0; i < MAX_CONFIG_INTERFACES; i++) { > struct usb_function *f = config->interface[i]; > @@ -851,6 +1051,7 @@ composite_setup(struct usb_gadget *gadget, const > struct usb_ctrlrequest *ctrl) > struct usb_composite_dev *cdev = get_gadget_data(gadget); > struct usb_request *req = cdev->req; > int value = -EOPNOTSUPP; > + int status = 0; > u16 w_index = le16_to_cpu(ctrl->wIndex); > u8 intf = w_index & 0xFF; > u16 w_value = le16_to_cpu(ctrl->wValue); > @@ -878,18 +1079,30 @@ composite_setup(struct usb_gadget *gadget, const > struct usb_ctrlrequest *ctrl) > case USB_DT_DEVICE: > cdev->desc.bNumConfigurations = > count_configs(cdev, USB_DT_DEVICE); > + cdev->desc.bMaxPacketSize0 = > + cdev->gadget->ep0->maxpacket; > + if (gadget->speed >= USB_SPEED_SUPER) > + cdev->desc.bcdUSB = cpu_to_le16(0x0300); > + else if ((gadget_is_superspeed(gadget)) && > + (gadget->speed <= USB_SPEED_HIGH)) > + cdev->desc.bcdUSB = cpu_to_le16(0x0210); > + > value = min(w_length, (u16) sizeof cdev->desc); > memcpy(req->buf, &cdev->desc, value); > break; > + > case USB_DT_DEVICE_QUALIFIER: > - if (!gadget_is_dualspeed(gadget)) > + if (!gadget_is_dualspeed(gadget) || > + gadget->speed >= USB_SPEED_SUPER) > break; > + > device_qual(cdev); > value = min_t(int, w_length, > sizeof(struct usb_qualifier_descriptor)); > break; > case USB_DT_OTHER_SPEED_CONFIG: > - if (!gadget_is_dualspeed(gadget)) > + if (!gadget_is_dualspeed(gadget) || > + gadget->speed >= USB_SPEED_SUPER) > break; > /* FALLTHROUGH */ > case USB_DT_CONFIG: > @@ -903,6 +1116,12 @@ composite_setup(struct usb_gadget *gadget, const > struct usb_ctrlrequest *ctrl) > if (value >= 0) > value = min(w_length, (u16) value); > break; > + case USB_DT_BOS: > + if (gadget_is_superspeed(gadget)) { > + value = bos(cdev); > + value = min(w_length, (u16) value); > + } > + break; > } > break; > > @@ -962,6 +1181,55 @@ composite_setup(struct usb_gadget *gadget, const > struct usb_ctrlrequest *ctrl) > *((u8 *)req->buf) = value; > value = min(w_length, (u16) 1); > break; > + > + /*USB 3.0 additions*/ > + /* Function driver should handle get_status request. If such cb > + wasn't supplied we respond with default value = 0 > + Note: FD should supply such cb only for the first interface > + of the function*/ > + case USB_REQ_GET_STATUS: > + if (!gadget_is_superspeed(gadget)) > + goto unknown; > + if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE)) > + goto unknown; > + value = 2; /*This is the length of the get_status reply*/ > + *((u16 *)req->buf) = 0; > + if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES) > + break; > + f = cdev->config->interface[intf]; > + if (!f) > + break; > + status = f->get_status ? f->get_status(f) : 0; > + if (status < 0) > + break; > + *((u16 *)req->buf) = status & 0x0000ffff; > + break; > + /*Function drivers should handle SetFeature(FUNCTION_SUSPEND) request. > + function_suspend cb should be supplied only for the first interface > + of the function*/ > + case USB_REQ_SET_FEATURE: > + if (!gadget_is_superspeed(gadget)) > + goto unknown; > + if (ctrl->bRequestType != (USB_DIR_IN | USB_RECIP_INTERFACE)) > + goto unknown; > + switch (w_value) { > + case USB_INTRF_FUNC_SUSPEND: > + if (!cdev->config || w_index >= MAX_CONFIG_INTERFACES) > + break; > + f = cdev->config->interface[intf]; > + if (!f) > + break; > + value = f->func_suspend ? f->func_suspend(f) : 0; > + if (value < 0) { > + ERROR(cdev, "func_suspend() returned " > + "error %d\n", value); > + value = 0; > + } > + break; > + default: > + break; > + } > + break; > default: > unknown: > VDBG(cdev, > @@ -1080,8 +1348,11 @@ composite_unbind(struct usb_gadget *gadget) > DBG(cdev, "unbind function '%s'/%p\n", > f->name, f); > f->unbind(c, f); > - /* may free memory for "f" */ > } > + /*Free memory allocated for ss descriptors*/ > + if (f->ss_desc_allocated && f->ss_descriptors) > + usb_free_descriptors(f->ss_descriptors); > + /* may free memory for "f" */ > } > list_del(&c->list); > if (c->unbind) { > @@ -1254,7 +1525,6 @@ composite_resume(struct usb_gadget *gadget) > > static struct usb_gadget_driver composite_driver = { > .speed = USB_SPEED_HIGH, > - > .bind = composite_bind, > .unbind = composite_unbind, > > @@ -1293,6 +1563,9 @@ int usb_composite_register(struct > usb_composite_driver *driver) > driver->name = "composite"; > composite_driver.function = (char *) driver->name; > composite_driver.driver.name = driver->name; > +#ifdef CONFIG_USB_GADGET_SUPERSPEED > + composite_driver.speed = USB_SPEED_SUPER; > +#endif /*CONFIG_USB_GADGET_SUPERSPEED*/ > composite = driver; > > return usb_gadget_register_driver(&composite_driver); > diff --git a/include/linux/usb/ch9.h b/include/linux/usb/ch9.h > index da2ed77..69e528a 100644 > --- a/include/linux/usb/ch9.h > +++ b/include/linux/usb/ch9.h > @@ -125,6 +125,20 @@ > > #define USB_ENDPOINT_HALT 0 /* IN/OUT will STALL */ > > +/** > + * New Feature Selectors as added by USB 3.0 > + * See USB 3.0 spec Table 9-6 > + */ > +#define USB_DEVICE_U1_ENABLE 48 /*enables the upstream port to > + initiate requests for transition > + into U1 state*/ > +#define USB_DEVICE_U2_ENABLE 49 /*enables the upstream port to > + initiate requests for transition > + into U2 state*/ > +#define USB_DEVICE_LTM_ENABLE 50 /*enables the devise to > send > + Latency tolerance messages.*/ > +#define USB_INTRF_FUNC_SUSPEND 0 /*function suspend*/ > + > > /** > * struct usb_ctrlrequest - SETUP data for a USB device control request > @@ -675,6 +689,7 @@ struct usb_bos_descriptor { > __u8 bNumDeviceCaps; > } __attribute__((packed)); > > +#define USB_DT_BOS_SIZE 5 > /*-------------------------------------------------------------------------*/ > > /* USB_DT_DEVICE_CAPABILITY: grouped with BOS */ > @@ -712,16 +727,51 @@ struct usb_wireless_cap_descriptor { /* Ultra Wide > Band */ > __u8 bReserved; > } __attribute__((packed)); > > +/*USB 2.0 Extension descriptor*/ > #define USB_CAP_TYPE_EXT 2 > - > struct usb_ext_cap_descriptor { /* Link Power Management */ > __u8 bLength; > __u8 bDescriptorType; > __u8 bDevCapabilityType; > - __u8 bmAttributes; > + __u32 bmAttributes; > #define USB_LPM_SUPPORT (1 << 1) /* supports LPM > */ > } __attribute__((packed)); > > +#define USB_DT_USB_EXT_CAP_SIZE 7 > + > +/*SuperSpeed USB Capability descriptor: Defines the set of SuperSpeed USB > + specific device level capabilities*/ > +#define SS_USB_CAP_TYPE 3 > +struct ss_usb_cap_descriptor { /* Link Power Management */ > + __u8 bLength; > + __u8 bDescriptorType; > + __u8 bDevCapabilityType; > + __u8 bmAttributes; > +#define USB_LTM_SUPPORT (1 << 1) /* supports LTM */ > + __u16 wSpeedSupported; > +#define USB_LOW_SPEED_OPERATION (1) /* Low speed operation > */ > +#define USB_FULL_SPEED_OPERATION (1 << 1) /* Full speed operation */ > +#define USB_HIGH_SPEED_OPERATION (1 << 2) /* High speed operation */ > +#define USB_5GBPS_OPERATION (1 << 3) /* Operation at 5Gbps */ > + __u8 bFunctionalitySupport; > + __u8 bU1devExitLat; > + __u16 bU2DevExitLat; > +} __attribute__((packed)); > + > +#define USB_DT_SS_USB_CAP_SIZE 10 > + > +/*Container ID Capability descriptor: Defines the instance unique ID used > to > + identify the instance across all operating modes*/ > +#define CONTAINER_ID_TYPE 4 > +struct ss_usb_container_id_descriptor { > + __u8 bLength; > + __u8 bDescriptorType; > + __u8 bDevCapabilityType; > + __u8 bReserved; > + __u8 ContainerID[16]; /*128-bit number*/ > +} __attribute__((packed)); > + > +#define USB_DT_SS_CONTN_ID_SIZE 20 > /*-------------------------------------------------------------------------*/ > > /* USB_DT_WIRELESS_ENDPOINT_COMP: companion descriptor associated with > diff --git a/include/linux/usb/composite.h b/include/linux/usb/composite.h > index c623bed..36ab1d0 100644 > --- a/include/linux/usb/composite.h > +++ b/include/linux/usb/composite.h > @@ -52,6 +52,18 @@ struct usb_configuration; > * @hs_descriptors: Table of high speed descriptors, using interface and > * string identifiers assigned during @bind(). If this pointer is null, > * the function will not be available at high speed. > + * @ss_descriptors: Table of super speed descriptors. If > + * wasnt supplied by the FD during @bind() and > + * !ss_not_capble, will be generated automaticly with > + * default values while working in superspeed mode. If this > + * pointer is null after initiation, the function will not > + * be available at super speed. > + * @ss_not_capable: This flag is used by the FD to indicate if > + * this function is SS capble. Meaning: if SS descriptors > + * weren't supplied by the FD, and the flag is set ss > + * descriptors will NOT be automatically generated > + * @ss_desc_allocated: This flag indicates whether the ss descriptors > were > + * dynamically allocated (and needs to be released). > * @config: assigned when @usb_add_function() is called; this is the > * configuration with which this function is associated. > * @bind: Before the gadget can register, all of its functions bind() to > the > @@ -70,6 +82,10 @@ struct usb_configuration; > * @setup: Used for interface-specific control requests. > * @suspend: Notifies functions when the host stops sending USB traffic. > * @resume: Notifies functions when the host restarts USB traffic. > + * @get_status: Returns function status as a reply to > + * GetStatus() request when the recepient is Interface. > + * @func_suspend: callback to be called when > + * SetFeature(FUNCTION_SUSPEND) is reseived > * > * A single USB function uses one or more interfaces, and should in most > * cases support operation at both full and high speeds. Each function > is > @@ -99,6 +115,10 @@ struct usb_function { > struct usb_gadget_strings **strings; > struct usb_descriptor_header **descriptors; > struct usb_descriptor_header **hs_descriptors; > + struct usb_descriptor_header **ss_descriptors; > + > + unsigned ss_desc_allocated:1; > + unsigned ss_not_capable:1; > > struct usb_configuration *config; > > @@ -125,6 +145,9 @@ struct usb_function { > void (*suspend)(struct usb_function *); > void (*resume)(struct usb_function *); > > + /* USB 3.0 additions */ > + int (*get_status)(struct usb_function *); > + int (*func_suspend)(struct usb_function *); > /* private: */ > /* internals */ > struct list_head list; > @@ -229,6 +252,7 @@ struct usb_configuration { > struct list_head list; > struct list_head functions; > u8 next_interface_id; > + unsigned superspeed:1; > unsigned highspeed:1; > unsigned fullspeed:1; > struct usb_function *interface[MAX_CONFIG_INTERFACES]; > diff --git a/include/linux/usb/gadget.h b/include/linux/usb/gadget.h > index bf7dc0b..40329b0 100644 > --- a/include/linux/usb/gadget.h > +++ b/include/linux/usb/gadget.h > @@ -139,6 +139,8 @@ struct usb_ep_ops { > * @desc:endpoint descriptor. this pointer set before endpoint is > enabled and > * remains valid until the endpoint is disabled; the data byte order > * is little-endian (usb-standard). > + * @comp_desc: In case of SuperSpeed support, this is the > + * endpoint companion descriptor that is used to configure the endpoint > * > * the bus controller driver lists all the general purpose endpoints in > * gadget->ep_list. the control endpoint (gadget->ep0) is not in that > list, > @@ -153,6 +155,7 @@ struct usb_ep { > unsigned maxpacket:16; > u8 bEndpointAddress; > struct usb_endpoint_descriptor *desc; > + struct usb_ss_ep_comp_descriptor *comp_desc; > }; > > /*-------------------------------------------------------------------------*/ > @@ -525,6 +528,22 @@ static inline int gadget_is_dualspeed(struct > usb_gadget *g) > } > > /** > + * gadget_is_superspeed - return true if the hardware handles > + * supperspeed > + */ > +static inline int gadget_is_superspeed(struct usb_gadget *g) > +{ > +#ifdef CONFIG_USB_GADGET_SUPERSPEED > + /* runtime test would check "g->is_superspeed" ... that might be > + * useful to work around hardware bugs, but is mostly pointless > + */ > + return 1; > +#else > + return 0; > +#endif > +} > + > +/** > * gadget_is_otg - return true iff the hardware is OTG-ready > * @g: controller that might have a Mini-AB connector > * > -- > 1.6.3.3 > > -- > Sent by an consultant of the Qualcomm Innovation Center, Inc. > The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum. > >
-- To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
