static int
uhso_attach_bulkserial(struct uhso_softc *sc, struct usb_interface *iface,
int type)
{
usb_error_t uerr;
int tty;
/* Try attaching RD/WR/INTR first */
uerr = usbd_transfer_setup(sc->sc_udev,
&iface->idesc->bInterfaceNumber, sc->sc_xfer,
uhso_bs_config, UHSO_BULK_ENDPT_MAX, sc, &sc->sc_mtx);
if (uerr) {
/* Try only RD/WR */
uerr = usbd_transfer_setup(sc->sc_udev,
&iface->idesc->bInterfaceNumber, sc->sc_xfer,
uhso_bs_config, UHSO_BULK_ENDPT_MAX - 1, sc, &sc->sc_mtx);
}
if (uerr) {
UHSO_DPRINTF(0, "usbd_transfer_setup failed");
return (-1);
}
tty = uhso_alloc_tty(sc);
if (tty < 0) {
usbd_transfer_unsetup(sc->sc_xfer, UHSO_BULK_ENDPT_MAX);
return (ENOMEM);
}
sc->sc_tty[tty].ht_muxport = -1;
return (0);
}
/*
* Attach a multiplexed serial port
* Data is read/written with requests on the default control pipe. An interrupt
* endpoint returns when there is new data to be read.
*/
static int
uhso_attach_muxserial(struct uhso_softc *sc, struct usb_interface *iface,
int type)
{
struct usb_descriptor *desc;
int i, port, tty;
usb_error_t uerr;
/*
* The class specific interface (type 0x24) descriptor subtype field
* contains a bitmask that specifies which (and how many) ports that
* are available through this multiplexed serial port.
*/
desc = usbd_find_descriptor(sc->sc_udev, NULL,
iface->idesc->bInterfaceNumber, UDESC_CS_INTERFACE, 0xff, 0, 0);
if (desc == NULL) {
UHSO_DPRINTF(0, "Failed to find UDESC_CS_INTERFACE\n");
return (ENXIO);
}
UHSO_DPRINTF(1, "Mux port mask %x\n", desc->bDescriptorSubtype);
if (desc->bDescriptorSubtype == 0)
return (ENXIO);
/*
* The bitmask is one octet, loop through the number of
* bits that are set and create a TTY for each.
*/
for (i = 0; i < 8; i++) {
port = (1 << i);
if ((port & desc->bDescriptorSubtype) == port) {
UHSO_DPRINTF(2, "Found mux port %x (%d)\n", port, i);
tty = uhso_alloc_tty(sc);
if (tty < 0)
return (ENOMEM);
sc->sc_tty[tty].ht_muxport = i;
uerr = usbd_transfer_setup(sc->sc_udev,
&sc->sc_iface_index, sc->sc_tty[tty].ht_xfer,
uhso_ctrl_config, UHSO_CTRL_MAX, sc, &sc->sc_mtx);
if (uerr) {
device_printf(sc->sc_dev,
"Failed to setup control pipe: %s\n",
usbd_errstr(uerr));
return (ENXIO);
}
}
}
/* Setup the intr. endpoint */
uerr = usbd_transfer_setup(sc->sc_udev,
&iface->idesc->bInterfaceNumber, sc->sc_xfer,
uhso_mux_config, 1, sc, &sc->sc_mtx);
if (uerr)
return (ENXIO);
return (0);
}
static int
ugen_transfer_setup(struct usb_fifo *f,
const struct usb_config *setup, uint8_t n_setup)
{
struct usb_endpoint *ep = usb_fifo_softc(f);
struct usb_device *udev = f->udev;
uint8_t iface_index = ep->iface_index;
int error;
mtx_unlock(f->priv_mtx);
/*
* "usbd_transfer_setup()" can sleep so one needs to make a wrapper,
* exiting the mutex and checking things
*/
error = usbd_transfer_setup(udev, &iface_index, f->xfer,
setup, n_setup, f, f->priv_mtx);
if (error == 0) {
if (f->xfer[0]->nframes == 1) {
error = usb_fifo_alloc_buffer(f,
f->xfer[0]->max_data_length, 2);
} else {
error = usb_fifo_alloc_buffer(f,
f->xfer[0]->max_frame_size,
2 * f->xfer[0]->nframes);
}
if (error) {
usbd_transfer_unsetup(f->xfer, n_setup);
}
}
mtx_lock(f->priv_mtx);
return (error);
}
static usb_error_t
usbd_setup_endpoint_one(irp *ip, uint8_t ifidx, struct ndisusb_ep *ne,
struct usb_config *epconf)
{
device_t dev = IRP_NDIS_DEV(ip);
struct ndis_softc *sc = device_get_softc(dev);
struct usb_xfer *xfer;
usb_error_t status;
InitializeListHead(&ne->ne_active);
InitializeListHead(&ne->ne_pending);
KeInitializeSpinLock(&ne->ne_lock);
status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
epconf, 1, sc, &sc->ndisusb_mtx);
if (status != USB_ERR_NORMAL_COMPLETION) {
device_printf(dev, "couldn't setup xfer: %s\n",
usbd_errstr(status));
return (status);
}
xfer = ne->ne_xfer[0];
usbd_xfer_set_priv(xfer, ne);
return (status);
}
static int
uhso_attach_ifnet(struct uhso_softc *sc, struct usb_interface *iface, int type)
{
struct ifnet *ifp;
usb_error_t uerr;
struct sysctl_ctx_list *sctx;
struct sysctl_oid *soid;
unsigned int devunit;
uerr = usbd_transfer_setup(sc->sc_udev,
&iface->idesc->bInterfaceNumber, sc->sc_if_xfer,
uhso_ifnet_config, UHSO_IFNET_MAX, sc, &sc->sc_mtx);
if (uerr) {
UHSO_DPRINTF(0, "usbd_transfer_setup failed: %s\n",
usbd_errstr(uerr));
return (-1);
}
sc->sc_ifp = ifp = if_alloc(IFT_OTHER);
if (sc->sc_ifp == NULL) {
device_printf(sc->sc_dev, "if_alloc() failed\n");
return (-1);
}
callout_init_mtx(&sc->sc_c, &sc->sc_mtx, 0);
mtx_lock(&sc->sc_mtx);
callout_reset(&sc->sc_c, 1, uhso_if_rxflush, sc);
mtx_unlock(&sc->sc_mtx);
/*
* We create our own unit numbers for ifnet devices because the
* USB interface unit numbers can be at arbitrary positions yielding
* odd looking device names.
*/
devunit = alloc_unr(uhso_ifnet_unit);
if_initname(ifp, device_get_name(sc->sc_dev), devunit);
ifp->if_mtu = UHSO_MAX_MTU;
ifp->if_ioctl = uhso_if_ioctl;
ifp->if_init = uhso_if_init;
ifp->if_start = uhso_if_start;
ifp->if_output = uhso_if_output;
ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_NOARP;
ifp->if_softc = sc;
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
bpfattach(ifp, DLT_RAW, 0);
sctx = device_get_sysctl_ctx(sc->sc_dev);
soid = device_get_sysctl_tree(sc->sc_dev);
/* Unlocked read... */
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "netif",
CTLFLAG_RD, ifp->if_xname, 0, "Attached network interface");
return (0);
}
static usb_error_t
usbd_setup_endpoint(irp *ip, uint8_t ifidx,
struct usb_endpoint_descriptor *ep)
{
device_t dev = IRP_NDIS_DEV(ip);
struct ndis_softc *sc = device_get_softc(dev);
struct ndisusb_ep *ne;
struct usb_config cfg;
struct usb_xfer *xfer;
usb_error_t status;
/* check for non-supported transfer types */
if (UE_GET_XFERTYPE(ep->bmAttributes) == UE_CONTROL ||
UE_GET_XFERTYPE(ep->bmAttributes) == UE_ISOCHRONOUS) {
device_printf(dev, "%s: unsuppotted transfer types %#x\n",
__func__, UE_GET_XFERTYPE(ep->bmAttributes));
return (USB_ERR_INVAL);
}
ne = &sc->ndisusb_ep[NDISUSB_GET_ENDPT(ep->bEndpointAddress)];
InitializeListHead(&ne->ne_active);
InitializeListHead(&ne->ne_pending);
KeInitializeSpinLock(&ne->ne_lock);
ne->ne_dirin = UE_GET_DIR(ep->bEndpointAddress) >> 7;
memset(&cfg, 0, sizeof(struct usb_config));
cfg.type = UE_GET_XFERTYPE(ep->bmAttributes);
cfg.endpoint = UE_GET_ADDR(ep->bEndpointAddress);
cfg.direction = UE_GET_DIR(ep->bEndpointAddress);
cfg.callback = &usbd_non_isoc_callback;
cfg.bufsize = UGETW(ep->wMaxPacketSize);
cfg.flags.proxy_buffer = 1;
if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN)
cfg.flags.short_xfer_ok = 1;
status = usbd_transfer_setup(sc->ndisusb_dev, &ifidx, ne->ne_xfer,
&cfg, 1, sc, &sc->ndisusb_mtx);
if (status != USB_ERR_NORMAL_COMPLETION) {
device_printf(dev, "couldn't setup xfer: %s\n",
usbd_errstr(status));
return (status);
}
xfer = ne->ne_xfer[0];
usbd_xfer_set_priv(xfer, ne);
if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_IN)
usbd_xfer_set_timeout(xfer, NDISUSB_NO_TIMEOUT);
else {
if (UE_GET_XFERTYPE(ep->bmAttributes) == UE_BULK)
usbd_xfer_set_timeout(xfer, NDISUSB_TX_TIMEOUT);
else
usbd_xfer_set_timeout(xfer, NDISUSB_INTR_TIMEOUT);
}
return (status);
}
static int
ipheth_attach(device_t dev)
{
struct ipheth_softc *sc = device_get_softc(dev);
struct usb_ether *ue = &sc->sc_ue;
struct usb_attach_arg *uaa = device_get_ivars(dev);
int error;
sc->sc_iface_no = uaa->info.bIfaceIndex;
device_set_usb_desc(dev);
mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
error = usbd_set_alt_interface_index(uaa->device,
uaa->info.bIfaceIndex, IPHETH_ALT_INTFNUM);
if (error) {
device_printf(dev, "Cannot set alternate setting\n");
goto detach;
}
error = usbd_transfer_setup(uaa->device, &sc->sc_iface_no,
sc->sc_xfer, ipheth_config, IPHETH_N_TRANSFER, sc, &sc->sc_mtx);
if (error) {
device_printf(dev, "Cannot setup USB transfers\n");
goto detach;
}
ue->ue_sc = sc;
ue->ue_dev = dev;
ue->ue_udev = uaa->device;
ue->ue_mtx = &sc->sc_mtx;
ue->ue_methods = &ipheth_ue_methods;
error = ipheth_get_mac_addr(sc);
if (error) {
device_printf(dev, "Cannot get MAC address\n");
goto detach;
}
error = uether_ifattach(ue);
if (error) {
device_printf(dev, "could not attach interface\n");
goto detach;
}
return (0); /* success */
detach:
ipheth_detach(dev);
return (ENXIO); /* failure */
}
static int
g_modem_attach(device_t dev)
{
struct g_modem_softc *sc = device_get_softc(dev);
struct usb_attach_arg *uaa = device_get_ivars(dev);
int error;
uint8_t iface_index[2];
DPRINTFN(11, "\n");
device_set_usb_desc(dev);
lockinit(&sc->sc_lock, "g_modem", 0, 0);
usb_callout_init_mtx(&sc->sc_callout, &sc->sc_lock, 0);
usb_callout_init_mtx(&sc->sc_watchdog, &sc->sc_lock, 0);
sc->sc_mode = G_MODEM_MODE_SILENT;
iface_index[0] = uaa->info.bIfaceIndex;
iface_index[1] = uaa->info.bIfaceIndex + 1;
error = usbd_transfer_setup(uaa->device,
iface_index, sc->sc_xfer, g_modem_config,
G_MODEM_N_TRANSFER, sc, &sc->sc_lock);
if (error) {
DPRINTF("error=%s\n", usbd_errstr(error));
goto detach;
}
usbd_set_parent_iface(uaa->device, iface_index[1], iface_index[0]);
lockmgr(&sc->sc_lock, LK_EXCLUSIVE);
g_modem_timeout_reset(sc);
g_modem_watchdog_reset(sc);
lockmgr(&sc->sc_lock, LK_RELEASE);
return (0); /* success */
detach:
g_modem_detach(dev);
return (ENXIO); /* error */
}
static int
ugen_ioctl(struct usb_fifo *f, u_long cmd, void *addr, int fflags)
{
struct usb_config usb_config[1];
struct usb_device_request req;
union {
struct usb_fs_complete *pcomp;
struct usb_fs_start *pstart;
struct usb_fs_stop *pstop;
struct usb_fs_open *popen;
struct usb_fs_close *pclose;
struct usb_fs_clear_stall_sync *pstall;
void *addr;
} u;
struct usb_endpoint *ep;
struct usb_endpoint_descriptor *ed;
int error = 0;
uint8_t iface_index;
uint8_t isread;
uint8_t ep_index;
u.addr = addr;
DPRINTFN(6, "cmd=0x%08lx\n", cmd);
switch (cmd) {
case USB_FS_COMPLETE:
mtx_lock(f->priv_mtx);
error = ugen_fs_get_complete(f, &ep_index);
mtx_unlock(f->priv_mtx);
if (error) {
error = EBUSY;
break;
}
u.pcomp->ep_index = ep_index;
error = ugen_fs_copy_out(f, u.pcomp->ep_index);
break;
case USB_FS_START:
error = ugen_fs_copy_in(f, u.pstart->ep_index);
if (error) {
break;
}
mtx_lock(f->priv_mtx);
usbd_transfer_start(f->fs_xfer[u.pstart->ep_index]);
mtx_unlock(f->priv_mtx);
break;
case USB_FS_STOP:
if (u.pstop->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
mtx_lock(f->priv_mtx);
usbd_transfer_stop(f->fs_xfer[u.pstop->ep_index]);
mtx_unlock(f->priv_mtx);
break;
case USB_FS_OPEN:
if (u.popen->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.popen->ep_index] != NULL) {
error = EBUSY;
break;
}
if (u.popen->max_bufsize > USB_FS_MAX_BUFSIZE) {
u.popen->max_bufsize = USB_FS_MAX_BUFSIZE;
}
if (u.popen->max_frames > USB_FS_MAX_FRAMES) {
u.popen->max_frames = USB_FS_MAX_FRAMES;
break;
}
if (u.popen->max_frames == 0) {
error = EINVAL;
break;
}
ep = usbd_get_ep_by_addr(f->udev, u.popen->ep_no);
if (ep == NULL) {
error = EINVAL;
break;
}
ed = ep->edesc;
if (ed == NULL) {
error = ENXIO;
break;
}
iface_index = ep->iface_index;
bzero(usb_config, sizeof(usb_config));
usb_config[0].type = ed->bmAttributes & UE_XFERTYPE;
usb_config[0].endpoint = ed->bEndpointAddress & UE_ADDR;
usb_config[0].direction = ed->bEndpointAddress & (UE_DIR_OUT | UE_DIR_IN);
usb_config[0].interval = USB_DEFAULT_INTERVAL;
usb_config[0].flags.proxy_buffer = 1;
usb_config[0].callback = &ugen_default_fs_callback;
usb_config[0].timeout = 0; /* no timeout */
usb_config[0].frames = u.popen->max_frames;
usb_config[0].bufsize = u.popen->max_bufsize;
usb_config[0].usb_mode = USB_MODE_DUAL; /* both modes */
if (usb_config[0].type == UE_CONTROL) {
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
error = EINVAL;
break;
}
} else {
isread = ((usb_config[0].endpoint &
(UE_DIR_IN | UE_DIR_OUT)) == UE_DIR_IN);
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
isread = !isread;
}
/* check permissions */
if (isread) {
if (!(fflags & FREAD)) {
error = EPERM;
break;
}
} else {
if (!(fflags & FWRITE)) {
error = EPERM;
break;
}
}
}
error = usbd_transfer_setup(f->udev, &iface_index,
f->fs_xfer + u.popen->ep_index, usb_config, 1,
f, f->priv_mtx);
if (error == 0) {
/* update maximums */
u.popen->max_packet_length =
f->fs_xfer[u.popen->ep_index]->max_frame_size;
u.popen->max_bufsize =
f->fs_xfer[u.popen->ep_index]->max_data_length;
f->fs_xfer[u.popen->ep_index]->priv_fifo =
((uint8_t *)0) + u.popen->ep_index;
} else {
error = ENOMEM;
}
break;
case USB_FS_CLOSE:
if (u.pclose->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.pclose->ep_index] == NULL) {
error = EINVAL;
break;
}
usbd_transfer_unsetup(f->fs_xfer + u.pclose->ep_index, 1);
break;
case USB_FS_CLEAR_STALL_SYNC:
if (u.pstall->ep_index >= f->fs_ep_max) {
error = EINVAL;
break;
}
if (f->fs_xfer[u.pstall->ep_index] == NULL) {
error = EINVAL;
break;
}
if (f->udev->flags.usb_mode != USB_MODE_HOST) {
error = EINVAL;
break;
}
mtx_lock(f->priv_mtx);
error = usbd_transfer_pending(f->fs_xfer[u.pstall->ep_index]);
mtx_unlock(f->priv_mtx);
if (error) {
return (EBUSY);
}
ep = f->fs_xfer[u.pstall->ep_index]->endpoint;
/* setup a clear-stall packet */
req.bmRequestType = UT_WRITE_ENDPOINT;
req.bRequest = UR_CLEAR_FEATURE;
USETW(req.wValue, UF_ENDPOINT_HALT);
req.wIndex[0] = ep->edesc->bEndpointAddress;
req.wIndex[1] = 0;
USETW(req.wLength, 0);
error = usbd_do_request(f->udev, NULL, &req, NULL);
if (error == 0) {
usbd_clear_data_toggle(f->udev, ep);
} else {
error = ENXIO;
}
break;
default:
error = ENOIOCTL;
break;
}
DPRINTFN(6, "error=%d\n", error);
return (error);
}
static int
uhso_attach(device_t self)
{
struct uhso_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
struct usb_interface_descriptor *id;
struct sysctl_ctx_list *sctx;
struct sysctl_oid *soid;
struct sysctl_oid *tree = NULL, *tty_node;
struct ucom_softc *ucom;
struct uhso_tty *ht;
int i, error, port;
void *probe_f;
usb_error_t uerr;
char *desc;
sc->sc_dev = self;
sc->sc_udev = uaa->device;
mtx_init(&sc->sc_mtx, "uhso", NULL, MTX_DEF);
ucom_ref(&sc->sc_super_ucom);
sc->sc_ucom = NULL;
sc->sc_ttys = 0;
sc->sc_radio = 1;
id = usbd_get_interface_descriptor(uaa->iface);
sc->sc_ctrl_iface_no = id->bInterfaceNumber;
sc->sc_iface_no = uaa->info.bIfaceNum;
sc->sc_iface_index = uaa->info.bIfaceIndex;
/* Setup control pipe */
uerr = usbd_transfer_setup(uaa->device,
&sc->sc_iface_index, sc->sc_ctrl_xfer,
uhso_ctrl_config, UHSO_CTRL_MAX, sc, &sc->sc_mtx);
if (uerr) {
device_printf(self, "Failed to setup control pipe: %s\n",
usbd_errstr(uerr));
goto out;
}
if (USB_GET_DRIVER_INFO(uaa) == UHSO_STATIC_IFACE)
probe_f = uhso_probe_iface_static;
else if (USB_GET_DRIVER_INFO(uaa) == UHSO_AUTO_IFACE)
probe_f = uhso_probe_iface_auto;
else
goto out;
error = uhso_probe_iface(sc, uaa->info.bIfaceNum, probe_f);
if (error != 0)
goto out;
sctx = device_get_sysctl_ctx(sc->sc_dev);
soid = device_get_sysctl_tree(sc->sc_dev);
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "type",
CTLFLAG_RD, uhso_port[UHSO_IFACE_PORT(sc->sc_type)], 0,
"Port available at this interface");
SYSCTL_ADD_PROC(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "radio",
CTLTYPE_INT | CTLFLAG_RW, sc, 0, uhso_radio_sysctl, "I", "Enable radio");
/*
* The default interface description on most Option devices isn't
* very helpful. So we skip device_set_usb_desc and set the
* device description manually.
*/
device_set_desc_copy(self, uhso_port_type[UHSO_IFACE_PORT_TYPE(sc->sc_type)]);
/* Announce device */
device_printf(self, "<%s port> at <%s %s> on %s\n",
uhso_port_type[UHSO_IFACE_PORT_TYPE(sc->sc_type)],
usb_get_manufacturer(uaa->device),
usb_get_product(uaa->device),
device_get_nameunit(device_get_parent(self)));
if (sc->sc_ttys > 0) {
SYSCTL_ADD_INT(sctx, SYSCTL_CHILDREN(soid), OID_AUTO, "ports",
CTLFLAG_RD, &sc->sc_ttys, 0, "Number of attached serial ports");
tree = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(soid), OID_AUTO,
"port", CTLFLAG_RD, NULL, "Serial ports");
}
/*
* Loop through the number of found TTYs and create sysctl
* nodes for them.
*/
for (i = 0; i < sc->sc_ttys; i++) {
ht = &sc->sc_tty[i];
ucom = &sc->sc_ucom[i];
if (UHSO_IFACE_USB_TYPE(sc->sc_type) & UHSO_IF_MUX)
port = uhso_mux_port_map[ht->ht_muxport];
else
port = UHSO_IFACE_PORT_TYPE(sc->sc_type);
desc = uhso_port_type_sysctl[port];
tty_node = SYSCTL_ADD_NODE(sctx, SYSCTL_CHILDREN(tree), OID_AUTO,
desc, CTLFLAG_RD, NULL, "");
ht->ht_name[0] = 0;
if (sc->sc_ttys == 1)
snprintf(ht->ht_name, 32, "cuaU%d", ucom->sc_super->sc_unit);
else {
snprintf(ht->ht_name, 32, "cuaU%d.%d",
ucom->sc_super->sc_unit, ucom->sc_subunit);
}
desc = uhso_port_type[port];
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
"tty", CTLFLAG_RD, ht->ht_name, 0, "");
SYSCTL_ADD_STRING(sctx, SYSCTL_CHILDREN(tty_node), OID_AUTO,
"desc", CTLFLAG_RD, desc, 0, "");
if (bootverbose)
device_printf(sc->sc_dev,
"\"%s\" port at %s\n", desc, ht->ht_name);
}
return (0);
out:
uhso_detach(sc->sc_dev);
return (ENXIO);
}
static int
usie_attach(device_t self)
{
struct usie_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
struct ifnet *ifp;
struct usb_interface *iface;
struct usb_interface_descriptor *id;
struct usb_device_request req;
int err;
uint16_t fwattr;
uint8_t iface_index;
uint8_t ifidx;
uint8_t start;
device_set_usb_desc(self);
sc->sc_udev = uaa->device;
sc->sc_dev = self;
mtx_init(&sc->sc_mtx, "usie", MTX_NETWORK_LOCK, MTX_DEF);
TASK_INIT(&sc->sc_if_status_task, 0, usie_if_status_cb, sc);
TASK_INIT(&sc->sc_if_sync_task, 0, usie_if_sync_cb, sc);
usb_callout_init_mtx(&sc->sc_if_sync_ch, &sc->sc_mtx, 0);
mtx_lock(&sc->sc_mtx);
/* set power mode to D0 */
req.bmRequestType = UT_WRITE_VENDOR_DEVICE;
req.bRequest = USIE_POWER;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, 0);
if (usie_do_request(sc, &req, NULL)) {
mtx_unlock(&sc->sc_mtx);
goto detach;
}
/* read fw attr */
fwattr = 0;
req.bmRequestType = UT_READ_VENDOR_DEVICE;
req.bRequest = USIE_FW_ATTR;
USETW(req.wValue, 0);
USETW(req.wIndex, 0);
USETW(req.wLength, sizeof(fwattr));
if (usie_do_request(sc, &req, &fwattr)) {
mtx_unlock(&sc->sc_mtx);
goto detach;
}
mtx_unlock(&sc->sc_mtx);
/* check DHCP supports */
DPRINTF("fwattr=%x\n", fwattr);
if (!(fwattr & USIE_FW_DHCP)) {
device_printf(self, "DHCP is not supported. A firmware upgrade might be needed.\n");
}
/* find available interfaces */
sc->sc_nucom = 0;
for (ifidx = 0; ifidx < USIE_IFACE_MAX; ifidx++) {
iface = usbd_get_iface(uaa->device, ifidx);
if (iface == NULL)
break;
id = usbd_get_interface_descriptor(iface);
if ((id == NULL) || (id->bInterfaceClass != UICLASS_VENDOR))
continue;
/* setup Direct IP transfer */
if (id->bInterfaceNumber >= 7 && id->bNumEndpoints == 3) {
sc->sc_if_ifnum = id->bInterfaceNumber;
iface_index = ifidx;
DPRINTF("ifnum=%d, ifidx=%d\n",
sc->sc_if_ifnum, ifidx);
err = usbd_transfer_setup(uaa->device,
&iface_index, sc->sc_if_xfer, usie_if_config,
USIE_IF_N_XFER, sc, &sc->sc_mtx);
if (err == 0)
continue;
device_printf(self,
"could not allocate USB transfers on "
"iface_index=%d, err=%s\n",
iface_index, usbd_errstr(err));
goto detach;
}
/* setup ucom */
if (sc->sc_nucom >= USIE_UCOM_MAX)
continue;
usbd_set_parent_iface(uaa->device, ifidx,
uaa->info.bIfaceIndex);
DPRINTF("NumEndpoints=%d bInterfaceNumber=%d\n",
id->bNumEndpoints, id->bInterfaceNumber);
if (id->bNumEndpoints == 2) {
sc->sc_uc_xfer[sc->sc_nucom][0] = NULL;
start = 1;
} else
start = 0;
err = usbd_transfer_setup(uaa->device, &ifidx,
sc->sc_uc_xfer[sc->sc_nucom] + start,
usie_uc_config + start, USIE_UC_N_XFER - start,
&sc->sc_ucom[sc->sc_nucom], &sc->sc_mtx);
if (err != 0) {
DPRINTF("usbd_transfer_setup error=%s\n", usbd_errstr(err));
continue;
}
mtx_lock(&sc->sc_mtx);
for (; start < USIE_UC_N_XFER; start++)
usbd_xfer_set_stall(sc->sc_uc_xfer[sc->sc_nucom][start]);
mtx_unlock(&sc->sc_mtx);
sc->sc_uc_ifnum[sc->sc_nucom] = id->bInterfaceNumber;
sc->sc_nucom++; /* found a port */
}
if (sc->sc_nucom == 0) {
device_printf(self, "no comports found\n");
goto detach;
}
err = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom,
sc->sc_nucom, sc, &usie_uc_callback, &sc->sc_mtx);
if (err != 0) {
DPRINTF("ucom_attach failed\n");
goto detach;
}
DPRINTF("Found %d interfaces.\n", sc->sc_nucom);
/* setup ifnet (Direct IP) */
sc->sc_ifp = ifp = if_alloc(IFT_OTHER);
if (ifp == NULL) {
device_printf(self, "Could not allocate a network interface\n");
goto detach;
}
if_initname(ifp, "usie", device_get_unit(self));
ifp->if_softc = sc;
ifp->if_mtu = USIE_MTU_MAX;
ifp->if_flags |= IFF_NOARP;
ifp->if_init = usie_if_init;
ifp->if_ioctl = usie_if_ioctl;
ifp->if_start = usie_if_start;
ifp->if_output = usie_if_output;
IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);
ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;
IFQ_SET_READY(&ifp->if_snd);
if_attach(ifp);
bpfattach(ifp, DLT_RAW, 0);
if (fwattr & USIE_PM_AUTO) {
usbd_set_power_mode(uaa->device, USB_POWER_MODE_SAVE);
DPRINTF("enabling automatic suspend and resume\n");
} else {
usbd_set_power_mode(uaa->device, USB_POWER_MODE_ON);
DPRINTF("USB power is always ON\n");
}
DPRINTF("device attached\n");
return (0);
detach:
usie_detach(self);
return (ENOMEM);
}
static int
cdce_attach(device_t dev)
{
struct cdce_softc *sc = device_get_softc(dev);
struct usb_ether *ue = &sc->sc_ue;
struct usb_attach_arg *uaa = device_get_ivars(dev);
struct usb_interface *iface;
const struct usb_cdc_union_descriptor *ud;
const struct usb_interface_descriptor *id;
const struct usb_cdc_ethernet_descriptor *ued;
const struct usb_config *pcfg;
int error;
uint8_t i;
uint8_t data_iface_no;
char eaddr_str[5 * ETHER_ADDR_LEN]; /* approx */
sc->sc_flags = USB_GET_DRIVER_INFO(uaa);
sc->sc_ue.ue_udev = uaa->device;
device_set_usb_desc(dev);
mtx_init(&sc->sc_mtx, device_get_nameunit(dev), NULL, MTX_DEF);
ud = usbd_find_descriptor
(uaa->device, NULL, uaa->info.bIfaceIndex,
UDESC_CS_INTERFACE, 0 - 1, UDESCSUB_CDC_UNION, 0 - 1);
if ((ud == NULL) || (ud->bLength < sizeof(*ud)) ||
(sc->sc_flags & CDCE_FLAG_NO_UNION)) {
DPRINTFN(1, "No union descriptor!\n");
sc->sc_ifaces_index[0] = uaa->info.bIfaceIndex;
sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex;
goto alloc_transfers;
}
data_iface_no = ud->bSlaveInterface[0];
for (i = 0;; i++) {
iface = usbd_get_iface(uaa->device, i);
if (iface) {
id = usbd_get_interface_descriptor(iface);
if (id && (id->bInterfaceNumber == data_iface_no)) {
sc->sc_ifaces_index[0] = i;
sc->sc_ifaces_index[1] = uaa->info.bIfaceIndex;
usbd_set_parent_iface(uaa->device, i, uaa->info.bIfaceIndex);
break;
}
} else {
device_printf(dev, "no data interface found\n");
goto detach;
}
}
/*
* <quote>
*
* The Data Class interface of a networking device shall have
* a minimum of two interface settings. The first setting
* (the default interface setting) includes no endpoints and
* therefore no networking traffic is exchanged whenever the
* default interface setting is selected. One or more
* additional interface settings are used for normal
* operation, and therefore each includes a pair of endpoints
* (one IN, and one OUT) to exchange network traffic. Select
* an alternate interface setting to initialize the network
* aspects of the device and to enable the exchange of
* network traffic.
*
* </quote>
*
* Some devices, most notably cable modems, include interface
* settings that have no IN or OUT endpoint, therefore loop
* through the list of all available interface settings
* looking for one with both IN and OUT endpoints.
*/
alloc_transfers:
pcfg = cdce_config; /* Default Configuration */
for (i = 0; i != 32; i++) {
error = usbd_set_alt_interface_index(uaa->device,
sc->sc_ifaces_index[0], i);
if (error)
break;
#if CDCE_HAVE_NCM
if ((i == 0) && (cdce_ncm_init(sc) == 0))
pcfg = cdce_ncm_config;
#endif
error = usbd_transfer_setup(uaa->device,
sc->sc_ifaces_index, sc->sc_xfer,
pcfg, CDCE_N_TRANSFER, sc, &sc->sc_mtx);
if (error == 0)
break;
}
if (error || (i == 32)) {
device_printf(dev, "No valid alternate "
"setting found\n");
goto detach;
}
ued = usbd_find_descriptor
(uaa->device, NULL, uaa->info.bIfaceIndex,
UDESC_CS_INTERFACE, 0 - 1, UDESCSUB_CDC_ENF, 0 - 1);
if ((ued == NULL) || (ued->bLength < sizeof(*ued))) {
error = USB_ERR_INVAL;
} else {
error = usbd_req_get_string_any(uaa->device, NULL,
eaddr_str, sizeof(eaddr_str), ued->iMacAddress);
}
if (error) {
/* fake MAC address */
device_printf(dev, "faking MAC address\n");
sc->sc_ue.ue_eaddr[0] = 0x2a;
memcpy(&sc->sc_ue.ue_eaddr[1], &ticks, sizeof(uint32_t));
sc->sc_ue.ue_eaddr[5] = device_get_unit(dev);
} else {
memset(sc->sc_ue.ue_eaddr, 0, sizeof(sc->sc_ue.ue_eaddr));
for (i = 0; i != (ETHER_ADDR_LEN * 2); i++) {
char c = eaddr_str[i];
if ('0' <= c && c <= '9')
c -= '0';
else if (c != 0)
c -= 'A' - 10;
else
break;
c &= 0xf;
if ((i & 1) == 0)
c <<= 4;
sc->sc_ue.ue_eaddr[i / 2] |= c;
}
if (uaa->usb_mode == USB_MODE_DEVICE) {
/*
* Do not use the same MAC address like the peer !
*/
sc->sc_ue.ue_eaddr[5] ^= 0xFF;
}
}
ue->ue_sc = sc;
ue->ue_dev = dev;
ue->ue_udev = uaa->device;
ue->ue_mtx = &sc->sc_mtx;
ue->ue_methods = &cdce_ue_methods;
error = uether_ifattach(ue);
if (error) {
device_printf(dev, "could not attach interface\n");
goto detach;
}
return (0); /* success */
detach:
cdce_detach(dev);
return (ENXIO); /* failure */
}
static int
g_audio_attach(device_t dev)
{
struct g_audio_softc *sc = device_get_softc(dev);
struct usb_attach_arg *uaa = device_get_ivars(dev);
int error;
int i;
uint8_t iface_index[3];
DPRINTFN(11, "\n");
device_set_usb_desc(dev);
mtx_init(&sc->sc_mtx, "g_audio", NULL, MTX_DEF);
usb_callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
usb_callout_init_mtx(&sc->sc_watchdog, &sc->sc_mtx, 0);
sc->sc_mode = G_AUDIO_MODE_SILENT;
sc->sc_noise_rem = 1;
for (i = 0; i != G_AUDIO_FRAMES; i++) {
sc->sc_data_len[0][i] = G_AUDIO_BUFSIZE / G_AUDIO_FRAMES;
sc->sc_data_len[1][i] = G_AUDIO_BUFSIZE / G_AUDIO_FRAMES;
}
iface_index[0] = uaa->info.bIfaceIndex;
iface_index[1] = uaa->info.bIfaceIndex + 1;
iface_index[2] = uaa->info.bIfaceIndex + 2;
error = usbd_set_alt_interface_index(uaa->device, iface_index[1], 1);
if (error) {
DPRINTF("alt iface setting error=%s\n", usbd_errstr(error));
goto detach;
}
error = usbd_set_alt_interface_index(uaa->device, iface_index[2], 1);
if (error) {
DPRINTF("alt iface setting error=%s\n", usbd_errstr(error));
goto detach;
}
error = usbd_transfer_setup(uaa->device,
iface_index, sc->sc_xfer, g_audio_config,
G_AUDIO_N_TRANSFER, sc, &sc->sc_mtx);
if (error) {
DPRINTF("error=%s\n", usbd_errstr(error));
goto detach;
}
usbd_set_parent_iface(uaa->device, iface_index[1], iface_index[0]);
usbd_set_parent_iface(uaa->device, iface_index[2], iface_index[0]);
mtx_lock(&sc->sc_mtx);
usbd_transfer_start(sc->sc_xfer[G_AUDIO_ISOC0_RD]);
usbd_transfer_start(sc->sc_xfer[G_AUDIO_ISOC1_RD]);
usbd_transfer_start(sc->sc_xfer[G_AUDIO_ISOC0_WR]);
usbd_transfer_start(sc->sc_xfer[G_AUDIO_ISOC1_WR]);
g_audio_timeout_reset(sc);
g_audio_watchdog_reset(sc);
mtx_unlock(&sc->sc_mtx);
return (0); /* success */
detach:
g_audio_detach(dev);
return (ENXIO); /* error */
}
static int
ubt_attach(device_t dev)
{
struct usb_attach_arg *uaa = device_get_ivars(dev);
struct ubt_softc *sc = device_get_softc(dev);
struct usb_endpoint_descriptor *ed;
struct usb_interface_descriptor *id;
struct usb_interface *iface;
uint16_t wMaxPacketSize;
uint8_t alt_index, i, j;
uint8_t iface_index[2] = { 0, 1 };
device_set_usb_desc(dev);
sc->sc_dev = dev;
sc->sc_debug = NG_UBT_WARN_LEVEL;
/*
* Create Netgraph node
*/
if (ng_make_node_common(&typestruct, &sc->sc_node) != 0) {
UBT_ALERT(sc, "could not create Netgraph node\n");
return (ENXIO);
}
/* Name Netgraph node */
if (ng_name_node(sc->sc_node, device_get_nameunit(dev)) != 0) {
UBT_ALERT(sc, "could not name Netgraph node\n");
NG_NODE_UNREF(sc->sc_node);
return (ENXIO);
}
NG_NODE_SET_PRIVATE(sc->sc_node, sc);
NG_NODE_FORCE_WRITER(sc->sc_node);
/*
* Initialize device softc structure
*/
/* initialize locks */
mtx_init(&sc->sc_ng_mtx, "ubt ng", NULL, MTX_DEF);
mtx_init(&sc->sc_if_mtx, "ubt if", NULL, MTX_DEF | MTX_RECURSE);
/* initialize packet queues */
NG_BT_MBUFQ_INIT(&sc->sc_cmdq, UBT_DEFAULT_QLEN);
NG_BT_MBUFQ_INIT(&sc->sc_aclq, UBT_DEFAULT_QLEN);
NG_BT_MBUFQ_INIT(&sc->sc_scoq, UBT_DEFAULT_QLEN);
/* initialize glue task */
TASK_INIT(&sc->sc_task, 0, ubt_task, sc);
/*
* Configure Bluetooth USB device. Discover all required USB
* interfaces and endpoints.
*
* USB device must present two interfaces:
* 1) Interface 0 that has 3 endpoints
* 1) Interrupt endpoint to receive HCI events
* 2) Bulk IN endpoint to receive ACL data
* 3) Bulk OUT endpoint to send ACL data
*
* 2) Interface 1 then has 2 endpoints
* 1) Isochronous IN endpoint to receive SCO data
* 2) Isochronous OUT endpoint to send SCO data
*
* Interface 1 (with isochronous endpoints) has several alternate
* configurations with different packet size.
*/
/*
* For interface #1 search alternate settings, and find
* the descriptor with the largest wMaxPacketSize
*/
wMaxPacketSize = 0;
alt_index = 0;
i = 0;
j = 0;
ed = NULL;
/*
* Search through all the descriptors looking for the largest
* packet size:
*/
while ((ed = (struct usb_endpoint_descriptor *)usb_desc_foreach(
usbd_get_config_descriptor(uaa->device),
(struct usb_descriptor *)ed))) {
if ((ed->bDescriptorType == UDESC_INTERFACE) &&
(ed->bLength >= sizeof(*id))) {
id = (struct usb_interface_descriptor *)ed;
i = id->bInterfaceNumber;
j = id->bAlternateSetting;
}
if ((ed->bDescriptorType == UDESC_ENDPOINT) &&
(ed->bLength >= sizeof(*ed)) &&
(i == 1)) {
uint16_t temp;
temp = UGETW(ed->wMaxPacketSize);
if (temp > wMaxPacketSize) {
wMaxPacketSize = temp;
alt_index = j;
}
}
}
/* Set alt configuration on interface #1 only if we found it */
if (wMaxPacketSize > 0 &&
usbd_set_alt_interface_index(uaa->device, 1, alt_index)) {
UBT_ALERT(sc, "could not set alternate setting %d " \
"for interface 1!\n", alt_index);
goto detach;
}
/* Setup transfers for both interfaces */
if (usbd_transfer_setup(uaa->device, iface_index, sc->sc_xfer,
ubt_config, UBT_N_TRANSFER, sc, &sc->sc_if_mtx)) {
UBT_ALERT(sc, "could not allocate transfers\n");
goto detach;
}
/* Claim all interfaces belonging to the Bluetooth part */
for (i = 1;; i++) {
iface = usbd_get_iface(uaa->device, i);
if (iface == NULL)
break;
id = usbd_get_interface_descriptor(iface);
if ((id != NULL) &&
(id->bInterfaceClass == UICLASS_WIRELESS) &&
(id->bInterfaceSubClass == UISUBCLASS_RF) &&
(id->bInterfaceProtocol == UIPROTO_BLUETOOTH)) {
usbd_set_parent_iface(uaa->device, i,
uaa->info.bIfaceIndex);
}
}
return (0); /* success */
detach:
ubt_detach(dev);
return (ENXIO);
} /* ubt_attach */
static int
uhid_attach(device_t dev)
{
struct usb_attach_arg *uaa = device_get_ivars(dev);
struct uhid_softc *sc = device_get_softc(dev);
int unit = device_get_unit(dev);
int error = 0;
DPRINTFN(10, "sc=%p\n", sc);
device_set_usb_desc(dev);
mtx_init(&sc->sc_mtx, "uhid lock", NULL, MTX_DEF | MTX_RECURSE);
sc->sc_udev = uaa->device;
sc->sc_iface_no = uaa->info.bIfaceNum;
sc->sc_iface_index = uaa->info.bIfaceIndex;
error = usbd_transfer_setup(uaa->device,
&uaa->info.bIfaceIndex, sc->sc_xfer, uhid_config,
UHID_N_TRANSFER, sc, &sc->sc_mtx);
if (error) {
DPRINTF("error=%s\n", usbd_errstr(error));
goto detach;
}
if (uaa->info.idVendor == USB_VENDOR_WACOM) {
/* the report descriptor for the Wacom Graphire is broken */
if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE) {
sc->sc_repdesc_size = sizeof(uhid_graphire_report_descr);
sc->sc_repdesc_ptr = (void *)&uhid_graphire_report_descr;
sc->sc_flags |= UHID_FLAG_STATIC_DESC;
} else if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE3_4X5) {
static uint8_t reportbuf[] = {2, 2, 2};
/*
* The Graphire3 needs 0x0202 to be written to
* feature report ID 2 before it'll start
* returning digitizer data.
*/
error = usbd_req_set_report(uaa->device, NULL,
reportbuf, sizeof(reportbuf),
uaa->info.bIfaceIndex, UHID_FEATURE_REPORT, 2);
if (error) {
DPRINTF("set report failed, error=%s (ignored)\n",
usbd_errstr(error));
}
sc->sc_repdesc_size = sizeof(uhid_graphire3_4x5_report_descr);
sc->sc_repdesc_ptr = (void *)&uhid_graphire3_4x5_report_descr;
sc->sc_flags |= UHID_FLAG_STATIC_DESC;
}
} else if ((uaa->info.bInterfaceClass == UICLASS_VENDOR) &&
(uaa->info.bInterfaceSubClass == UISUBCLASS_XBOX360_CONTROLLER) &&
(uaa->info.bInterfaceProtocol == UIPROTO_XBOX360_GAMEPAD)) {
/* the Xbox 360 gamepad has no report descriptor */
sc->sc_repdesc_size = sizeof(uhid_xb360gp_report_descr);
sc->sc_repdesc_ptr = (void *)&uhid_xb360gp_report_descr;
sc->sc_flags |= UHID_FLAG_STATIC_DESC;
}
if (sc->sc_repdesc_ptr == NULL) {
error = usbd_req_get_hid_desc(uaa->device, NULL,
&sc->sc_repdesc_ptr, &sc->sc_repdesc_size,
M_USBDEV, uaa->info.bIfaceIndex);
if (error) {
device_printf(dev, "no report descriptor\n");
goto detach;
}
}
error = usbd_req_set_idle(uaa->device, NULL,
uaa->info.bIfaceIndex, 0, 0);
if (error) {
DPRINTF("set idle failed, error=%s (ignored)\n",
usbd_errstr(error));
}
sc->sc_isize = hid_report_size
(sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_input, &sc->sc_iid);
sc->sc_osize = hid_report_size
(sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_output, &sc->sc_oid);
sc->sc_fsize = hid_report_size
(sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_feature, &sc->sc_fid);
if (sc->sc_isize > UHID_BSIZE) {
DPRINTF("input size is too large, "
"%d bytes (truncating)\n",
sc->sc_isize);
sc->sc_isize = UHID_BSIZE;
}
if (sc->sc_osize > UHID_BSIZE) {
DPRINTF("output size is too large, "
"%d bytes (truncating)\n",
sc->sc_osize);
sc->sc_osize = UHID_BSIZE;
}
if (sc->sc_fsize > UHID_BSIZE) {
DPRINTF("feature size is too large, "
"%d bytes (truncating)\n",
sc->sc_fsize);
sc->sc_fsize = UHID_BSIZE;
}
error = usb_fifo_attach(uaa->device, sc, &sc->sc_mtx,
&uhid_fifo_methods, &sc->sc_fifo,
unit, -1, uaa->info.bIfaceIndex,
UID_ROOT, GID_OPERATOR, 0644);
if (error) {
goto detach;
}
return (0); /* success */
detach:
uhid_detach(dev);
return (ENOMEM);
}
