static int
u3g_match(device_t parent, cfdata_t match, void *aux)
{
struct usbif_attach_arg *uaa = aux;
usbd_interface_handle iface;
usb_interface_descriptor_t *id;
usbd_status error;
if (!usb_lookup(u3g_devs, uaa->vendor, uaa->product))
return (UMATCH_NONE);
error = usbd_device2interface_handle(uaa->device, uaa->ifaceno, &iface);
if (error) {
printf("u3g_match: failed to get interface, err=%s\n",
usbd_errstr(error));
return (UMATCH_NONE);
}
id = usbd_get_interface_descriptor(iface);
if (id == NULL) {
printf("u3g_match: failed to get interface descriptor\n");
return (UMATCH_NONE);
}
/*
* 3G modems generally report vendor-specific class
*
* XXX: this may be too generalised.
*/
return ((id->bInterfaceClass == UICLASS_VENDOR) ?
UMATCH_VENDOR_PRODUCT : UMATCH_NONE);
}
void
usbd_devinfo(usbd_device_handle dev, int showclass, char *cp)
{
usb_device_descriptor_t *udd = &dev->ddesc;
usbd_interface_handle iface;
char vendor[USB_MAX_STRING_LEN];
char product[USB_MAX_STRING_LEN];
int bcdDevice, bcdUSB;
usb_interface_descriptor_t *id;
usbd_devinfo_vp(dev, vendor, product, 1);
cp += ksprintf(cp, "%s %s", vendor, product);
if (showclass & USBD_SHOW_DEVICE_CLASS)
cp += ksprintf(cp, ", class %d/%d",
udd->bDeviceClass, udd->bDeviceSubClass);
bcdUSB = UGETW(udd->bcdUSB);
bcdDevice = UGETW(udd->bcdDevice);
cp += ksprintf(cp, ", rev ");
cp += usbd_printBCD(cp, bcdUSB);
*cp++ = '/';
cp += usbd_printBCD(cp, bcdDevice);
cp += ksprintf(cp, ", addr %d", dev->address);
if (showclass & USBD_SHOW_INTERFACE_CLASS)
{
/* fetch the interface handle for the first interface */
(void)usbd_device2interface_handle(dev, 0, &iface);
id = usbd_get_interface_descriptor(iface);
cp += ksprintf(cp, ", iclass %d/%d",
id->bInterfaceClass, id->bInterfaceSubClass);
}
*cp = 0;
}
void
urio_attach(struct device *parent, struct device *self, void *aux)
{
struct urio_softc *sc = (struct urio_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *dev = uaa->device;
struct usbd_interface *iface;
usbd_status err;
usb_endpoint_descriptor_t *ed;
u_int8_t epcount;
int i;
DPRINTFN(10,("urio_attach: sc=%p\n", sc));
err = usbd_set_config_no(dev, URIO_CONFIG_NO, 1);
if (err) {
printf("%s: setting config no failed\n",
sc->sc_dev.dv_xname);
return;
}
err = usbd_device2interface_handle(dev, URIO_IFACE_IDX, &iface);
if (err) {
printf("%s: getting interface handle failed\n",
sc->sc_dev.dv_xname);
return;
}
sc->sc_udev = dev;
sc->sc_iface = iface;
epcount = 0;
(void)usbd_endpoint_count(iface, &epcount);
sc->sc_in_addr = -1;
sc->sc_out_addr = -1;
for (i = 0; i < epcount; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->sc_dev.dv_xname, i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_in_addr = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_out_addr = ed->bEndpointAddress;
}
}
if (sc->sc_in_addr == -1 || sc->sc_out_addr == -1) {
printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
return;
}
DPRINTFN(10, ("urio_attach: %p\n", sc->sc_udev));
}
int
ugen_set_interface(struct ugen_softc *sc, int ifaceidx, int altno)
{
struct usbd_interface *iface;
usb_endpoint_descriptor_t *ed;
int err;
struct ugen_endpoint *sce;
u_int8_t niface, nendpt, endptno, endpt;
int dir;
DPRINTFN(15, ("ugen_set_interface %d %d\n", ifaceidx, altno));
err = usbd_interface_count(sc->sc_udev, &niface);
if (err)
return (err);
if (ifaceidx < 0 || ifaceidx >= niface ||
usbd_iface_claimed(sc->sc_udev, ifaceidx))
return (USBD_INVAL);
err = usbd_device2interface_handle(sc->sc_udev, ifaceidx, &iface);
if (err)
return (err);
err = usbd_endpoint_count(iface, &nendpt);
if (err)
return (err);
for (endptno = 0; endptno < nendpt; endptno++) {
ed = usbd_interface2endpoint_descriptor(iface,endptno);
endpt = ed->bEndpointAddress;
dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
sce->sc = 0;
sce->edesc = 0;
sce->iface = 0;
}
/* change setting */
err = usbd_set_interface(iface, altno);
if (err)
goto out;
err = usbd_endpoint_count(iface, &nendpt);
if (err)
goto out;
out:
for (endptno = 0; endptno < nendpt; endptno++) {
ed = usbd_interface2endpoint_descriptor(iface,endptno);
endpt = ed->bEndpointAddress;
dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
sce->sc = sc;
sce->edesc = ed;
sce->iface = iface;
}
return (err);
}
int
ugen_get_alt_index(struct ugen_softc *sc, int ifaceidx)
{
struct usbd_interface *iface;
usbd_status err;
err = usbd_device2interface_handle(sc->sc_udev, ifaceidx, &iface);
if (err)
return (-1);
return (usbd_get_interface_altindex(iface));
}
/*
* Issue a SET_CONFIGURATION command to reset the MAC. This should be
* done after the firmware is loaded into the adapter in order to
* bring it into proper operation.
*/
void
kue_reset(struct kue_softc *sc)
{
DPRINTFN(5,("%s: %s: enter\n", sc->kue_dev.dv_xname, __func__));
if (usbd_set_config_no(sc->kue_udev, KUE_CONFIG_NO, 1) ||
usbd_device2interface_handle(sc->kue_udev, KUE_IFACE_IDX,
&sc->kue_iface))
printf("%s: reset failed\n", sc->kue_dev.dv_xname);
/* Wait a little while for the chip to get its brains in order. */
usbd_delay_ms(sc->kue_udev, 10);
}
int
ugen_set_interface(struct ugen_softc *sc, int ifaceidx, int altno)
{
struct usbd_interface *iface;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct ugen_endpoint *sce;
uint8_t endptno, endpt;
int dir, err;
DPRINTFN(15, ("ugen_set_interface %d %d\n", ifaceidx, altno));
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (ifaceidx < 0 || ifaceidx >= cdesc->bNumInterface ||
usbd_iface_claimed(sc->sc_udev, ifaceidx))
return (USBD_INVAL);
err = usbd_device2interface_handle(sc->sc_udev, ifaceidx, &iface);
if (err)
return (err);
id = usbd_get_interface_descriptor(iface);
for (endptno = 0; endptno < id->bNumEndpoints; endptno++) {
ed = usbd_interface2endpoint_descriptor(iface,endptno);
endpt = ed->bEndpointAddress;
dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
sce->sc = 0;
sce->edesc = 0;
sce->iface = 0;
}
/* change setting */
err = usbd_set_interface(iface, altno);
if (err)
return (err);
id = usbd_get_interface_descriptor(iface);
for (endptno = 0; endptno < id->bNumEndpoints; endptno++) {
ed = usbd_interface2endpoint_descriptor(iface,endptno);
endpt = ed->bEndpointAddress;
dir = UE_GET_DIR(endpt) == UE_DIR_IN ? IN : OUT;
sce = &sc->sc_endpoints[UE_GET_ADDR(endpt)][dir];
sce->sc = sc;
sce->edesc = ed;
sce->iface = iface;
}
return (err);
}
/*ARGSUSED*/
static int
u3g_open(void *arg, int portno)
{
struct u3g_softc *sc = arg;
usb_device_request_t req;
usb_endpoint_descriptor_t *ed;
usb_interface_descriptor_t *id;
usbd_interface_handle ih;
usbd_status err;
int i;
if (sc->sc_dying)
return (0);
err = usbd_device2interface_handle(sc->sc_udev, portno, &ih);
if (err)
return (EIO);
id = usbd_get_interface_descriptor(ih);
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(ih, i);
if (ed == NULL)
return (EIO);
if (UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
/* Issue ENDPOINT_HALT request */
req.bmRequestType = UT_WRITE_ENDPOINT;
req.bRequest = UR_CLEAR_FEATURE;
USETW(req.wValue, UF_ENDPOINT_HALT);
USETW(req.wIndex, ed->bEndpointAddress);
USETW(req.wLength, 0);
err = usbd_do_request(sc->sc_udev, &req, 0);
if (err)
return (EIO);
}
}
sc->sc_open = true;
sc->sc_purging = true;
getmicrotime(&sc->sc_purge_start);
return (0);
}
void
uts_attach(struct device *parent, struct device *self, void *aux)
{
struct uts_softc *sc = (struct uts_softc *)self;
struct usb_attach_arg *uaa = aux;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct wsmousedev_attach_args a;
int i;
sc->sc_udev = uaa->device;
sc->sc_product = uaa->product;
sc->sc_vendor = uaa->vendor;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
sc->sc_enabled = sc->sc_isize = 0;
/* Copy the default scalue values to each softc */
bcopy(&def_scale, &sc->sc_tsscale, sizeof(sc->sc_tsscale));
/* Move the device into the configured state. */
if (usbd_set_config_index(uaa->device, UTS_CONFIG_INDEX, 1) != 0) {
printf("%s: could not set configuartion no\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* get the interface */
if (usbd_device2interface_handle(uaa->device, 0, &sc->sc_iface) != 0) {
printf("%s: failed to get interface\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* Find the interrupt endpoint */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
}
}
if (sc->sc_intr_number== -1) {
printf("%s: Could not find interrupt in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
a.accessops = &uts_accessops;
a.accesscookie = sc;
sc->sc_wsmousedev = config_found(self, &a, wsmousedevprint);
}
static int
moscom_attach(device_t self)
{
struct moscom_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
struct ucom_softc *ucom;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
usbd_status error;
int i;
bzero(sc, sizeof (struct moscom_softc));
ucom = &sc->sc_ucom;
ucom->sc_dev = self;
ucom->sc_udev = uaa->device;
ucom->sc_iface = uaa->iface;
if (usbd_set_config_index(ucom->sc_udev, MOSCOM_CONFIG_NO, 1) != 0) {
device_printf(ucom->sc_dev, "could not set configuration no\n");
ucom->sc_dying = 1;
return ENXIO;
}
/* get the first interface handle */
error = usbd_device2interface_handle(ucom->sc_udev, MOSCOM_IFACE_NO,
&ucom->sc_iface);
if (error != 0) {
device_printf(ucom->sc_dev, "could not get interface handle\n");
ucom->sc_dying = 1;
return ENXIO;
}
id = usbd_get_interface_descriptor(ucom->sc_iface);
ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
if (ed == NULL) {
device_printf(ucom->sc_dev, "no endpoint descriptor "
"found for %d\n", i);
ucom->sc_dying = 1;
return ENXIO;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
ucom->sc_bulkin_no = ed->bEndpointAddress;
else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
ucom->sc_bulkout_no = ed->bEndpointAddress;
}
if (ucom->sc_bulkin_no == -1 || ucom->sc_bulkout_no == -1) {
device_printf(ucom->sc_dev, "missing endpoint\n");
ucom->sc_dying = 1;
return ENXIO;
}
ucom->sc_parent = sc;
ucom->sc_portno = UCOM_UNK_PORTNO;
ucom->sc_ibufsize = MOSCOMBUFSZ;
ucom->sc_obufsize = MOSCOMBUFSZ;
ucom->sc_ibufsizepad = MOSCOMBUFSZ;
ucom->sc_opkthdrlen = 0;
ucom->sc_callback = &moscom_callback;
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, ucom->sc_udev,
ucom->sc_dev);
return 0;
}
void
umct_attach(struct device *parent, struct device *self, void *aux)
{
struct umct_softc *sc = (struct umct_softc *)self;
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devname = sc->sc_dev.dv_xname;
usbd_status err;
int i;
struct ucom_attach_args uca;
sc->sc_udev = dev;
sc->sc_product = uaa->product;
DPRINTF(("\n\numct attach: sc=%p\n", sc));
/* initialize endpoints */
uca.bulkin = uca.bulkout = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UMCT_CONFIG_INDEX, 1);
if (err) {
printf("\n%s: failed to set configuration, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
return;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* get the interface */
err = usbd_device2interface_handle(dev, UMCT_IFACE_INDEX,
&sc->sc_iface);
if (err) {
printf("\n%s: failed to get interface, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
return;
}
/* Find the bulk{in,out} and interrupt endpoints */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
return;
}
/*
* The Bulkin endpoint is marked as an interrupt. Since
* we can't rely on the endpoint descriptor order, we'll
* check the wMaxPacketSize field to differentiate.
*/
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT &&
UGETW(ed->wMaxPacketSize) != 0x2) {
uca.bulkin = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
}
}
if (uca.bulkin == -1) {
printf("%s: Could not find data bulk in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
if (uca.bulkout == -1) {
printf("%s: Could not find data bulk out\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
if (sc->sc_intr_number== -1) {
printf("%s: Could not find interrupt in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
sc->sc_dtr = sc->sc_rts = 0;
uca.portno = UCOM_UNK_PORTNO;
/* bulkin, bulkout set above */
uca.ibufsize = UMCTIBUFSIZE;
if (sc->sc_product == USB_PRODUCT_MCT_SITECOM_USB232)
uca.obufsize = 16; /* device is broken */
else
uca.obufsize = UMCTOBUFSIZE;
uca.ibufsizepad = UMCTIBUFSIZE;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = sc->sc_iface;
uca.methods = &umct_methods;
uca.arg = sc;
uca.info = NULL;
umct_init(sc);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
&sc->sc_dev);
DPRINTF(("umct: in=0x%x out=0x%x intr=0x%x\n",
uca.bulkin, uca.bulkout, sc->sc_intr_number ));
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
}
void
uticom_attach_hook(void *arg)
{
struct uticom_softc *sc = arg;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
usbd_status err;
int status, i;
usb_device_descriptor_t *dd;
struct ucom_attach_args uca;
/* Initialize endpoints. */
uca.bulkin = uca.bulkout = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
dd = usbd_get_device_descriptor(sc->sc_udev);
DPRINTF(("%s: uticom_attach: num of configurations %d\n",
sc->sc_dev.dv_xname, dd->bNumConfigurations));
/* The device without firmware has single configuration with single
* bulk out interface. */
if (dd->bNumConfigurations > 1)
goto fwload_done;
/* Loading firmware. */
DPRINTF(("%s: uticom_attach: starting loading firmware\n",
sc->sc_dev.dv_xname));
err = usbd_set_config_index(sc->sc_udev, UTICOM_CONFIG_INDEX, 1);
if (err) {
printf("%s: failed to set configuration: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
return;
}
/* Get the config descriptor. */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
err = usbd_device2interface_handle(sc->sc_udev, UTICOM_IFACE_INDEX,
&sc->sc_iface);
if (err) {
printf("%s: failed to get interface: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
return;
}
/* Find the bulk out interface used to upload firmware. */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
usbd_deactivate(sc->sc_udev);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
DPRINTF(("%s: uticom_attach: data bulk out num: %d\n",
sc->sc_dev.dv_xname, ed->bEndpointAddress));
}
if (uca.bulkout == -1) {
printf("%s: could not find data bulk out\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
}
status = uticom_download_fw(sc, uca.bulkout, sc->sc_udev);
if (status) {
printf("%s: firmware download failed\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
} else {
DPRINTF(("%s: firmware download succeeded\n",
sc->sc_dev.dv_xname));
}
status = usbd_reload_device_desc(sc->sc_udev);
if (status) {
printf("%s: error reloading device descriptor\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
fwload_done:
dd = usbd_get_device_descriptor(sc->sc_udev);
DPRINTF(("%s: uticom_attach: num of configurations %d\n",
sc->sc_dev.dv_xname, dd->bNumConfigurations));
err = usbd_set_config_index(sc->sc_udev, UTICOM_ACTIVE_INDEX, 1);
if (err) {
printf("%s: failed to set configuration: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
return;
}
/* Get the config descriptor. */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
/* Get the interface (XXX: multiport chips are not supported yet). */
err = usbd_device2interface_handle(sc->sc_udev, UTICOM_IFACE_INDEX,
&sc->sc_iface);
if (err) {
printf("%s: failed to get interface: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
return;
}
/* Find the interrupt endpoints. */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
usbd_deactivate(sc->sc_udev);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
}
}
if (sc->sc_intr_number == -1) {
printf("%s: could not find interrupt in\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
/* Keep interface for interrupt. */
sc->sc_intr_iface = sc->sc_iface;
/* Find the bulk{in,out} endpoints. */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
usbd_deactivate(sc->sc_udev);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
}
}
if (uca.bulkin == -1) {
printf("%s: could not find data bulk in\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
if (uca.bulkout == -1) {
printf("%s: could not find data bulk out\n",
sc->sc_dev.dv_xname);
usbd_deactivate(sc->sc_udev);
return;
}
sc->sc_dtr = sc->sc_rts = -1;
uca.portno = UCOM_UNK_PORTNO;
uca.ibufsize = UTICOM_IBUFSZ;
uca.obufsize = UTICOM_OBUFSZ;
uca.ibufsizepad = UTICOM_IBUFSZ;
uca.device = sc->sc_udev;
uca.iface = sc->sc_iface;
uca.opkthdrlen = 0;
uca.methods = &uticom_methods;
uca.arg = sc;
uca.info = NULL;
err = uticom_reset(sc);
if (err) {
printf("%s: reset failed: %s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
return;
}
DPRINTF(("%s: uticom_attach: in = 0x%x, out = 0x%x, intr = 0x%x\n",
sc->sc_dev.dv_xname, uca.bulkin,
uca.bulkout, sc->sc_intr_number));
sc->sc_subdev = config_found_sm((struct device *)sc, &uca, ucomprint, ucomsubmatch);
}
void
urio_attach(device_t parent, device_t self, void *aux)
{
struct urio_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
char *devinfop;
usbd_status err;
usb_endpoint_descriptor_t *ed;
u_int8_t epcount;
int i;
DPRINTFN(10,("urio_attach: sc=%p\n", sc));
sc->sc_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, URIO_CONFIG_NO, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
return;
}
err = usbd_device2interface_handle(dev, URIO_IFACE_IDX, &iface);
if (err) {
aprint_error_dev(self, "getting interface handle failed\n");
return;
}
sc->sc_udev = dev;
sc->sc_iface = iface;
epcount = 0;
(void)usbd_endpoint_count(iface, &epcount);
sc->sc_in_addr = -1;
sc->sc_out_addr = -1;
for (i = 0; i < epcount; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_in_addr = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_out_addr = ed->bEndpointAddress;
}
}
if (sc->sc_in_addr == -1 || sc->sc_out_addr == -1) {
aprint_error_dev(self, "missing endpoint\n");
return;
}
DPRINTFN(10, ("urio_attach: %p\n", sc->sc_udev));
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_dev);
return;
}
/* Attach */
void
url_attach(device_t parent, device_t self, void *aux)
{
struct url_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devinfop;
struct ifnet *ifp;
struct mii_data *mii;
u_char eaddr[ETHER_ADDR_LEN];
int i, s;
sc->sc_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
/* Move the device into the configured state. */
err = usbd_set_config_no(dev, URL_CONFIG_NO, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
goto bad;
}
usb_init_task(&sc->sc_tick_task, url_tick_task, sc, 0);
rw_init(&sc->sc_mii_rwlock);
usb_init_task(&sc->sc_stop_task, (void (*)(void *))url_stop_task, sc, 0);
/* get control interface */
err = usbd_device2interface_handle(dev, URL_IFACE_INDEX, &iface);
if (err) {
aprint_error_dev(self, "failed to get interface, err=%s\n",
usbd_errstr(err));
goto bad;
}
sc->sc_udev = dev;
sc->sc_ctl_iface = iface;
sc->sc_flags = url_lookup(uaa->vendor, uaa->product)->url_flags;
/* get interface descriptor */
id = usbd_get_interface_descriptor(sc->sc_ctl_iface);
/* find endpoints */
sc->sc_bulkin_no = sc->sc_bulkout_no = sc->sc_intrin_no = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_ctl_iface, i);
if (ed == NULL) {
aprint_error_dev(self,
"couldn't get endpoint %d\n", i);
goto bad;
}
if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
sc->sc_bulkin_no = ed->bEndpointAddress; /* RX */
else if ((ed->bmAttributes & UE_XFERTYPE) == UE_BULK &&
UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT)
sc->sc_bulkout_no = ed->bEndpointAddress; /* TX */
else if ((ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT &&
UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
sc->sc_intrin_no = ed->bEndpointAddress; /* Status */
}
if (sc->sc_bulkin_no == -1 || sc->sc_bulkout_no == -1 ||
sc->sc_intrin_no == -1) {
aprint_error_dev(self, "missing endpoint\n");
goto bad;
}
s = splnet();
/* reset the adapter */
url_reset(sc);
/* Get Ethernet Address */
err = url_mem(sc, URL_CMD_READMEM, URL_IDR0, (void *)eaddr,
ETHER_ADDR_LEN);
if (err) {
aprint_error_dev(self, "read MAC address failed\n");
splx(s);
goto bad;
}
/* Print Ethernet Address */
aprint_normal_dev(self, "Ethernet address %s\n", ether_sprintf(eaddr));
/* initialize interface information */
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
strncpy(ifp->if_xname, device_xname(self), IFNAMSIZ);
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_start = url_start;
ifp->if_ioctl = url_ioctl;
ifp->if_watchdog = url_watchdog;
ifp->if_init = url_init;
ifp->if_stop = url_stop;
IFQ_SET_READY(&ifp->if_snd);
/*
* Do ifmedia setup.
*/
mii = &sc->sc_mii;
mii->mii_ifp = ifp;
mii->mii_readreg = url_int_miibus_readreg;
mii->mii_writereg = url_int_miibus_writereg;
#if 0
if (sc->sc_flags & URL_EXT_PHY) {
mii->mii_readreg = url_ext_miibus_readreg;
mii->mii_writereg = url_ext_miibus_writereg;
}
#endif
mii->mii_statchg = url_miibus_statchg;
mii->mii_flags = MIIF_AUTOTSLEEP;
sc->sc_ec.ec_mii = mii;
ifmedia_init(&mii->mii_media, 0,
url_ifmedia_change, url_ifmedia_status);
mii_attach(self, mii, 0xffffffff, MII_PHY_ANY, MII_OFFSET_ANY, 0);
if (LIST_FIRST(&mii->mii_phys) == NULL) {
ifmedia_add(&mii->mii_media, IFM_ETHER | IFM_NONE, 0, NULL);
ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_NONE);
} else
ifmedia_set(&mii->mii_media, IFM_ETHER | IFM_AUTO);
/* attach the interface */
if_attach(ifp);
ether_ifattach(ifp, eaddr);
rnd_attach_source(&sc->rnd_source, device_xname(self),
RND_TYPE_NET, 0);
callout_init(&sc->sc_stat_ch, 0);
sc->sc_attached = 1;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, dev, sc->sc_dev);
return;
bad:
sc->sc_dying = 1;
return;
}
void
uvscom_attach(struct device *parent, struct device *self, void *aux)
{
struct uvscom_softc *sc = (struct uvscom_softc *)self;
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
const char *devname = sc->sc_dev.dv_xname;
usbd_status err;
int i;
struct ucom_attach_args uca;
sc->sc_udev = dev;
DPRINTF(("uvscom attach: sc = %p\n", sc));
/* initialize endpoints */
uca.bulkin = uca.bulkout = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UVSCOM_CONFIG_INDEX, 1);
if (err) {
printf("%s: failed to set configuration, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
return;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* get the common interface */
err = usbd_device2interface_handle(dev, UVSCOM_IFACE_INDEX,
&sc->sc_iface);
if (err) {
printf("%s: failed to get interface, err=%s\n",
devname, usbd_errstr(err));
sc->sc_dying = 1;
return;
}
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
/* Find endpoints */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
}
}
if (uca.bulkin == -1) {
printf("%s: Could not find data bulk in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
if (uca.bulkout == -1) {
printf("%s: Could not find data bulk out\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
if (sc->sc_intr_number == -1) {
printf("%s: Could not find interrupt in\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
sc->sc_dtr = sc->sc_rts = 0;
sc->sc_lcr = UVSCOM_LINE_INIT;
uca.portno = UCOM_UNK_PORTNO;
/* bulkin, bulkout set above */
uca.ibufsize = UVSCOMIBUFSIZE;
uca.obufsize = UVSCOMOBUFSIZE;
uca.ibufsizepad = UVSCOMIBUFSIZE;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = sc->sc_iface;
uca.methods = &uvscom_methods;
uca.arg = sc;
uca.info = NULL;
err = uvscom_reset(sc);
if (err) {
printf("%s: reset failed, %s\n", sc->sc_dev.dv_xname,
usbd_errstr(err));
sc->sc_dying = 1;
return;
}
DPRINTF(("uvscom: in = 0x%x out = 0x%x intr = 0x%x\n",
ucom->sc_bulkin_no, ucom->sc_bulkout_no, sc->sc_intr_number));
DPRINTF(("uplcom: in=0x%x out=0x%x intr=0x%x\n",
uca.bulkin, uca.bulkout, sc->sc_intr_number ));
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
}
void
ubsa_attach(struct device *parent, struct device *self, void *aux)
{
struct ubsa_softc *sc = (struct ubsa_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *dev = uaa->device;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
const char *devname = sc->sc_dev.dv_xname;
usbd_status err;
struct ucom_attach_args uca;
int i;
sc->sc_udev = dev;
/*
* initialize rts, dtr variables to something
* different from boolean 0, 1
*/
sc->sc_dtr = -1;
sc->sc_rts = -1;
DPRINTF(("ubsa attach: sc = %p\n", sc));
/* initialize endpoints */
uca.bulkin = uca.bulkout = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UBSA_CONFIG_INDEX, 1);
if (err) {
printf("%s: failed to set configuration: %s\n",
devname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
goto error;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
printf("%s: failed to get configuration descriptor\n",
devname);
usbd_deactivate(sc->sc_udev);
goto error;
}
/* get the first interface */
err = usbd_device2interface_handle(dev, UBSA_IFACE_INDEX,
&sc->sc_iface);
if (err) {
printf("%s: failed to get interface: %s\n",
devname, usbd_errstr(err));
usbd_deactivate(sc->sc_udev);
goto error;
}
/* Find the endpoints */
id = usbd_get_interface_descriptor(sc->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor for %d\n",
sc->sc_dev.dv_xname, i);
usbd_deactivate(sc->sc_udev);
goto error;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
uca.ibufsize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
uca.obufsize = UGETW(ed->wMaxPacketSize);
}
}
if (sc->sc_intr_number == -1) {
printf("%s: Could not find interrupt in\n", devname);
usbd_deactivate(sc->sc_udev);
goto error;
}
if (uca.bulkin == -1) {
printf("%s: Could not find data bulk in\n", devname);
usbd_deactivate(sc->sc_udev);
goto error;
}
if (uca.bulkout == -1) {
printf("%s: Could not find data bulk out\n", devname);
usbd_deactivate(sc->sc_udev);
goto error;
}
uca.portno = UCOM_UNK_PORTNO;
/* bulkin, bulkout set above */
uca.ibufsizepad = uca.ibufsize;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = sc->sc_iface;
uca.methods = &ubsa_methods;
uca.arg = sc;
uca.info = NULL;
DPRINTF(("ubsa: in = 0x%x, out = 0x%x, intr = 0x%x\n",
uca.bulkin, uca.bulkout, sc->sc_intr_number));
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
error:
return;
}
static int
uhub_attach(device_t self)
{
struct uhub_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
usbd_device_handle dev = uaa->device;
usbd_status err;
struct usbd_hub *hub = NULL;
usb_device_request_t req;
usb_hub_descriptor_t hubdesc;
int p, port, nports, nremov, pwrdly;
usbd_interface_handle iface;
usb_endpoint_descriptor_t *ed;
struct usbd_tt *tts = NULL;
DPRINTFN(1,("uhub_attach\n"));
sc->sc_hub = dev;
if (dev->depth > 0 && UHUB_IS_HIGH_SPEED(sc)) {
device_printf(self,
"%s transaction translator%s\n",
UHUB_IS_SINGLE_TT(sc) ? "single" : "multiple",
UHUB_IS_SINGLE_TT(sc) ? "" : "s");
}
err = usbd_set_config_index(dev, 0, 1);
if (err) {
DPRINTF(("%s: configuration failed, error=%s\n",
device_get_nameunit(self), usbd_errstr(err)));
return ENXIO;
}
if (dev->depth > USB_HUB_MAX_DEPTH) {
device_printf(self,
"hub depth (%d) exceeded, hub ignored\n",
USB_HUB_MAX_DEPTH);
return ENXIO;
}
/* Get hub descriptor. */
req.bmRequestType = UT_READ_CLASS_DEVICE;
req.bRequest = UR_GET_DESCRIPTOR;
USETW2(req.wValue, (dev->address > 1 ? UDESC_HUB : 0), 0);
USETW(req.wIndex, 0);
USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE);
DPRINTFN(1,("usb_init_hub: getting hub descriptor\n"));
err = usbd_do_request(dev, &req, &hubdesc);
nports = hubdesc.bNbrPorts;
if (!err && nports > 7) {
USETW(req.wLength, USB_HUB_DESCRIPTOR_SIZE + (nports+1) / 8);
err = usbd_do_request(dev, &req, &hubdesc);
}
if (err) {
DPRINTF(("%s: getting hub descriptor failed, error=%s\n",
device_get_nameunit(self), usbd_errstr(err)));
return ENXIO;
}
for (nremov = 0, port = 1; port <= nports; port++)
if (!UHD_NOT_REMOV(&hubdesc, port))
nremov++;
device_printf(self,
"%d port%s with %d removable, %s powered\n",
nports, nports != 1 ? "s" : "",
nremov, dev->self_powered ? "self" : "bus");
if (nports == 0) {
device_printf(self, "no ports, hub ignored\n");
goto bad;
}
hub = kmalloc(sizeof(*hub) + (nports-1) * sizeof(struct usbd_port),
M_USBDEV, M_WAITOK);
dev->hub = hub;
dev->hub->hubdev = self;
hub->explore = uhub_explore;
hub->hubdesc = hubdesc;
DPRINTFN(1,("usbhub_init_hub: selfpowered=%d, parent=%p, "
"parent->selfpowered=%d\n",
dev->self_powered, dev->powersrc->parent,
dev->powersrc->parent ?
dev->powersrc->parent->self_powered : 0));
if (!dev->self_powered && dev->powersrc->parent != NULL &&
!dev->powersrc->parent->self_powered) {
device_printf(self,
"bus powered hub connected to bus powered hub, "
"ignored\n");
goto bad;
}
/* Set up interrupt pipe. */
err = usbd_device2interface_handle(dev, 0, &iface);
if (err) {
device_printf(self, "no interface handle\n");
goto bad;
}
ed = usbd_interface2endpoint_descriptor(iface, 0);
if (ed == NULL) {
device_printf(self, "no endpoint descriptor\n");
goto bad;
}
if ((ed->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT) {
device_printf(self, "bad interrupt endpoint\n");
goto bad;
}
err = usbd_open_pipe_intr(iface, ed->bEndpointAddress,
USBD_SHORT_XFER_OK, &sc->sc_ipipe, sc, sc->sc_status,
sizeof(sc->sc_status), uhub_intr, UHUB_INTR_INTERVAL);
if (err) {
device_printf(self, "cannot open interrupt pipe\n");
goto bad;
}
/* Wait with power off for a while. */
usbd_delay_ms(dev, USB_POWER_DOWN_TIME);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, dev, self);
/*
* To have the best chance of success we do things in the exact same
* order as Windoze98. This should not be necessary, but some
* devices do not follow the USB specs to the letter.
*
* These are the events on the bus when a hub is attached:
* Get device and config descriptors (see attach code)
* Get hub descriptor (see above)
* For all ports
* turn on power
* wait for power to become stable
* (all below happens in explore code)
* For all ports
* clear C_PORT_CONNECTION
* For all ports
* get port status
* if device connected
* wait 100 ms
* turn on reset
* wait
* clear C_PORT_RESET
* get port status
* proceed with device attachment
*/
if (UHUB_IS_HIGH_SPEED(sc)) {
tts = kmalloc((UHUB_IS_SINGLE_TT(sc) ? 1 : nports) *
sizeof(struct usbd_tt), M_USBDEV, M_WAITOK);
}
/* Set up data structures */
for (p = 0; p < nports; p++) {
struct usbd_port *up = &hub->ports[p];
up->device = NULL;
up->parent = dev;
up->portno = p+1;
if (dev->self_powered)
/* Self powered hub, give ports maximum current. */
up->power = USB_MAX_POWER;
else
up->power = USB_MIN_POWER;
up->restartcnt = 0;
if (UHUB_IS_HIGH_SPEED(sc)) {
up->tt = &tts[UHUB_IS_SINGLE_TT(sc) ? 0 : p];
up->tt->hub = hub;
} else {
up->tt = NULL;
}
}
/* XXX should check for none, individual, or ganged power? */
pwrdly = dev->hub->hubdesc.bPwrOn2PwrGood * UHD_PWRON_FACTOR
+ USB_EXTRA_POWER_UP_TIME;
for (port = 1; port <= nports; port++) {
/* Turn the power on. */
err = usbd_set_port_feature(dev, port, UHF_PORT_POWER);
if (err)
device_printf(self,
"port %d power on failed, %s\n",
port, usbd_errstr(err));
DPRINTF(("usb_init_port: turn on port %d power\n", port));
}
/* Wait for stable power if we are not a root hub */
if (dev->powersrc->parent != NULL)
usbd_delay_ms(dev, pwrdly);
/* The usual exploration will finish the setup. */
sc->sc_running = 1;
return 0;
bad:
if (hub)
kfree(hub, M_USBDEV);
dev->hub = NULL;
return ENXIO;
}
void
ubsa_attach(device_t parent, device_t self, void *aux)
{
struct ubsa_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devinfop;
usbd_status err;
struct ucom_attach_args uca;
int i;
sc->sc_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
sc->sc_udev = dev;
sc->sc_config_index = UBSA_DEFAULT_CONFIG_INDEX;
sc->sc_numif = 1; /* default device has one interface */
/*
* initialize rts, dtr variables to something
* different from boolean 0, 1
*/
sc->sc_dtr = -1;
sc->sc_rts = -1;
/*
* Quad UMTS cards use different requests to
* control com settings and only some.
*/
sc->sc_quadumts = 0;
if (uaa->vendor == USB_VENDOR_OPTIONNV) {
switch (uaa->product) {
case USB_PRODUCT_OPTIONNV_QUADUMTS:
case USB_PRODUCT_OPTIONNV_QUADUMTS2:
sc->sc_quadumts = 1;
break;
}
}
DPRINTF(("ubsa attach: sc = %p\n", sc));
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, sc->sc_config_index, 1);
if (err) {
aprint_error_dev(self,
"failed to set configuration: %s\n",
usbd_errstr(err));
sc->sc_dying = 1;
goto error;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(sc->sc_udev);
if (cdesc == NULL) {
aprint_error_dev(self,
"failed to get configuration descriptor\n");
sc->sc_dying = 1;
goto error;
}
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
/* get the interfaces */
err = usbd_device2interface_handle(dev, UBSA_IFACE_INDEX_OFFSET,
&sc->sc_iface[0]);
if (err) {
/* can not get main interface */
sc->sc_dying = 1;
goto error;
}
/* Find the endpoints */
id = usbd_get_interface_descriptor(sc->sc_iface[0]);
sc->sc_iface_number[0] = id->bInterfaceNumber;
/* initialize endpoints */
uca.bulkin = uca.bulkout = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface[0], i);
if (ed == NULL) {
aprint_error_dev(self,
"no endpoint descriptor for %d\n", i);
break;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkin = ed->bEndpointAddress;
uca.ibufsize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
uca.bulkout = ed->bEndpointAddress;
uca.obufsize = UGETW(ed->wMaxPacketSize);
}
} /* end of Endpoint loop */
if (sc->sc_intr_number == -1) {
aprint_error_dev(self, "Could not find interrupt in\n");
sc->sc_dying = 1;
goto error;
}
if (uca.bulkin == -1) {
aprint_error_dev(self, "Could not find data bulk in\n");
sc->sc_dying = 1;
goto error;
}
if (uca.bulkout == -1) {
aprint_error_dev(self, "Could not find data bulk out\n");
sc->sc_dying = 1;
goto error;
}
uca.portno = 0;
/* bulkin, bulkout set above */
uca.ibufsizepad = uca.ibufsize;
uca.opkthdrlen = 0;
uca.device = dev;
uca.iface = sc->sc_iface[0];
uca.methods = &ubsa_methods;
uca.arg = sc;
uca.info = NULL;
DPRINTF(("ubsa: int#=%d, in = 0x%x, out = 0x%x, intr = 0x%x\n",
i, uca.bulkin, uca.bulkout, sc->sc_intr_number));
sc->sc_subdevs[0] = config_found_sm_loc(self, "ucombus", NULL, &uca,
ucomprint, ucomsubmatch);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_dev);
return;
error:
return;
}
/*
* Attach the interface. Allocate softc structures, do ifmedia
* setup and ethernet/BPF attach.
*/
void
wi_usb_attach(struct device *parent, struct device *self, void *aux)
{
struct wi_usb_softc *sc = (struct wi_usb_softc *)self;
struct usb_attach_arg *uaa = aux;
/* int s; */
struct usbd_device *dev = uaa->device;
struct usbd_interface *iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
DPRINTFN(5,(" : wi_usb_attach: sc=%p", sc));
err = usbd_set_config_no(dev, WI_USB_CONFIG_NO, 1);
if (err) {
printf("%s: setting config no failed\n", sc->wi_usb_dev.dv_xname);
return;
}
/* XXX - any tasks? */
err = usbd_device2interface_handle(dev, WI_USB_IFACE_IDX, &iface);
if (err) {
printf("%s: getting interface handle failed\n",
sc->wi_usb_dev.dv_xname);
return;
}
/* XXX - flags? */
sc->wi_usb_udev = dev;
sc->wi_usb_iface = iface;
sc->wi_usb_product = uaa->product;
sc->wi_usb_vendor = uaa->vendor;
sc->sc_wi.wi_usb_cdata = sc;
sc->sc_wi.wi_flags |= WI_FLAGS_BUS_USB;
sc->wi_lock = 0;
sc->wi_lockwait = 0;
sc->wi_resetonce = 0;
id = usbd_get_interface_descriptor(iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: couldn't get endpoint descriptor %d\n",
sc->wi_usb_dev.dv_xname, i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->wi_usb_ed[WI_USB_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->wi_usb_ed[WI_USB_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->wi_usb_ed[WI_USB_ENDPT_INTR] = ed->bEndpointAddress;
}
}
sc->wi_usb_nummem = 0;
/* attach wi device */
if (wi_usb_rx_list_init(sc)) {
printf("%s: rx list init failed\n",
sc->wi_usb_dev.dv_xname);
return;
}
if (wi_usb_tx_list_init(sc)) {
printf("%s: tx list init failed\n",
sc->wi_usb_dev.dv_xname);
return;
}
if (wi_usb_open_pipes(sc)){
printf("%s: open pipes failed\n",
sc->wi_usb_dev.dv_xname);
return;
}
sc->wi_usb_attached = 1;
kthread_create_deferred(wi_usb_start_thread, sc);
}
/*
* Attach the interface. Allocate softc structures, do
* setup and ethernet/BPF attach.
*/
void
kue_attach(device_t parent, device_t self, void *aux)
{
struct kue_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
char *devinfop;
int s;
struct ifnet *ifp;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
DPRINTFN(5,(" : kue_attach: sc=%p, dev=%p", sc, dev));
sc->kue_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, KUE_CONFIG_NO, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
return;
}
sc->kue_udev = dev;
sc->kue_product = uaa->product;
sc->kue_vendor = uaa->vendor;
/* Load the firmware into the NIC. */
if (kue_load_fw(sc)) {
aprint_error_dev(self, "loading firmware failed\n");
return;
}
err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
if (err) {
aprint_error_dev(self, "getting interface handle failed\n");
return;
}
sc->kue_iface = iface;
id = usbd_get_interface_descriptor(iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
}
}
if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
aprint_error_dev(self, "missing endpoint\n");
return;
}
/* Read ethernet descriptor */
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
0, &sc->kue_desc, sizeof(sc->kue_desc));
if (err) {
aprint_error_dev(self, "could not read Ethernet descriptor\n");
return;
}
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
M_USBDEV, M_NOWAIT);
if (sc->kue_mcfilters == NULL) {
aprint_error_dev(self,
"no memory for multicast filter buffer\n");
return;
}
s = splnet();
/*
* A KLSI chip was detected. Inform the world.
*/
aprint_normal_dev(self, "Ethernet address %s\n",
ether_sprintf(sc->kue_desc.kue_macaddr));
/* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_mtu = ETHERMTU;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = kue_ioctl;
ifp->if_start = kue_start;
ifp->if_watchdog = kue_watchdog;
strncpy(ifp->if_xname, device_xname(sc->kue_dev), IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
/* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp, sc->kue_desc.kue_macaddr);
rnd_attach_source(&sc->rnd_source, device_xname(sc->kue_dev),
RND_TYPE_NET, RND_FLAG_DEFAULT);
sc->kue_attached = true;
splx(s);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->kue_udev,
sc->kue_dev);
return;
}
void
uftdi_attach(struct device *parent, struct device *self, void *aux)
{
struct uftdi_softc *sc = (struct uftdi_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *dev = uaa->device;
struct usbd_interface *iface;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devname = sc->sc_dev.dv_xname;
int i;
usbd_status err;
struct ucom_attach_args uca;
DPRINTFN(10,("\nuftdi_attach: sc=%p\n", sc));
sc->sc_udev = dev;
if (uaa->iface == NULL) {
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UFTDI_CONFIG_INDEX, 1);
if (err) {
printf("%s: failed to set configuration, err=%s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
goto bad;
}
err = usbd_device2interface_handle(dev, UFTDI_IFACE_INDEX, &iface);
if (err) {
printf("%s: failed to get interface, err=%s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
goto bad;
}
} else
iface = uaa->iface;
id = usbd_get_interface_descriptor(iface);
sc->sc_iface = iface;
if (uaa->release < 0x0200) {
sc->sc_type = UFTDI_TYPE_SIO;
sc->sc_hdrlen = 1;
} else if (uaa->release == 0x0700 || uaa->release == 0x0800) {
sc->sc_type = UFTDI_TYPE_2232H;
sc->sc_hdrlen = 0;
} else {
sc->sc_type = UFTDI_TYPE_8U232AM;
sc->sc_hdrlen = 0;
}
uca.bulkin = uca.bulkout = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
int addr, dir, attr;
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: could not read endpoint descriptor\n",
devname);
goto bad;
}
addr = ed->bEndpointAddress;
dir = UE_GET_DIR(ed->bEndpointAddress);
attr = ed->bmAttributes & UE_XFERTYPE;
if (dir == UE_DIR_IN && attr == UE_BULK) {
uca.bulkin = addr;
uca.ibufsize = (UGETW(ed->wMaxPacketSize) > 0) ?
UGETW(ed->wMaxPacketSize) : UFTDIIBUFSIZE;
} else if (dir == UE_DIR_OUT && attr == UE_BULK) {
uca.bulkout = addr;
uca.obufsize = (UGETW(ed->wMaxPacketSize) > 0) ?
UGETW(ed->wMaxPacketSize) : UFTDIOBUFSIZE;
uca.obufsize-= sc->sc_hdrlen;
} else {
printf("%s: unexpected endpoint\n", devname);
goto bad;
}
}
if (uca.bulkin == -1) {
printf("%s: Could not find data bulk in\n",
sc->sc_dev.dv_xname);
goto bad;
}
if (uca.bulkout == -1) {
printf("%s: Could not find data bulk out\n",
sc->sc_dev.dv_xname);
goto bad;
}
if (uaa->iface == NULL)
uca.portno = FTDI_PIT_SIOA;
else
uca.portno = FTDI_PIT_SIOA + id->bInterfaceNumber;
/* bulkin, bulkout set above */
uca.ibufsizepad = uca.ibufsize;
uca.opkthdrlen = sc->sc_hdrlen;
uca.device = dev;
uca.iface = iface;
uca.methods = &uftdi_methods;
uca.arg = sc;
uca.info = NULL;
DPRINTF(("uftdi: in=0x%x out=0x%x\n", uca.bulkin, uca.bulkout));
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
return;
bad:
DPRINTF(("uftdi_attach: ATTACH ERROR\n"));
usbd_deactivate(sc->sc_udev);
}
/*
****************************************************************
* Função de "attach" *
****************************************************************
*/
int
uhub_attach (struct device *dev)
{
struct uhub_softc *sc;
struct usb_attach_arg *uaa = dev->ivars;
struct usbd_device *udev = uaa->device;
struct usbd_hub *hub = NULL;
struct usb_device_request req;
struct usb_hub_descriptor *hubdesc = NULL;
struct usbd_interface *iface;
struct usb_endpoint_descriptor *ed;
int p, port, nports, nremov, pwrdly, err;
/*
* Aloca e zera a estrutura "softc"
*/
if ((sc = dev->softc = malloc_byte (sizeof (struct uhub_softc))) == NULL)
return (-1);
memclr (sc, sizeof (struct uhub_softc));
#if (0) /*******************************************************/
{
char *devinfo;
if ((devinfo = malloc_byte (1024)) == NULL)
goto bad;
memclr (devinfo, 1024);
usbd_devinfo (udev, USBD_SHOW_INTERFACE_CLASS, devinfo);
device_set_desc_copy (dev, devinfo);
free_byte (devinfo);
}
#endif /*******************************************************/
sc->sc_hub = udev;
sc->sc_dev = dev;
if (err = usbd_set_config_index (udev, 0, 1))
{
printf ("uhub_attach (%s): erro na configuração (%s)\n", dev->nameunit, usbd_errstr (err));
goto bad;
}
if (udev->depth > USB_HUB_MAX_DEPTH)
{
printf
( "uhub_attach (%s): profundidade máxima excedida (%d > %d), \"hub\" ignorado\n",
dev->nameunit, udev->depth, USB_HUB_MAX_DEPTH
);
goto bad;
}
/* Get hub descriptor */
if ((hubdesc = malloc_byte (sizeof (struct usb_hub_descriptor))) == NULL)
{ err = USBD_NOMEM; goto bad; }
req.bmRequestType = UT_READ_CLASS_DEVICE;
req.bRequest = UR_GET_DESCRIPTOR;
USETW2 (req.wValue, (udev->address > 1 ? UDESC_HUB : 0), 0);
USETW (req.wIndex, 0);
USETW (req.wLength, USB_HUB_DESCRIPTOR_SIZE);
err = usbd_do_request (udev, &req, hubdesc);
nports = hubdesc->bNbrPorts;
if (err == 0 && nports > 7)
{
USETW (req.wLength, USB_HUB_DESCRIPTOR_SIZE + (nports + 1) / 8);
err = usbd_do_request (udev, &req, hubdesc);
}
if (err)
{
printf
( "uhub_attach (%s): erro ao ler descritor do hub (%s)\n",
dev->nameunit, usbd_errstr (err)
);
goto bad;
}
for (nremov = 0, port = 1; port <= nports; port++)
{
if (!UHD_NOT_REMOV (hubdesc, port))
nremov++;
}
if (nports == 0)
{ printf ("%s: hub sem portas ignorado\n", dev->nameunit); goto bad; }
printf
( "%s: %d porta%s, %d removÃve%s, %s energizadas\n",
dev->nameunit,
nports, nports != 1 ? "s" : "",
nremov, nremov != 1 ? "is" : "l",
udev->self_powered ? "auto" : "bus"
);
if ((hub = malloc_byte (sizeof (*hub) + (nports - 1) * sizeof (struct usbd_port))) == NULL)
goto bad;
memclr (hub, (sizeof (*hub) + (nports - 1) * sizeof (struct usbd_port)));
udev->hub = hub;
udev->hub->hubsoftc = sc;
hub->explore = uhub_explore;
hub->hubdesc = *hubdesc;
free_byte (hubdesc); hubdesc = NULL;
#ifdef USB_MSG
printf
( "uhub_attach: selfpowered=%d, parent=%p, parent->selfpowered=%d\n",
dev->self_powered, dev->powersrc->parent,
dev->powersrc->parent ? dev->powersrc->parent->self_powered : 0
);
#endif USB_MSG
if (!udev->self_powered && udev->powersrc->parent != NULL && !udev->powersrc->parent->self_powered)
{
printf
( "uhub_attach (%s): bus powered hub connected to bus powered hub, ignored\n",
dev->nameunit
);
goto bad;
}
/* Set up interrupt pipe */
if (usbd_device2interface_handle (udev, 0, &iface))
{
printf ("uhub_attach (%s): no interface handle\n", dev->nameunit);
goto bad;
}
if ((ed = usbd_interface2endpoint_descriptor (iface, 0)) == NULL)
{
printf ("uhub_attach (%s): no endpoint descriptor\n", dev->nameunit);
goto bad;
}
if ((ed->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT)
{
printf ("uhub_attach (%s): bad interrupt endpoint\n", dev->nameunit);
goto bad;
}
if
( usbd_open_pipe_intr
( iface, ed->bEndpointAddress,
USBD_SHORT_XFER_OK, &sc->sc_ipipe, sc, sc->sc_status,
sizeof (sc->sc_status), uhub_intr, UHUB_INTR_INTERVAL
)
)
{
printf ("uhub_attach (%s): cannot open interrupt pipe\n", dev->nameunit);
goto bad;
}
/* Wait with power off for a while */
usbd_delay_ms (udev, USB_POWER_DOWN_TIME);
/*
* To have the best chance of success we do things in the exact same
* order as Windoze98. This should not be necessary, but some
* devices do not follow the USB specs to the letter.
*
* These are the events on the bus when a hub is attached:
* Get device and config descriptors (see attach code)
* Get hub descriptor (see above)
* For all ports
* turn on power
* wait for power to become stable
* (all below happens in explore code)
* For all ports
* clear C_PORT_CONNECTION
* For all ports
* get port status
* if device connected
* wait 100 ms
* turn on reset
* wait
* clear C_PORT_RESET
* get port status
* proceed with device attachment
*/
/* Set up data structures */
for (p = 0; p < nports; p++)
{
struct usbd_port *up = &hub->ports[p];
up->device = NULL;
up->parent = udev;
up->portno = p+1;
if (udev->self_powered) /* Self powered hub, give ports maximum current */
up->power = USB_MAX_POWER;
else
up->power = USB_MIN_POWER;
up->restartcnt = 0;
}
/* XXX should check for none, individual, or ganged power? */
pwrdly = udev->hub->hubdesc.bPwrOn2PwrGood * UHD_PWRON_FACTOR + USB_EXTRA_POWER_UP_TIME;
for (port = 1; port <= nports; port++)
{
/* Turn the power on */
if (err = usbd_set_port_feature (udev, port, UHF_PORT_POWER))
{
printf
( "uhub_attach (%s): port %d power on failed, %s\n",
dev->nameunit, port, usbd_errstr (err)
);
}
#ifdef USB_MSG
printf ("uhub_attach: turn on port %d power\n", port);
#endif USB_MSG
/* Wait for stable power */
usbd_delay_ms (udev, pwrdly);
}
/* The usual exploration will finish the setup */
sc->sc_running = 1;
return (0);
/*
* Em caso de erro, ...
*/
bad:
if (hubdesc != NULL)
free_byte (hubdesc);
if (hub != NULL)
free_byte (hub);
udev->hub = NULL;
free_byte (sc); dev->softc = NULL;
return (-1);
} /* end uhub_attach */
void
smsc_attach(struct device *parent, struct device *self, void *aux)
{
struct smsc_softc *sc = (struct smsc_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *dev = uaa->device;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
struct mii_data *mii;
struct ifnet *ifp;
int err, s, i;
uint32_t mac_h, mac_l;
sc->sc_udev = dev;
err = usbd_set_config_no(dev, SMSC_CONFIG_INDEX, 1);
/* Setup the endpoints for the SMSC LAN95xx device(s) */
usb_init_task(&sc->sc_tick_task, smsc_tick_task, sc,
USB_TASK_TYPE_GENERIC);
rw_init(&sc->sc_mii_lock, "smscmii");
usb_init_task(&sc->sc_stop_task, (void (*)(void *))smsc_stop, sc,
USB_TASK_TYPE_GENERIC);
err = usbd_device2interface_handle(dev, SMSC_IFACE_IDX, &sc->sc_iface);
if (err) {
printf("%s: getting interface handle failed\n",
sc->sc_dev.dv_xname);
return;
}
id = usbd_get_interface_descriptor(sc->sc_iface);
if (sc->sc_udev->speed >= USB_SPEED_HIGH)
sc->sc_bufsz = SMSC_MAX_BUFSZ;
else
sc->sc_bufsz = SMSC_MIN_BUFSZ;
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (!ed) {
printf("%s: couldn't get ep %d\n",
sc->sc_dev.dv_xname, i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[SMSC_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[SMSC_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_ed[SMSC_ENDPT_INTR] = ed->bEndpointAddress;
}
}
s = splnet();
ifp = &sc->sc_ac.ac_if;
ifp->if_softc = sc;
strlcpy(ifp->if_xname, sc->sc_dev.dv_xname, IFNAMSIZ);
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = smsc_ioctl;
ifp->if_start = smsc_start;
ifp->if_capabilities = IFCAP_VLAN_MTU;
/* Setup some of the basics */
sc->sc_phyno = 1;
/*
* Attempt to get the mac address, if an EEPROM is not attached this
* will just return FF:FF:FF:FF:FF:FF, so in such cases we invent a MAC
* address based on urandom.
*/
memset(sc->sc_ac.ac_enaddr, 0xff, ETHER_ADDR_LEN);
/* Check if there is already a MAC address in the register */
if ((smsc_read_reg(sc, SMSC_MAC_ADDRL, &mac_l) == 0) &&
(smsc_read_reg(sc, SMSC_MAC_ADDRH, &mac_h) == 0)) {
sc->sc_ac.ac_enaddr[5] = (uint8_t)((mac_h >> 8) & 0xff);
sc->sc_ac.ac_enaddr[4] = (uint8_t)((mac_h) & 0xff);
sc->sc_ac.ac_enaddr[3] = (uint8_t)((mac_l >> 24) & 0xff);
sc->sc_ac.ac_enaddr[2] = (uint8_t)((mac_l >> 16) & 0xff);
sc->sc_ac.ac_enaddr[1] = (uint8_t)((mac_l >> 8) & 0xff);
sc->sc_ac.ac_enaddr[0] = (uint8_t)((mac_l) & 0xff);
}
void
uslcom_attach(struct device *parent, struct device *self, void *aux)
{
struct uslcom_softc *sc = (struct uslcom_softc *)self;
struct usb_attach_arg *uaa = aux;
struct ucom_attach_args uca;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
usbd_status error;
int i;
bzero(&uca, sizeof(uca));
sc->sc_udev = uaa->device;
if (usbd_set_config_index(sc->sc_udev, USLCOM_CONFIG_NO, 1) != 0) {
printf("%s: could not set configuration no\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
/* get the first interface handle */
error = usbd_device2interface_handle(sc->sc_udev, USLCOM_IFACE_NO,
&sc->sc_iface);
if (error != 0) {
printf("%s: could not get interface handle\n",
sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
id = usbd_get_interface_descriptor(sc->sc_iface);
uca.bulkin = uca.bulkout = -1;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == NULL) {
printf("%s: no endpoint descriptor found for %d\n",
sc->sc_dev.dv_xname, i);
sc->sc_dying = 1;
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
uca.bulkin = ed->bEndpointAddress;
else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK)
uca.bulkout = ed->bEndpointAddress;
}
if (uca.bulkin == -1 || uca.bulkout == -1) {
printf("%s: missing endpoint\n", sc->sc_dev.dv_xname);
sc->sc_dying = 1;
return;
}
uca.ibufsize = USLCOMBUFSZ;
uca.obufsize = USLCOMBUFSZ;
uca.ibufsizepad = USLCOMBUFSZ;
uca.opkthdrlen = 0;
uca.device = sc->sc_udev;
uca.iface = sc->sc_iface;
uca.methods = &uslcom_methods;
uca.arg = sc;
uca.info = NULL;
sc->sc_subdev = config_found_sm(self, &uca, ucomprint, ucomsubmatch);
}
void
kue_attachhook(void *xsc)
{
struct kue_softc *sc = xsc;
int s;
struct ifnet *ifp;
usbd_device_handle dev = sc->kue_udev;
usbd_interface_handle iface;
usbd_status err;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
int i;
/* Load the firmware into the NIC. */
if (kue_load_fw(sc)) {
printf("%s: loading firmware failed\n",
sc->kue_dev.dv_xname);
return;
}
err = usbd_device2interface_handle(dev, KUE_IFACE_IDX, &iface);
if (err) {
printf("%s: getting interface handle failed\n",
sc->kue_dev.dv_xname);
return;
}
sc->kue_iface = iface;
id = usbd_get_interface_descriptor(iface);
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
printf("%s: couldn't get ep %d\n",
sc->kue_dev.dv_xname, i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->kue_ed[KUE_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->kue_ed[KUE_ENDPT_INTR] = ed->bEndpointAddress;
}
}
if (sc->kue_ed[KUE_ENDPT_RX] == 0 || sc->kue_ed[KUE_ENDPT_TX] == 0) {
printf("%s: missing endpoint\n", sc->kue_dev.dv_xname);
return;
}
/* Read ethernet descriptor */
err = kue_ctl(sc, KUE_CTL_READ, KUE_CMD_GET_ETHER_DESCRIPTOR,
0, &sc->kue_desc, sizeof(sc->kue_desc));
if (err) {
printf("%s: could not read Ethernet descriptor\n",
sc->kue_dev.dv_xname);
return;
}
sc->kue_mcfilters = malloc(KUE_MCFILTCNT(sc) * ETHER_ADDR_LEN,
M_USBDEV, M_NOWAIT);
if (sc->kue_mcfilters == NULL) {
printf("%s: no memory for multicast filter buffer\n",
sc->kue_dev.dv_xname);
return;
}
s = splnet();
/*
* A KLSI chip was detected. Inform the world.
*/
printf("%s: address %s\n", sc->kue_dev.dv_xname,
ether_sprintf(sc->kue_desc.kue_macaddr));
bcopy(sc->kue_desc.kue_macaddr,
(char *)&sc->arpcom.ac_enaddr, ETHER_ADDR_LEN);
/* Initialize interface info.*/
ifp = GET_IFP(sc);
ifp->if_softc = sc;
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_ioctl = kue_ioctl;
ifp->if_start = kue_start;
ifp->if_watchdog = kue_watchdog;
strlcpy(ifp->if_xname, sc->kue_dev.dv_xname, IFNAMSIZ);
IFQ_SET_READY(&ifp->if_snd);
/* Attach the interface. */
if_attach(ifp);
ether_ifattach(ifp);
sc->kue_attached = 1;
splx(s);
}
void
uftdi_attach(device_t parent, device_t self, void *aux)
{
struct uftdi_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usbd_interface_handle iface;
usb_device_descriptor_t *ddesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devinfop;
const char *devname = device_xname(self);
int i,idx;
usbd_status err;
struct ucom_attach_args uca;
DPRINTFN(10,("\nuftdi_attach: sc=%p\n", sc));
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UFTDI_CONFIG_INDEX, 1);
if (err) {
aprint_error("\n%s: failed to set configuration, err=%s\n",
devname, usbd_errstr(err));
goto bad;
}
sc->sc_dev = self;
sc->sc_udev = dev;
sc->sc_numports = 1;
sc->sc_type = UFTDI_TYPE_8U232AM; /* most devices are post-8U232AM */
sc->sc_hdrlen = 0;
if (uaa->vendor == USB_VENDOR_FTDI
&& uaa->product == USB_PRODUCT_FTDI_SERIAL_8U100AX) {
sc->sc_type = UFTDI_TYPE_SIO;
sc->sc_hdrlen = 1;
}
ddesc = usbd_get_device_descriptor(dev);
sc->sc_chiptype = UGETW(ddesc->bcdDevice);
switch (sc->sc_chiptype) {
case 0x500: /* 2232D */
case 0x700: /* 2232H */
sc->sc_numports = 2;
break;
case 0x800: /* 4232H */
sc->sc_numports = 4;
break;
case 0x200: /* 232/245AM */
case 0x400: /* 232/245BL */
case 0x600: /* 232/245R */
default:
break;
}
for (idx = UFTDI_IFACE_INDEX; idx < sc->sc_numports; idx++) {
err = usbd_device2interface_handle(dev, idx, &iface);
if (err) {
aprint_error(
"\n%s: failed to get interface idx=%d, err=%s\n",
devname, idx, usbd_errstr(err));
goto bad;
}
id = usbd_get_interface_descriptor(iface);
sc->sc_iface[idx] = iface;
uca.bulkin = uca.bulkout = -1;
uca.ibufsize = uca.obufsize = 0;
for (i = 0; i < id->bNumEndpoints; i++) {
int addr, dir, attr;
ed = usbd_interface2endpoint_descriptor(iface, i);
if (ed == NULL) {
aprint_error_dev(self,
"could not read endpoint descriptor: %s\n",
usbd_errstr(err));
goto bad;
}
addr = ed->bEndpointAddress;
dir = UE_GET_DIR(ed->bEndpointAddress);
attr = ed->bmAttributes & UE_XFERTYPE;
if (dir == UE_DIR_IN && attr == UE_BULK) {
uca.bulkin = addr;
uca.ibufsize = UGETW(ed->wMaxPacketSize);
if (uca.ibufsize >= UFTDI_MAX_IBUFSIZE)
uca.ibufsize = UFTDI_MAX_IBUFSIZE;
} else if (dir == UE_DIR_OUT && attr == UE_BULK) {
uca.bulkout = addr;
uca.obufsize = UGETW(ed->wMaxPacketSize)
- sc->sc_hdrlen;
if (uca.obufsize >= UFTDI_MAX_OBUFSIZE)
uca.obufsize = UFTDI_MAX_OBUFSIZE;
/* Limit length if we have a 6-bit header. */
if ((sc->sc_hdrlen > 0) &&
(uca.obufsize > UFTDIOBUFSIZE))
uca.obufsize = UFTDIOBUFSIZE;
} else {
aprint_error_dev(self,
"unexpected endpoint\n");
goto bad;
}
}
if (uca.bulkin == -1) {
aprint_error_dev(self,
"Could not find data bulk in\n");
goto bad;
}
if (uca.bulkout == -1) {
aprint_error_dev(self,
"Could not find data bulk out\n");
goto bad;
}
uca.portno = FTDI_PIT_SIOA + idx;
/* bulkin, bulkout set above */
if (uca.ibufsize == 0)
uca.ibufsize = UFTDIIBUFSIZE;
uca.ibufsizepad = uca.ibufsize;
if (uca.obufsize == 0)
uca.obufsize = UFTDIOBUFSIZE - sc->sc_hdrlen;
uca.opkthdrlen = sc->sc_hdrlen;
uca.device = dev;
uca.iface = iface;
uca.methods = &uftdi_methods;
uca.arg = sc;
uca.info = NULL;
DPRINTF(("uftdi: in=0x%x out=0x%x isize=0x%x osize=0x%x\n",
uca.bulkin, uca.bulkout,
uca.ibufsize, uca.obufsize));
sc->sc_subdev[idx] = config_found_sm_loc(self, "ucombus", NULL,
&uca, ucomprint, ucomsubmatch);
}
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_dev);
return;
bad:
DPRINTF(("uftdi_attach: ATTACH ERROR\n"));
sc->sc_dying = 1;
return;
}
static int
ubsa_attach(device_t self)
{
struct ubsa_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
usbd_device_handle dev;
struct ucom_softc *ucom;
usb_config_descriptor_t *cdesc;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
usbd_status err;
int i;
dev = uaa->device;
ucom = &sc->sc_ucom;
bzero(sc, sizeof (struct ubsa_softc));
/*
* initialize rts, dtr variables to something
* different from boolean 0, 1
*/
sc->sc_dtr = -1;
sc->sc_rts = -1;
ucom->sc_dev = self;
ucom->sc_udev = dev;
ucom->sc_iface = uaa->iface;
DPRINTF(("ubsa attach: sc = %p\n", sc));
/* initialize endpoints */
ucom->sc_bulkin_no = ucom->sc_bulkout_no = -1;
sc->sc_intr_number = -1;
sc->sc_intr_pipe = NULL;
/* Move the device into the configured state. */
err = usbd_set_config_index(dev, UBSA_CONFIG_INDEX, 1);
if (err) {
device_printf(ucom->sc_dev, "failed to set configuration: %s\n",
usbd_errstr(err));
ucom->sc_dying = 1;
goto error;
}
/* get the config descriptor */
cdesc = usbd_get_config_descriptor(ucom->sc_udev);
if (cdesc == NULL) {
device_printf(ucom->sc_dev, "failed to get configuration "
"descriptor\n");
ucom->sc_dying = 1;
goto error;
}
/* get the first interface */
err = usbd_device2interface_handle(dev, UBSA_IFACE_INDEX,
&ucom->sc_iface);
if (err) {
device_printf(ucom->sc_dev, "failed to get interface: %s\n",
usbd_errstr(err));
ucom->sc_dying = 1;
goto error;
}
/* Find the endpoints */
id = usbd_get_interface_descriptor(ucom->sc_iface);
sc->sc_iface_number = id->bInterfaceNumber;
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(ucom->sc_iface, i);
if (ed == NULL) {
device_printf(ucom->sc_dev, "no endpoint descriptor "
"for %d\n", i);
ucom->sc_dying = 1;
goto error;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_intr_number = ed->bEndpointAddress;
sc->sc_isize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
ucom->sc_bulkin_no = ed->bEndpointAddress;
ucom->sc_ibufsize = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
ucom->sc_bulkout_no = ed->bEndpointAddress;
ucom->sc_obufsize = UGETW(ed->wMaxPacketSize);
}
}
if (sc->sc_intr_number == -1) {
device_printf(ucom->sc_dev, "could not find interrupt in\n");
ucom->sc_dying = 1;
goto error;
}
/* keep interface for interrupt */
sc->sc_intr_iface = ucom->sc_iface;
if (ucom->sc_bulkin_no == -1) {
device_printf(ucom->sc_dev, "could not find data bulk in\n");
ucom->sc_dying = 1;
goto error;
}
if (ucom->sc_bulkout_no == -1) {
device_printf(ucom->sc_dev, "could not find data bulk out\n");
ucom->sc_dying = 1;
goto error;
}
ucom->sc_parent = sc;
ucom->sc_portno = UCOM_UNK_PORTNO;
/* bulkin, bulkout set above */
ucom->sc_ibufsizepad = ucom->sc_ibufsize;
ucom->sc_opkthdrlen = 0;
ucom->sc_callback = &ubsa_callback;
DPRINTF(("ubsa: in = 0x%x, out = 0x%x, intr = 0x%x\n",
ucom->sc_bulkin_no, ucom->sc_bulkout_no, sc->sc_intr_number));
ucom_attach(ucom);
return 0;
error:
return ENXIO;
}
void
smsc_attach(device_t parent, device_t self, void *aux)
{
struct smsc_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
usb_interface_descriptor_t *id;
usb_endpoint_descriptor_t *ed;
char *devinfop;
struct mii_data *mii;
struct ifnet *ifp;
int err, s, i;
uint32_t mac_h, mac_l;
sc->sc_dev = self;
sc->sc_udev = dev;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(sc->sc_udev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
err = usbd_set_config_no(dev, SMSC_CONFIG_INDEX, 1);
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
return;
}
/* Setup the endpoints for the SMSC LAN95xx device(s) */
usb_init_task(&sc->sc_tick_task, smsc_tick_task, sc, 0);
usb_init_task(&sc->sc_stop_task, (void (*)(void *))smsc_stop, sc, 0);
mutex_init(&sc->sc_mii_lock, MUTEX_DEFAULT, IPL_NONE);
err = usbd_device2interface_handle(dev, SMSC_IFACE_IDX, &sc->sc_iface);
if (err) {
aprint_error_dev(self, "getting interface handle failed\n");
return;
}
id = usbd_get_interface_descriptor(sc->sc_iface);
if (sc->sc_udev->speed >= USB_SPEED_HIGH)
sc->sc_bufsz = SMSC_MAX_BUFSZ;
else
sc->sc_bufsz = SMSC_MIN_BUFSZ;
/* Find endpoints. */
for (i = 0; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (!ed) {
aprint_error_dev(self, "couldn't get ep %d\n", i);
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[SMSC_ENDPT_RX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_BULK) {
sc->sc_ed[SMSC_ENDPT_TX] = ed->bEndpointAddress;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_ed[SMSC_ENDPT_INTR] = ed->bEndpointAddress;
}
}
s = splnet();
ifp = &sc->sc_ec.ec_if;
ifp->if_softc = sc;
strlcpy(ifp->if_xname, device_xname(sc->sc_dev), IFNAMSIZ);
ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
ifp->if_init = smsc_init;
ifp->if_ioctl = smsc_ioctl;
ifp->if_start = smsc_start;
ifp->if_stop = smsc_stop;
#ifdef notyet
/*
* We can do TCPv4, and UDPv4 checksums in hardware.
*/
ifp->if_capabilities |=
/*IFCAP_CSUM_TCPv4_Tx |*/ IFCAP_CSUM_TCPv4_Rx |
/*IFCAP_CSUM_UDPv4_Tx |*/ IFCAP_CSUM_UDPv4_Rx;
#endif
sc->sc_ec.ec_capabilities = ETHERCAP_VLAN_MTU;
/* Setup some of the basics */
sc->sc_phyno = 1;
/*
* Attempt to get the mac address, if an EEPROM is not attached this
* will just return FF:FF:FF:FF:FF:FF, so in such cases we invent a MAC
* address based on urandom.
*/
memset(sc->sc_enaddr, 0xff, ETHER_ADDR_LEN);
prop_dictionary_t dict = device_properties(self);
prop_data_t eaprop = prop_dictionary_get(dict, "mac-address");
if (eaprop != NULL) {
KASSERT(prop_object_type(eaprop) == PROP_TYPE_DATA);
KASSERT(prop_data_size(eaprop) == ETHER_ADDR_LEN);
memcpy(sc->sc_enaddr, prop_data_data_nocopy(eaprop),
ETHER_ADDR_LEN);
} else
/* Check if there is already a MAC address in the register */
if ((smsc_read_reg(sc, SMSC_MAC_ADDRL, &mac_l) == 0) &&
(smsc_read_reg(sc, SMSC_MAC_ADDRH, &mac_h) == 0)) {
sc->sc_enaddr[5] = (uint8_t)((mac_h >> 8) & 0xff);
sc->sc_enaddr[4] = (uint8_t)((mac_h) & 0xff);
sc->sc_enaddr[3] = (uint8_t)((mac_l >> 24) & 0xff);
sc->sc_enaddr[2] = (uint8_t)((mac_l >> 16) & 0xff);
sc->sc_enaddr[1] = (uint8_t)((mac_l >> 8) & 0xff);
sc->sc_enaddr[0] = (uint8_t)((mac_l) & 0xff);
}
void
uscanner_attach(device_t parent, device_t self, void *aux)
{
struct uscanner_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usb_interface_descriptor_t *id = 0;
usb_endpoint_descriptor_t *ed, *ed_bulkin = NULL, *ed_bulkout = NULL;
char *devinfop;
int i;
usbd_status err;
sc->sc_dev = self;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(uaa->device, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
sc->sc_dev_flags = uscanner_lookup(uaa->vendor, uaa->product)->flags;
sc->sc_udev = uaa->device;
err = usbd_set_config_no(uaa->device, 1, 1); /* XXX */
if (err) {
aprint_error_dev(self, "failed to set configuration"
", err=%s\n", usbd_errstr(err));
sc->sc_dying = 1;
return;
}
/* XXX We only check the first interface */
err = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface);
if (!err && sc->sc_iface)
id = usbd_get_interface_descriptor(sc->sc_iface);
if (err || id == 0) {
aprint_error_dev(self,
"could not get interface descriptor, err=%d,id=%p\n",
err, id);
sc->sc_dying = 1;
return;
}
/* Find the two first bulk endpoints */
for (i = 0 ; i < id->bNumEndpoints; i++) {
ed = usbd_interface2endpoint_descriptor(sc->sc_iface, i);
if (ed == 0) {
aprint_error_dev(self,
"could not read endpoint descriptor\n");
sc->sc_dying = 1;
return;
}
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN
&& (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
ed_bulkin = ed;
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT
&& (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {
ed_bulkout = ed;
}
if (ed_bulkin && ed_bulkout) /* found all we need */
break;
}
/* Verify that we got something sensible */
if (ed_bulkin == NULL || ed_bulkout == NULL) {
aprint_error_dev(self,
"bulk-in and/or bulk-out endpoint not found\n");
sc->sc_dying = 1;
return;
}
sc->sc_bulkin = ed_bulkin->bEndpointAddress;
sc->sc_bulkout = ed_bulkout->bEndpointAddress;
selinit(&sc->sc_selq);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_dev);
return;
}
void
uhub_attach(struct device *parent, struct device *self, void *aux)
{
struct uhub_softc *sc = (struct uhub_softc *)self;
struct usb_attach_arg *uaa = aux;
struct usbd_device *dev = uaa->device;
struct usbd_hub *hub = NULL;
union {
usb_hub_descriptor_t hs;
usb_hub_ss_descriptor_t ss;
} hd;
int p, port, nports, powerdelay;
struct usbd_interface *iface;
usb_endpoint_descriptor_t *ed;
struct usbd_tt *tts = NULL;
uint8_t ttthink = 0;
usbd_status err;
#ifdef UHUB_DEBUG
int nremov;
#endif
sc->sc_hub = dev;
err = usbd_set_config_index(dev, 0, 1);
if (err) {
DPRINTF("%s: configuration failed, error=%s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
return;
}
if (dev->depth > USB_HUB_MAX_DEPTH) {
printf("%s: hub depth (%d) exceeded, hub ignored\n",
sc->sc_dev.dv_xname, USB_HUB_MAX_DEPTH);
return;
}
/*
* Super-Speed hubs need to know their depth to be able to
* parse the bits of the route-string that correspond to
* their downstream port number.
*
* This does no apply to root hubs.
*/
if (dev->depth != 0 && dev->speed == USB_SPEED_SUPER) {
if (usbd_set_hub_depth(dev, dev->depth - 1)) {
printf("%s: unable to set HUB depth\n",
sc->sc_dev.dv_xname);
return;
}
}
/* Get hub descriptor. */
if (dev->speed == USB_SPEED_SUPER) {
err = usbd_get_hub_ss_descriptor(dev, &hd.ss, 1);
nports = hd.ss.bNbrPorts;
powerdelay = (hd.ss.bPwrOn2PwrGood * UHD_PWRON_FACTOR);
if (!err && nports > 7)
usbd_get_hub_ss_descriptor(dev, &hd.ss, nports);
} else {
err = usbd_get_hub_descriptor(dev, &hd.hs, 1);
nports = hd.hs.bNbrPorts;
powerdelay = (hd.hs.bPwrOn2PwrGood * UHD_PWRON_FACTOR);
ttthink = UGETW(hd.hs.wHubCharacteristics) & UHD_TT_THINK;
if (!err && nports > 7)
usbd_get_hub_descriptor(dev, &hd.hs, nports);
}
if (err) {
DPRINTF("%s: getting hub descriptor failed, error=%s\n",
sc->sc_dev.dv_xname, usbd_errstr(err));
return;
}
#ifdef UHUB_DEBUG
for (nremov = 0, port = 1; port <= nports; port++) {
if (dev->speed == USB_SPEED_SUPER) {
if (!UHD_NOT_REMOV(&hd.ss, port))
nremov++;
} else {
if (!UHD_NOT_REMOV(&hd.hs, port))
nremov++;
}
}
printf("%s: %d port%s with %d removable, %s powered",
sc->sc_dev.dv_xname, nports, nports != 1 ? "s" : "",
nremov, dev->self_powered ? "self" : "bus");
if (dev->depth > 0 && UHUB_IS_HIGH_SPEED(sc)) {
printf(", %s transaction translator%s",
UHUB_IS_SINGLE_TT(sc) ? "single" : "multiple",
UHUB_IS_SINGLE_TT(sc) ? "" : "s");
}
printf("\n");
#endif
if (nports == 0) {
printf("%s: no ports, hub ignored\n", sc->sc_dev.dv_xname);
goto bad;
}
hub = malloc(sizeof(*hub), M_USBDEV, M_NOWAIT);
if (hub == NULL)
return;
hub->ports = mallocarray(nports, sizeof(struct usbd_port),
M_USBDEV, M_NOWAIT);
if (hub->ports == NULL) {
free(hub, M_USBDEV, 0);
return;
}
dev->hub = hub;
dev->hub->hubsoftc = sc;
hub->explore = uhub_explore;
hub->nports = nports;
hub->powerdelay = powerdelay;
hub->ttthink = ttthink >> 5;
if (!dev->self_powered && dev->powersrc->parent != NULL &&
!dev->powersrc->parent->self_powered) {
printf("%s: bus powered hub connected to bus powered hub, "
"ignored\n", sc->sc_dev.dv_xname);
goto bad;
}
/* Set up interrupt pipe. */
err = usbd_device2interface_handle(dev, 0, &iface);
if (err) {
printf("%s: no interface handle\n", sc->sc_dev.dv_xname);
goto bad;
}
ed = usbd_interface2endpoint_descriptor(iface, 0);
if (ed == NULL) {
printf("%s: no endpoint descriptor\n", sc->sc_dev.dv_xname);
goto bad;
}
if ((ed->bmAttributes & UE_XFERTYPE) != UE_INTERRUPT) {
printf("%s: bad interrupt endpoint\n", sc->sc_dev.dv_xname);
goto bad;
}
sc->sc_statuslen = (nports + 1 + 7) / 8;
sc->sc_statusbuf = malloc(sc->sc_statuslen, M_USBDEV, M_NOWAIT);
if (!sc->sc_statusbuf)
goto bad;
err = usbd_open_pipe_intr(iface, ed->bEndpointAddress,
USBD_SHORT_XFER_OK, &sc->sc_ipipe, sc, sc->sc_statusbuf,
sc->sc_statuslen, uhub_intr, UHUB_INTR_INTERVAL);
if (err) {
printf("%s: cannot open interrupt pipe\n",
sc->sc_dev.dv_xname);
goto bad;
}
/* Wait with power off for a while. */
usbd_delay_ms(dev, USB_POWER_DOWN_TIME);
/*
* To have the best chance of success we do things in the exact same
* order as Windoze98. This should not be necessary, but some
* devices do not follow the USB specs to the letter.
*
* These are the events on the bus when a hub is attached:
* Get device and config descriptors (see attach code)
* Get hub descriptor (see above)
* For all ports
* turn on power
* wait for power to become stable
* (all below happens in explore code)
* For all ports
* clear C_PORT_CONNECTION
* For all ports
* get port status
* if device connected
* wait 100 ms
* turn on reset
* wait
* clear C_PORT_RESET
* get port status
* proceed with device attachment
*/
if (UHUB_IS_HIGH_SPEED(sc)) {
tts = mallocarray((UHUB_IS_SINGLE_TT(sc) ? 1 : nports),
sizeof (struct usbd_tt), M_USBDEV, M_NOWAIT);
if (!tts)
goto bad;
}
/* Set up data structures */
for (p = 0; p < nports; p++) {
struct usbd_port *up = &hub->ports[p];
up->device = NULL;
up->parent = dev;
up->portno = p + 1;
if (dev->self_powered)
/* Self powered hub, give ports maximum current. */
up->power = USB_MAX_POWER;
else
up->power = USB_MIN_POWER;
up->restartcnt = 0;
up->reattach = 0;
if (UHUB_IS_HIGH_SPEED(sc)) {
up->tt = &tts[UHUB_IS_SINGLE_TT(sc) ? 0 : p];
up->tt->hub = hub;
} else {
up->tt = NULL;
}
}
for (port = 1; port <= nports; port++) {
/* Turn the power on. */
err = usbd_set_port_feature(dev, port, UHF_PORT_POWER);
if (err)
printf("%s: port %d power on failed, %s\n",
sc->sc_dev.dv_xname, port,
usbd_errstr(err));
/* Make sure we check the port status at least once. */
sc->sc_status |= (1 << port);
}
/* Wait for stable power. */
if (dev->powersrc->parent != NULL)
usbd_delay_ms(dev, powerdelay + USB_EXTRA_POWER_UP_TIME);
/* The usual exploration will finish the setup. */
sc->sc_running = 1;
return;
bad:
if (sc->sc_statusbuf)
free(sc->sc_statusbuf, M_USBDEV, 0);
if (hub) {
if (hub->ports)
free(hub->ports, M_USBDEV, 0);
free(hub, M_USBDEV, 0);
}
dev->hub = NULL;
}