/*------------------------------------------------------------------------
* ugen_re_enumerate
*------------------------------------------------------------------------*/
static int
ugen_re_enumerate(struct usb_fifo *f)
{
struct usb_device *udev = f->udev;
int error;
/*
* This request can be useful for testing USB drivers:
*/
error = priv_check(curthread, PRIV_DRIVER);
if (error) {
return (error);
}
/* get the device unconfigured */
error = ugen_set_config(f, USB_UNCONFIG_INDEX);
if (error) {
return (error);
}
/* do a bus-reset */
mtx_lock(f->priv_mtx);
error = usbd_req_re_enumerate(udev, f->priv_mtx);
mtx_unlock(f->priv_mtx);
if (error) {
return (ENXIO);
}
/* restore configuration to index 0 */
error = ugen_set_config(f, 0);
if (error) {
return (error);
}
return (0);
}
void
ugen_attach(struct device *parent, struct device *self, void *aux)
{
struct ugen_softc *sc = (struct ugen_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *udev;
usbd_status err;
int conf;
sc->sc_udev = udev = uaa->device;
if (usbd_get_devcnt(udev) > 0)
sc->sc_secondary = 1;
if (!sc->sc_secondary) {
/* First set configuration index 0, the default one for ugen. */
err = usbd_set_config_index(udev, 0, 0);
if (err) {
printf("%s: setting configuration index 0 failed\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
}
conf = usbd_get_config_descriptor(udev)->bConfigurationValue;
/* Set up all the local state for this configuration. */
err = ugen_set_config(sc, conf);
if (err) {
printf("%s: setting configuration %d failed\n",
sc->sc_dev.dv_xname, conf);
usbd_deactivate(sc->sc_udev);
return;
}
}
static int
ugen_ioctl_post(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
{
union {
struct usb_interface_descriptor *idesc;
struct usb_alt_interface *ai;
struct usb_device_descriptor *ddesc;
struct usb_config_descriptor *cdesc;
struct usb_device_stats *stat;
struct usb_fs_init *pinit;
struct usb_fs_uninit *puninit;
uint32_t *ptime;
void *addr;
int *pint;
} u;
struct usb_device_descriptor *dtemp;
struct usb_config_descriptor *ctemp;
struct usb_interface *iface;
int error = 0;
uint8_t n;
u.addr = addr;
DPRINTFN(6, "cmd=0x%08lx\n", cmd);
switch (cmd) {
case USB_DISCOVER:
usb_needs_explore_all();
break;
case USB_SETDEBUG:
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
usb_debug = *(int *)addr;
break;
case USB_GET_CONFIG:
*(int *)addr = f->udev->curr_config_index;
break;
case USB_SET_CONFIG:
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
error = ugen_set_config(f, *(int *)addr);
break;
case USB_GET_ALTINTERFACE:
iface = usbd_get_iface(f->udev,
u.ai->uai_interface_index);
if (iface && iface->idesc) {
u.ai->uai_alt_index = iface->alt_index;
} else {
error = EINVAL;
}
break;
case USB_SET_ALTINTERFACE:
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
error = ugen_set_interface(f,
u.ai->uai_interface_index, u.ai->uai_alt_index);
break;
case USB_GET_DEVICE_DESC:
dtemp = usbd_get_device_descriptor(f->udev);
if (!dtemp) {
error = EIO;
break;
}
*u.ddesc = *dtemp;
break;
case USB_GET_CONFIG_DESC:
ctemp = usbd_get_config_descriptor(f->udev);
if (!ctemp) {
error = EIO;
break;
}
*u.cdesc = *ctemp;
break;
case USB_GET_FULL_DESC:
error = ugen_get_cdesc(f, addr);
break;
case USB_GET_STRING_DESC:
error = ugen_get_sdesc(f, addr);
break;
case USB_GET_IFACE_DRIVER:
error = ugen_get_iface_driver(f, addr);
break;
case USB_REQUEST:
case USB_DO_REQUEST:
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
error = ugen_do_request(f, addr);
break;
case USB_DEVICEINFO:
case USB_GET_DEVICEINFO:
error = usb_gen_fill_deviceinfo(f, addr);
break;
case USB_DEVICESTATS:
for (n = 0; n != 4; n++) {
u.stat->uds_requests_fail[n] =
f->udev->bus->stats_err.uds_requests[n];
u.stat->uds_requests_ok[n] =
f->udev->bus->stats_ok.uds_requests[n];
}
break;
case USB_DEVICEENUMERATE:
error = ugen_re_enumerate(f);
break;
case USB_GET_PLUGTIME:
*u.ptime = f->udev->plugtime;
break;
case USB_CLAIM_INTERFACE:
case USB_RELEASE_INTERFACE:
/* TODO */
break;
case USB_IFACE_DRIVER_ACTIVE:
/* TODO */
*u.pint = 0;
break;
case USB_IFACE_DRIVER_DETACH:
/* TODO */
error = priv_check(curthread, PRIV_DRIVER);
if (error) {
break;
}
error = EINVAL;
break;
case USB_SET_POWER_MODE:
error = ugen_set_power_mode(f, *u.pint);
break;
case USB_GET_POWER_MODE:
*u.pint = ugen_get_power_mode(f);
break;
case USB_SET_PORT_ENABLE:
error = ugen_do_port_feature(f,
*u.pint, 1, UHF_PORT_ENABLE);
break;
case USB_SET_PORT_DISABLE:
error = ugen_do_port_feature(f,
*u.pint, 0, UHF_PORT_ENABLE);
break;
case USB_FS_INIT:
/* verify input parameters */
if (u.pinit->pEndpoints == NULL) {
error = EINVAL;
break;
}
if (u.pinit->ep_index_max > 127) {
error = EINVAL;
break;
}
if (u.pinit->ep_index_max == 0) {
error = EINVAL;
break;
}
if (f->fs_xfer != NULL) {
error = EBUSY;
break;
}
if (f->dev_ep_index != 0) {
error = EINVAL;
break;
}
if (ugen_fifo_in_use(f, fflags)) {
error = EBUSY;
break;
}
error = usb_fifo_alloc_buffer(f, 1, u.pinit->ep_index_max);
if (error) {
break;
}
f->fs_xfer = malloc(sizeof(f->fs_xfer[0]) *
u.pinit->ep_index_max, M_USB, M_WAITOK | M_ZERO);
if (f->fs_xfer == NULL) {
usb_fifo_free_buffer(f);
error = ENOMEM;
break;
}
f->fs_ep_max = u.pinit->ep_index_max;
f->fs_ep_ptr = u.pinit->pEndpoints;
break;
case USB_FS_UNINIT:
if (u.puninit->dummy != 0) {
error = EINVAL;
break;
}
error = ugen_fs_uninit(f);
break;
default:
mtx_lock(f->priv_mtx);
error = ugen_iface_ioctl(f, cmd, addr, fflags);
mtx_unlock(f->priv_mtx);
break;
}
DPRINTFN(6, "error=%d\n", error);
return (error);
}
static int
ugen_set_power_mode(struct usb_fifo *f, int mode)
{
struct usb_device *udev = f->udev;
int err;
uint8_t old_mode;
if ((udev == NULL) ||
(udev->parent_hub == NULL)) {
return (EINVAL);
}
err = priv_check(curthread, PRIV_DRIVER);
if (err)
return (err);
/* get old power mode */
old_mode = udev->power_mode;
/* if no change, then just return */
if (old_mode == mode)
return (0);
switch (mode) {
case USB_POWER_MODE_OFF:
/* get the device unconfigured */
err = ugen_set_config(f, USB_UNCONFIG_INDEX);
if (err) {
DPRINTFN(0, "Could not unconfigure "
"device (ignored)\n");
}
/* clear port enable */
err = usbd_req_clear_port_feature(udev->parent_hub,
NULL, udev->port_no, UHF_PORT_ENABLE);
break;
case USB_POWER_MODE_ON:
case USB_POWER_MODE_SAVE:
break;
case USB_POWER_MODE_RESUME:
err = usbd_req_clear_port_feature(udev->parent_hub,
NULL, udev->port_no, UHF_PORT_SUSPEND);
mode = USB_POWER_MODE_SAVE;
break;
case USB_POWER_MODE_SUSPEND:
err = usbd_req_set_port_feature(udev->parent_hub,
NULL, udev->port_no, UHF_PORT_SUSPEND);
mode = USB_POWER_MODE_SAVE;
break;
default:
return (EINVAL);
}
if (err)
return (ENXIO); /* I/O failure */
/* if we are powered off we need to re-enumerate first */
if (old_mode == USB_POWER_MODE_OFF) {
err = ugen_re_enumerate(f);
if (err)
return (err);
}
/* set new power mode */
usbd_set_power_mode(udev, mode);
return (0); /* success */
}
static int
ugen_set_power_mode(struct usb_fifo *f, int mode)
{
struct usb_device *udev = f->udev;
int err;
uint8_t old_mode;
if ((udev == NULL) ||
(udev->parent_hub == NULL)) {
return (EINVAL);
}
err = priv_check(curthread, PRIV_DRIVER);
if (err)
return (err);
/* get old power mode */
old_mode = udev->power_mode;
/* if no change, then just return */
if (old_mode == mode)
return (0);
switch (mode) {
case USB_POWER_MODE_OFF:
/* get the device unconfigured */
err = ugen_set_config(f, USB_UNCONFIG_INDEX);
if (err) {
DPRINTFN(0, "Could not unconfigure "
"device (ignored)\n");
}
/* clear port enable */
err = usbd_req_clear_port_feature(udev->parent_hub,
NULL, udev->port_no, UHF_PORT_ENABLE);
break;
case USB_POWER_MODE_ON:
case USB_POWER_MODE_SAVE:
break;
case USB_POWER_MODE_RESUME:
#if USB_HAVE_POWERD
/* let USB-powerd handle resume */
USB_BUS_LOCK(udev->bus);
udev->pwr_save.write_refs++;
udev->pwr_save.last_xfer_time = ticks;
USB_BUS_UNLOCK(udev->bus);
/* set new power mode */
usbd_set_power_mode(udev, USB_POWER_MODE_SAVE);
/* wait for resume to complete */
usb_pause_mtx(NULL, hz / 4);
/* clear write reference */
USB_BUS_LOCK(udev->bus);
udev->pwr_save.write_refs--;
USB_BUS_UNLOCK(udev->bus);
#endif
mode = USB_POWER_MODE_SAVE;
break;
case USB_POWER_MODE_SUSPEND:
#if USB_HAVE_POWERD
/* let USB-powerd handle suspend */
USB_BUS_LOCK(udev->bus);
udev->pwr_save.last_xfer_time = ticks - (256 * hz);
USB_BUS_UNLOCK(udev->bus);
#endif
mode = USB_POWER_MODE_SAVE;
break;
default:
return (EINVAL);
}
if (err)
return (ENXIO); /* I/O failure */
/* if we are powered off we need to re-enumerate first */
if (old_mode == USB_POWER_MODE_OFF) {
if (udev->flags.usb_mode == USB_MODE_HOST) {
if (udev->re_enumerate_wait == 0)
udev->re_enumerate_wait = 1;
}
/* set power mode will wake up the explore thread */
}
/* set new power mode */
usbd_set_power_mode(udev, mode);
return (0); /* success */
}
int
ugen_do_ioctl(struct ugen_softc *sc, int endpt, u_long cmd,
caddr_t addr, int flag, struct proc *p)
{
struct ugen_endpoint *sce;
int err;
struct usbd_interface *iface;
struct usb_config_desc *cd;
usb_config_descriptor_t *cdesc;
struct usb_interface_desc *id;
usb_interface_descriptor_t *idesc;
struct usb_endpoint_desc *ed;
usb_endpoint_descriptor_t *edesc;
struct usb_alt_interface *ai;
struct usb_string_desc *si;
u_int8_t conf, alt;
DPRINTFN(5, ("ugenioctl: cmd=%08lx\n", cmd));
if (usbd_is_dying(sc->sc_udev))
return (EIO);
switch (cmd) {
case FIONBIO:
/* All handled in the upper FS layer. */
return (0);
case USB_SET_SHORT_XFER:
if (endpt == USB_CONTROL_ENDPOINT)
return (EINVAL);
/* This flag only affects read */
sce = &sc->sc_endpoints[endpt][IN];
if (sce == NULL || sce->pipeh == NULL)
return (EINVAL);
if (*(int *)addr)
sce->state |= UGEN_SHORT_OK;
else
sce->state &= ~UGEN_SHORT_OK;
return (0);
case USB_SET_TIMEOUT:
sce = &sc->sc_endpoints[endpt][IN];
if (sce == NULL)
return (EINVAL);
sce->timeout = *(int *)addr;
sce = &sc->sc_endpoints[endpt][OUT];
if (sce == NULL)
return (EINVAL);
sce->timeout = *(int *)addr;
return (0);
default:
break;
}
if (endpt != USB_CONTROL_ENDPOINT)
return (EINVAL);
switch (cmd) {
#ifdef UGEN_DEBUG
case USB_SETDEBUG:
ugendebug = *(int *)addr;
break;
#endif
case USB_GET_CONFIG:
err = usbd_get_config(sc->sc_udev, &conf);
if (err)
return (EIO);
*(int *)addr = conf;
break;
case USB_SET_CONFIG:
if (!(flag & FWRITE))
return (EPERM);
err = ugen_set_config(sc, *(int *)addr);
switch (err) {
case USBD_NORMAL_COMPLETION:
break;
case USBD_IN_USE:
return (EBUSY);
default:
return (EIO);
}
break;
case USB_GET_ALTINTERFACE:
ai = (struct usb_alt_interface *)addr;
err = usbd_device2interface_handle(sc->sc_udev,
ai->uai_interface_index, &iface);
if (err)
return (EINVAL);
idesc = usbd_get_interface_descriptor(iface);
if (idesc == NULL)
return (EIO);
ai->uai_alt_no = idesc->bAlternateSetting;
break;
case USB_SET_ALTINTERFACE:
if (!(flag & FWRITE))
return (EPERM);
ai = (struct usb_alt_interface *)addr;
err = usbd_device2interface_handle(sc->sc_udev,
ai->uai_interface_index, &iface);
if (err)
return (EINVAL);
err = ugen_set_interface(sc, ai->uai_interface_index,
ai->uai_alt_no);
if (err)
return (EINVAL);
break;
case USB_GET_NO_ALT:
ai = (struct usb_alt_interface *)addr;
cdesc = usbd_get_cdesc(sc->sc_udev, ai->uai_config_index, 0);
if (cdesc == NULL)
return (EINVAL);
idesc = usbd_find_idesc(cdesc, ai->uai_interface_index, 0);
if (idesc == NULL) {
free(cdesc, M_TEMP, 0);
return (EINVAL);
}
ai->uai_alt_no = usbd_get_no_alts(cdesc,
idesc->bInterfaceNumber);
free(cdesc, M_TEMP, 0);
break;
case USB_GET_DEVICE_DESC:
*(usb_device_descriptor_t *)addr =
*usbd_get_device_descriptor(sc->sc_udev);
break;
case USB_GET_CONFIG_DESC:
cd = (struct usb_config_desc *)addr;
cdesc = usbd_get_cdesc(sc->sc_udev, cd->ucd_config_index, 0);
if (cdesc == NULL)
return (EINVAL);
cd->ucd_desc = *cdesc;
free(cdesc, M_TEMP, 0);
break;
case USB_GET_INTERFACE_DESC:
id = (struct usb_interface_desc *)addr;
cdesc = usbd_get_cdesc(sc->sc_udev, id->uid_config_index, 0);
if (cdesc == NULL)
return (EINVAL);
if (id->uid_config_index == USB_CURRENT_CONFIG_INDEX &&
id->uid_alt_index == USB_CURRENT_ALT_INDEX)
alt = ugen_get_alt_index(sc, id->uid_interface_index);
else
alt = id->uid_alt_index;
idesc = usbd_find_idesc(cdesc, id->uid_interface_index, alt);
if (idesc == NULL) {
free(cdesc, M_TEMP, 0);
return (EINVAL);
}
id->uid_desc = *idesc;
free(cdesc, M_TEMP, 0);
break;
case USB_GET_ENDPOINT_DESC:
ed = (struct usb_endpoint_desc *)addr;
cdesc = usbd_get_cdesc(sc->sc_udev, ed->ued_config_index, 0);
if (cdesc == NULL)
return (EINVAL);
if (ed->ued_config_index == USB_CURRENT_CONFIG_INDEX &&
ed->ued_alt_index == USB_CURRENT_ALT_INDEX)
alt = ugen_get_alt_index(sc, ed->ued_interface_index);
else
alt = ed->ued_alt_index;
edesc = usbd_find_edesc(cdesc, ed->ued_interface_index,
alt, ed->ued_endpoint_index);
if (edesc == NULL) {
free(cdesc, M_TEMP, 0);
return (EINVAL);
}
ed->ued_desc = *edesc;
free(cdesc, M_TEMP, 0);
break;
case USB_GET_FULL_DESC:
{
int len;
struct iovec iov;
struct uio uio;
struct usb_full_desc *fd = (struct usb_full_desc *)addr;
int error;
cdesc = usbd_get_cdesc(sc->sc_udev, fd->ufd_config_index, &len);
if (cdesc == NULL)
return (EINVAL);
if (len > fd->ufd_size)
len = fd->ufd_size;
iov.iov_base = (caddr_t)fd->ufd_data;
iov.iov_len = len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_resid = len;
uio.uio_offset = 0;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_rw = UIO_READ;
uio.uio_procp = p;
error = uiomove((void *)cdesc, len, &uio);
free(cdesc, M_TEMP, 0);
return (error);
}
case USB_GET_STRING_DESC:
{
int len;
si = (struct usb_string_desc *)addr;
err = usbd_get_string_desc(sc->sc_udev, si->usd_string_index,
si->usd_language_id, &si->usd_desc, &len);
if (err)
return (EINVAL);
break;
}
case USB_DO_REQUEST:
{
struct usb_ctl_request *ur = (void *)addr;
int len = UGETW(ur->ucr_request.wLength);
struct iovec iov;
struct uio uio;
void *ptr = 0;
int error = 0;
if (!(flag & FWRITE))
return (EPERM);
/* Avoid requests that would damage the bus integrity. */
if ((ur->ucr_request.bmRequestType == UT_WRITE_DEVICE &&
ur->ucr_request.bRequest == UR_SET_ADDRESS) ||
(ur->ucr_request.bmRequestType == UT_WRITE_DEVICE &&
ur->ucr_request.bRequest == UR_SET_CONFIG) ||
(ur->ucr_request.bmRequestType == UT_WRITE_INTERFACE &&
ur->ucr_request.bRequest == UR_SET_INTERFACE))
return (EINVAL);
if (len < 0 || len > 32767)
return (EINVAL);
if (len != 0) {
iov.iov_base = (caddr_t)ur->ucr_data;
iov.iov_len = len;
uio.uio_iov = &iov;
uio.uio_iovcnt = 1;
uio.uio_resid = len;
uio.uio_offset = 0;
uio.uio_segflg = UIO_USERSPACE;
uio.uio_rw =
ur->ucr_request.bmRequestType & UT_READ ?
UIO_READ : UIO_WRITE;
uio.uio_procp = p;
ptr = malloc(len, M_TEMP, M_WAITOK);
if (uio.uio_rw == UIO_WRITE) {
error = uiomove(ptr, len, &uio);
if (error)
goto ret;
}
}
sce = &sc->sc_endpoints[endpt][IN];
err = usbd_do_request_flags(sc->sc_udev, &ur->ucr_request,
ptr, ur->ucr_flags, &ur->ucr_actlen, sce->timeout);
if (err) {
error = EIO;
goto ret;
}
/* Only if USBD_SHORT_XFER_OK is set. */
if (len > ur->ucr_actlen)
len = ur->ucr_actlen;
if (len != 0) {
if (uio.uio_rw == UIO_READ) {
error = uiomove(ptr, len, &uio);
if (error)
goto ret;
}
}
ret:
if (ptr)
free(ptr, M_TEMP, 0);
return (error);
}
case USB_GET_DEVICEINFO:
usbd_fill_deviceinfo(sc->sc_udev,
(struct usb_device_info *)addr, 1);
break;
default:
return (EINVAL);
}
return (0);
}
