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; }
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; }
/* **************************************************************** * 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 */