void
ucom_cleanup(struct ucom_softc *sc)
{
DPRINTF(("ucom_cleanup: closing pipes\n"));
sc->sc_open = 0;
ucom_shutdown(sc);
if (sc->sc_bulkin_pipe != NULL) {
usbd_abort_pipe(sc->sc_bulkin_pipe);
usbd_close_pipe(sc->sc_bulkin_pipe);
sc->sc_bulkin_pipe = NULL;
}
if (sc->sc_bulkout_pipe != NULL) {
usbd_abort_pipe(sc->sc_bulkout_pipe);
usbd_close_pipe(sc->sc_bulkout_pipe);
sc->sc_bulkout_pipe = NULL;
}
if (sc->sc_ixfer != NULL) {
if (sc->sc_uhidev == NULL)
usbd_free_xfer(sc->sc_ixfer);
sc->sc_ixfer = NULL;
}
if (sc->sc_oxfer != NULL) {
usbd_free_buffer(sc->sc_oxfer);
if (sc->sc_uhidev == NULL)
usbd_free_xfer(sc->sc_oxfer);
sc->sc_oxfer = NULL;
}
}
static void
ucom_cleanup(struct ucom_softc *sc)
{
struct ucom_buffer *ub;
DPRINTF(("ucom_cleanup: closing pipes\n"));
ucom_shutdown(sc);
if (sc->sc_bulkin_pipe != NULL) {
usbd_abort_pipe(sc->sc_bulkin_pipe);
usbd_close_pipe(sc->sc_bulkin_pipe);
sc->sc_bulkin_pipe = NULL;
}
if (sc->sc_bulkout_pipe != NULL) {
usbd_abort_pipe(sc->sc_bulkout_pipe);
usbd_close_pipe(sc->sc_bulkout_pipe);
sc->sc_bulkout_pipe = NULL;
}
for (ub = &sc->sc_ibuff[0]; ub != &sc->sc_ibuff[UCOM_IN_BUFFS]; ub++) {
if (ub->ub_xfer != NULL) {
usbd_free_xfer(ub->ub_xfer);
ub->ub_xfer = NULL;
ub->ub_data = NULL;
}
}
for (ub = &sc->sc_obuff[0]; ub != &sc->sc_obuff[UCOM_OUT_BUFFS]; ub++){
if (ub->ub_xfer != NULL) {
usbd_free_xfer(ub->ub_xfer);
ub->ub_xfer = NULL;
ub->ub_data = NULL;
}
}
}
int
uirda_close(void *h, int flag, int mode,
struct lwp *l)
{
struct uirda_softc *sc = h;
DPRINTF(("%s: sc=%p\n", __func__, sc));
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;
}
if (sc->sc_rd_xfer != NULL) {
usbd_free_xfer(sc->sc_rd_xfer);
sc->sc_rd_xfer = NULL;
sc->sc_rd_buf = NULL;
}
if (sc->sc_wr_xfer != NULL) {
usbd_free_xfer(sc->sc_wr_xfer);
sc->sc_wr_xfer = NULL;
sc->sc_wr_buf = NULL;
}
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));
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);
return (0);
}
void
ubcmtp_disable(void *v)
{
struct ubcmtp_softc *sc = v;
if (usbd_is_dying(sc->sc_udev) || !(sc->sc_status & UBCMTP_ENABLED))
return;
sc->sc_status &= ~UBCMTP_ENABLED;
ubcmtp_raw_mode(sc, 0);
if (sc->sc_tp_pipe != NULL) {
usbd_abort_pipe(sc->sc_tp_pipe);
usbd_close_pipe(sc->sc_tp_pipe);
sc->sc_tp_pipe = NULL;
}
if (sc->sc_bt_pipe != NULL) {
usbd_abort_pipe(sc->sc_bt_pipe);
usbd_close_pipe(sc->sc_bt_pipe);
sc->sc_bt_pipe = NULL;
}
if (sc->tp_pkt != NULL) {
free(sc->tp_pkt, M_USBDEV, 0);
sc->tp_pkt = NULL;
}
if (sc->bt_pkt != NULL) {
free(sc->bt_pkt, M_USBDEV, 0);
sc->bt_pkt = NULL;
}
}
void cdc_abort_data_pipes(uwh_cdc_dev_h dev_ctx)
{
jcdc_dev_softc_t *sc = (jcdc_dev_softc_t *)dev_ctx;
if (sc->bulk_pipe_in)
usbd_abort_pipe(sc->bulk_pipe_in);
if (sc->bulk_pipe_out)
usbd_abort_pipe(sc->bulk_pipe_out);
}
/*
* Stop the adapter and free any mbufs allocated to the
* RX and TX lists.
*/
void
ugl_stop(struct ugl_softc *sc)
{
struct ifnet *ifp;
int i;
DPRINTFN(10,("%s: %s: enter\n", sc->sc_dev.dv_xname,__func__));
ifp = GET_IFP(sc);
ifp->if_timer = 0;
ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
/* Stop transfers. */
if (sc->sc_ep[UGL_ENDPT_RX] != NULL) {
usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_RX]);
usbd_close_pipe(sc->sc_ep[UGL_ENDPT_RX]);
sc->sc_ep[UGL_ENDPT_RX] = NULL;
}
if (sc->sc_ep[UGL_ENDPT_TX] != NULL) {
usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_TX]);
usbd_close_pipe(sc->sc_ep[UGL_ENDPT_TX]);
sc->sc_ep[UGL_ENDPT_TX] = NULL;
}
if (sc->sc_ep[UGL_ENDPT_INTR] != NULL) {
usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_INTR]);
usbd_close_pipe(sc->sc_ep[UGL_ENDPT_INTR]);
sc->sc_ep[UGL_ENDPT_INTR] = NULL;
}
/* Free RX resources. */
for (i = 0; i < UGL_RX_LIST_CNT; i++) {
if (sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf != NULL) {
m_freem(sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf);
sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf = NULL;
}
if (sc->sc_cdata.ugl_rx_chain[i].ugl_xfer != NULL) {
usbd_free_xfer(sc->sc_cdata.ugl_rx_chain[i].ugl_xfer);
sc->sc_cdata.ugl_rx_chain[i].ugl_xfer = NULL;
}
}
/* Free TX resources. */
for (i = 0; i < UGL_TX_LIST_CNT; i++) {
if (sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf != NULL) {
m_freem(sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf);
sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf = NULL;
}
if (sc->sc_cdata.ugl_tx_chain[i].ugl_xfer != NULL) {
usbd_free_xfer(sc->sc_cdata.ugl_tx_chain[i].ugl_xfer);
sc->sc_cdata.ugl_tx_chain[i].ugl_xfer = NULL;
}
}
}
/* ARGSUSED */
static int
udsir_close(void *h, int flag, int mode, struct lwp *l)
{
struct udsir_softc *sc = h;
DPRINTFN(0, ("%s: sc=%p\n", __func__, sc));
sc->sc_refcnt++;
sc->sc_rd_readinprogress = 1;
sc->sc_closing = 1;
wakeup(&sc->sc_thread);
while (sc->sc_thread != NULL)
tsleep(&sc->sc_closing, PWAIT, "usircl", 0);
if (sc->sc_rd_pipe != NULL) {
usbd_abort_pipe(sc->sc_rd_pipe);
}
if (sc->sc_wr_pipe != NULL) {
usbd_abort_pipe(sc->sc_wr_pipe);
}
if (sc->sc_rd_xfer != NULL) {
usbd_destroy_xfer(sc->sc_rd_xfer);
sc->sc_rd_xfer = NULL;
sc->sc_rd_buf = NULL;
}
if (sc->sc_wr_xfer != NULL) {
usbd_destroy_xfer(sc->sc_wr_xfer);
sc->sc_wr_xfer = NULL;
sc->sc_wr_buf = NULL;
}
if (sc->sc_rd_pipe != NULL) {
usbd_close_pipe(sc->sc_rd_pipe);
sc->sc_rd_pipe = NULL;
}
if (sc->sc_wr_pipe != NULL) {
usbd_close_pipe(sc->sc_wr_pipe);
sc->sc_wr_pipe = NULL;
}
if (sc->sc_ur_buf != NULL) {
kmem_free(sc->sc_ur_buf, IRDA_MAX_FRAME_SIZE);
sc->sc_ur_buf = NULL;
}
if (--sc->sc_refcnt < 0)
usb_detach_wakeupold(sc->sc_dev);
return 0;
}
int
ucom_detach(struct device *self, int flags)
{
struct ucom_softc *sc = (struct ucom_softc *)self;
struct tty *tp = sc->sc_tty;
int maj, mn;
int s;
DPRINTF(("ucom_detach: sc=%p flags=%d tp=%p, pipe=%d,%d\n",
sc, flags, tp, sc->sc_bulkin_no, sc->sc_bulkout_no));
sc->sc_dying = 1;
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) {
/* Wake up anyone waiting */
if (tp != NULL) {
CLR(tp->t_state, TS_CARR_ON);
CLR(tp->t_cflag, CLOCAL | MDMBUF);
ttyflush(tp, FREAD|FWRITE);
}
/* 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 == ucomopen)
break;
/* Nuke the vnodes for any open instances. */
mn = self->dv_unit;
DPRINTF(("ucom_detach: maj=%d mn=%d\n", maj, mn));
vdevgone(maj, mn, mn, VCHR);
vdevgone(maj, mn | UCOMCUA_MASK, mn | UCOMCUA_MASK, VCHR);
/* Detach and free the tty. */
if (tp != NULL) {
ttyfree(tp);
sc->sc_tty = NULL;
}
return (0);
}
int
uhidclose(dev_t dev, int flag, int mode, usb_proc_ptr p)
{
struct uhid_softc *sc;
USB_GET_SC(uhid, UHIDUNIT(dev), sc);
DPRINTF(("uhidclose: sc=%p\n", sc));
/* Disable interrupts. */
usbd_abort_pipe(sc->sc_intrpipe);
usbd_close_pipe(sc->sc_intrpipe);
sc->sc_intrpipe = 0;
ndflush(&sc->sc_q, sc->sc_q.c_cc);
clfree(&sc->sc_q);
free(sc->sc_ibuf, M_USBDEV);
free(sc->sc_obuf, M_USBDEV);
sc->sc_state &= ~UHID_OPEN;
sc->sc_async = 0;
return (0);
}
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);
}
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;
}
static void
uplcom_close(void *addr, int portno)
{
struct uplcom_softc *sc = addr;
int err;
if (sc->sc_ucom.sc_dying)
return;
DPRINTF(("uplcom_close: close\n"));
if (sc->sc_intr_pipe != NULL) {
err = usbd_abort_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: abort interrupt pipe failed: %s\n",
device_get_nameunit(sc->sc_ucom.sc_dev),
usbd_errstr(err));
err = usbd_close_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: close interrupt pipe failed: %s\n",
device_get_nameunit(sc->sc_ucom.sc_dev),
usbd_errstr(err));
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
}
static void
xboxcontroller_wsmouse_disable(void *opaque)
{
struct xboxcontroller_softc *sc;
sc = (struct xboxcontroller_softc *)opaque;
if (!sc->sc_enabled) {
aprint_error_dev(sc->sc_dev, "already disabled!\n");
return;
}
if (sc->sc_ep != NULL) {
usbd_abort_pipe(sc->sc_ep);
usbd_close_pipe(sc->sc_ep);
sc->sc_ep = NULL;
}
if (sc->sc_buf != NULL) {
free(sc->sc_buf, M_USBDEV);
sc->sc_buf = NULL;
}
sc->sc_enabled = 0;
return;
}
void
ubsa_close(void *addr, int portno)
{
struct ubsa_softc *sc = addr;
int err;
if (sc->sc_dying)
return;
DPRINTF(("ubsa_close: close\n"));
if (sc->sc_intr_pipe != NULL) {
err = usbd_abort_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: abort interrupt pipe failed: %s\n",
sc->sc_dev.dv_xname,
usbd_errstr(err));
err = usbd_close_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: close interrupt pipe failed: %s\n",
sc->sc_dev.dv_xname,
usbd_errstr(err));
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
}
usbd_status
usbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,
u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, char *lbl)
{
usbd_status err;
int s, error;
usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout,
usbd_intr_transfer_cb);
DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes\n", *size));
s = splusb(); /* don't want callback until tsleep() */
err = usbd_transfer(xfer);
if (err != USBD_IN_PROGRESS) {
splx(s);
return (err);
}
error = tsleep(xfer, PZERO | PCATCH, lbl, 0);
splx(s);
if (error) {
DPRINTF(("usbd_intr_transfer: tsleep=%d\n", error));
usbd_abort_pipe(pipe);
return (USBD_INTERRUPTED);
}
usbd_get_xfer_status(xfer, NULL, NULL, size, &err);
DPRINTFN(1,("usbd_intr_transfer: transferred %d\n", *size));
if (err) {
DPRINTF(("usbd_intr_transfer: error=%d\n", err));
usbd_clear_endpoint_stall(pipe);
}
return (err);
}
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;
}
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);
}
/*
* 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);
}
static int
u3g_detach(device_t self, int flags)
{
struct u3g_softc *sc = device_private(self);
int rv;
if (sc->sc_dying)
return 0;
pmf_device_deregister(self);
if (sc->sc_ucom != NULL) {
rv = config_detach(sc->sc_ucom, flags);
if (rv != 0) {
aprint_verbose_dev(self, "Can't deallocate "
"port (%d)", rv);
}
}
if (sc->sc_intr_pipe != NULL) {
(void) usbd_abort_pipe(sc->sc_intr_pipe);
(void) usbd_close_pipe(sc->sc_intr_pipe);
sc->sc_intr_pipe = NULL;
}
if (sc->sc_intr_buff != NULL) {
free(sc->sc_intr_buff, M_USBDEV);
sc->sc_intr_buff = NULL;
}
return (0);
}
static void
ubsa_close(void *addr, int portno)
{
struct ubsa_softc *sc;
int err;
sc = addr;
if (sc->sc_ucom.sc_dying)
return;
DPRINTF(("ubsa_close: close\n"));
if (sc->sc_intr_pipe != NULL) {
err = usbd_abort_pipe(sc->sc_intr_pipe);
if (err)
device_printf(sc->sc_ucom.sc_dev, "abort interrupt "
"pipe failed: %s\n", usbd_errstr(err));
err = usbd_close_pipe(sc->sc_intr_pipe);
if (err)
device_printf(sc->sc_ucom.sc_dev, "close interrupt "
"pipe failed: %s\n", usbd_errstr(err));
kfree(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
}
static int
ukbd_enable_intr(keyboard_t *kbd, int on, usbd_intr_t *func)
{
ukbd_state_t *state = (ukbd_state_t *)kbd->kb_data;
usbd_status err;
if (on) {
/* Set up interrupt pipe. */
if (state->ks_ifstate & INTRENABLED) {
return EBUSY;
}
state->ks_ifstate |= INTRENABLED;
err = usbd_open_pipe_intr(state->ks_iface, state->ks_ep_addr,
USBD_SHORT_XFER_OK | USBD_CALLBACK_LAST,
&state->ks_intrpipe, kbd,
&state->ks_ndata,
sizeof(state->ks_ndata), func,
USBD_DEFAULT_INTERVAL);
if (err) {
return (EIO);
}
} else {
/* Disable interrupts. */
usbd_abort_pipe(state->ks_intrpipe);
usbd_close_pipe(state->ks_intrpipe);
state->ks_ifstate &= ~INTRENABLED;
}
return (0);
}
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);
}
/*
* 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;
if (hub == NULL) /* Must be partially working */
return (0);
usbd_abort_pipe(sc->sc_ipipe);
usbd_close_pipe(sc->sc_ipipe);
for (port = 0; port < hub->nports; port++) {
rup = &hub->ports[port];
if (rup->device != NULL) {
usbd_detach(rup->device, self);
rup->device = NULL;
}
}
if (hub->ports[0].tt)
free(hub->ports[0].tt, M_USBDEV, 0);
if (sc->sc_statusbuf)
free(sc->sc_statusbuf, M_USBDEV, 0);
if (hub->ports)
free(hub->ports, M_USBDEV, 0);
free(hub, M_USBDEV, 0);
sc->sc_hub->hub = NULL;
return (0);
}
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);
}
Static void
uvscom_close(void *addr, int portno)
{
struct uvscom_softc *sc = addr;
int err;
if (sc->sc_dying)
return;
DPRINTF(("uvscom_close: close\n"));
uvscom_shutdown(sc);
if (sc->sc_intr_pipe != NULL) {
err = usbd_abort_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: abort interrupt pipe failed: %s\n",
USBDEVNAME(sc->sc_dev),
usbd_errstr(err));
err = usbd_close_pipe(sc->sc_intr_pipe);
if (err)
printf("%s: close interrupt pipe failed: %s\n",
USBDEVNAME(sc->sc_dev),
usbd_errstr(err));
free(sc->sc_intr_buf, M_USBDEV);
sc->sc_intr_pipe = NULL;
}
}
/*
****************************************************************
* Função de "detach" *
****************************************************************
*/
int
uhub_detach (struct device *dev)
{
struct uhub_softc *sc = dev->softc;
struct usbd_hub *hub;
struct usbd_port *rup;
int port, nports;
if ((hub = sc->sc_hub->hub) == NULL)
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, dev);
}
free_byte (hub); sc->sc_hub->hub = NULL;
return (0);
} /* end uhub_detach */
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;
}
/* Comment : Must be called before any other devi_hid... function */
void devi_unregister_usb_client(void * h)
{
int rc;
pModule_data_t pModule = (pModule_data_t)h;
struct timespec t;
assert(pModule);
if(pModule -> ep_int)
{
usbd_reset_pipe(pModule -> ep_int);
usbd_abort_pipe(pModule -> ep_int);
}
if(pModule -> ep_cntl)
usbd_abort_pipe(pModule -> ep_cntl);
if(pModule -> urb)
usbd_free_urb(pModule -> urb);
if(pModule -> ep_int_buf)
usbd_free(pModule -> ep_int_buf);
if(pModule -> ep_cnt_buf)
usbd_free(pModule -> ep_cnt_buf);
sleep(1);
if(EOK != (rc = usbd_detach(pModule -> pDevice)))
{
if(verbosity)
fprintf(stderr, "Detach device: error %i\n", rc);
}
clock_gettime(CLOCK_REALTIME, &t);
t.tv_sec += MAX_TIME_WAIT;
if(EOK != pthread_mutex_timedlock(&mod_mutex, &t))
return ;
LIST_REMOVE(pModule, lst_conn);
pthread_mutex_unlock(&mod_mutex);
free(pModule);
}
void cdc_close_data_pipes(uwh_cdc_dev_h dev_ctx)
{
jcdc_dev_softc_t *sc = (jcdc_dev_softc_t *)dev_ctx;
if (sc->bulk_pipe_in)
{
usbd_abort_pipe(sc->bulk_pipe_in);
usbd_close_pipe(sc->bulk_pipe_in);
sc->bulk_pipe_in = NULL;
}
if (sc->bulk_pipe_out)
{
usbd_abort_pipe(sc->bulk_pipe_out);
usbd_close_pipe(sc->bulk_pipe_out);
sc->bulk_pipe_out = NULL;
}
}
