/* read 1byte from register */ Static int url_csr_read_1(struct url_softc *sc, int reg) { u_int8_t val = 0; DPRINTFN(0x100, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return (0); return (url_mem(sc, URL_CMD_READMEM, reg, &val, 1) ? 0 : val); }
Static void url_watchdog(struct ifnet *ifp) { struct url_softc *sc = ifp->if_softc; struct url_chain *c; usbd_status stat; int s; DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); ifp->if_oerrors++; printf("%s: watchdog timeout\n", USBDEVNAME(sc->sc_dev)); s = splusb(); c = &sc->sc_cdata.url_tx_chain[0]; usbd_get_xfer_status(c->url_xfer, NULL, NULL, NULL, &stat); url_txeof(c->url_xfer, c, stat); if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) url_start(ifp); splx(s); }
/* write 1byte to register */ Static int url_csr_write_1(struct url_softc *sc, int reg, int aval) { u_int8_t val = aval; DPRINTFN(0x100, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return (0); return (url_mem(sc, URL_CMD_WRITEMEM, reg, &val, 1) ? -1 : 0); }
Static void url_tick_task(void *xsc) { struct url_softc *sc = xsc; struct ifnet *ifp; struct mii_data *mii; int s; if (sc == NULL) return; DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return; ifp = GET_IFP(sc); mii = GET_MII(sc); if (mii == NULL) return; s = splnet(); mii_tick(mii); if (!sc->sc_link && mii->mii_media_status & IFM_ACTIVE && IFM_SUBTYPE(mii->mii_media_active) != IFM_NONE) { DPRINTF(("%s: %s: got link\n", USBDEVNAME(sc->sc_dev), __func__)); sc->sc_link++; if (IFQ_IS_EMPTY(&ifp->if_snd) == 0) url_start(ifp); } usb_callout(sc->sc_stat_ch, hz, url_tick, sc); splx(s); }
void uplcom_intr(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) { struct uplcom_softc *sc = priv; u_char *buf = sc->sc_intr_buf; u_char pstatus; if (sc->sc_dying) return; if (status != USBD_NORMAL_COMPLETION) { if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) return; DPRINTF(("%s: abnormal status: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(status))); usbd_clear_endpoint_stall_async(sc->sc_intr_pipe); return; } DPRINTF(("%s: uplcom status = %02x\n", USBDEVNAME(sc->sc_dev), buf[8])); sc->sc_lsr = sc->sc_msr = 0; pstatus = buf[8]; if (ISSET(pstatus, RSAQ_STATUS_CTS)) sc->sc_msr |= UMSR_CTS; else sc->sc_msr &= ~UMSR_CTS; if (ISSET(pstatus, RSAQ_STATUS_DSR)) sc->sc_msr |= UMSR_DSR; else sc->sc_msr &= ~UMSR_DSR; if (ISSET(pstatus, RSAQ_STATUS_DCD)) sc->sc_msr |= UMSR_DCD; else sc->sc_msr &= ~UMSR_DCD; ucom_status_change((struct ucom_softc *) sc->sc_subdev); }
Static void url_miibus_statchg(device_ptr_t dev) { #ifdef URL_DEBUG struct url_softc *sc; if (dev == NULL) return; sc = USBGETSOFTC(dev); DPRINTF(("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); #endif /* Nothing to do */ }
/* alloc/free pipe */ static usbd_status alloc_pipe(struct umidi_endpoint *ep) { struct umidi_softc *sc = ep->sc; usbd_status err; usb_endpoint_descriptor_t *epd; epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr); /* * For output, an improvement would be to have a buffer bigger than * wMaxPacketSize by num_jacks-1 additional packet slots; that would * allow out_solicit to fill the buffer to the full packet size in * all cases. But to use usbd_alloc_buffer to get a slightly larger * buffer would not be a good way to do that, because if the addition * would make the buffer exceed USB_MEM_SMALL then a substantially * larger block may be wastefully allocated. Some flavor of double * buffering could serve the same purpose, but would increase the * code complexity, so for now I will live with the current slight * penalty of reducing max transfer size by (num_open-num_scheduled) * packet slots. */ ep->buffer_size = UGETW(epd->wMaxPacketSize); ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE; DPRINTF(("%s: alloc_pipe %p, buffer size %u\n", USBDEVNAME(sc->sc_dev), ep, ep->buffer_size)); ep->num_scheduled = 0; ep->this_schedule = 0; ep->next_schedule = 0; ep->soliciting = 0; ep->armed = 0; ep->xfer = usbd_alloc_xfer(sc->sc_udev); if (ep->xfer == NULL) { err = USBD_NOMEM; goto quit; } ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size); if (ep->buffer == NULL) { usbd_free_xfer(ep->xfer); err = USBD_NOMEM; goto quit; } ep->next_slot = ep->buffer; err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe); if (err) usbd_free_xfer(ep->xfer); ep->solicit_cookie = softint_establish(SOFTINT_CLOCK, out_solicit, ep); quit: return err; }
/* read 2bytes from register */ Static int url_csr_read_2(struct url_softc *sc, int reg) { uWord val; DPRINTFN(0x100, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return (0); USETW(val, 0); return (url_mem(sc, URL_CMD_READMEM, reg, &val, 2) ? 0 : UGETW(val)); }
Static usbd_status uvscom_shutdown(struct uvscom_softc *sc) { usb_device_request_t req; usbd_status err; DPRINTF(("%s: send shutdown\n", USBDEVNAME(sc->sc_dev))); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = UVSCOM_SHUTDOWN; USETW(req.wValue, 0); USETW(req.wIndex, 0); USETW(req.wLength, 0); err = usbd_do_request(sc->sc_udev, &req, NULL); if (err) { printf("%s: uvscom_shutdown: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(err)); return (err); } return (USBD_NORMAL_COMPLETION); }
Static void umct_close(void *addr, int portno) { struct umct_softc *sc; int err; sc = addr; if (sc->sc_ucom.sc_dying) return; 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_ucom.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_ucom.sc_dev), usbd_errstr(err)); free(sc->sc_intr_buf, M_USBDEV); sc->sc_intr_pipe = NULL; } }
/* read/write memory */ Static int url_mem(struct url_softc *sc, int cmd, int offset, void *buf, int len) { usb_device_request_t req; usbd_status err; if (sc == NULL) return (0); DPRINTFN(0x200, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return (0); if (cmd == URL_CMD_READMEM) req.bmRequestType = UT_READ_VENDOR_DEVICE; else req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = URL_REQ_MEM; USETW(req.wValue, offset); USETW(req.wIndex, 0x0000); USETW(req.wLength, len); sc->sc_refcnt++; err = usbd_do_request(sc->sc_udev, &req, buf); if (--sc->sc_refcnt < 0) usb_detach_wakeup(USBDEV(sc->sc_dev)); if (err) { DPRINTF(("%s: url_mem(): %s failed. off=%04x, err=%d\n", USBDEVNAME(sc->sc_dev), cmd == URL_CMD_READMEM ? "read" : "write", offset, err)); } return (err); }
Static usbd_status uvscom_set_line_coding(struct uvscom_softc *sc, uint16_t lsp, uint16_t ls) { usb_device_request_t req; usbd_status err; DPRINTF(("%s: uvscom_set_line_coding: %02x %02x\n", USBDEVNAME(sc->sc_dev), lsp, ls)); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = UVSCOM_SET_SPEED; USETW(req.wValue, lsp); USETW(req.wIndex, 0); USETW(req.wLength, 0); err = usbd_do_request(sc->sc_udev, &req, NULL); if (err) { printf("%s: uvscom_set_line_coding: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(err)); return (err); } req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = UVSCOM_SET_PARAM; USETW(req.wValue, ls); USETW(req.wIndex, 0); USETW(req.wLength, 0); err = usbd_do_request(sc->sc_udev, &req, NULL); if (err) { printf("%s: uvscom_set_line_coding: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(err)); return (err); } return (USBD_NORMAL_COMPLETION); }
Static void cdce_txeof(usbd_xfer_handle xfer, usbd_private_handle priv, usbd_status status) { struct ue_chain *c = priv; struct cdce_softc *sc = c->ue_sc; struct ifnet *ifp; usbd_status err; CDCE_LOCK(sc); ifp = GET_IFP(sc); if (sc->cdce_dying || !(ifp->if_flags & IFF_RUNNING)) { CDCE_UNLOCK(sc); return; } if (status != USBD_NORMAL_COMPLETION) { if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) { CDCE_UNLOCK(sc); return; } ifp->if_oerrors++; printf("%s: usb error on tx: %s\n", USBDEVNAME(sc->cdce_dev), usbd_errstr(status)); if (status == USBD_STALLED) usbd_clear_endpoint_stall(sc->cdce_bulkout_pipe); CDCE_UNLOCK(sc); return; } ifp->if_flags &= ~IFF_OACTIVE; usbd_get_xfer_status(c->ue_xfer, NULL, NULL, NULL, &err); if (c->ue_mbuf != NULL) { c->ue_mbuf->m_pkthdr.rcvif = ifp; usb_tx_done(c->ue_mbuf); c->ue_mbuf = NULL; } if (err) ifp->if_oerrors++; else ifp->if_opackets++; CDCE_UNLOCK(sc); return; }
static void dump_sc(struct umidi_softc *sc) { int i; DPRINTFN(10, ("%s: dump_sc\n", USBDEVNAME(sc->sc_dev))); for (i=0; i<sc->sc_out_num_endpoints; i++) { DPRINTFN(10, ("\tout_ep(%p):\n", &sc->sc_out_ep[i])); dump_ep(&sc->sc_out_ep[i]); } for (i=0; i<sc->sc_in_num_endpoints; i++) { DPRINTFN(10, ("\tin_ep(%p):\n", &sc->sc_in_ep[i])); dump_ep(&sc->sc_in_ep[i]); } }
static void uslsa_set(void *vsc, int portno, int reg, int onoff) { struct uslsa_softc *sc; sc = vsc; DPRINTF(("uslsa_set: sc=%p, port=%d reg=%d onoff=%d\n", sc, portno, reg, onoff)); switch (reg) { case UCOM_SET_DTR: if (uslsa_request_set(sc, USLSA_REQ_SET_FLOW, (onoff ? (USLSA_FLOW_DTR | USLSA_FLOW_SET_DTR) : USLSA_FLOW_SET_DTR))) printf("%s: uslsa_set_dtr failed\n", USBDEVNAME(sc->sc_dev)); break; case UCOM_SET_RTS: if (uslsa_request_set(sc, USLSA_REQ_SET_FLOW, (onoff ? (USLSA_FLOW_RTS | USLSA_FLOW_SET_RTS) : USLSA_FLOW_SET_RTS))) printf("%s: uslsa_set_rts failed\n", USBDEVNAME(sc->sc_dev)); break; case UCOM_SET_BREAK: if (uslsa_request_set(sc, USLSA_REQ_SET_BREAK, (onoff ? USLSA_BREAK_ENABLE : USLSA_BREAK_DISABLE))) printf("%s: uslsa_set_break failed\n", USBDEVNAME(sc->sc_dev)); break; default: break; } }
Static usbd_status umass_init_insystem(struct umass_softc *sc) { usbd_status err; err = usbd_set_interface(sc->sc_iface, 1); if (err) { DPRINTF(UDMASS_USB, ("%s: could not switch to Alt Interface 1\n", USBDEVNAME(sc->sc_dev))); return (err); } return (USBD_NORMAL_COMPLETION); }
Static usbd_status uvscom_set_line(struct uvscom_softc *sc, uint16_t line) { usb_device_request_t req; usbd_status err; DPRINTF(("%s: uvscom_set_line: %04x\n", USBDEVNAME(sc->sc_ucom.sc_dev), line)); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = UVSCOM_LINE_CTL; USETW(req.wValue, line); USETW(req.wIndex, 0); USETW(req.wLength, 0); err = usbd_do_request(sc->sc_ucom.sc_udev, &req, NULL); if (err) { printf("%s: uvscom_set_line: %s\n", USBDEVNAME(sc->sc_ucom.sc_dev), usbd_errstr(err)); return (err); } return (USBD_NORMAL_COMPLETION); }
Static usbd_status kue_setword(struct kue_softc *sc, u_int8_t breq, u_int16_t word) { usb_device_request_t req; DPRINTFN(10,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev),__func__)); req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = breq; USETW(req.wValue, word); USETW(req.wIndex, 0); USETW(req.wLength, 0); return (usbd_do_request(sc->kue_udev, &req, NULL)); }
Static void url_tick(void *xsc) { struct url_softc *sc = xsc; if (sc == NULL) return; DPRINTFN(0xff, ("%s: %s: enter\n", USBDEVNAME(sc->sc_dev), __func__)); if (sc->sc_dying) return; /* Perform periodic stuff in process context */ usb_add_task(sc->sc_udev, &sc->sc_tick_task); }
void uslsa_close(void *vsc, int portno) { struct uslsa_softc *sc; sc = vsc; if (sc->sc_dying) return; DPRINTF(("uslsa_close: sc=%p\n", sc)); if (uslsa_request_set(sc, USLSA_REQ_SET_STATE, USLSA_STATE_DISABLE)) printf("%s: disable-on-close failed\n", USBDEVNAME(sc->sc_dev)); }
int kue_activate(device_ptr_t self, enum devact act) { struct kue_softc *sc = device_private(self); DPRINTFN(2,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __func__)); switch (act) { case DVACT_DEACTIVATE: /* Deactivate the interface. */ if_deactivate(&sc->kue_ec.ec_if); sc->kue_dying = 1; return 0; default: return EOPNOTSUPP; } }
Static void kue_setmulti(struct kue_softc *sc) { struct ifnet *ifp = GET_IFP(sc); struct ether_multi *enm; struct ether_multistep step; int i; DPRINTFN(5,("%s: %s: enter\n", USBDEVNAME(sc->kue_dev), __func__)); if (ifp->if_flags & IFF_PROMISC) { allmulti: ifp->if_flags |= IFF_ALLMULTI; sc->kue_rxfilt |= KUE_RXFILT_ALLMULTI; sc->kue_rxfilt &= ~KUE_RXFILT_MULTICAST; kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); return; } sc->kue_rxfilt &= ~KUE_RXFILT_ALLMULTI; i = 0; #if defined (__NetBSD__) ETHER_FIRST_MULTI(step, &sc->kue_ec, enm); #else ETHER_FIRST_MULTI(step, &sc->arpcom, enm); #endif while (enm != NULL) { if (i == KUE_MCFILTCNT(sc) || memcmp(enm->enm_addrlo, enm->enm_addrhi, ETHER_ADDR_LEN) != 0) goto allmulti; memcpy(KUE_MCFILT(sc, i), enm->enm_addrlo, ETHER_ADDR_LEN); ETHER_NEXT_MULTI(step, enm); i++; } ifp->if_flags &= ~IFF_ALLMULTI; sc->kue_rxfilt |= KUE_RXFILT_MULTICAST; kue_ctl(sc, KUE_CTL_WRITE, KUE_CMD_SET_MCAST_FILTERS, i, sc->kue_mcfilters, i * ETHER_ADDR_LEN); kue_setword(sc, KUE_CMD_SET_PKT_FILTER, sc->kue_rxfilt); }
int ukbd_detach(device_t self, int flags) { struct ukbd_softc *sc = device_private(self); int rv = 0; DPRINTF(("ukbd_detach: sc=%p flags=%d\n", sc, flags)); pmf_device_deregister(self); if (sc->sc_console_keyboard) { #if 0 /* * XXX Should probably disconnect our consops, * XXX and either notify some other keyboard that * XXX it can now be the console, or if there aren't * XXX any more USB keyboards, set ukbd_is_console * XXX back to 1 so that the next USB keyboard attached * XXX to the system will get it. */ panic("ukbd_detach: console keyboard"); #else /* * Disconnect our consops and set ukbd_is_console * back to 1 so that the next USB keyboard attached * to the system will get it. * XXX Should notify some other keyboard that it can be * XXX console, if there are any other keyboards. */ printf("%s: was console keyboard\n", USBDEVNAME(sc->sc_hdev.sc_dev)); wskbd_cndetach(); ukbd_is_console = 1; #endif } /* No need to do reference counting of ukbd, wskbd has all the goo. */ if (sc->sc_wskbddev != NULL) rv = config_detach(sc->sc_wskbddev, flags); /* The console keyboard does not get a disable call, so check pipe. */ if (sc->sc_hdev.sc_state & UHIDEV_OPEN) uhidev_close(&sc->sc_hdev); return (rv); }
Static void ucomwritecb(usbd_xfer_handle xfer, usbd_private_handle p, usbd_status status) { struct ucom_softc *sc = (struct ucom_softc *)p; struct tty *tp = sc->sc_tty; u_int32_t cc; int s; DPRINTF(("ucomwritecb: status = %d\n", status)); if (status == USBD_CANCELLED || sc->sc_dying) goto error; if (status != USBD_NORMAL_COMPLETION) { printf("%s: ucomwritecb: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(status)); if (status == USBD_STALLED) usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe); /* XXX we should restart after some delay. */ goto error; } usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL); DPRINTF(("ucomwritecb: cc = %d\n", cc)); /* convert from USB bytes to tty bytes */ cc -= sc->sc_opkthdrlen; s = spltty(); CLR(tp->t_state, TS_BUSY); if (ISSET(tp->t_state, TS_FLUSH)) CLR(tp->t_state, TS_FLUSH); else ndflush(&tp->t_outq, cc); (*linesw[tp->t_line].l_start)(tp); splx(s); return; error: s = spltty(); CLR(tp->t_state, TS_BUSY); splx(s); return; }
/* * uslsa_request_set(), wrapper for doing sets with usbd_do_request() */ static int uslsa_request_set(struct uslsa_softc * sc, uint8_t request, uint16_t value) { usb_device_request_t req; usbd_status err; req.bmRequestType = USLSA_REQUEST_SET; req.bRequest = request; USETW(req.wValue, value); USETW(req.wIndex, 0); USETW(req.wLength, 0); err = usbd_do_request(sc->sc_udev, &req, 0); if (err) printf("%s: uslsa_request: %s\n", USBDEVNAME(sc->sc_dev), usbd_errstr(err)); return err; }
Static void uvscom_rts(struct uvscom_softc *sc, int onoff) { DPRINTF(("%s: uvscom_rts: onoff = %d\n", USBDEVNAME(sc->sc_dev), onoff)); if (sc->sc_rts == onoff) return; /* no change */ sc->sc_rts = onoff; if (onoff) SET(sc->sc_lcr, UVSCOM_RTS); else CLR(sc->sc_lcr, UVSCOM_RTS); uvscom_set_line(sc, sc->sc_lcr); }
static int ucomclose(dev_t dev, int flag, int mode, usb_proc_ptr p) { struct ucom_softc *sc; struct tty *tp; int s; USB_GET_SC(ucom, UCOMUNIT(dev), sc); tp = sc->sc_tty; DPRINTF(("%s: ucomclose: unit = %d\n", USBDEVNAME(sc->sc_dev), UCOMUNIT(dev))); if (!ISSET(tp->t_state, TS_ISOPEN)) goto quit; s = spltty(); (*linesw[tp->t_line].l_close)(tp, flag); disc_optim(tp, &tp->t_termios, sc); ttyclose(tp); splx(s); if (sc->sc_dying) goto quit; if (!ISSET(tp->t_state, TS_ISOPEN)) { /* * Although we got a last close, the device may still be in * use; e.g. if this was the dialout node, and there are still * processes waiting for carrier on the non-dialout node. */ ucom_cleanup(sc); } if (sc->sc_callback->ucom_close != NULL) sc->sc_callback->ucom_close(sc->sc_parent, sc->sc_portno); quit: if (--sc->sc_refcnt < 0) usb_detach_wakeup(USBDEV(sc->sc_dev)); return (0); }
/* * TODO: the 0-based cable numbers will often not match the labeling of the * equipment. Ideally: * For class-compliant devices: get the iJack string from the jack descriptor. * Otherwise: * - support a DISPLAY_BASE_CN quirk (add the value to each internal cable * number for display) * - support an array quirk explictly giving a char * for each jack. * For now, you get 0-based cable numbers. If there are multiple endpoints and * the CNs are not globally unique, each is shown with its associated endpoint * address in hex also. That should not be necessary when using iJack values * or a quirk array. */ static char * describe_mididev(struct umidi_mididev *md) { char in_label[16]; char out_label[16]; const char *unit_label; char *final_label; struct umidi_softc *sc; int show_ep_in; int show_ep_out; size_t len; sc = md->sc; show_ep_in = sc-> sc_in_num_endpoints > 1 && !sc->cblnums_global; show_ep_out = sc->sc_out_num_endpoints > 1 && !sc->cblnums_global; if ( NULL != md->in_jack ) snprintf(in_label, sizeof in_label, show_ep_in ? "<%d(%x) " : "<%d ", md->in_jack->cable_number, md->in_jack->endpoint->addr); else in_label[0] = '\0'; if ( NULL != md->out_jack ) snprintf(out_label, sizeof out_label, show_ep_out ? ">%d(%x) " : ">%d ", md->out_jack->cable_number, md->out_jack->endpoint->addr); else in_label[0] = '\0'; unit_label = USBDEVNAME(sc->sc_dev); len = strlen(in_label) + strlen(out_label) + strlen(unit_label) + 4; final_label = malloc(len, M_USBDEV, M_WAITOK); snprintf(final_label, len, "%s%son %s", in_label, out_label, unit_label); return final_label; }
Static int umct_request(struct umct_softc *sc, uint8_t request, int len, uint32_t value) { usb_device_request_t req; usbd_status err; uint8_t oval[4]; req.bmRequestType = UT_WRITE_VENDOR_DEVICE; req.bRequest = request; USETW(req.wValue, 0); USETW(req.wIndex, sc->sc_iface_number); USETW(req.wLength, len); USETDW(oval, value); err = usbd_do_request(sc->sc_ucom.sc_udev, &req, oval); if (err) printf("%s: ubsa_request: %s\n", USBDEVNAME(sc->sc_ucom.sc_dev), usbd_errstr(err)); return (err); }
int url_activate(device_ptr_t self, enum devact act) { struct url_softc *sc = (struct url_softc *)self; DPRINTF(("%s: %s: enter, act=%d\n", USBDEVNAME(sc->sc_dev), __func__, act)); switch (act) { case DVACT_ACTIVATE: break; case DVACT_DEACTIVATE: if_deactivate(GET_IFP(sc)); sc->sc_dying = 1; break; } return (0); }