d/freebsd-skq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
118c173868
freebsd-skq/sys/dev/usb/template/usb_template.c
hselasky e399d78925 Resolve deadlock between device_detach() and usbd_do_request_flags() 
by reviving the SX control request lock and refining which lock
protects the common scratch area in "struct usb_device".

The SX control request lock was removed by r246759 because it caused a
lock order reversal with the USB enumeration lock inside
usbd_transfer_setup() as a function of r246616. It was thought that
reducing the number of locks would resolve the LOR, but because some
USB device drivers use usbd_do_request_flags() inside callback
functions, like in taskqueues, a deadlock may occur when these are
drained from device_detach(). By restoring the SX control request
lock usbd_do_request_flags() is allowed to complete its execution
when a USB device driver is detaching. By using the SX control request
lock to protect the scratch area, the LOR introduced by r246616 is
also resolved.

Bump the FreeBSD version while at it to force recompilation of all USB
kernel modules.

Found by:	avos@
MFC after:	1 week
2016-09-05 15:35:58 +00:00

1398 lines
35 KiB
C
Raw Blame History

/* $FreeBSD$ */
/*-
* Copyright (c) 2007 Hans Petter Selasky. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/
/*
* This file contains sub-routines to build up USB descriptors from
* USB templates.
*/
#ifdef USB_GLOBAL_INCLUDE_FILE
#include USB_GLOBAL_INCLUDE_FILE
#else
#include <sys/stdint.h>
#include <sys/stddef.h>
#include <sys/param.h>
#include <sys/queue.h>
#include <sys/types.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/bus.h>
#include <sys/module.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <sys/condvar.h>
#include <sys/sysctl.h>
#include <sys/sx.h>
#include <sys/unistd.h>
#include <sys/callout.h>
#include <sys/malloc.h>
#include <sys/priv.h>
#include <dev/usb/usb.h>
#include <dev/usb/usb_ioctl.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include "usbdevs.h"
#include <dev/usb/usb_cdc.h>
#include <dev/usb/usb_core.h>
#include <dev/usb/usb_dynamic.h>
#include <dev/usb/usb_busdma.h>
#include <dev/usb/usb_process.h>
#include <dev/usb/usb_device.h>
#define USB_DEBUG_VAR usb_debug
#include <dev/usb/usb_debug.h>
#include <dev/usb/usb_controller.h>
#include <dev/usb/usb_bus.h>
#include <dev/usb/usb_request.h>
#include <dev/usb/template/usb_template.h>
#endif /* USB_GLOBAL_INCLUDE_FILE */
MODULE_DEPEND(usb_template, usb, 1, 1, 1);
MODULE_VERSION(usb_template, 1);
/* function prototypes */
static void usb_make_raw_desc(struct usb_temp_setup *, const uint8_t *);
static void usb_make_endpoint_desc(struct usb_temp_setup *,
const struct usb_temp_endpoint_desc *);
static void usb_make_interface_desc(struct usb_temp_setup *,
const struct usb_temp_interface_desc *);
static void usb_make_config_desc(struct usb_temp_setup *,
const struct usb_temp_config_desc *);
static void usb_make_device_desc(struct usb_temp_setup *,
const struct usb_temp_device_desc *);
static uint8_t usb_hw_ep_match(const struct usb_hw_ep_profile *, uint8_t,
uint8_t);
static uint8_t usb_hw_ep_find_match(struct usb_hw_ep_scratch *,
struct usb_hw_ep_scratch_sub *, uint8_t);
static uint8_t usb_hw_ep_get_needs(struct usb_hw_ep_scratch *, uint8_t,
uint8_t);
static usb_error_t usb_hw_ep_resolve(struct usb_device *,
struct usb_descriptor *);
static const struct usb_temp_device_desc *usb_temp_get_tdd(struct usb_device *);
static void *usb_temp_get_device_desc(struct usb_device *);
static void *usb_temp_get_qualifier_desc(struct usb_device *);
static void *usb_temp_get_config_desc(struct usb_device *, uint16_t *,
uint8_t);
static const void *usb_temp_get_string_desc(struct usb_device *, uint16_t,
uint8_t);
static const void *usb_temp_get_vendor_desc(struct usb_device *,
const struct usb_device_request *, uint16_t *plen);
static const void *usb_temp_get_hub_desc(struct usb_device *);
static usb_error_t usb_temp_get_desc(struct usb_device *,
struct usb_device_request *, const void **, uint16_t *);
static usb_error_t usb_temp_setup_by_index(struct usb_device *,
uint16_t index);
static void usb_temp_init(void *);
/*------------------------------------------------------------------------*
* usb_make_raw_desc
*
* This function will insert a raw USB descriptor into the generated
* USB configuration.
*------------------------------------------------------------------------*/
static void
usb_make_raw_desc(struct usb_temp_setup *temp,
const uint8_t *raw)
{
void *dst;
uint8_t len;
/*
* The first byte of any USB descriptor gives the length.
*/
if (raw) {
len = raw[0];
if (temp->buf) {
dst = USB_ADD_BYTES(temp->buf, temp->size);
memcpy(dst, raw, len);
/* check if we have got a CDC union descriptor */
if ((raw[0] == sizeof(struct usb_cdc_union_descriptor)) &&
(raw[1] == UDESC_CS_INTERFACE) &&
(raw[2] == UDESCSUB_CDC_UNION)) {
struct usb_cdc_union_descriptor *ud = (void *)dst;
/* update the interface numbers */
ud->bMasterInterface +=
temp->bInterfaceNumber;
ud->bSlaveInterface[0] +=
temp->bInterfaceNumber;
}
/* check if we have got an interface association descriptor */
if ((raw[0] == sizeof(struct usb_interface_assoc_descriptor)) &&
(raw[1] == UDESC_IFACE_ASSOC)) {
struct usb_interface_assoc_descriptor *iad = (void *)dst;
/* update the interface number */
iad->bFirstInterface +=
temp->bInterfaceNumber;
}
/* check if we have got a call management descriptor */
if ((raw[0] == sizeof(struct usb_cdc_cm_descriptor)) &&
(raw[1] == UDESC_CS_INTERFACE) &&
(raw[2] == UDESCSUB_CDC_CM)) {
struct usb_cdc_cm_descriptor *ccd = (void *)dst;
/* update the interface number */
ccd->bDataInterface +=
temp->bInterfaceNumber;
}
}
temp->size += len;
}
}
/*------------------------------------------------------------------------*
* usb_make_endpoint_desc
*
* This function will generate an USB endpoint descriptor from the
* given USB template endpoint descriptor, which will be inserted into
* the USB configuration.
*------------------------------------------------------------------------*/
static void
usb_make_endpoint_desc(struct usb_temp_setup *temp,
const struct usb_temp_endpoint_desc *ted)
{
struct usb_endpoint_descriptor *ed;
const void **rd;
uint16_t old_size;
uint16_t mps;
uint8_t ea; /* Endpoint Address */
uint8_t et; /* Endpiont Type */
/* Reserve memory */
old_size = temp->size;
ea = (ted->bEndpointAddress & (UE_ADDR | UE_DIR_IN | UE_DIR_OUT));
et = (ted->bmAttributes & UE_XFERTYPE);
if (et == UE_ISOCHRONOUS) {
/* account for extra byte fields */
temp->size += sizeof(*ed) + 2;
} else {
temp->size += sizeof(*ed);
}
/* Scan all Raw Descriptors first */
rd = ted->ppRawDesc;
if (rd) {
while (*rd) {
usb_make_raw_desc(temp, *rd);
rd++;
}
}
if (ted->pPacketSize == NULL) {
/* not initialized */
temp->err = USB_ERR_INVAL;
return;
}
mps = ted->pPacketSize->mps[temp->usb_speed];
if (mps == 0) {
/* not initialized */
temp->err = USB_ERR_INVAL;
return;
} else if (mps == UE_ZERO_MPS) {
/* escape for Zero Max Packet Size */
mps = 0;
}
/*
* Fill out the real USB endpoint descriptor
* in case there is a buffer present:
*/
if (temp->buf) {
ed = USB_ADD_BYTES(temp->buf, old_size);
if (et == UE_ISOCHRONOUS)
ed->bLength = sizeof(*ed) + 2;
else
ed->bLength = sizeof(*ed);
ed->bDescriptorType = UDESC_ENDPOINT;
ed->bEndpointAddress = ea;
ed->bmAttributes = ted->bmAttributes;
USETW(ed->wMaxPacketSize, mps);
/* setup bInterval parameter */
if (ted->pIntervals &&
ted->pIntervals->bInterval[temp->usb_speed]) {
ed->bInterval =
ted->pIntervals->bInterval[temp->usb_speed];
} else {
switch (et) {
case UE_BULK:
case UE_CONTROL:
ed->bInterval = 0; /* not used */
break;
case UE_INTERRUPT:
switch (temp->usb_speed) {
case USB_SPEED_LOW:
case USB_SPEED_FULL:
ed->bInterval = 1; /* 1 ms */
break;
default:
ed->bInterval = 4; /* 1 ms */
break;
}
break;
default: /* UE_ISOCHRONOUS */
switch (temp->usb_speed) {
case USB_SPEED_LOW:
case USB_SPEED_FULL:
ed->bInterval = 1; /* 1 ms */
break;
default:
ed->bInterval = 1; /* 125 us */
break;
}
break;
}
}
}
temp->bNumEndpoints++;
}
/*------------------------------------------------------------------------*
* usb_make_interface_desc
*
* This function will generate an USB interface descriptor from the
* given USB template interface descriptor, which will be inserted
* into the USB configuration.
*------------------------------------------------------------------------*/
static void
usb_make_interface_desc(struct usb_temp_setup *temp,
const struct usb_temp_interface_desc *tid)
{
struct usb_interface_descriptor *id;
const struct usb_temp_endpoint_desc **ted;
const void **rd;
uint16_t old_size;
/* Reserve memory */
old_size = temp->size;
temp->size += sizeof(*id);
/* Update interface and alternate interface numbers */
if (tid->isAltInterface == 0) {
temp->bAlternateSetting = 0;
temp->bInterfaceNumber++;
} else {
temp->bAlternateSetting++;
}
/* Scan all Raw Descriptors first */
rd = tid->ppRawDesc;
if (rd) {
while (*rd) {
usb_make_raw_desc(temp, *rd);
rd++;
}
}
/* Reset some counters */
temp->bNumEndpoints = 0;
/* Scan all Endpoint Descriptors second */
ted = tid->ppEndpoints;
if (ted) {
while (*ted) {
usb_make_endpoint_desc(temp, *ted);
ted++;
}
}
/*
* Fill out the real USB interface descriptor
* in case there is a buffer present:
*/
if (temp->buf) {
id = USB_ADD_BYTES(temp->buf, old_size);
id->bLength = sizeof(*id);
id->bDescriptorType = UDESC_INTERFACE;
id->bInterfaceNumber = temp->bInterfaceNumber;
id->bAlternateSetting = temp->bAlternateSetting;
id->bNumEndpoints = temp->bNumEndpoints;
id->bInterfaceClass = tid->bInterfaceClass;
id->bInterfaceSubClass = tid->bInterfaceSubClass;
id->bInterfaceProtocol = tid->bInterfaceProtocol;
id->iInterface = tid->iInterface;
}
}
/*------------------------------------------------------------------------*
* usb_make_config_desc
*
* This function will generate an USB config descriptor from the given
* USB template config descriptor, which will be inserted into the USB
* configuration.
*------------------------------------------------------------------------*/
static void
usb_make_config_desc(struct usb_temp_setup *temp,
const struct usb_temp_config_desc *tcd)
{
struct usb_config_descriptor *cd;
const struct usb_temp_interface_desc **tid;
uint16_t old_size;
/* Reserve memory */
old_size = temp->size;
temp->size += sizeof(*cd);
/* Reset some counters */
temp->bInterfaceNumber = 0xFF;
temp->bAlternateSetting = 0;
/* Scan all the USB interfaces */
tid = tcd->ppIfaceDesc;
if (tid) {
while (*tid) {
usb_make_interface_desc(temp, *tid);
tid++;
}
}
/*
* Fill out the real USB config descriptor
* in case there is a buffer present:
*/
if (temp->buf) {
cd = USB_ADD_BYTES(temp->buf, old_size);
/* compute total size */
old_size = temp->size - old_size;
cd->bLength = sizeof(*cd);
cd->bDescriptorType = UDESC_CONFIG;
USETW(cd->wTotalLength, old_size);
cd->bNumInterface = temp->bInterfaceNumber + 1;
cd->bConfigurationValue = temp->bConfigurationValue;
cd->iConfiguration = tcd->iConfiguration;
cd->bmAttributes = tcd->bmAttributes;
cd->bMaxPower = tcd->bMaxPower;
cd->bmAttributes |= (UC_REMOTE_WAKEUP | UC_BUS_POWERED);
if (temp->self_powered) {
cd->bmAttributes |= UC_SELF_POWERED;
} else {
cd->bmAttributes &= ~UC_SELF_POWERED;
}
}
}
/*------------------------------------------------------------------------*
* usb_make_device_desc
*
* This function will generate an USB device descriptor from the
* given USB template device descriptor.
*------------------------------------------------------------------------*/
static void
usb_make_device_desc(struct usb_temp_setup *temp,
const struct usb_temp_device_desc *tdd)
{
struct usb_temp_data *utd;
const struct usb_temp_config_desc **tcd;
uint16_t old_size;
/* Reserve memory */
old_size = temp->size;
temp->size += sizeof(*utd);
/* Scan all the USB configs */
temp->bConfigurationValue = 1;
tcd = tdd->ppConfigDesc;
if (tcd) {
while (*tcd) {
usb_make_config_desc(temp, *tcd);
temp->bConfigurationValue++;
tcd++;
}
}
/*
* Fill out the real USB device descriptor
* in case there is a buffer present:
*/
if (temp->buf) {
utd = USB_ADD_BYTES(temp->buf, old_size);
/* Store a pointer to our template device descriptor */
utd->tdd = tdd;
/* Fill out USB device descriptor */
utd->udd.bLength = sizeof(utd->udd);
utd->udd.bDescriptorType = UDESC_DEVICE;
utd->udd.bDeviceClass = tdd->bDeviceClass;
utd->udd.bDeviceSubClass = tdd->bDeviceSubClass;
utd->udd.bDeviceProtocol = tdd->bDeviceProtocol;
USETW(utd->udd.idVendor, tdd->idVendor);
USETW(utd->udd.idProduct, tdd->idProduct);
USETW(utd->udd.bcdDevice, tdd->bcdDevice);
utd->udd.iManufacturer = tdd->iManufacturer;
utd->udd.iProduct = tdd->iProduct;
utd->udd.iSerialNumber = tdd->iSerialNumber;
utd->udd.bNumConfigurations = temp->bConfigurationValue - 1;
/*
* Fill out the USB device qualifier. Pretend that we
* don't support any other speeds by setting
* "bNumConfigurations" equal to zero. That saves us
* generating an extra set of configuration
* descriptors.
*/
utd->udq.bLength = sizeof(utd->udq);
utd->udq.bDescriptorType = UDESC_DEVICE_QUALIFIER;
utd->udq.bDeviceClass = tdd->bDeviceClass;
utd->udq.bDeviceSubClass = tdd->bDeviceSubClass;
utd->udq.bDeviceProtocol = tdd->bDeviceProtocol;
utd->udq.bNumConfigurations = 0;
USETW(utd->udq.bcdUSB, 0x0200);
utd->udq.bMaxPacketSize0 = 0;
switch (temp->usb_speed) {
case USB_SPEED_LOW:
USETW(utd->udd.bcdUSB, 0x0110);
utd->udd.bMaxPacketSize = 8;
break;
case USB_SPEED_FULL:
USETW(utd->udd.bcdUSB, 0x0110);
utd->udd.bMaxPacketSize = 32;
break;
case USB_SPEED_HIGH:
USETW(utd->udd.bcdUSB, 0x0200);
utd->udd.bMaxPacketSize = 64;
break;
case USB_SPEED_VARIABLE:
USETW(utd->udd.bcdUSB, 0x0250);
utd->udd.bMaxPacketSize = 255; /* 512 bytes */
break;
case USB_SPEED_SUPER:
USETW(utd->udd.bcdUSB, 0x0300);
utd->udd.bMaxPacketSize = 9; /* 2**9 = 512 bytes */
break;
default:
temp->err = USB_ERR_INVAL;
break;
}
}
}
/*------------------------------------------------------------------------*
* usb_hw_ep_match
*
* Return values:
* 0: The endpoint profile does not match the criteria
* Else: The endpoint profile matches the criteria
*------------------------------------------------------------------------*/
static uint8_t
usb_hw_ep_match(const struct usb_hw_ep_profile *pf,
uint8_t ep_type, uint8_t ep_dir_in)
{
if (ep_type == UE_CONTROL) {
/* special */
return (pf->support_control);
}
if ((pf->support_in && ep_dir_in) ||
(pf->support_out && !ep_dir_in)) {
if ((pf->support_interrupt && (ep_type == UE_INTERRUPT)) ||
(pf->support_isochronous && (ep_type == UE_ISOCHRONOUS)) ||
(pf->support_bulk && (ep_type == UE_BULK))) {
return (1);
}
}
return (0);
}
/*------------------------------------------------------------------------*
* usb_hw_ep_find_match
*
* This function is used to find the best matching endpoint profile
* for and endpoint belonging to an USB descriptor.
*
* Return values:
* 0: Success. Got a match.
* Else: Failure. No match.
*------------------------------------------------------------------------*/
static uint8_t
usb_hw_ep_find_match(struct usb_hw_ep_scratch *ues,
struct usb_hw_ep_scratch_sub *ep, uint8_t is_simplex)
{
const struct usb_hw_ep_profile *pf;
uint16_t distance;
uint16_t temp;
uint16_t max_frame_size;
uint8_t n;
uint8_t best_n;
uint8_t dir_in;
uint8_t dir_out;
distance = 0xFFFF;
best_n = 0;
if ((!ep->needs_in) && (!ep->needs_out)) {
return (0); /* we are done */
}
if (ep->needs_ep_type == UE_CONTROL) {
dir_in = 1;
dir_out = 1;
} else {
if (ep->needs_in) {
dir_in = 1;
dir_out = 0;
} else {
dir_in = 0;
dir_out = 1;
}
}
for (n = 1; n != (USB_EP_MAX / 2); n++) {
/* get HW endpoint profile */
(ues->methods->get_hw_ep_profile) (ues->udev, &pf, n);
if (pf == NULL) {
/* end of profiles */
break;
}
/* check if IN-endpoint is reserved */
if (dir_in || pf->is_simplex) {
if (ues->bmInAlloc[n / 8] & (1 << (n % 8))) {
/* mismatch */
continue;
}
}
/* check if OUT-endpoint is reserved */
if (dir_out || pf->is_simplex) {
if (ues->bmOutAlloc[n / 8] & (1 << (n % 8))) {
/* mismatch */
continue;
}
}
/* check simplex */
if (pf->is_simplex == is_simplex) {
/* mismatch */
continue;
}
/* check if HW endpoint matches */
if (!usb_hw_ep_match(pf, ep->needs_ep_type, dir_in)) {
/* mismatch */
continue;
}
/* get maximum frame size */
if (dir_in)
max_frame_size = pf->max_in_frame_size;
else
max_frame_size = pf->max_out_frame_size;
/* check if we have a matching profile */
if (max_frame_size >= ep->max_frame_size) {
temp = (max_frame_size - ep->max_frame_size);
if (distance > temp) {
distance = temp;
best_n = n;
ep->pf = pf;
}
}
}
/* see if we got a match */
if (best_n != 0) {
/* get the correct profile */
pf = ep->pf;
/* reserve IN-endpoint */
if (dir_in) {
ues->bmInAlloc[best_n / 8] |=
(1 << (best_n % 8));
ep->hw_endpoint_in = best_n | UE_DIR_IN;
ep->needs_in = 0;
}
/* reserve OUT-endpoint */
if (dir_out) {
ues->bmOutAlloc[best_n / 8] |=
(1 << (best_n % 8));
ep->hw_endpoint_out = best_n | UE_DIR_OUT;
ep->needs_out = 0;
}
return (0); /* got a match */
}
return (1); /* failure */
}
/*------------------------------------------------------------------------*
* usb_hw_ep_get_needs
*
* This function will figure out the type and number of endpoints
* which are needed for an USB configuration.
*
* Return values:
* 0: Success.
* Else: Failure.
*------------------------------------------------------------------------*/
static uint8_t
usb_hw_ep_get_needs(struct usb_hw_ep_scratch *ues,
uint8_t ep_type, uint8_t is_complete)
{
const struct usb_hw_ep_profile *pf;
struct usb_hw_ep_scratch_sub *ep_iface;
struct usb_hw_ep_scratch_sub *ep_curr;
struct usb_hw_ep_scratch_sub *ep_max;
struct usb_hw_ep_scratch_sub *ep_end;
struct usb_descriptor *desc;
struct usb_interface_descriptor *id;
struct usb_endpoint_descriptor *ed;
enum usb_dev_speed speed;
uint16_t wMaxPacketSize;
uint16_t temp;
uint8_t ep_no;
ep_iface = ues->ep_max;
ep_curr = ues->ep_max;
ep_end = ues->ep + USB_EP_MAX;
ep_max = ues->ep_max;
desc = NULL;
speed = usbd_get_speed(ues->udev);
repeat:
while ((desc = usb_desc_foreach(ues->cd, desc))) {
if ((desc->bDescriptorType == UDESC_INTERFACE) &&
(desc->bLength >= sizeof(*id))) {
id = (void *)desc;
if (id->bAlternateSetting == 0) {
/* going forward */
ep_iface = ep_max;
} else {
/* reset */
ep_curr = ep_iface;
}
}
if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
(desc->bLength >= sizeof(*ed))) {
ed = (void *)desc;
goto handle_endpoint_desc;
}
}
ues->ep_max = ep_max;
return (0);
handle_endpoint_desc:
temp = (ed->bmAttributes & UE_XFERTYPE);
if (temp == ep_type) {
if (ep_curr == ep_end) {
/* too many endpoints */
return (1); /* failure */
}
wMaxPacketSize = UGETW(ed->wMaxPacketSize);
if ((wMaxPacketSize & 0xF800) &&
(speed == USB_SPEED_HIGH)) {
/* handle packet multiplier */
temp = (wMaxPacketSize >> 11) & 3;
wMaxPacketSize &= 0x7FF;
if (temp == 1) {
wMaxPacketSize *= 2;
} else {
wMaxPacketSize *= 3;
}
}
/*
* Check if we have a fixed endpoint number, else the
* endpoint number is allocated dynamically:
*/
ep_no = (ed->bEndpointAddress & UE_ADDR);
if (ep_no != 0) {
/* get HW endpoint profile */
(ues->methods->get_hw_ep_profile)
(ues->udev, &pf, ep_no);
if (pf == NULL) {
/* HW profile does not exist - failure */
DPRINTFN(0, "Endpoint profile %u "
"does not exist\n", ep_no);
return (1);
}
/* reserve fixed endpoint number */
if (ep_type == UE_CONTROL) {
ues->bmInAlloc[ep_no / 8] |=
(1 << (ep_no % 8));
ues->bmOutAlloc[ep_no / 8] |=
(1 << (ep_no % 8));
if ((pf->max_in_frame_size < wMaxPacketSize) ||
(pf->max_out_frame_size < wMaxPacketSize)) {
DPRINTFN(0, "Endpoint profile %u "
"has too small buffer\n", ep_no);
return (1);
}
} else if (ed->bEndpointAddress & UE_DIR_IN) {
ues->bmInAlloc[ep_no / 8] |=
(1 << (ep_no % 8));
if (pf->max_in_frame_size < wMaxPacketSize) {
DPRINTFN(0, "Endpoint profile %u "
"has too small buffer\n", ep_no);
return (1);
}
} else {
ues->bmOutAlloc[ep_no / 8] |=
(1 << (ep_no % 8));
if (pf->max_out_frame_size < wMaxPacketSize) {
DPRINTFN(0, "Endpoint profile %u "
"has too small buffer\n", ep_no);
return (1);
}
}
} else if (is_complete) {
/* check if we have enough buffer space */
if (wMaxPacketSize >
ep_curr->max_frame_size) {
return (1); /* failure */
}
if (ed->bEndpointAddress & UE_DIR_IN) {
ed->bEndpointAddress =
ep_curr->hw_endpoint_in;
} else {
ed->bEndpointAddress =
ep_curr->hw_endpoint_out;
}
} else {
/* compute the maximum frame size */
if (ep_curr->max_frame_size < wMaxPacketSize) {
ep_curr->max_frame_size = wMaxPacketSize;
}
if (temp == UE_CONTROL) {
ep_curr->needs_in = 1;
ep_curr->needs_out = 1;
} else {
if (ed->bEndpointAddress & UE_DIR_IN) {
ep_curr->needs_in = 1;
} else {
ep_curr->needs_out = 1;
}
}
ep_curr->needs_ep_type = ep_type;
}
ep_curr++;
if (ep_max < ep_curr) {
ep_max = ep_curr;
}
}
goto repeat;
}
/*------------------------------------------------------------------------*
* usb_hw_ep_resolve
*
* This function will try to resolve endpoint requirements by the
* given endpoint profiles that the USB hardware reports.
*
* Return values:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
static usb_error_t
usb_hw_ep_resolve(struct usb_device *udev,
struct usb_descriptor *desc)
{
struct usb_hw_ep_scratch *ues;
struct usb_hw_ep_scratch_sub *ep;
const struct usb_hw_ep_profile *pf;
const struct usb_bus_methods *methods;
struct usb_device_descriptor *dd;
uint16_t mps;
if (desc == NULL)
return (USB_ERR_INVAL);
/* get bus methods */
methods = udev->bus->methods;
if (methods->get_hw_ep_profile == NULL)
return (USB_ERR_INVAL);
if (desc->bDescriptorType == UDESC_DEVICE) {
if (desc->bLength < sizeof(*dd))
return (USB_ERR_INVAL);
dd = (void *)desc;
/* get HW control endpoint 0 profile */
(methods->get_hw_ep_profile) (udev, &pf, 0);
if (pf == NULL) {
return (USB_ERR_INVAL);
}
if (!usb_hw_ep_match(pf, UE_CONTROL, 0)) {
DPRINTFN(0, "Endpoint 0 does not "
"support control\n");
return (USB_ERR_INVAL);
}
mps = dd->bMaxPacketSize;
if (udev->speed == USB_SPEED_FULL) {
/*
* We can optionally choose another packet size !
*/
while (1) {
/* check if "mps" is ok */
if (pf->max_in_frame_size >= mps) {
break;
}
/* reduce maximum packet size */
mps /= 2;
/* check if "mps" is too small */
if (mps < 8) {
return (USB_ERR_INVAL);
}
}
dd->bMaxPacketSize = mps;
} else {
/* We only have one choice */
if (mps == 255) {
mps = 512;
}
/* Check if we support the specified wMaxPacketSize */
if (pf->max_in_frame_size < mps) {
return (USB_ERR_INVAL);
}
}
return (0); /* success */
}
if (desc->bDescriptorType != UDESC_CONFIG)
return (USB_ERR_INVAL);
if (desc->bLength < sizeof(*(ues->cd)))
return (USB_ERR_INVAL);
ues = udev->scratch.hw_ep_scratch;
memset(ues, 0, sizeof(*ues));
ues->ep_max = ues->ep;
ues->cd = (void *)desc;
ues->methods = methods;
ues->udev = udev;
/* Get all the endpoints we need */
if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 0) ||
usb_hw_ep_get_needs(ues, UE_INTERRUPT, 0) ||
usb_hw_ep_get_needs(ues, UE_CONTROL, 0) ||
usb_hw_ep_get_needs(ues, UE_BULK, 0)) {
DPRINTFN(0, "Could not get needs\n");
return (USB_ERR_INVAL);
}
for (ep = ues->ep; ep != ues->ep_max; ep++) {
while (ep->needs_in || ep->needs_out) {
/*
* First try to use a simplex endpoint.
* Then try to use a duplex endpoint.
*/
if (usb_hw_ep_find_match(ues, ep, 1) &&
usb_hw_ep_find_match(ues, ep, 0)) {
DPRINTFN(0, "Could not find match\n");
return (USB_ERR_INVAL);
}
}
}
ues->ep_max = ues->ep;
/* Update all endpoint addresses */
if (usb_hw_ep_get_needs(ues, UE_ISOCHRONOUS, 1) ||
usb_hw_ep_get_needs(ues, UE_INTERRUPT, 1) ||
usb_hw_ep_get_needs(ues, UE_CONTROL, 1) ||
usb_hw_ep_get_needs(ues, UE_BULK, 1)) {
DPRINTFN(0, "Could not update endpoint address\n");
return (USB_ERR_INVAL);
}
return (0); /* success */
}
/*------------------------------------------------------------------------*
* usb_temp_get_tdd
*
* Returns:
* NULL: No USB template device descriptor found.
* Else: Pointer to the USB template device descriptor.
*------------------------------------------------------------------------*/
static const struct usb_temp_device_desc *
usb_temp_get_tdd(struct usb_device *udev)
{
if (udev->usb_template_ptr == NULL) {
return (NULL);
}
return (udev->usb_template_ptr->tdd);
}
/*------------------------------------------------------------------------*
* usb_temp_get_device_desc
*
* Returns:
* NULL: No USB device descriptor found.
* Else: Pointer to USB device descriptor.
*------------------------------------------------------------------------*/
static void *
usb_temp_get_device_desc(struct usb_device *udev)
{
struct usb_device_descriptor *dd;
if (udev->usb_template_ptr == NULL) {
return (NULL);
}
dd = &udev->usb_template_ptr->udd;
if (dd->bDescriptorType != UDESC_DEVICE) {
/* sanity check failed */
return (NULL);
}
return (dd);
}
/*------------------------------------------------------------------------*
* usb_temp_get_qualifier_desc
*
* Returns:
* NULL: No USB device_qualifier descriptor found.
* Else: Pointer to USB device_qualifier descriptor.
*------------------------------------------------------------------------*/
static void *
usb_temp_get_qualifier_desc(struct usb_device *udev)
{
struct usb_device_qualifier *dq;
if (udev->usb_template_ptr == NULL) {
return (NULL);
}
dq = &udev->usb_template_ptr->udq;
if (dq->bDescriptorType != UDESC_DEVICE_QUALIFIER) {
/* sanity check failed */
return (NULL);
}
return (dq);
}
/*------------------------------------------------------------------------*
* usb_temp_get_config_desc
*
* Returns:
* NULL: No USB config descriptor found.
* Else: Pointer to USB config descriptor having index "index".
*------------------------------------------------------------------------*/
static void *
usb_temp_get_config_desc(struct usb_device *udev,
uint16_t *pLength, uint8_t index)
{
struct usb_device_descriptor *dd;
struct usb_config_descriptor *cd;
uint16_t temp;
if (udev->usb_template_ptr == NULL) {
return (NULL);
}
dd = &udev->usb_template_ptr->udd;
cd = (void *)(udev->usb_template_ptr + 1);
if (index >= dd->bNumConfigurations) {
/* out of range */
return (NULL);
}
while (index--) {
if (cd->bDescriptorType != UDESC_CONFIG) {
/* sanity check failed */
return (NULL);
}
temp = UGETW(cd->wTotalLength);
cd = USB_ADD_BYTES(cd, temp);
}
if (pLength) {
*pLength = UGETW(cd->wTotalLength);
}
return (cd);
}
/*------------------------------------------------------------------------*
* usb_temp_get_vendor_desc
*
* Returns:
* NULL: No vendor descriptor found.
* Else: Pointer to a vendor descriptor.
*------------------------------------------------------------------------*/
static const void *
usb_temp_get_vendor_desc(struct usb_device *udev,
const struct usb_device_request *req, uint16_t *plen)
{
const struct usb_temp_device_desc *tdd;
tdd = usb_temp_get_tdd(udev);
if (tdd == NULL) {
return (NULL);
}
if (tdd->getVendorDesc == NULL) {
return (NULL);
}
return ((tdd->getVendorDesc) (req, plen));
}
/*------------------------------------------------------------------------*
* usb_temp_get_string_desc
*
* Returns:
* NULL: No string descriptor found.
* Else: Pointer to a string descriptor.
*------------------------------------------------------------------------*/
static const void *
usb_temp_get_string_desc(struct usb_device *udev,
uint16_t lang_id, uint8_t string_index)
{
const struct usb_temp_device_desc *tdd;
tdd = usb_temp_get_tdd(udev);
if (tdd == NULL) {
return (NULL);
}
if (tdd->getStringDesc == NULL) {
return (NULL);
}
return ((tdd->getStringDesc) (lang_id, string_index));
}
/*------------------------------------------------------------------------*
* usb_temp_get_hub_desc
*
* Returns:
* NULL: No USB HUB descriptor found.
* Else: Pointer to a USB HUB descriptor.
*------------------------------------------------------------------------*/
static const void *
usb_temp_get_hub_desc(struct usb_device *udev)
{
return (NULL); /* needs to be implemented */
}
/*------------------------------------------------------------------------*
* usb_temp_get_desc
*
* This function is a demultiplexer for local USB device side control
* endpoint requests.
*------------------------------------------------------------------------*/
static usb_error_t
usb_temp_get_desc(struct usb_device *udev, struct usb_device_request *req,
const void **pPtr, uint16_t *pLength)
{
const uint8_t *buf;
uint16_t len;
buf = NULL;
len = 0;
switch (req->bmRequestType) {
case UT_READ_DEVICE:
switch (req->bRequest) {
case UR_GET_DESCRIPTOR:
goto tr_handle_get_descriptor;
default:
goto tr_stalled;
}
case UT_READ_CLASS_DEVICE:
switch (req->bRequest) {
case UR_GET_DESCRIPTOR:
goto tr_handle_get_class_descriptor;
default:
goto tr_stalled;
}
default:
goto tr_stalled;
}
tr_handle_get_descriptor:
switch (req->wValue[1]) {
case UDESC_DEVICE:
if (req->wValue[0]) {
goto tr_stalled;
}
buf = usb_temp_get_device_desc(udev);
goto tr_valid;
case UDESC_DEVICE_QUALIFIER:
if (udev->speed != USB_SPEED_HIGH) {
goto tr_stalled;
}
if (req->wValue[0]) {
goto tr_stalled;
}
buf = usb_temp_get_qualifier_desc(udev);
goto tr_valid;
case UDESC_OTHER_SPEED_CONFIGURATION:
if (udev->speed != USB_SPEED_HIGH) {
goto tr_stalled;
}
case UDESC_CONFIG:
buf = usb_temp_get_config_desc(udev,
&len, req->wValue[0]);
goto tr_valid;
case UDESC_STRING:
buf = usb_temp_get_string_desc(udev,
UGETW(req->wIndex), req->wValue[0]);
goto tr_valid;
default:
goto tr_stalled;
}
tr_handle_get_class_descriptor:
if (req->wValue[0]) {
goto tr_stalled;
}
buf = usb_temp_get_hub_desc(udev);
goto tr_valid;
tr_valid:
if (buf == NULL)
goto tr_stalled;
if (len == 0)
len = buf[0];
*pPtr = buf;
*pLength = len;
return (0); /* success */
tr_stalled:
/* try to get a vendor specific descriptor */
len = 0;
buf = usb_temp_get_vendor_desc(udev, req, &len);
if (buf != NULL)
goto tr_valid;
*pPtr = NULL;
*pLength = 0;
return (0); /* we ignore failures */
}
/*------------------------------------------------------------------------*
* usb_temp_setup
*
* This function generates USB descriptors according to the given USB
* template device descriptor. It will also try to figure out the best
* matching endpoint addresses using the hardware endpoint profiles.
*
* Returns:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
usb_error_t
usb_temp_setup(struct usb_device *udev,
const struct usb_temp_device_desc *tdd)
{
struct usb_temp_setup *uts;
void *buf;
usb_error_t error;
uint8_t n;
uint8_t do_unlock;
/* be NULL safe */
if (tdd == NULL)
return (0);
/* Protect scratch area */
do_unlock = usbd_ctrl_lock(udev);
uts = udev->scratch.temp_setup;
memset(uts, 0, sizeof(*uts));
uts->usb_speed = udev->speed;
uts->self_powered = udev->flags.self_powered;
/* first pass */
usb_make_device_desc(uts, tdd);
if (uts->err) {
/* some error happened */
goto done;
}
/* sanity check */
if (uts->size == 0) {
uts->err = USB_ERR_INVAL;
goto done;
}
/* allocate zeroed memory */
uts->buf = usbd_alloc_config_desc(udev, uts->size);
/*
* Allow malloc() to return NULL regardless of M_WAITOK flag.
* This helps when porting the software to non-FreeBSD
* systems.
*/
if (uts->buf == NULL) {
/* could not allocate memory */
uts->err = USB_ERR_NOMEM;
goto done;
}
/* second pass */
uts->size = 0;
usb_make_device_desc(uts, tdd);
/*
* Store a pointer to our descriptors:
*/
udev->usb_template_ptr = uts->buf;
if (uts->err) {
/* some error happened during second pass */
goto done;
}
/*
* Resolve all endpoint addresses !
*/
buf = usb_temp_get_device_desc(udev);
uts->err = usb_hw_ep_resolve(udev, buf);
if (uts->err) {
DPRINTFN(0, "Could not resolve endpoints for "
"Device Descriptor, error = %s\n",
usbd_errstr(uts->err));
goto done;
}
for (n = 0;; n++) {
buf = usb_temp_get_config_desc(udev, NULL, n);
if (buf == NULL) {
break;
}
uts->err = usb_hw_ep_resolve(udev, buf);
if (uts->err) {
DPRINTFN(0, "Could not resolve endpoints for "
"Config Descriptor %u, error = %s\n", n,
usbd_errstr(uts->err));
goto done;
}
}
done:
error = uts->err;
if (error)
usb_temp_unsetup(udev);
if (do_unlock)
usbd_ctrl_unlock(udev);
return (error);
}
/*------------------------------------------------------------------------*
* usb_temp_unsetup
*
* This function frees any memory associated with the currently
* setup template, if any.
*------------------------------------------------------------------------*/
void
usb_temp_unsetup(struct usb_device *udev)
{
usbd_free_config_desc(udev, udev->usb_template_ptr);
udev->usb_template_ptr = NULL;
}
static usb_error_t
usb_temp_setup_by_index(struct usb_device *udev, uint16_t index)
{
usb_error_t err;
switch (index) {
case USB_TEMP_MSC:
err = usb_temp_setup(udev, &usb_template_msc);
break;
case USB_TEMP_CDCE:
err = usb_temp_setup(udev, &usb_template_cdce);
break;
case USB_TEMP_MTP:
err = usb_temp_setup(udev, &usb_template_mtp);
break;
case USB_TEMP_MODEM:
err = usb_temp_setup(udev, &usb_template_modem);
break;
case USB_TEMP_AUDIO:
err = usb_temp_setup(udev, &usb_template_audio);
break;
case USB_TEMP_KBD:
err = usb_temp_setup(udev, &usb_template_kbd);
break;
case USB_TEMP_MOUSE:
err = usb_temp_setup(udev, &usb_template_mouse);
break;
case USB_TEMP_PHONE:
err = usb_temp_setup(udev, &usb_template_phone);
break;
case USB_TEMP_SERIALNET:
err = usb_temp_setup(udev, &usb_template_serialnet);
break;
case USB_TEMP_MIDI:
err = usb_temp_setup(udev, &usb_template_midi);
break;
default:
return (USB_ERR_INVAL);
}
return (err);
}
static void
usb_temp_init(void *arg)
{
/* register our functions */
usb_temp_get_desc_p = &usb_temp_get_desc;
usb_temp_setup_by_index_p = &usb_temp_setup_by_index;
usb_temp_unsetup_p = &usb_temp_unsetup;
}
SYSINIT(usb_temp_init, SI_SUB_LOCK, SI_ORDER_FIRST, usb_temp_init, NULL);
SYSUNINIT(usb_temp_unload, SI_SUB_LOCK, SI_ORDER_ANY, usb_temp_unload, NULL);
Reference in New Issue View Git Blame Copy Permalink