/*------------------------------------------------------------------------*
* usbd_get_page - lookup DMA-able memory for the given offset
*
* NOTE: Only call this function when the "page_cache" structure has
* been properly initialized !
*------------------------------------------------------------------------*/
void
usbd_get_page(struct usb_page_cache *pc, usb_frlength_t offset,
struct usb_page_search *res)
{
#if USB_HAVE_BUSDMA
struct usb_page *page;
if (pc->page_start) {
/* Case 1 - something has been loaded into DMA */
if (pc->buffer) {
/* Case 1a - Kernel Virtual Address */
res->buffer = USB_ADD_BYTES(pc->buffer, offset);
}
offset += pc->page_offset_buf;
/* compute destination page */
page = pc->page_start;
if (pc->ismultiseg) {
page += (offset / USB_PAGE_SIZE);
offset %= USB_PAGE_SIZE;
res->length = USB_PAGE_SIZE - offset;
res->physaddr = page->physaddr + offset;
} else {
res->length = (usb_size_t)-1;
res->physaddr = page->physaddr + offset;
}
if (!pc->buffer) {
/* Case 1b - Non Kernel Virtual Address */
res->buffer = USB_ADD_BYTES(page->buffer, offset);
}
return;
}
#endif
/* Case 2 - Plain PIO */
res->buffer = USB_ADD_BYTES(pc->buffer, offset);
res->length = (usb_size_t)-1;
#if USB_HAVE_BUSDMA
res->physaddr = 0;
#endif
}
/*------------------------------------------------------------------------*
* 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);
bcopy(raw, dst, 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;
}
}
temp->size += len;
}
}
/*------------------------------------------------------------------------*
* 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_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;
}
}
}
/*------------------------------------------------------------------------*
* usbd_copy_in - copy directly to DMA-able memory
*------------------------------------------------------------------------*/
void
usbd_copy_in(struct usb_page_cache *cache, usb_frlength_t offset,
const void *ptr, usb_frlength_t len)
{
struct usb_page_search buf_res;
while (len != 0) {
usbd_get_page(cache, offset, &buf_res);
if (buf_res.length > len) {
buf_res.length = len;
}
memcpy(buf_res.buffer, ptr, buf_res.length);
offset += buf_res.length;
len -= buf_res.length;
ptr = USB_ADD_BYTES(ptr, buf_res.length);
}
}
/*------------------------------------------------------------------------*
* usbd_copy_out - copy directly from DMA-able memory
*------------------------------------------------------------------------*/
void
usbd_copy_out(struct usb_page_cache *cache, usb_frlength_t offset,
void *ptr, usb_frlength_t len)
{
struct usb_page_search res;
while (len != 0) {
usbd_get_page(cache, offset, &res);
if (res.length > len) {
res.length = len;
}
memcpy(ptr, res.buffer, res.length);
offset += res.length;
len -= res.length;
ptr = USB_ADD_BYTES(ptr, res.length);
}
}
int
usbd_copy_out_user(struct usb_page_cache *cache, usb_frlength_t offset,
void *ptr, usb_frlength_t len)
{
struct usb_page_search res;
int error;
while (len != 0) {
usbd_get_page(cache, offset, &res);
if (res.length > len) {
res.length = len;
}
error = copyout(res.buffer, ptr, res.length);
if (error)
return (error);
offset += res.length;
len -= res.length;
ptr = USB_ADD_BYTES(ptr, res.length);
}
return (0); /* success */
}
int
usbd_copy_in_user(struct usb_page_cache *cache, usb_frlength_t offset,
const void *ptr, usb_frlength_t len)
{
struct usb_page_search buf_res;
int error;
while (len != 0) {
usbd_get_page(cache, offset, &buf_res);
if (buf_res.length > len) {
buf_res.length = len;
}
error = copyin(ptr, buf_res.buffer, buf_res.length);
if (error)
return (error);
offset += buf_res.length;
len -= buf_res.length;
ptr = USB_ADD_BYTES(ptr, buf_res.length);
}
return (0); /* success */
}
static int
ugen_fs_copy_out(struct usb_fifo *f, uint8_t ep_index)
{
struct usb_device_request *req;
struct usb_xfer *xfer;
struct usb_fs_endpoint fs_ep;
struct usb_fs_endpoint *fs_ep_uptr; /* userland ptr */
void *uaddr; /* userland ptr */
void *kaddr;
usb_frlength_t offset;
usb_frlength_t rem;
usb_frcount_t n;
uint32_t length;
uint32_t temp;
int error;
uint8_t isread;
if (ep_index >= f->fs_ep_max)
return (EINVAL);
xfer = f->fs_xfer[ep_index];
if (xfer == NULL)
return (EINVAL);
mtx_lock(f->priv_mtx);
if (usbd_transfer_pending(xfer)) {
mtx_unlock(f->priv_mtx);
return (EBUSY); /* should not happen */
}
mtx_unlock(f->priv_mtx);
fs_ep_uptr = f->fs_ep_ptr + ep_index;
error = copyin(fs_ep_uptr, &fs_ep, sizeof(fs_ep));
if (error) {
return (error);
}
fs_ep.status = xfer->error;
fs_ep.aFrames = xfer->aframes;
fs_ep.isoc_time_complete = xfer->isoc_time_complete;
if (xfer->error) {
goto complete;
}
if (xfer->flags_int.control_xfr) {
req = xfer->frbuffers[0].buffer;
/* Host mode only ! */
if ((req->bmRequestType & (UT_READ | UT_WRITE)) == UT_READ) {
isread = 1;
} else {
isread = 0;
}
if (xfer->nframes == 0)
n = 0; /* should never happen */
else
n = 1;
} else {
/* Device and Host mode */
if (USB_GET_DATA_ISREAD(xfer)) {
isread = 1;
} else {
isread = 0;
}
n = 0;
}
/* Update lengths and copy out data */
rem = usbd_xfer_max_len(xfer);
offset = 0;
for (; n != xfer->nframes; n++) {
/* get initial length into "temp" */
error = copyin(fs_ep.pLength + n,
&temp, sizeof(temp));
if (error) {
return (error);
}
if (temp > rem) {
/* the userland length has been corrupted */
DPRINTF("corrupt userland length "
"%u > %u\n", temp, rem);
fs_ep.status = USB_ERR_INVAL;
goto complete;
}
rem -= temp;
/* get actual transfer length */
length = xfer->frlengths[n];
if (length > temp) {
/* data overflow */
fs_ep.status = USB_ERR_INVAL;
DPRINTF("data overflow %u > %u\n",
length, temp);
goto complete;
}
if (isread) {
/* we need to know the destination buffer */
error = copyin(fs_ep.ppBuffer + n,
&uaddr, sizeof(uaddr));
if (error) {
return (error);
}
if (xfer->flags_int.isochronous_xfr) {
/* only one frame buffer */
kaddr = USB_ADD_BYTES(
xfer->frbuffers[0].buffer, offset);
} else {
/* multiple frame buffers */
kaddr = xfer->frbuffers[n].buffer;
}
/* move data */
error = copyout(kaddr, uaddr, length);
if (error) {
return (error);
}
}
/*
* Update offset according to initial length, which is
* needed by isochronous transfers!
*/
offset += temp;
/* update length */
error = copyout(&length,
fs_ep.pLength + n, sizeof(length));
if (error) {
return (error);
}
}
complete:
/* update "aFrames" */
error = copyout(&fs_ep.aFrames, &fs_ep_uptr->aFrames,
sizeof(fs_ep.aFrames));
if (error)
goto done;
/* update "isoc_time_complete" */
error = copyout(&fs_ep.isoc_time_complete,
&fs_ep_uptr->isoc_time_complete,
sizeof(fs_ep.isoc_time_complete));
if (error)
goto done;
/* update "status" */
error = copyout(&fs_ep.status, &fs_ep_uptr->status,
sizeof(fs_ep.status));
done:
return (error);
}
static int
ugen_fs_copy_in(struct usb_fifo *f, uint8_t ep_index)
{
struct usb_device_request *req;
struct usb_xfer *xfer;
struct usb_fs_endpoint fs_ep;
void *uaddr; /* userland pointer */
void *kaddr;
usb_frlength_t offset;
usb_frlength_t rem;
usb_frcount_t n;
uint32_t length;
int error;
uint8_t isread;
if (ep_index >= f->fs_ep_max) {
return (EINVAL);
}
xfer = f->fs_xfer[ep_index];
if (xfer == NULL) {
return (EINVAL);
}
mtx_lock(f->priv_mtx);
if (usbd_transfer_pending(xfer)) {
mtx_unlock(f->priv_mtx);
return (EBUSY); /* should not happen */
}
mtx_unlock(f->priv_mtx);
error = copyin(f->fs_ep_ptr +
ep_index, &fs_ep, sizeof(fs_ep));
if (error) {
return (error);
}
/* security checks */
if (fs_ep.nFrames > xfer->max_frame_count) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
if (fs_ep.nFrames == 0) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
error = copyin(fs_ep.ppBuffer,
&uaddr, sizeof(uaddr));
if (error) {
return (error);
}
/* reset first frame */
usbd_xfer_set_frame_offset(xfer, 0, 0);
if (xfer->flags_int.control_xfr) {
req = xfer->frbuffers[0].buffer;
error = copyin(fs_ep.pLength,
&length, sizeof(length));
if (error) {
return (error);
}
if (length != sizeof(*req)) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
if (length != 0) {
error = copyin(uaddr, req, length);
if (error) {
return (error);
}
}
if (ugen_check_request(f->udev, req)) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
usbd_xfer_set_frame_len(xfer, 0, length);
/* Host mode only ! */
if ((req->bmRequestType &
(UT_READ | UT_WRITE)) == UT_READ) {
isread = 1;
} else {
isread = 0;
}
n = 1;
offset = sizeof(*req);
} else {
/* Device and Host mode */
if (USB_GET_DATA_ISREAD(xfer)) {
isread = 1;
} else {
isread = 0;
}
n = 0;
offset = 0;
}
rem = usbd_xfer_max_len(xfer);
xfer->nframes = fs_ep.nFrames;
xfer->timeout = fs_ep.timeout;
if (xfer->timeout > 65535) {
xfer->timeout = 65535;
}
if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)
xfer->flags.short_xfer_ok = 1;
else
xfer->flags.short_xfer_ok = 0;
if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)
xfer->flags.short_frames_ok = 1;
else
xfer->flags.short_frames_ok = 0;
if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)
xfer->flags.force_short_xfer = 1;
else
xfer->flags.force_short_xfer = 0;
if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)
usbd_xfer_set_stall(xfer);
else
xfer->flags.stall_pipe = 0;
for (; n != xfer->nframes; n++) {
error = copyin(fs_ep.pLength + n,
&length, sizeof(length));
if (error) {
break;
}
usbd_xfer_set_frame_len(xfer, n, length);
if (length > rem) {
xfer->error = USB_ERR_INVAL;
goto complete;
}
rem -= length;
if (!isread) {
/* we need to know the source buffer */
error = copyin(fs_ep.ppBuffer + n,
&uaddr, sizeof(uaddr));
if (error) {
break;
}
if (xfer->flags_int.isochronous_xfr) {
/* get kernel buffer address */
kaddr = xfer->frbuffers[0].buffer;
kaddr = USB_ADD_BYTES(kaddr, offset);
} else {
/* set current frame offset */
usbd_xfer_set_frame_offset(xfer, offset, n);
/* get kernel buffer address */
kaddr = xfer->frbuffers[n].buffer;
}
/* move data */
error = copyin(uaddr, kaddr, length);
if (error) {
break;
}
}
offset += length;
}
return (error);
complete:
mtx_lock(f->priv_mtx);
ugen_fs_set_complete(f, ep_index);
mtx_unlock(f->priv_mtx);
return (0);
}
/*------------------------------------------------------------------------*
* usb_handle_request
*
* Internal state sequence:
*
* USB_HR_NOT_COMPLETE -> USB_HR_COMPLETE_OK v USB_HR_COMPLETE_ERR
*
* Returns:
* 0: Ready to start hardware
* Else: Stall current transfer, if any
*------------------------------------------------------------------------*/
static usb_error_t
usb_handle_request(struct usb_xfer *xfer)
{
struct usb_device_request req;
struct usb_device *udev;
const void *src_zcopy; /* zero-copy source pointer */
const void *src_mcopy; /* non zero-copy source pointer */
uint16_t off; /* data offset */
uint16_t rem; /* data remainder */
uint16_t max_len; /* max fragment length */
uint16_t wValue;
uint16_t wIndex;
uint8_t state;
uint8_t is_complete = 1;
usb_error_t err;
union {
uWord wStatus;
uint8_t buf[2];
} temp;
/*
* Filter the USB transfer state into
* something which we understand:
*/
switch (USB_GET_STATE(xfer)) {
case USB_ST_SETUP:
state = USB_HR_NOT_COMPLETE;
if (!xfer->flags_int.control_act) {
/* nothing to do */
goto tr_stalled;
}
break;
case USB_ST_TRANSFERRED:
if (!xfer->flags_int.control_act) {
state = USB_HR_COMPLETE_OK;
} else {
state = USB_HR_NOT_COMPLETE;
}
break;
default:
state = USB_HR_COMPLETE_ERR;
break;
}
/* reset frame stuff */
usbd_xfer_set_frame_len(xfer, 0, 0);
usbd_xfer_set_frame_offset(xfer, 0, 0);
usbd_xfer_set_frame_offset(xfer, sizeof(req), 1);
/* get the current request, if any */
usbd_copy_out(xfer->frbuffers, 0, &req, sizeof(req));
if (xfer->flags_int.control_rem == 0xFFFF) {
/* first time - not initialised */
rem = UGETW(req.wLength);
off = 0;
} else {
/* not first time - initialised */
rem = xfer->flags_int.control_rem;
off = UGETW(req.wLength) - rem;
}
/* set some defaults */
max_len = 0;
src_zcopy = NULL;
src_mcopy = NULL;
udev = xfer->xroot->udev;
/* get some request fields decoded */
wValue = UGETW(req.wValue);
wIndex = UGETW(req.wIndex);
DPRINTF("req 0x%02x 0x%02x 0x%04x 0x%04x "
"off=0x%x rem=0x%x, state=%d\n", req.bmRequestType,
req.bRequest, wValue, wIndex, off, rem, state);
/* demultiplex the control request */
switch (req.bmRequestType) {
case UT_READ_DEVICE:
if (state != USB_HR_NOT_COMPLETE) {
break;
}
switch (req.bRequest) {
case UR_GET_DESCRIPTOR:
goto tr_handle_get_descriptor;
case UR_GET_CONFIG:
goto tr_handle_get_config;
case UR_GET_STATUS:
goto tr_handle_get_status;
default:
goto tr_stalled;
}
break;
case UT_WRITE_DEVICE:
switch (req.bRequest) {
case UR_SET_ADDRESS:
goto tr_handle_set_address;
case UR_SET_CONFIG:
goto tr_handle_set_config;
case UR_CLEAR_FEATURE:
switch (wValue) {
case UF_DEVICE_REMOTE_WAKEUP:
goto tr_handle_clear_wakeup;
default:
goto tr_stalled;
}
break;
case UR_SET_FEATURE:
switch (wValue) {
case UF_DEVICE_REMOTE_WAKEUP:
goto tr_handle_set_wakeup;
default:
goto tr_stalled;
}
break;
default:
goto tr_stalled;
}
break;
case UT_WRITE_ENDPOINT:
switch (req.bRequest) {
case UR_CLEAR_FEATURE:
switch (wValue) {
case UF_ENDPOINT_HALT:
goto tr_handle_clear_halt;
default:
goto tr_stalled;
}
break;
case UR_SET_FEATURE:
switch (wValue) {
case UF_ENDPOINT_HALT:
goto tr_handle_set_halt;
default:
goto tr_stalled;
}
break;
default:
goto tr_stalled;
}
break;
case UT_READ_ENDPOINT:
switch (req.bRequest) {
case UR_GET_STATUS:
goto tr_handle_get_ep_status;
default:
goto tr_stalled;
}
break;
default:
/* we use "USB_ADD_BYTES" to de-const the src_zcopy */
err = usb_handle_iface_request(xfer,
USB_ADD_BYTES(&src_zcopy, 0),
&max_len, req, off, state);
if (err == 0) {
is_complete = 0;
goto tr_valid;
} else if (err == USB_ERR_SHORT_XFER) {
goto tr_valid;
}
/*
* Reset zero-copy pointer and max length
* variable in case they were unintentionally
* set:
*/
src_zcopy = NULL;
max_len = 0;
/*
* Check if we have a vendor specific
* descriptor:
*/
goto tr_handle_get_descriptor;
}
goto tr_valid;
tr_handle_get_descriptor:
err = (usb_temp_get_desc_p) (udev, &req, &src_zcopy, &max_len);
if (err)
goto tr_stalled;
if (src_zcopy == NULL)
goto tr_stalled;
goto tr_valid;
tr_handle_get_config:
temp.buf[0] = udev->curr_config_no;
src_mcopy = temp.buf;
max_len = 1;
goto tr_valid;
tr_handle_get_status:
wValue = 0;
USB_BUS_LOCK(udev->bus);
if (udev->flags.remote_wakeup) {
wValue |= UDS_REMOTE_WAKEUP;
}
if (udev->flags.self_powered) {
wValue |= UDS_SELF_POWERED;
}
USB_BUS_UNLOCK(udev->bus);
USETW(temp.wStatus, wValue);
src_mcopy = temp.wStatus;
max_len = sizeof(temp.wStatus);
goto tr_valid;
tr_handle_set_address:
if (state == USB_HR_NOT_COMPLETE) {
if (wValue >= 0x80) {
/* invalid value */
goto tr_stalled;
} else if (udev->curr_config_no != 0) {
/* we are configured ! */
goto tr_stalled;
}
} else if (state != USB_HR_NOT_COMPLETE) {
udev->address = (wValue & 0x7F);
goto tr_bad_context;
}
goto tr_valid;
tr_handle_set_config:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_config(xfer, req.wValue[0])) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_clear_halt:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_stall(xfer, req.wIndex[0], 0)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_clear_wakeup:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_remote_wakeup(xfer, 0)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_set_halt:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_set_stall(xfer, req.wIndex[0], 1)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_set_wakeup:
if (state == USB_HR_NOT_COMPLETE) {
if (usb_handle_remote_wakeup(xfer, 1)) {
goto tr_stalled;
}
}
goto tr_valid;
tr_handle_get_ep_status:
if (state == USB_HR_NOT_COMPLETE) {
temp.wStatus[0] =
usb_handle_get_stall(udev, req.wIndex[0]);
temp.wStatus[1] = 0;
src_mcopy = temp.wStatus;
max_len = sizeof(temp.wStatus);
}
goto tr_valid;
tr_valid:
if (state != USB_HR_NOT_COMPLETE) {
goto tr_stalled;
}
/* subtract offset from length */
max_len -= off;
/* Compute the real maximum data length */
if (max_len > xfer->max_data_length) {
max_len = usbd_xfer_max_len(xfer);
}
if (max_len > rem) {
max_len = rem;
}
/*
* If the remainder is greater than the maximum data length,
* we need to truncate the value for the sake of the
* comparison below:
*/
if (rem > xfer->max_data_length) {
rem = usbd_xfer_max_len(xfer);
}
if ((rem != max_len) && (is_complete != 0)) {
/*
* If we don't transfer the data we can transfer, then
* the transfer is short !
*/
xfer->flags.force_short_xfer = 1;
xfer->nframes = 2;
} else {
/*
* Default case
*/
xfer->flags.force_short_xfer = 0;
xfer->nframes = max_len ? 2 : 1;
}
if (max_len > 0) {
if (src_mcopy) {
src_mcopy = USB_ADD_BYTES(src_mcopy, off);
usbd_copy_in(xfer->frbuffers + 1, 0,
src_mcopy, max_len);
usbd_xfer_set_frame_len(xfer, 1, max_len);
} else {
usbd_xfer_set_frame_data(xfer, 1,
USB_ADD_BYTES(src_zcopy, off), max_len);
}
} else {
/* the end is reached, send status */
xfer->flags.manual_status = 0;
usbd_xfer_set_frame_len(xfer, 1, 0);
}
DPRINTF("success\n");
return (0); /* success */
tr_stalled:
DPRINTF("%s\n", (state != USB_HR_NOT_COMPLETE) ?
"complete" : "stalled");
return (USB_ERR_STALLED);
tr_bad_context:
DPRINTF("bad context\n");
return (USB_ERR_BAD_CONTEXT);
}
/*------------------------------------------------------------------------*
* 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_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_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++;
}
/*------------------------------------------------------------------------*
* usbd_do_request_flags and usbd_do_request
*
* Description of arguments passed to these functions:
*
* "udev" - this is the "usb_device" structure pointer on which the
* request should be performed. It is possible to call this function
* in both Host Side mode and Device Side mode.
*
* "mtx" - if this argument is non-NULL the mutex pointed to by it
* will get dropped and picked up during the execution of this
* function, hence this function sometimes needs to sleep. If this
* argument is NULL it has no effect.
*
* "req" - this argument must always be non-NULL and points to an
* 8-byte structure holding the USB request to be done. The USB
* request structure has a bit telling the direction of the USB
* request, if it is a read or a write.
*
* "data" - if the "wLength" part of the structure pointed to by "req"
* is non-zero this argument must point to a valid kernel buffer which
* can hold at least "wLength" bytes. If "wLength" is zero "data" can
* be NULL.
*
* "flags" - here is a list of valid flags:
*
* o USB_SHORT_XFER_OK: allows the data transfer to be shorter than
* specified
*
* o USB_DELAY_STATUS_STAGE: allows the status stage to be performed
* at a later point in time. This is tunable by the "hw.usb.ss_delay"
* sysctl. This flag is mostly useful for debugging.
*
* o USB_USER_DATA_PTR: treat the "data" pointer like a userland
* pointer.
*
* "actlen" - if non-NULL the actual transfer length will be stored in
* the 16-bit unsigned integer pointed to by "actlen". This
* information is mostly useful when the "USB_SHORT_XFER_OK" flag is
* used.
*
* "timeout" - gives the timeout for the control transfer in
* milliseconds. A "timeout" value less than 50 milliseconds is
* treated like a 50 millisecond timeout. A "timeout" value greater
* than 30 seconds is treated like a 30 second timeout. This USB stack
* does not allow control requests without a timeout.
*
* NOTE: This function is thread safe. All calls to
* "usbd_do_request_flags" will be serialised by the use of an
* internal "sx_lock".
*
* Returns:
* 0: Success
* Else: Failure
*------------------------------------------------------------------------*/
usb_error_t
usbd_do_request_flags(struct usb_device *udev, struct mtx *mtx,
struct usb_device_request *req, void *data, uint16_t flags,
uint16_t *actlen, usb_timeout_t timeout)
{
usb_handle_req_t *hr_func;
struct usb_xfer *xfer;
const void *desc;
int err = 0;
usb_ticks_t start_ticks;
usb_ticks_t delta_ticks;
usb_ticks_t max_ticks;
uint16_t length;
uint16_t temp;
if (timeout < 50) {
/* timeout is too small */
timeout = 50;
}
if (timeout > 30000) {
/* timeout is too big */
timeout = 30000;
}
length = UGETW(req->wLength);
DPRINTFN(5, "udev=%p bmRequestType=0x%02x bRequest=0x%02x "
"wValue=0x%02x%02x wIndex=0x%02x%02x wLength=0x%02x%02x\n",
udev, req->bmRequestType, req->bRequest,
req->wValue[1], req->wValue[0],
req->wIndex[1], req->wIndex[0],
req->wLength[1], req->wLength[0]);
/* Check if the device is still alive */
if (udev->state < USB_STATE_POWERED) {
DPRINTF("usb device has gone\n");
return (USB_ERR_NOT_CONFIGURED);
}
/*
* Set "actlen" to a known value in case the caller does not
* check the return value:
*/
if (actlen)
*actlen = 0;
#if (USB_HAVE_USER_IO == 0)
if (flags & USB_USER_DATA_PTR)
return (USB_ERR_INVAL);
#endif
if (mtx) {
mtx_unlock(mtx);
if (mtx != &Giant) {
mtx_assert(mtx, MA_NOTOWNED);
}
}
/*
* Grab the default sx-lock so that serialisation
* is achieved when multiple threads are involved:
*/
sx_xlock(udev->default_sx);
hr_func = usbd_get_hr_func(udev);
if (hr_func != NULL) {
DPRINTF("Handle Request function is set\n");
desc = NULL;
temp = 0;
if (!(req->bmRequestType & UT_READ)) {
if (length != 0) {
DPRINTFN(1, "The handle request function "
"does not support writing data!\n");
err = USB_ERR_INVAL;
goto done;
}
}
/* The root HUB code needs the BUS lock locked */
USB_BUS_LOCK(udev->bus);
err = (hr_func) (udev, req, &desc, &temp);
USB_BUS_UNLOCK(udev->bus);
if (err)
goto done;
if (length > temp) {
if (!(flags & USB_SHORT_XFER_OK)) {
err = USB_ERR_SHORT_XFER;
goto done;
}
length = temp;
}
if (actlen)
*actlen = length;
if (length > 0) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
if (copyout(desc, data, length)) {
err = USB_ERR_INVAL;
goto done;
}
} else
#endif
bcopy(desc, data, length);
}
goto done; /* success */
}
/*
* Setup a new USB transfer or use the existing one, if any:
*/
usbd_default_transfer_setup(udev);
xfer = udev->default_xfer[0];
if (xfer == NULL) {
/* most likely out of memory */
err = USB_ERR_NOMEM;
goto done;
}
USB_XFER_LOCK(xfer);
if (flags & USB_DELAY_STATUS_STAGE)
xfer->flags.manual_status = 1;
else
xfer->flags.manual_status = 0;
if (flags & USB_SHORT_XFER_OK)
xfer->flags.short_xfer_ok = 1;
else
xfer->flags.short_xfer_ok = 0;
xfer->timeout = timeout;
start_ticks = ticks;
max_ticks = USB_MS_TO_TICKS(timeout);
usbd_copy_in(xfer->frbuffers, 0, req, sizeof(*req));
usbd_xfer_set_frame_len(xfer, 0, sizeof(*req));
xfer->nframes = 2;
while (1) {
temp = length;
if (temp > xfer->max_data_length) {
temp = usbd_xfer_max_len(xfer);
}
usbd_xfer_set_frame_len(xfer, 1, temp);
if (temp > 0) {
if (!(req->bmRequestType & UT_READ)) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
USB_XFER_UNLOCK(xfer);
err = usbd_copy_in_user(xfer->frbuffers + 1,
0, data, temp);
USB_XFER_LOCK(xfer);
if (err) {
err = USB_ERR_INVAL;
break;
}
} else
#endif
usbd_copy_in(xfer->frbuffers + 1,
0, data, temp);
}
xfer->nframes = 2;
} else {
if (xfer->frlengths[0] == 0) {
if (xfer->flags.manual_status) {
#if USB_DEBUG
int temp;
temp = usb_ss_delay;
if (temp > 5000) {
temp = 5000;
}
if (temp > 0) {
usb_pause_mtx(
xfer->xroot->xfer_mtx,
USB_MS_TO_TICKS(temp));
}
#endif
xfer->flags.manual_status = 0;
} else {
break;
}
}
xfer->nframes = 1;
}
usbd_transfer_start(xfer);
while (usbd_transfer_pending(xfer)) {
cv_wait(udev->default_cv,
xfer->xroot->xfer_mtx);
}
err = xfer->error;
if (err) {
break;
}
/* subtract length of SETUP packet, if any */
if (xfer->aframes > 0) {
xfer->actlen -= xfer->frlengths[0];
} else {
xfer->actlen = 0;
}
/* check for short packet */
if (temp > xfer->actlen) {
temp = xfer->actlen;
length = temp;
}
if (temp > 0) {
if (req->bmRequestType & UT_READ) {
#if USB_HAVE_USER_IO
if (flags & USB_USER_DATA_PTR) {
USB_XFER_UNLOCK(xfer);
err = usbd_copy_out_user(xfer->frbuffers + 1,
0, data, temp);
USB_XFER_LOCK(xfer);
if (err) {
err = USB_ERR_INVAL;
break;
}
} else
#endif
usbd_copy_out(xfer->frbuffers + 1,
0, data, temp);
}
}
/*
* Clear "frlengths[0]" so that we don't send the setup
* packet again:
*/
usbd_xfer_set_frame_len(xfer, 0, 0);
/* update length and data pointer */
length -= temp;
data = USB_ADD_BYTES(data, temp);
if (actlen) {
(*actlen) += temp;
}
/* check for timeout */
delta_ticks = ticks - start_ticks;
if (delta_ticks > max_ticks) {
if (!err) {
err = USB_ERR_TIMEOUT;
}
}
if (err) {
break;
}
}
if (err) {
/*
* Make sure that the control endpoint is no longer
* blocked in case of a non-transfer related error:
*/
usbd_transfer_stop(xfer);
}
USB_XFER_UNLOCK(xfer);
done:
sx_xunlock(udev->default_sx);
if (mtx) {
mtx_lock(mtx);
}
return ((usb_error_t)err);
}
