static int
uhso_probe(device_t self)
{
struct usb_attach_arg *uaa = device_get_ivars(self);
int error;
if (uaa->usb_mode != USB_MODE_HOST)
return (ENXIO);
if (uaa->info.bConfigIndex != 0)
return (ENXIO);
if (uaa->info.bDeviceClass != 0xff)
return (ENXIO);
error = usbd_lookup_id_by_uaa(uhso_devs, sizeof(uhso_devs), uaa);
if (error != 0)
return (error);
/*
* Probe device to see if we are able to attach
* to this interface or not.
*/
if (USB_GET_DRIVER_INFO(uaa) == UHSO_AUTO_IFACE) {
if (uhso_probe_iface_auto(uaa->device,
uaa->info.bIfaceNum) == 0)
return (ENXIO);
}
return (error);
}
static int
rtwn_usb_attach(device_t self)
{
struct usb_attach_arg *uaa = device_get_ivars(self);
struct rtwn_usb_softc *uc = device_get_softc(self);
struct rtwn_softc *sc = &uc->uc_sc;
struct ieee80211com *ic = &sc->sc_ic;
int error;
device_set_usb_desc(self);
uc->uc_udev = uaa->device;
sc->sc_dev = self;
ic->ic_name = device_get_nameunit(self);
/* Need to be initialized early. */
rtwn_sysctlattach(sc);
rtwn_usb_sysctlattach(sc);
mtx_init(&sc->sc_mtx, ic->ic_name, MTX_NETWORK_LOCK, MTX_DEF);
rtwn_usb_attach_methods(sc);
rtwn_usb_attach_private(uc, USB_GET_DRIVER_INFO(uaa));
error = rtwn_usb_setup_endpoints(uc);
if (error != 0)
goto detach;
/* Allocate Tx/Rx buffers. */
error = rtwn_usb_alloc_rx_list(sc);
if (error != 0)
goto detach;
error = rtwn_usb_alloc_tx_list(sc);
if (error != 0)
goto detach;
/* Generic attach. */
error = rtwn_attach(sc);
if (error != 0)
goto detach;
return (0);
detach:
rtwn_usb_detach(self); /* failure */
return (ENXIO);
}
static void
cdce_test_autoinst(void *arg, struct usb_device *udev,
struct usb_attach_arg *uaa)
{
struct usb_interface *iface;
struct usb_interface_descriptor *id;
if (uaa->dev_state != UAA_DEV_READY)
return;
iface = usbd_get_iface(udev, 0);
if (iface == NULL)
return;
id = iface->idesc;
if (id == NULL || id->bInterfaceClass != UICLASS_MASS)
return;
if (usbd_lookup_id_by_uaa(cdce_switch_devs, sizeof(cdce_switch_devs), uaa))
return; /* no device match */
if (usb_msc_eject(udev, 0, USB_GET_DRIVER_INFO(uaa)) == 0) {
/* success, mark the udev as disappearing */
uaa->dev_state = UAA_DEV_EJECTING;
}
}
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
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 */
}
