int
uhidev_detach(device_t self, int flags)
{
struct uhidev_softc *sc = device_private(self);
int i, rv;
struct uhidev *csc;
DPRINTF(("uhidev_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
if (sc->sc_ipipe != NULL)
usbd_abort_pipe(sc->sc_ipipe);
if (sc->sc_repdesc != NULL)
kmem_free(sc->sc_repdesc, sc->sc_repdesc_size);
rv = 0;
for (i = 0; i < sc->sc_nrepid; i++) {
if (sc->sc_subdevs[i] != NULL) {
csc = device_private(sc->sc_subdevs[i]);
rnd_detach_source(&csc->rnd_source);
rv |= config_detach(sc->sc_subdevs[i], flags);
}
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
pmf_device_deregister(self);
mutex_destroy(&sc->sc_lock);
return rv;
}
int
umct_detach(struct device *self, int flags)
{
struct umct_softc *sc = (struct umct_softc *)self;
int rv = 0;
DPRINTF(("umct_detach: sc=%p flags=%d\n", sc, flags));
if (sc->sc_intr_pipe != NULL) {
usbd_abort_pipe(sc->sc_intr_pipe);
usbd_close_pipe(sc->sc_intr_pipe);
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
sc->sc_dying = 1;
if (sc->sc_subdev != NULL) {
rv = config_detach(sc->sc_subdev, flags);
sc->sc_subdev = NULL;
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
&sc->sc_dev);
return (rv);
}
int
ubsa_detach(device_t self, int flags)
{
struct ubsa_softc *sc = device_private(self);
int i;
int rv = 0;
DPRINTF(("ubsa_detach: sc = %p\n", sc));
if (sc->sc_intr_pipe != NULL) {
usbd_abort_pipe(sc->sc_intr_pipe);
usbd_close_pipe(sc->sc_intr_pipe);
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
sc->sc_dying = 1;
for (i = 0; i < sc->sc_numif; i++) {
if (sc->sc_subdevs[i] != NULL)
rv |= config_detach(sc->sc_subdevs[i], flags);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (rv);
}
static int
ndisusb_detach(device_t self)
{
int i, error;
struct ndis_softc *sc = device_get_softc(self);
struct usb_attach_arg *uaa = device_get_ivars(self);
wlan_serialize_enter();
sc->ndisusb_status |= NDISUSB_STATUS_DETACH;
for (i = 0; i < NDISUSB_ENDPT_MAX; i++) {
if (sc->ndisusb_ep[i] == NULL)
continue;
usbd_abort_pipe(sc->ndisusb_ep[i]);
usbd_close_pipe(sc->ndisusb_ep[i]);
sc->ndisusb_ep[i] = NULL;
}
if (sc->ndisusb_iin_buf != NULL) {
kfree(sc->ndisusb_iin_buf, M_USBDEV);
sc->ndisusb_iin_buf = NULL;
}
ndis_pnpevent_nic(self, NDIS_PNP_EVENT_SURPRISE_REMOVED);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, uaa->device, self);
error = ndis_detach(self);
wlan_serialize_exit();
return error;
}
void
uberry_attach(device_t parent, device_t self, void *aux)
{
struct uberry_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
usbd_device_handle dev = uaa->device;
char *devinfop;
DPRINTFN(10,("uberry_attach: sc=%p\n", sc));
sc->sc_dev = self;
sc->sc_udev = dev;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
uberry_charge(sc);
if (uaa->product == USB_PRODUCT_RIM_BLACKBERRY_PEARL)
uberry_dual_mode(sc);
DPRINTFN(10, ("uberry_attach: %p\n", sc->sc_udev));
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
return;
}
int
uhidev_detach(struct device *self, int flags)
{
struct uhidev_softc *sc = (struct uhidev_softc *)self;
int i, rv;
DPRINTF(("uhidev_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
if (sc->sc_ipipe != NULL)
usbd_abort_pipe(sc->sc_ipipe);
if (sc->sc_repdesc != NULL)
free(sc->sc_repdesc, M_USBDEV);
rv = 0;
for (i = 0; i < sc->sc_nrepid; i++) {
if (sc->sc_subdevs[i] != NULL) {
rv |= config_detach(&sc->sc_subdevs[i]->sc_dev, flags);
sc->sc_subdevs[i] = NULL;
}
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
&sc->sc_dev);
return (rv);
}
/*
* Called from process context when the hub is gone.
* Detach all devices on active ports.
*/
int
uhub_detach(struct device *self, int flags)
{
struct uhub_softc *sc = (struct uhub_softc *)self;
struct usbd_hub *hub = sc->sc_hub->hub;
struct usbd_port *rup;
int port, nports;
DPRINTF(("uhub_detach: sc=%p flags=%d\n", sc, flags));
if (hub == NULL) /* Must be partially working */
return (0);
usbd_abort_pipe(sc->sc_ipipe);
usbd_close_pipe(sc->sc_ipipe);
nports = hub->hubdesc.bNbrPorts;
for(port = 0; port < nports; port++) {
rup = &hub->ports[port];
if (rup->device)
usb_disconnect_port(rup, self);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_hub,
&sc->sc_dev);
if (hub->ports[0].tt)
free(hub->ports[0].tt, M_USBDEV);
free(hub, M_USBDEV);
sc->sc_hub->hub = NULL;
return (0);
}
void
uipad_attach(device_t parent, device_t self, void *aux)
{
struct uipad_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
struct usbd_device * dev = uaa->uaa_device;
char *devinfop;
DPRINTFN(10,("uipad_attach: sc=%p\n", sc));
sc->sc_dev = self;
sc->sc_udev = dev;
aprint_naive("\n");
aprint_normal("\n");
devinfop = usbd_devinfo_alloc(dev, 0);
aprint_normal_dev(self, "%s\n", devinfop);
usbd_devinfo_free(devinfop);
uipad_charge(sc);
DPRINTFN(10, ("uipad_attach: %p\n", sc->sc_udev));
if (!pmf_device_register(self, NULL, NULL))
aprint_error_dev(self, "couldn't establish power handler\n");
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
return;
}
int
uticom_detach(struct device *self, int flags)
{
struct uticom_softc *sc = (struct uticom_softc *)self;
DPRINTF(("%s: uticom_detach: sc = %p\n",
sc->sc_dev.dv_xname, sc));
sc->sc_dying = 1;
if (sc->sc_subdev != NULL) {
config_detach(sc->sc_subdev, flags);
sc->sc_subdev = NULL;
}
if (sc->sc_intr_pipe != NULL) {
usbd_abort_pipe(sc->sc_intr_pipe);
usbd_close_pipe(sc->sc_intr_pipe);
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
&sc->sc_dev);
return (0);
}
/* detach */
int
url_detach(device_t self, int flags)
{
struct url_softc *sc = device_private(self);
struct ifnet *ifp = GET_IFP(sc);
int s;
DPRINTF(("%s: %s: enter\n", device_xname(sc->sc_dev), __func__));
/* Detached before attached finished */
if (!sc->sc_attached)
return (0);
callout_stop(&sc->sc_stat_ch);
/* Remove any pending tasks */
usb_rem_task(sc->sc_udev, &sc->sc_tick_task);
usb_rem_task(sc->sc_udev, &sc->sc_stop_task);
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away */
usb_detach_waitold(sc->sc_dev);
}
if (ifp->if_flags & IFF_RUNNING)
url_stop(GET_IFP(sc), 1);
rnd_detach_source(&sc->rnd_source);
mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);
ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);
ether_ifdetach(ifp);
if_detach(ifp);
#ifdef DIAGNOSTIC
if (sc->sc_pipe_tx != NULL)
aprint_debug_dev(self, "detach has active tx endpoint.\n");
if (sc->sc_pipe_rx != NULL)
aprint_debug_dev(self, "detach has active rx endpoint.\n");
if (sc->sc_pipe_intr != NULL)
aprint_debug_dev(self, "detach has active intr endpoint.\n");
#endif
sc->sc_attached = 0;
splx(s);
rw_destroy(&sc->sc_mii_rwlock);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (0);
}
int
uberry_detach(device_t self, int flags)
{
struct uberry_softc *sc = device_private(self);
DPRINTF(("uberry_detach: sc=%p flags=%d\n", sc, flags));
pmf_device_deregister(self);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
return (0);
}
static int
moscom_detach(device_t self)
{
struct moscom_softc *sc = device_get_softc(self);
int rv = 0;
sc->sc_ucom.sc_dying = 1;
rv = ucom_detach(&sc->sc_ucom);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
sc->sc_ucom.sc_dev);
return (rv);
}
int
moscom_detach(device_t self, int flags)
{
struct moscom_softc *sc = device_private(self);
int rv = 0;
sc->sc_dying = 1;
if (sc->sc_subdev != NULL)
rv = config_detach(sc->sc_subdev, flags);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (rv);
}
int
uipaq_detach(device_t self, int flags)
{
struct uipaq_softc *sc = device_private(self);
int rv = 0;
DPRINTF(("uipaq_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
if (sc->sc_subdev != NULL)
rv |= config_detach(sc->sc_subdev, flags);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (rv);
}
static int
udsir_detach(device_t self, int flags)
{
struct udsir_softc *sc = device_private(self);
int s;
int rv = 0;
DPRINTFN(0, ("udsir_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_closing = sc->sc_dying = 1;
wakeup(&sc->sc_thread);
while (sc->sc_thread != NULL)
tsleep(&sc->sc_closing, PWAIT, "usircl", 0);
/* Abort all pipes. Causes processes waiting for transfer to wake. */
if (sc->sc_rd_pipe != NULL) {
usbd_abort_pipe(sc->sc_rd_pipe);
usbd_close_pipe(sc->sc_rd_pipe);
sc->sc_rd_pipe = NULL;
}
if (sc->sc_wr_pipe != NULL) {
usbd_abort_pipe(sc->sc_wr_pipe);
usbd_close_pipe(sc->sc_wr_pipe);
sc->sc_wr_pipe = NULL;
}
wakeup(&sc->sc_ur_framelen);
wakeup(&sc->sc_wr_buf);
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away. */
usb_detach_waitold(sc->sc_dev);
}
splx(s);
if (sc->sc_child != NULL)
rv = config_detach(sc->sc_child, flags);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev, sc->sc_dev);
seldestroy(&sc->sc_rd_sel);
seldestroy(&sc->sc_wr_sel);
return rv;
}
int
uipaq_detach(struct device *self, int flags)
{
struct uipaq_softc *sc = (struct uipaq_softc *)self;
int rv = 0;
DPRINTF(("uipaq_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
if (sc->sc_subdev != NULL) {
rv |= config_detach(sc->sc_subdev, flags);
sc->sc_subdev = NULL;
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
&sc->sc_dev);
return (rv);
}
int
uftdi_detach(device_t self, int flags)
{
struct uftdi_softc *sc = device_private(self);
int i;
DPRINTF(("uftdi_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
for (i=0; i < sc->sc_numports; i++) {
if (sc->sc_subdev[i] != NULL)
config_detach(sc->sc_subdev[i], flags);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (0);
}
static int
ubt_detach(device_t self)
{
struct ubt_softc *sc = device_get_softc(self);
DPRINTF("sc=%p \n", sc);
sc->sc_dying = 1;
if (!sc->sc_ok)
return 0;
/* Detach HCI interface */
if (sc->sc_unit) {
hci_detach(sc->sc_unit);
sc->sc_unit = NULL;
}
/*
* Abort all pipes. Causes processes waiting for transfer to wake.
*
* Actually, hci_detach() above will call ubt_disable() which may
* call ubt_abortdealloc(), but lets be sure since doing it twice
* wont cause an error.
*/
ubt_abortdealloc(sc);
/* wait for all processes to finish */
if (sc->sc_refcnt-- > 0)
usb_detach_wait(sc->sc_dev);
if (sc->sysctl_tree != NULL) {
sc->sysctl_tree = NULL;
sysctl_ctx_free(&sc->sysctl_ctx);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
DPRINTFN(1, "driver detached\n");
return 0;
}
int
urio_detach(device_t self, int flags)
{
struct urio_softc *sc = device_private(self);
int s;
int maj, mn;
DPRINTF(("urio_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
/* Abort all pipes. Causes processes waiting for transfer to wake. */
if (sc->sc_in_pipe != NULL) {
usbd_abort_pipe(sc->sc_in_pipe);
usbd_close_pipe(sc->sc_in_pipe);
sc->sc_in_pipe = NULL;
}
if (sc->sc_out_pipe != NULL) {
usbd_abort_pipe(sc->sc_out_pipe);
usbd_close_pipe(sc->sc_out_pipe);
sc->sc_out_pipe = NULL;
}
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away. */
usb_detach_waitold(sc->sc_dev);
}
splx(s);
/* locate the major number */
maj = cdevsw_lookup_major(&urio_cdevsw);
/* Nuke the vnodes for any open instances (calls close). */
mn = device_unit(self);
vdevgone(maj, mn, mn, VCHR);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
return (0);
}
int
uyurex_detach(device_t self, int flags)
{
struct uyurex_softc *sc = device_private(self);
int rv = 0;
sc->sc_dying = 1;
callout_halt(&sc->sc_deltach, NULL);
callout_destroy(&sc->sc_deltach);
sysmon_envsys_unregister(sc->sc_sme);
if (sc->sc_ibuf != NULL) {
free(sc->sc_ibuf, M_USBDEV);
sc->sc_ibuf = NULL;
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_hdev.sc_dev);
return (rv);
}
static int
ugensa_detach(device_t self)
{
struct ugensa_softc *sc = device_get_softc(self);
int rv = 0;
/* close the interrupt endpoint if that is opened */
if (sc->sc_intr_pipe != NULL) {
usbd_abort_pipe(sc->sc_intr_pipe);
usbd_close_pipe(sc->sc_intr_pipe);
kfree(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
DPRINTF(("ugensa_detach: sc=%p\n", sc));
sc->sc_ucom.sc_dying = 1;
rv = ucom_detach(&sc->sc_ucom);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_ucom.sc_udev,
sc->sc_ucom.sc_dev);
return (rv);
}
/*
* Called from process context when the hub is gone.
* Detach all devices on active ports.
*/
static int
uhub_detach(device_t self)
{
struct uhub_softc *sc = device_get_softc(self);
struct usbd_hub *hub = sc->sc_hub->hub;
struct usbd_port *rup;
int port, nports;
DPRINTF(("uhub_detach: sc=%port\n", sc));
crit_enter();
if (hub == NULL) { /* Must be partially working */
crit_exit();
return (0);
}
usbd_abort_pipe(sc->sc_ipipe);
usbd_close_pipe(sc->sc_ipipe);
nports = hub->hubdesc.bNbrPorts;
for(port = 0; port < nports; port++) {
rup = &hub->ports[port];
if (rup->device)
usb_disconnect_port(rup, self);
}
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_hub, self);
if (hub->ports[0].tt)
kfree(hub->ports[0].tt, M_USBDEV);
kfree(hub, M_USBDEV);
sc->sc_hub->hub = NULL;
crit_exit();
return (0);
}
int
uscanner_detach(device_t self, int flags)
{
struct uscanner_softc *sc = device_private(self);
int s;
int maj, mn;
DPRINTF(("uscanner_detach: sc=%p flags=%d\n", sc, flags));
sc->sc_dying = 1;
sc->sc_dev_flags = 0; /* make close really close device */
/* Abort all pipes. Causes processes waiting for transfer to wake. */
if (sc->sc_bulkin_pipe != NULL)
usbd_abort_pipe(sc->sc_bulkin_pipe);
if (sc->sc_bulkout_pipe != NULL)
usbd_abort_pipe(sc->sc_bulkout_pipe);
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wait for processes to go away. */
usb_detach_waitold(sc->sc_dev);
}
splx(s);
/* locate the major number */
maj = cdevsw_lookup_major(&uscanner_cdevsw);
/* Nuke the vnodes for any open instances (calls close). */
mn = device_unit(self) * USB_MAX_ENDPOINTS;
vdevgone(maj, mn, mn + USB_MAX_ENDPOINTS - 1, VCHR);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
sc->sc_dev);
seldestroy(&sc->sc_selq);
return (0);
}
int
ulpt_detach(struct device *self, int flags)
{
struct ulpt_softc *sc = (struct ulpt_softc *)self;
int s;
int maj, mn;
DPRINTF(("ulpt_detach: sc=%p\n", sc));
sc->sc_dying = 1;
if (sc->sc_out_pipe != NULL)
usbd_abort_pipe(sc->sc_out_pipe);
if (sc->sc_in_pipe != NULL)
usbd_abort_pipe(sc->sc_in_pipe);
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* There is noone to wake, aborting the pipe is enough */
/* Wait for processes to go away. */
usb_detach_wait(&sc->sc_dev);
}
splx(s);
/* locate the major number */
for (maj = 0; maj < nchrdev; maj++)
if (cdevsw[maj].d_open == ulptopen)
break;
/* Nuke the vnodes for any open instances (calls close). */
mn = self->dv_unit;
vdevgone(maj, mn, mn, VCHR);
vdevgone(maj, mn | ULPT_NOPRIME , mn | ULPT_NOPRIME, VCHR);
usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,
&sc->sc_dev);
return (0);
}
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;
}
static void
udsir_attach(device_t parent, device_t self, void *aux)
{
struct udsir_softc *sc = device_private(self);
struct usbif_attach_arg *uiaa = aux;
struct usbd_device *dev = uiaa->uiaa_device;
struct usbd_interface *iface = uiaa->uiaa_iface;
char *devinfop;
usb_endpoint_descriptor_t *ed;
uint8_t epcount;
int i;
struct ir_attach_args ia;
DPRINTFN(10, ("udsir_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);
sc->sc_udev = dev;
sc->sc_iface = iface;
epcount = 0;
(void)usbd_endpoint_count(iface, &epcount);
sc->sc_rd_addr = -1;
sc->sc_wr_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_INTERRUPT) {
sc->sc_rd_addr = ed->bEndpointAddress;
sc->sc_rd_maxpsz = UGETW(ed->wMaxPacketSize);
} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&
UE_GET_XFERTYPE(ed->bmAttributes) == UE_INTERRUPT) {
sc->sc_wr_addr = ed->bEndpointAddress;
sc->sc_wr_maxpsz = UGETW(ed->wMaxPacketSize);
}
}
if (sc->sc_rd_addr == -1 || sc->sc_wr_addr == -1) {
aprint_error_dev(self, "missing endpoint\n");
return;
}
DPRINTFN(10, ("udsir_attach: %p\n", sc->sc_udev));
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev, sc->sc_dev);
ia.ia_type = IR_TYPE_IRFRAME;
ia.ia_methods = &udsir_methods;
ia.ia_handle = sc;
sc->sc_child = config_found(self, &ia, ir_print);
selinit(&sc->sc_rd_sel);
selinit(&sc->sc_wr_sel);
return;
}
void
uyurex_attach(device_t parent, device_t self, void *aux)
{
struct uyurex_softc *sc = device_private(self);
struct usb_attach_arg *uaa = aux;
struct uhidev_attach_arg *uha = (struct uhidev_attach_arg *)uaa;
usbd_device_handle dev = uha->parent->sc_udev;
int size, repid, err;
void *desc;
sc->sc_udev = dev;
sc->sc_hdev.sc_dev = self;
sc->sc_hdev.sc_intr = uyurex_intr;
sc->sc_hdev.sc_parent = uha->parent;
sc->sc_hdev.sc_report_id = uha->reportid;
uhidev_get_report_desc(uha->parent, &desc, &size);
repid = uha->reportid;
sc->sc_ilen = hid_report_size(desc, size, hid_input, repid);
sc->sc_olen = hid_report_size(desc, size, hid_output, repid);
sc->sc_flen = hid_report_size(desc, size, hid_feature, repid);
aprint_normal("\n");
aprint_naive("\n");
err = uhidev_open(&sc->sc_hdev);
if (err) {
aprint_error_dev(self, "uyurex_open: uhidev_open %d\n", err);
return;
}
sc->sc_ibuf = malloc(sc->sc_ilen, M_USBDEV, M_WAITOK);
usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,
sc->sc_hdev.sc_dev);
/* attach sensor */
sc->sc_sme = sysmon_envsys_create();
/* error handling? XXX */
sc->sc_sme->sme_name = device_xname(self);
/* add BBU sensor */
sc->sc_sensor_val.units = ENVSYS_INTEGER;
sc->sc_sensor_val.state = ENVSYS_SINVALID;
sc->sc_sensor_val.flags = ENVSYS_FMONCRITICAL; /* abuse XXX */
strlcpy(sc->sc_sensor_val.desc, "BBU",
sizeof(sc->sc_sensor_val.desc));
sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_val);
/* add BBU delta sensor */
sc->sc_sensor_delta.units = ENVSYS_INTEGER;
sc->sc_sensor_delta.state = ENVSYS_SINVALID;
strlcpy(sc->sc_sensor_delta.desc, "mBBU/sec",
sizeof(sc->sc_sensor_delta.desc));
sysmon_envsys_sensor_attach(sc->sc_sme, &sc->sc_sensor_delta);
sc->sc_sme->sme_cookie = sc;
sc->sc_sme->sme_refresh = uyurex_refresh;
sc->sc_sme->sme_events_timeout = UPDATE_TICK;
sc->sc_sme->sme_flags = SME_INIT_REFRESH;
if (sysmon_envsys_register(sc->sc_sme)) {
aprint_error_dev(self, "unable to register with sysmon\n");
sysmon_envsys_destroy(sc->sc_sme);
}
callout_init(&sc->sc_deltach, 0);
callout_reset(&sc->sc_deltach, UPDATE_TICK * hz, uyurex_delta, sc);
DPRINTF(("uyurex_attach: complete\n"));
/* init device */ /* XXX */
uyurex_set_mode(sc, 0);
}
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;
}
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
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);
}
