自学教程：C++ usbd_errstr函数代码示例

/*------------------------------------------------------------------------* *	usbd_req_reset_port * * This function will instruct an USB HUB to perform a reset sequence * on the specified port number. * * Returns: *    0: Success. The USB device should now be at address zero. * Else: Failure. No USB device is present and the USB port should be *       disabled. *------------------------------------------------------------------------*/usb_error_tusbd_req_reset_port(struct usb_device *udev, struct mtx *mtx, uint8_t port){	struct usb_port_status ps;	usb_error_t err;	uint16_t n;#if USB_DEBUG	uint16_t pr_poll_delay;	uint16_t pr_recovery_delay;#endif	err = usbd_req_set_port_feature(udev, mtx, port, UHF_PORT_RESET);	if (err) {		goto done;	}#if USB_DEBUG	/* range check input parameters */	pr_poll_delay = usb_pr_poll_delay;	if (pr_poll_delay < 1) {		pr_poll_delay = 1;	} else if (pr_poll_delay > 1000) {		pr_poll_delay = 1000;	}	pr_recovery_delay = usb_pr_recovery_delay;	if (pr_recovery_delay > 1000) {		pr_recovery_delay = 1000;	}#endif	n = 0;	while (1) {#if USB_DEBUG		/* wait for the device to recover from reset */		usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_poll_delay));		n += pr_poll_delay;#else		/* wait for the device to recover from reset */		usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_DELAY));		n += USB_PORT_RESET_DELAY;#endif		err = usbd_req_get_port_status(udev, mtx, &ps, port);		if (err) {			goto done;		}		/* if the device disappeared, just give up */		if (!(UGETW(ps.wPortStatus) & UPS_CURRENT_CONNECT_STATUS)) {			goto done;		}		/* check if reset is complete */		if (UGETW(ps.wPortChange) & UPS_C_PORT_RESET) {			break;		}		/* check for timeout */		if (n > 1000) {			n = 0;			break;		}	}	/* clear port reset first */	err = usbd_req_clear_port_feature(	    udev, mtx, port, UHF_C_PORT_RESET);	if (err) {		goto done;	}	/* check for timeout */	if (n == 0) {		err = USB_ERR_TIMEOUT;		goto done;	}#if USB_DEBUG	/* wait for the device to recover from reset */	usb_pause_mtx(mtx, USB_MS_TO_TICKS(pr_recovery_delay));#else	/* wait for the device to recover from reset */	usb_pause_mtx(mtx, USB_MS_TO_TICKS(USB_PORT_RESET_RECOVERY));#endifdone:	DPRINTFN(2, "port %d reset returning error=%s/n",	    port, usbd_errstr(err));	return (err);}

/* * A frame has been uploaded: pass the resulting mbuf chain up to * the higher level protocols. */voidugl_rxeof(struct usbd_xfer *xfer, void *priv, usbd_status status){	struct ugl_chain	*c = priv;	struct ugl_softc	*sc = c->ugl_sc;	struct ifnet		*ifp = GET_IFP(sc);	struct mbuf		*m;	int			total_len = 0;	unsigned int		packet_len, packet_count;	int			s;	if (usbd_is_dying(sc->sc_udev))		return;	if (!(ifp->if_flags & IFF_RUNNING))		return;	if (status != USBD_NORMAL_COMPLETION) {		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)			return;		sc->sc_rx_errs++;		if (usbd_ratecheck(&sc->sc_rx_notice)) {			printf("%s: %u usb errors on rx: %s/n",			    sc->sc_dev.dv_xname, sc->sc_rx_errs,			    usbd_errstr(status));			sc->sc_rx_errs = 0;		}		if (status == USBD_STALLED)			usbd_clear_endpoint_stall_async(sc->sc_ep[UGL_ENDPT_RX]);		goto done;	}	usbd_get_xfer_status(xfer, NULL, NULL, &total_len, NULL);	DPRINTFN(9,("%s: %s: enter status=%d length=%d/n",		    sc->sc_dev.dv_xname, __func__, status, total_len));	if (total_len < offsetof(struct ugl_packet, pkt_data)) {		printf("%s: bad header (length=%d)/n",		    sc->sc_dev.dv_xname, total_len);		goto done;	}	packet_count = UGETDW(c->ugl_buf->pkt_count);	if (packet_count != UGL_RX_FRAMES) {		printf("%s: bad packet count (%d)/n",		    sc->sc_dev.dv_xname, packet_count);		if (packet_count == 0)			goto done;	}	packet_len = UGETDW(c->ugl_buf->pkt_length);	if (total_len < packet_len) {		printf("%s: bad packet size(%d), length=%d/n",		    sc->sc_dev.dv_xname, packet_len, total_len);		if (packet_len == 0)			goto done;	}	m = c->ugl_mbuf;	memcpy(mtod(c->ugl_mbuf, char *), c->ugl_buf->pkt_data, packet_len);	ifp->if_ipackets++;	m->m_pkthdr.len = m->m_len = packet_len;	m->m_pkthdr.rcvif = ifp;	s = splnet();	/* XXX ugly */	if (ugl_newbuf(sc, c, NULL) == ENOBUFS) {		ifp->if_ierrors++;		goto done1;	}#if NBPFILTER > 0	/*	 * Handle BPF listeners. Let the BPF user see the packet, but	 * don't pass it up to the ether_input() layer unless it's	 * a broadcast packet, multicast packet, matches our ethernet	 * address or the interface is in promiscuous mode.	 */	if (ifp->if_bpf) {		bpf_mtap(ifp->if_bpf, m, BPF_DIRECTION_IN);	}#endif	DPRINTFN(10,("%s: %s: deliver %d/n", sc->sc_dev.dv_xname,		    __func__, m->m_len));	ether_input_mbuf(ifp, m); done1://.........这里部分代码省略.........

//.........这里部分代码省略.........			SET(t.c_cflag, CLOCAL);		if (ISSET(sc->sc_swflags, TIOCFLAG_CRTSCTS))			SET(t.c_cflag, CRTSCTS);		if (ISSET(sc->sc_swflags, TIOCFLAG_MDMBUF))			SET(t.c_cflag, MDMBUF);		/* Make sure ucomparam() will do something. */		tp->t_ospeed = 0;		(void) ucomparam(tp, &t);		tp->t_iflag = TTYDEF_IFLAG;		tp->t_oflag = TTYDEF_OFLAG;		tp->t_lflag = TTYDEF_LFLAG;		ttychars(tp);		ttsetwater(tp);		/*		 * Turn on DTR.  We must always do this, even if carrier is not		 * present, because otherwise we'd have to use TIOCSDTR		 * immediately after setting CLOCAL, which applications do not		 * expect.  We always assert DTR while the device is open		 * unless explicitly requested to deassert it.  Ditto RTS.		 */		ucom_dtr(sc, 1);		ucom_rts(sc, 1);		DPRINTF(("ucomopen: open pipes in=%d out=%d/n",			 sc->sc_bulkin_no, sc->sc_bulkout_no));		/* Open the bulk pipes */		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no,				     USBD_EXCLUSIVE_USE, &sc->sc_bulkin_pipe);		if (err) {			DPRINTF(("%s: open bulk in error (addr %d), err=%s/n",				 device_xname(sc->sc_dev), sc->sc_bulkin_no,				 usbd_errstr(err)));			error = EIO;			goto fail_0;		}		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,				     USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);		if (err) {			DPRINTF(("%s: open bulk out error (addr %d), err=%s/n",				 device_xname(sc->sc_dev), sc->sc_bulkout_no,				 usbd_errstr(err)));			error = EIO;			goto fail_1;		}		sc->sc_rx_unblock = 0;		sc->sc_rx_stopped = 0;		sc->sc_tx_stopped = 0;		memset(sc->sc_ibuff, 0, sizeof(sc->sc_ibuff));		memset(sc->sc_obuff, 0, sizeof(sc->sc_obuff));		SIMPLEQ_INIT(&sc->sc_ibuff_empty);		SIMPLEQ_INIT(&sc->sc_ibuff_full);		SIMPLEQ_INIT(&sc->sc_obuff_free);		SIMPLEQ_INIT(&sc->sc_obuff_full);		/* Allocate input buffers */		for (ub = &sc->sc_ibuff[0]; ub != &sc->sc_ibuff[UCOM_IN_BUFFS];		    ub++) {			ub->ub_xfer = usbd_alloc_xfer(sc->sc_udev);			if (ub->ub_xfer == NULL) {				error = ENOMEM;				goto fail_2;

voiduhub_attach(struct device *parent, struct device *self, void *aux){    struct uhub_softc *sc = (struct uhub_softc *)self;    struct usb_attach_arg *uaa = aux;    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;    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;    }    /* Get hub descriptor. */    req.bmRequestType = UT_READ_CLASS_DEVICE;    req.bRequest = UR_GET_DESCRIPTOR;    USETW2(req.wValue, UDESC_HUB, 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",                 sc->sc_dev.dv_xname, usbd_errstr(err)));        return;    }    for (nremov = 0, port = 1; port <= nports; port++)        if (!UHD_NOT_REMOV(&hubdesc, port))            nremov++;#ifdef UHUB_DEBUG    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) + (nports-1) * sizeof(struct usbd_port),                 M_USBDEV, M_NOWAIT);    if (hub == NULL)        return;    dev->hub = hub;    dev->hub->hubsoftc = sc;    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) {        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;    }//.........这里部分代码省略.........

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;//.........这里部分代码省略.........

static voidipheth_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct ipheth_softc *sc = usbd_xfer_softc(xfer);	struct ifnet *ifp = uether_getifp(&sc->sc_ue);	struct usb_page_cache *pc;	struct mbuf *m;	uint8_t x;	int actlen;	int aframes;	usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);	DPRINTFN(1, "/n");	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTFN(11, "transfer complete: %u bytes in %u frames/n",		    actlen, aframes);		ifp->if_opackets++;		/* free all previous TX buffers */		ipheth_free_queue(sc->sc_tx_buf, IPHETH_TX_FRAMES_MAX);		/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:		for (x = 0; x != IPHETH_TX_FRAMES_MAX; x++) {			IFQ_DRV_DEQUEUE(&ifp->if_snd, m);			if (m == NULL)				break;			usbd_xfer_set_frame_offset(xfer,			    x * IPHETH_BUF_SIZE, x);			pc = usbd_xfer_get_frame(xfer, x);			sc->sc_tx_buf[x] = m;			if (m->m_pkthdr.len > IPHETH_BUF_SIZE)				m->m_pkthdr.len = IPHETH_BUF_SIZE;			usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);			usbd_xfer_set_frame_len(xfer, x, IPHETH_BUF_SIZE);			if (IPHETH_BUF_SIZE != m->m_pkthdr.len) {				usbd_frame_zero(pc, m->m_pkthdr.len,					IPHETH_BUF_SIZE - m->m_pkthdr.len);			}			/*			 * If there's a BPF listener, bounce a copy of			 * this frame to him:			 */			BPF_MTAP(ifp, m);		}		if (x != 0) {			usbd_xfer_set_frames(xfer, x);			usbd_transfer_submit(xfer);		}		break;	default:			/* Error */		DPRINTFN(11, "transfer error, %s/n",		    usbd_errstr(error));		/* free all previous TX buffers */		ipheth_free_queue(sc->sc_tx_buf, IPHETH_TX_FRAMES_MAX);		/* count output errors */		ifp->if_oerrors++;		if (error != USB_ERR_CANCELLED) {			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voidipheth_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct ipheth_softc *sc = usbd_xfer_softc(xfer);	struct mbuf *m;	uint8_t x;	int actlen;	int aframes;	int len;	usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTF("received %u bytes in %u frames/n", actlen, aframes);		for (x = 0; x != aframes; x++) {			m = sc->sc_rx_buf[x];			sc->sc_rx_buf[x] = NULL;			len = usbd_xfer_frame_len(xfer, x);			if (len < (int)(sizeof(struct ether_header) +			    IPHETH_RX_ADJ)) {				m_freem(m);				continue;			}			m_adj(m, IPHETH_RX_ADJ);			/* queue up mbuf */			uether_rxmbuf(&sc->sc_ue, m, len - IPHETH_RX_ADJ);		}		/* FALLTHROUGH */	case USB_ST_SETUP:		for (x = 0; x != IPHETH_RX_FRAMES_MAX; x++) {			if (sc->sc_rx_buf[x] == NULL) {				m = uether_newbuf();				if (m == NULL)					goto tr_stall;				/* cancel alignment for ethernet */				m_adj(m, ETHER_ALIGN);				sc->sc_rx_buf[x] = m;			} else {				m = sc->sc_rx_buf[x];			}			usbd_xfer_set_frame_data(xfer, x, m->m_data, m->m_len);		}		/* set number of frames and start hardware */		usbd_xfer_set_frames(xfer, x);		usbd_transfer_submit(xfer);		/* flush any received frames */		uether_rxflush(&sc->sc_ue);		break;	default:			/* Error */		DPRINTF("error = %s/n", usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {	tr_stall:			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			usbd_xfer_set_frames(xfer, 0);			usbd_transfer_submit(xfer);			break;		}		/* need to free the RX-mbufs when we are cancelled */		ipheth_free_queue(sc->sc_rx_buf, IPHETH_RX_FRAMES_MAX);		break;	}}

static voidcdce_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error){    struct cdce_softc *sc = usbd_xfer_softc(xfer);    struct ifnet *ifp = uether_getifp(&sc->sc_ue);    struct mbuf *m;    struct mbuf *mt;    uint32_t crc;    uint8_t x;    int actlen, aframes;    usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);    DPRINTFN(1, "/n");    switch (USB_GET_STATE(xfer)) {    case USB_ST_TRANSFERRED:        DPRINTFN(11, "transfer complete: %u bytes in %u frames/n",                 actlen, aframes);        ifp->if_opackets++;        /* free all previous TX buffers */        cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);    /* FALLTHROUGH */    case USB_ST_SETUP:tr_setup:        for (x = 0; x != CDCE_FRAMES_MAX; x++) {            IFQ_DRV_DEQUEUE(&ifp->if_snd, m);            if (m == NULL)                break;            if (sc->sc_flags & CDCE_FLAG_ZAURUS) {                /*                 * Zaurus wants a 32-bit CRC appended                 * to every frame                 */                crc = cdce_m_crc32(m, 0, m->m_pkthdr.len);                crc = htole32(crc);                if (!m_append(m, 4, (void *)&crc)) {                    m_freem(m);                    ifp->if_oerrors++;                    continue;                }            }            if (m->m_len != m->m_pkthdr.len) {                mt = m_defrag(m, M_NOWAIT);                if (mt == NULL) {                    m_freem(m);                    ifp->if_oerrors++;                    continue;                }                m = mt;            }            if (m->m_pkthdr.len > MCLBYTES) {                m->m_pkthdr.len = MCLBYTES;            }            sc->sc_tx_buf[x] = m;            usbd_xfer_set_frame_data(xfer, x, m->m_data, m->m_len);            /*             * If there's a BPF listener, bounce a copy of             * this frame to him:             */            BPF_MTAP(ifp, m);        }        if (x != 0) {            usbd_xfer_set_frames(xfer, x);            usbd_transfer_submit(xfer);        }        break;    default:			/* Error */        DPRINTFN(11, "transfer error, %s/n",                 usbd_errstr(error));        /* free all previous TX buffers */        cdce_free_queue(sc->sc_tx_buf, CDCE_FRAMES_MAX);        /* count output errors */        ifp->if_oerrors++;        if (error != USB_ERR_CANCELLED) {            /* try to clear stall first */            usbd_xfer_set_stall(xfer);            goto tr_setup;        }        break;    }}

static voidcdce_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error){    struct cdce_softc *sc = usbd_xfer_softc(xfer);    struct mbuf *m;    uint8_t x;    int actlen;    int aframes;    int len;    usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);    switch (USB_GET_STATE(xfer)) {    case USB_ST_TRANSFERRED:        DPRINTF("received %u bytes in %u frames/n", actlen, aframes);        for (x = 0; x != aframes; x++) {            m = sc->sc_rx_buf[x];            sc->sc_rx_buf[x] = NULL;            len = usbd_xfer_frame_len(xfer, x);            /* Strip off CRC added by Zaurus, if any */            if ((sc->sc_flags & CDCE_FLAG_ZAURUS) && len >= 14)                len -= 4;            if (len < (int)sizeof(struct ether_header)) {                m_freem(m);                continue;            }            /* queue up mbuf */            uether_rxmbuf(&sc->sc_ue, m, len);        }    /* FALLTHROUGH */    case USB_ST_SETUP:        /*         * TODO: Implement support for multi frame transfers,         * when the USB hardware supports it.         */        for (x = 0; x != 1; x++) {            if (sc->sc_rx_buf[x] == NULL) {                m = uether_newbuf();                if (m == NULL)                    goto tr_stall;                sc->sc_rx_buf[x] = m;            } else {                m = sc->sc_rx_buf[x];            }            usbd_xfer_set_frame_data(xfer, x, m->m_data, m->m_len);        }        /* set number of frames and start hardware */        usbd_xfer_set_frames(xfer, x);        usbd_transfer_submit(xfer);        /* flush any received frames */        uether_rxflush(&sc->sc_ue);        break;    default:			/* Error */        DPRINTF("error = %s/n",                usbd_errstr(error));        if (error != USB_ERR_CANCELLED) {tr_stall:            /* try to clear stall first */            usbd_xfer_set_stall(xfer);            usbd_xfer_set_frames(xfer, 0);            usbd_transfer_submit(xfer);            break;        }        /* need to free the RX-mbufs when we are cancelled */        cdce_free_queue(sc->sc_rx_buf, CDCE_FRAMES_MAX);        break;    }}

//.........这里部分代码省略.........                (sc->sc_ncm.dpt.dwSignature[2] != 'M') ||                (sc->sc_ncm.dpt.dwSignature[3] != '0')) {            DPRINTFN(1, "invalid DPT signature"                     "0x%02x:0x%02x:0x%02x:0x%02x/n",                     sc->sc_ncm.dpt.dwSignature[0],                     sc->sc_ncm.dpt.dwSignature[1],                     sc->sc_ncm.dpt.dwSignature[2],                     sc->sc_ncm.dpt.dwSignature[3]);            goto tr_stall;        }        nframes = UGETW(sc->sc_ncm.dpt.wLength) / 4;        /* Subtract size of header and last zero padded entry */        if (nframes >= (2 + 1))            nframes -= (2 + 1);        else            nframes = 0;        DPRINTFN(1, "nframes = %u/n", nframes);        temp += sizeof(sc->sc_ncm.dpt);        if ((temp + (4 * nframes)) > actlen)            goto tr_stall;        if (nframes > CDCE_NCM_SUBFRAMES_MAX) {            DPRINTFN(1, "Truncating number of frames from %u to %u/n",                     nframes, CDCE_NCM_SUBFRAMES_MAX);            nframes = CDCE_NCM_SUBFRAMES_MAX;        }        usbd_copy_out(pc, temp, &(sc->sc_ncm.dp), (4 * nframes));        sumdata = 0;        for (x = 0; x != nframes; x++) {            offset = UGETW(sc->sc_ncm.dp[x].wFrameIndex);            temp = UGETW(sc->sc_ncm.dp[x].wFrameLength);            if ((offset == 0) ||                    (temp < (int)sizeof(struct ether_header)) ||                    (temp > (MCLBYTES - ETHER_ALIGN))) {                DPRINTFN(1, "NULL frame detected at %d/n", x);                m = NULL;                /* silently ignore this frame */                continue;            } else if ((offset + temp) > actlen) {                DPRINTFN(1, "invalid frame "                         "detected at %d/n", x);                m = NULL;                /* silently ignore this frame */                continue;            } else if (temp > (int)(MHLEN - ETHER_ALIGN)) {                m = m_getcl(M_NOWAIT, MT_DATA, M_PKTHDR);            } else {                m = m_gethdr(M_NOWAIT, MT_DATA);            }            DPRINTFN(16, "frame %u, offset = %u, length = %u /n",                     x, offset, temp);            /* check if we have a buffer */            if (m) {                m_adj(m, ETHER_ALIGN);                usbd_copy_out(pc, offset, m->m_data, temp);                /* enqueue */                uether_rxmbuf(&sc->sc_ue, m, temp);                sumdata += temp;            } else {                ifp->if_ierrors++;            }        }        DPRINTFN(1, "Efficiency: %u/%u bytes/n", sumdata, actlen);    case USB_ST_SETUP:tr_setup:        usbd_xfer_set_frame_len(xfer, 0, sc->sc_ncm.rx_max);        usbd_xfer_set_frames(xfer, 1);        usbd_transfer_submit(xfer);        uether_rxflush(&sc->sc_ue);	/* must be last */        break;    default:			/* Error */        DPRINTFN(1, "error = %s/n",                 usbd_errstr(error));        if (error != USB_ERR_CANCELLED) {tr_stall:            /* try to clear stall first */            usbd_xfer_set_stall(xfer);            usbd_xfer_set_frames(xfer, 0);            usbd_transfer_submit(xfer);        }        break;    }}

voiduvisor_attach(struct device *parent, struct device *self, void *aux){	struct uvisor_softc *sc = (struct uvisor_softc *)self;	struct usb_attach_arg *uaa = aux;	struct usbd_device *dev = uaa->device;	struct usbd_interface *iface;	usb_interface_descriptor_t *id;	struct uvisor_connection_info coninfo;	struct uvisor_palm_connection_info palmconinfo;	usb_endpoint_descriptor_t *ed;	int i, j, hasin, hasout, port;	usbd_status err;	struct ucom_attach_args uca;	DPRINTFN(10,("/nuvisor_attach: sc=%p/n", sc));	/* Move the device into the configured state. */	err = usbd_set_config_index(dev, UVISOR_CONFIG_INDEX, 1);	if (err) {		printf(": failed to set configuration, err=%s/n",		    usbd_errstr(err));		goto bad;	}	err = usbd_device2interface_handle(dev, UVISOR_IFACE_INDEX, &iface);	if (err) {		printf(": failed to get interface, err=%s/n",		    usbd_errstr(err));		goto bad;	}	sc->sc_flags = uvisor_lookup(uaa->vendor, uaa->product)->uv_flags;	sc->sc_vendor = uaa->vendor;		if ((sc->sc_flags & (VISOR | PALM4)) == 0) {		printf("%s: device is neither visor nor palm/n", 		    sc->sc_dev.dv_xname);		goto bad;	}	id = usbd_get_interface_descriptor(iface);	sc->sc_udev = dev;	sc->sc_iface = iface;	uca.ibufsize = UVISORIBUFSIZE;	uca.obufsize = UVISOROBUFSIZE;	uca.ibufsizepad = UVISORIBUFSIZE;	uca.opkthdrlen = 0;	uca.device = dev;	uca.iface = iface;	uca.methods = &uvisor_methods;	uca.arg = sc;	err = uvisor_init(sc, &coninfo, &palmconinfo);	if (err) {		printf("%s: init failed, %s/n", sc->sc_dev.dv_xname,		       usbd_errstr(err));		goto bad;	}	if (sc->sc_flags & VISOR) {		sc->sc_numcon = UGETW(coninfo.num_ports);		if (sc->sc_numcon > UVISOR_MAX_CONN)			sc->sc_numcon = UVISOR_MAX_CONN;		/* Attach a ucom for each connection. */		for (i = 0; i < sc->sc_numcon; ++i) {			switch (coninfo.connections[i].port_function_id) {			case UVISOR_FUNCTION_GENERIC:				uca.info = "Generic";				break;			case UVISOR_FUNCTION_DEBUGGER:				uca.info = "Debugger";				break;			case UVISOR_FUNCTION_HOTSYNC:				uca.info = "HotSync";				break;			case UVISOR_FUNCTION_REMOTE_FILE_SYS:				uca.info = "Remote File System";				break;			default:				uca.info = "unknown";				break;			}			port = coninfo.connections[i].port;			uca.portno = port;			uca.bulkin = port | UE_DIR_IN;			uca.bulkout = port | UE_DIR_OUT;			/* Verify that endpoints exist. */			hasin = 0;			hasout = 0;			for (j = 0; j < id->bNumEndpoints; j++) {				ed = usbd_interface2endpoint_descriptor(iface, j);				if (ed == NULL)					break;				if (UE_GET_ADDR(ed->bEndpointAddress) == port &&				    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {					if (UE_GET_DIR(ed->bEndpointAddress)//.........这里部分代码省略.........

void uipaq_attach(device_t parent, device_t self, void *aux){	struct uipaq_softc *sc = device_private(self);	struct usb_attach_arg *uaa = aux;	usbd_device_handle dev = uaa->device;	usbd_interface_handle iface;	usb_interface_descriptor_t *id;	usb_endpoint_descriptor_t *ed;	char *devinfop;	const char *devname = device_xname(self);	int i;	usbd_status err;	struct ucom_attach_args uca;	DPRINTFN(10,("/nuipaq_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);	/* Move the device into the configured state. */	err = usbd_set_config_no(dev, UIPAQ_CONFIG_NO, 1);	if (err) {		aprint_error_dev(self, "failed to set configuration"		    ", err=%s/n", usbd_errstr(err));		goto bad;	}	err = usbd_device2interface_handle(dev, UIPAQ_IFACE_INDEX, &iface);	if (err) {		aprint_error("/n%s: failed to get interface, err=%s/n",		    devname, usbd_errstr(err));		goto bad;	}	sc->sc_flags = uipaq_lookup(uaa->vendor, uaa->product)->uv_flags;	id = usbd_get_interface_descriptor(iface);	sc->sc_udev = dev;	sc->sc_iface = iface;	uca.ibufsize = UIPAQIBUFSIZE;	uca.obufsize = UIPAQOBUFSIZE;	uca.ibufsizepad = UIPAQIBUFSIZE;	uca.opkthdrlen = 0;	uca.device = dev;	uca.iface = iface;	uca.methods = &uipaq_methods;	uca.arg = sc;	uca.portno = UCOM_UNK_PORTNO;	uca.info = "Generic";/*	err = uipaq_init(sc);	if (err) {		printf("%s: init failed, %s/n", device_xname(sc->sc_dev),		    usbd_errstr(err));		goto bad;	}*/	usbd_add_drv_event(USB_EVENT_DRIVER_ATTACH, sc->sc_udev,	    sc->sc_dev);	uca.bulkin = uca.bulkout = -1;	for (i=0; i<id->bNumEndpoints; i++) {		ed = usbd_interface2endpoint_descriptor(iface, i);		if (ed == NULL) {			aprint_error_dev(self,			    "no endpoint descriptor for %d/n", i);			goto bad;		}		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&		    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {			uca.bulkin = ed->bEndpointAddress;		} else if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_OUT &&		    (ed->bmAttributes & UE_XFERTYPE) == UE_BULK) {			uca.bulkout = ed->bEndpointAddress;		}	}	if (uca.bulkin == -1 || uca.bulkout == -1) {		aprint_error_dev(self, "no proper endpoints found (%d,%d) /n",		    uca.bulkin, uca.bulkout);		return;	}	sc->sc_subdev = config_found_sm_loc(self, "ucombus", NULL, &uca,					    ucomprint, ucomsubmatch);	return;bad:	DPRINTF(("uipaq_attach: ATTACH ERROR/n"));	sc->sc_dying = 1;	return;//.........这里部分代码省略.........

Static voiducomstart(struct tty *tp){	struct ucom_softc *sc;	struct cblock *cbp;	usbd_status err;	int s;	u_char *data;	int cnt;	USB_GET_SC(ucom, UCOMUNIT(tp->t_dev), sc);	DPRINTF(("ucomstart: sc = %p/n", sc));	if (sc->sc_dying)		return;	s = spltty();	if (tp->t_state & TS_TBLOCK) {		if (ISSET(sc->sc_mcr, UMCR_RTS) &&		    ISSET(sc->sc_state, UCS_RTS_IFLOW)) {			DPRINTF(("ucomstart: clear RTS/n"));			(void)ucomctl(sc, UMCR_RTS, DMBIC);		}	} else {		if (!ISSET(sc->sc_mcr, UMCR_RTS) &&		    tp->t_rawq.c_cc <= tp->t_ilowat &&		    ISSET(sc->sc_state, UCS_RTS_IFLOW)) {			DPRINTF(("ucomstart: set RTS/n"));			(void)ucomctl(sc, UMCR_RTS, DMBIS);		}	}	if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) {		ttwwakeup(tp);		DPRINTF(("ucomstart: stopped/n"));		goto out;	}	if (tp->t_outq.c_cc <= tp->t_olowat) {		if (ISSET(tp->t_state, TS_SO_OLOWAT)) {			CLR(tp->t_state, TS_SO_OLOWAT);			wakeup(TSA_OLOWAT(tp));		}		selwakeup(&tp->t_wsel);		if (tp->t_outq.c_cc == 0) {			if (ISSET(tp->t_state, TS_BUSY | TS_SO_OCOMPLETE) ==			    TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {				CLR(tp->t_state, TS_SO_OCOMPLETE);				wakeup(TSA_OCOMPLETE(tp));			}			goto out;		}	}	/* Grab the first contiguous region of buffer space. */	data = tp->t_outq.c_cf;	cbp = (struct cblock *) ((intptr_t) tp->t_outq.c_cf & ~CROUND);	cnt = min((char *) (cbp+1) - tp->t_outq.c_cf, tp->t_outq.c_cc);	if (cnt == 0) {		DPRINTF(("ucomstart: cnt == 0/n"));		goto out;	}	SET(tp->t_state, TS_BUSY);	if (cnt > sc->sc_obufsize) {		DPRINTF(("ucomstart: big buffer %d chars/n", cnt));		cnt = sc->sc_obufsize;	}	if (sc->sc_callback->ucom_write != NULL)		sc->sc_callback->ucom_write(sc->sc_parent, sc->sc_portno,					    sc->sc_obuf, data, &cnt);	else		memcpy(sc->sc_obuf, data, cnt);	DPRINTF(("ucomstart: %d chars/n", cnt));	usbd_setup_xfer(sc->sc_oxfer, sc->sc_bulkout_pipe, 			(usbd_private_handle)sc, sc->sc_obuf, cnt,			USBD_NO_COPY, USBD_NO_TIMEOUT, ucomwritecb);	/* What can we do on error? */	err = usbd_transfer(sc->sc_oxfer);	if (err != USBD_IN_PROGRESS)		printf("ucomstart: err=%s/n", usbd_errstr(err));	ttwwakeup(tp);    out:	splx(s);}

/*------------------------------------------------------------------------* *	usb_bus_attach * * This function attaches USB in context of the explore thread. *------------------------------------------------------------------------*/static voidusb_bus_attach(struct usb_proc_msg *pm){	struct usb_bus *bus;	struct usb_device *child;	device_t dev;	usb_error_t err;	enum usb_dev_speed speed;	bus = ((struct usb_bus_msg *)pm)->bus;	dev = bus->bdev;	DPRINTF("/n");	switch (bus->usbrev) {	case USB_REV_1_0:		speed = USB_SPEED_FULL;		device_printf(bus->bdev, "12Mbps Full Speed USB v1.0/n");		break;	case USB_REV_1_1:		speed = USB_SPEED_FULL;		device_printf(bus->bdev, "12Mbps Full Speed USB v1.1/n");		break;	case USB_REV_2_0:		speed = USB_SPEED_HIGH;		device_printf(bus->bdev, "480Mbps High Speed USB v2.0/n");		break;	case USB_REV_2_5:		speed = USB_SPEED_VARIABLE;		device_printf(bus->bdev, "480Mbps Wireless USB v2.5/n");		break;	case USB_REV_3_0:		speed = USB_SPEED_SUPER;		device_printf(bus->bdev, "5.0Gbps Super Speed USB v3.0/n");		break;	default:		device_printf(bus->bdev, "Unsupported USB revision/n");		usb_root_mount_rel(bus);		return;	}	/* default power_mask value */	bus->hw_power_state =	  USB_HW_POWER_CONTROL |	  USB_HW_POWER_BULK |	  USB_HW_POWER_INTERRUPT |	  USB_HW_POWER_ISOC |	  USB_HW_POWER_NON_ROOT_HUB;	USB_BUS_UNLOCK(bus);	/* make sure power is set at least once */	if (bus->methods->set_hw_power != NULL) {		(bus->methods->set_hw_power) (bus);	}	/* allocate the Root USB device */	child = usb_alloc_device(bus->bdev, bus, NULL, 0, 0, 1,	    speed, USB_MODE_HOST);	if (child) {		err = usb_probe_and_attach(child,		    USB_IFACE_INDEX_ANY);		if (!err) {			if ((bus->devices[USB_ROOT_HUB_ADDR] == NULL) ||			    (bus->devices[USB_ROOT_HUB_ADDR]->hub == NULL)) {				err = USB_ERR_NO_ROOT_HUB;			}		}	} else {		err = USB_ERR_NOMEM;	}	USB_BUS_LOCK(bus);	if (err) {		device_printf(bus->bdev, "Root HUB problem, error=%s/n",		    usbd_errstr(err));		usb_root_mount_rel(bus);	}	/* set softc - we are ready */	device_set_softc(dev, bus);	/* start watchdog */	usb_power_wdog(bus);}

usbd_statusuhub_explore(usbd_device_handle dev){    usb_hub_descriptor_t *hd = &dev->hub->hubdesc;    struct uhub_softc *sc = dev->hub->hubsoftc;    struct usbd_port *up;    usbd_status err;    int speed;    int port;    int change, status, reconnect;    DPRINTFN(10, ("uhub_explore dev=%p addr=%d/n", dev, dev->address));    if (!sc->sc_running)        return (USBD_NOT_STARTED);    /* Ignore hubs that are too deep. */    if (dev->depth > USB_HUB_MAX_DEPTH)        return (USBD_TOO_DEEP);    for(port = 1; port <= hd->bNbrPorts; port++) {        up = &dev->hub->ports[port-1];        err = usbd_get_port_status(dev, port, &up->status);        if (err) {            DPRINTF(("uhub_explore: get port status failed, "                     "error=%s/n", usbd_errstr(err)));            continue;        }        status = UGETW(up->status.wPortStatus);        change = UGETW(up->status.wPortChange);        reconnect = up->reattach;        up->reattach = 0;        DPRINTFN(3,("uhub_explore: %s port %d status 0x%04x 0x%04x/n",                    sc->sc_dev.dv_xname, port, status, change));        if (change & UPS_C_PORT_ENABLED) {            DPRINTF(("uhub_explore: C_PORT_ENABLED/n"));            usbd_clear_port_feature(dev, port, UHF_C_PORT_ENABLE);            if (change & UPS_C_CONNECT_STATUS) {                /* Ignore the port error if the device                   vanished. */            } else if (status & UPS_PORT_ENABLED) {                printf("%s: illegal enable change, port %d/n",                       sc->sc_dev.dv_xname, port);            } else {                /* Port error condition. */                if (up->restartcnt) /* no message first time */                    printf("%s: port error, restarting "                           "port %d/n",                           sc->sc_dev.dv_xname, port);                if (up->restartcnt++ < USBD_RESTART_MAX)                    goto disco;                else                    printf("%s: port error, giving up "                           "port %d/n",                           sc->sc_dev.dv_xname, port);            }        }        if (!reconnect && !(change & UPS_C_CONNECT_STATUS)) {            DPRINTFN(3,("uhub_explore: port=%d !C_CONNECT_"                        "STATUS/n", port));            /* No status change, just do recursive explore. */            if (up->device != NULL && up->device->hub != NULL)                up->device->hub->explore(up->device);#if 0 && defined(DIAGNOSTIC)            if (up->device == NULL &&                    (status & UPS_CURRENT_CONNECT_STATUS))                printf("%s: connected, no device/n",                       sc->sc_dev.dv_xname);#endif            continue;        }        /* We have a connect status change, handle it. */        DPRINTF(("uhub_explore: status change hub=%d port=%d/n",                 dev->address, port));        usbd_clear_port_feature(dev, port, UHF_C_PORT_CONNECTION);        /*usbd_clear_port_feature(dev, port, UHF_C_PORT_ENABLE);*/        /*         * If there is already a device on the port the change status         * must mean that is has disconnected.  Looking at the         * current connect status is not enough to figure this out         * since a new unit may have been connected before we handle         * the disconnect.         */disco:        if (up->device != NULL) {            /* Disconnected */            DPRINTF(("uhub_explore: device addr=%d disappeared "                     "on port %d/n", up->device->address, port));            usb_disconnect_port(up, &sc->sc_dev);            usbd_clear_port_feature(dev, port,                                    UHF_C_PORT_CONNECTION);        }        if (!(status & UPS_CURRENT_CONNECT_STATUS)) {            /* Nothing connected, just ignore it. */            DPRINTFN(3,("uhub_explore: port=%d !CURRENT_CONNECT"                        "_STATUS/n", port));            continue;//.........这里部分代码省略.........

static voidusie_if_status_cb(void *arg, int pending){    struct usie_softc *sc = arg;    struct ifnet *ifp = sc->sc_ifp;    struct usb_device_request req;    struct usie_hip *hip;    struct usie_lsi *lsi;    uint16_t actlen;    uint8_t ntries;    uint8_t pad;    mtx_lock(&sc->sc_mtx);    req.bmRequestType = UT_READ_CLASS_INTERFACE;    req.bRequest = UCDC_GET_ENCAPSULATED_RESPONSE;    USETW(req.wValue, 0);    USETW(req.wIndex, sc->sc_if_ifnum);    USETW(req.wLength, sizeof(sc->sc_status_temp));    for (ntries = 0; ntries != 10; ntries++) {        int err;        err = usbd_do_request_flags(sc->sc_udev,                                    &sc->sc_mtx, &req, sc->sc_status_temp, USB_SHORT_XFER_OK,                                    &actlen, USB_DEFAULT_TIMEOUT);        if (err == 0)            break;        DPRINTF("Control request failed: %s %d/10/n",                usbd_errstr(err), ntries);        usb_pause_mtx(&sc->sc_mtx, USB_MS_TO_TICKS(10));    }    if (ntries == 10) {        mtx_unlock(&sc->sc_mtx);        DPRINTF("Timeout/n");        return;    }    hip = (struct usie_hip *)sc->sc_status_temp;    pad = (hip->id & USIE_HIP_PAD) ? 1 : 0;    DPRINTF("hip.id=%x hip.len=%d actlen=%u pad=%d/n",            hip->id, be16toh(hip->len), actlen, pad);    switch (hip->id & USIE_HIP_MASK) {    case USIE_HIP_SYNC2H:        usie_if_cmd(sc, USIE_HIP_SYNC2M);        break;    case USIE_HIP_RESTR:        usb_callout_stop(&sc->sc_if_sync_ch);        break;    case USIE_HIP_UMTS:        lsi = (struct usie_lsi *)(                  sc->sc_status_temp + sizeof(struct usie_hip) + pad);        DPRINTF("lsi.proto=%x lsi.len=%d/n", lsi->proto,                be16toh(lsi->len));        if (lsi->proto != USIE_LSI_UMTS)            break;        if (lsi->area == USIE_LSI_AREA_NO ||                lsi->area == USIE_LSI_AREA_NODATA) {            device_printf(sc->sc_dev, "no service available/n");            break;        }        if (lsi->state == USIE_LSI_STATE_IDLE) {            DPRINTF("lsi.state=%x/n", lsi->state);            break;        }        DPRINTF("ctx=%x/n", hip->param);        sc->sc_txd.hip.param = hip->param;        sc->sc_net.addr_len = lsi->pdp_addr_len;        memcpy(&sc->sc_net.dns1_addr, &lsi->dns1_addr, 16);        memcpy(&sc->sc_net.dns2_addr, &lsi->dns2_addr, 16);        memcpy(sc->sc_net.pdp_addr, lsi->pdp_addr, 16);        memcpy(sc->sc_net.gw_addr, lsi->gw_addr, 16);        ifp->if_flags |= IFF_UP;        ifp->if_drv_flags |= IFF_DRV_RUNNING;        device_printf(sc->sc_dev, "IP Addr=%d.%d.%d.%d/n",                      *lsi->pdp_addr, *(lsi->pdp_addr + 1),                      *(lsi->pdp_addr + 2), *(lsi->pdp_addr + 3));        device_printf(sc->sc_dev, "Gateway Addr=%d.%d.%d.%d/n",                      *lsi->gw_addr, *(lsi->gw_addr + 1),                      *(lsi->gw_addr + 2), *(lsi->gw_addr + 3));        device_printf(sc->sc_dev, "Prim NS Addr=%d.%d.%d.%d/n",                      *lsi->dns1_addr, *(lsi->dns1_addr + 1),                      *(lsi->dns1_addr + 2), *(lsi->dns1_addr + 3));        device_printf(sc->sc_dev, "Scnd NS Addr=%d.%d.%d.%d/n",                      *lsi->dns2_addr, *(lsi->dns2_addr + 1),                      *(lsi->dns2_addr + 2), *(lsi->dns2_addr + 3));        usie_cns_req(sc, USIE_CNS_ID_RSSI, USIE_CNS_OB_RSSI);//.........这里部分代码省略.........

static voiducomreadcb(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;	struct ucom_buffer *ub;	u_int32_t cc;	u_char *cp;	int s;	ub = SIMPLEQ_FIRST(&sc->sc_ibuff_empty);	SIMPLEQ_REMOVE_HEAD(&sc->sc_ibuff_empty, ub_link);	if (status == USBD_CANCELLED || status == USBD_IOERROR ||	    sc->sc_dying) {		DPRINTF(("ucomreadcb: dying/n"));		ub->ub_index = ub->ub_len = 0;		/* Send something to wake upper layer */		s = spltty();		if (status != USBD_CANCELLED) {			(tp->t_linesw->l_rint)('/n', tp);			mutex_spin_enter(&tty_lock);	/* XXX */			ttwakeup(tp);			mutex_spin_exit(&tty_lock);	/* XXX */		}		splx(s);		return;	}	if (status == USBD_STALLED) {		usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);		ucomsubmitread(sc, ub);		return;	}	if (status != USBD_NORMAL_COMPLETION) {		printf("ucomreadcb: wonky status=%s/n", usbd_errstr(status));		return;	}	usbd_get_xfer_status(xfer, NULL, (void *)&cp, &cc, NULL);#ifdef UCOM_DEBUG	/* This is triggered by uslsa(4) occasionally. */	if ((ucomdebug > 0) && (cc == 0)) {		device_printf(sc->sc_dev, "ucomreadcb: zero length xfer!/n");	}#endif	KDASSERT(cp == ub->ub_data);	rnd_add_uint32(&sc->sc_rndsource, cc);	if (sc->sc_opening) {		ucomsubmitread(sc, ub);		return;	}	if (sc->sc_methods->ucom_read != NULL) {		sc->sc_methods->ucom_read(sc->sc_parent, sc->sc_portno,		    &cp, &cc);		ub->ub_index = (u_int)(cp - ub->ub_data);	} else		ub->ub_index = 0;	ub->ub_len = cc;	SIMPLEQ_INSERT_TAIL(&sc->sc_ibuff_full, ub, ub_link);	ucom_read_complete(sc);}

static intusie_attach(device_t self){    struct usie_softc *sc = device_get_softc(self);    struct usb_attach_arg *uaa = device_get_ivars(self);    struct ifnet *ifp;    struct usb_interface *iface;    struct usb_interface_descriptor *id;    struct usb_device_request req;    int err;    uint16_t fwattr;    uint8_t iface_index;    uint8_t ifidx;    uint8_t start;    device_set_usb_desc(self);    sc->sc_udev = uaa->device;    sc->sc_dev = self;    mtx_init(&sc->sc_mtx, "usie", MTX_NETWORK_LOCK, MTX_DEF);    ucom_ref(&sc->sc_super_ucom);    TASK_INIT(&sc->sc_if_status_task, 0, usie_if_status_cb, sc);    TASK_INIT(&sc->sc_if_sync_task, 0, usie_if_sync_cb, sc);    usb_callout_init_mtx(&sc->sc_if_sync_ch, &sc->sc_mtx, 0);    mtx_lock(&sc->sc_mtx);    /* set power mode to D0 */    req.bmRequestType = UT_WRITE_VENDOR_DEVICE;    req.bRequest = USIE_POWER;    USETW(req.wValue, 0);    USETW(req.wIndex, 0);    USETW(req.wLength, 0);    if (usie_do_request(sc, &req, NULL)) {        mtx_unlock(&sc->sc_mtx);        goto detach;    }    /* read fw attr */    fwattr = 0;    req.bmRequestType = UT_READ_VENDOR_DEVICE;    req.bRequest = USIE_FW_ATTR;    USETW(req.wValue, 0);    USETW(req.wIndex, 0);    USETW(req.wLength, sizeof(fwattr));    if (usie_do_request(sc, &req, &fwattr)) {        mtx_unlock(&sc->sc_mtx);        goto detach;    }    mtx_unlock(&sc->sc_mtx);    /* check DHCP supports */    DPRINTF("fwattr=%x/n", fwattr);    if (!(fwattr & USIE_FW_DHCP)) {        device_printf(self, "DHCP is not supported. A firmware upgrade might be needed./n");    }    /* find available interfaces */    sc->sc_nucom = 0;    for (ifidx = 0; ifidx < USIE_IFACE_MAX; ifidx++) {        iface = usbd_get_iface(uaa->device, ifidx);        if (iface == NULL)            break;        id = usbd_get_interface_descriptor(iface);        if ((id == NULL) || (id->bInterfaceClass != UICLASS_VENDOR))            continue;        /* setup Direct IP transfer */        if (id->bInterfaceNumber >= 7 && id->bNumEndpoints == 3) {            sc->sc_if_ifnum = id->bInterfaceNumber;            iface_index = ifidx;            DPRINTF("ifnum=%d, ifidx=%d/n",                    sc->sc_if_ifnum, ifidx);            err = usbd_transfer_setup(uaa->device,                                      &iface_index, sc->sc_if_xfer, usie_if_config,                                      USIE_IF_N_XFER, sc, &sc->sc_mtx);            if (err == 0)                continue;            device_printf(self,                          "could not allocate USB transfers on "                          "iface_index=%d, err=%s/n",                          iface_index, usbd_errstr(err));            goto detach;        }        /* setup ucom */        if (sc->sc_nucom >= USIE_UCOM_MAX)            continue;        usbd_set_parent_iface(uaa->device, ifidx,                              uaa->info.bIfaceIndex);        DPRINTF("NumEndpoints=%d bInterfaceNumber=%d/n",                id->bNumEndpoints, id->bInterfaceNumber);//.........这里部分代码省略.........

static voidusie_if_rx_callback(struct usb_xfer *xfer, usb_error_t error){    struct usie_softc *sc = usbd_xfer_softc(xfer);    struct ifnet *ifp = sc->sc_ifp;    struct mbuf *m0;    struct mbuf *m = NULL;    struct usie_desc *rxd;    uint32_t actlen;    uint16_t err;    uint16_t pkt;    uint16_t ipl;    uint16_t len;    uint16_t diff;    uint8_t pad;    uint8_t ipv;    usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);    switch (USB_GET_STATE(xfer)) {    case USB_ST_TRANSFERRED:        DPRINTFN(15, "rx done, actlen=%u/n", actlen);        if (actlen < sizeof(struct usie_hip)) {            DPRINTF("data too short %u/n", actlen);            goto tr_setup;        }        m = sc->sc_rxm;        sc->sc_rxm = NULL;    /* fall though */    case USB_ST_SETUP:tr_setup:        if (sc->sc_rxm == NULL) {            sc->sc_rxm = m_getjcl(M_NOWAIT, MT_DATA, M_PKTHDR,                                  MJUMPAGESIZE /* could be bigger than MCLBYTES */ );        }        if (sc->sc_rxm == NULL) {            DPRINTF("could not allocate Rx mbuf/n");            if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);            usbd_xfer_set_stall(xfer);            usbd_xfer_set_frames(xfer, 0);        } else {            /*             * Directly loading a mbuf cluster into DMA to             * save some data copying. This works because             * there is only one cluster.             */            usbd_xfer_set_frame_data(xfer, 0,                                     mtod(sc->sc_rxm, caddr_t), MIN(MJUMPAGESIZE, USIE_RXSZ_MAX));            usbd_xfer_set_frames(xfer, 1);        }        usbd_transfer_submit(xfer);        break;    default:			/* Error */        DPRINTF("USB transfer error, %s/n", usbd_errstr(error));        if (error != USB_ERR_CANCELLED) {            /* try to clear stall first */            usbd_xfer_set_stall(xfer);            if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);            goto tr_setup;        }        if (sc->sc_rxm != NULL) {            m_freem(sc->sc_rxm);            sc->sc_rxm = NULL;        }        break;    }    if (m == NULL)        return;    mtx_unlock(&sc->sc_mtx);    m->m_pkthdr.len = m->m_len = actlen;    err = pkt = 0;    /* HW can aggregate multiple frames in a single USB xfer */    for (;;) {        rxd = mtod(m, struct usie_desc *);        len = be16toh(rxd->hip.len) & USIE_HIP_IP_LEN_MASK;        pad = (rxd->hip.id & USIE_HIP_PAD) ? 1 : 0;        ipl = (len - pad - ETHER_HDR_LEN);        if (ipl >= len) {            DPRINTF("Corrupt frame/n");            m_freem(m);            break;        }        diff = sizeof(struct usie_desc) + ipl + pad;        if (((rxd->hip.id & USIE_HIP_MASK) != USIE_HIP_IP) ||                (be16toh(rxd->desc_type) & USIE_TYPE_MASK) != USIE_IP_RX) {            DPRINTF("received wrong type of packet/n");            m->m_data += diff;            m->m_pkthdr.len = (m->m_len -= diff);//.........这里部分代码省略.........

static voidusie_if_tx_callback(struct usb_xfer *xfer, usb_error_t error){    struct usie_softc *sc = usbd_xfer_softc(xfer);    struct usb_page_cache *pc;    struct ifnet *ifp = sc->sc_ifp;    struct mbuf *m;    uint16_t size;    switch (USB_GET_STATE(xfer)) {    case USB_ST_TRANSFERRED:        DPRINTFN(11, "transfer complete/n");        ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;        if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);    /* fall though */    case USB_ST_SETUP:tr_setup:        if ((ifp->if_drv_flags & IFF_DRV_RUNNING) == 0)            break;        IFQ_DRV_DEQUEUE(&ifp->if_snd, m);        if (m == NULL)            break;        if (m->m_pkthdr.len > (int)(MCLBYTES - ETHER_HDR_LEN +                                    ETHER_CRC_LEN - sizeof(sc->sc_txd))) {            DPRINTF("packet len is too big: %d/n",                    m->m_pkthdr.len);            break;        }        pc = usbd_xfer_get_frame(xfer, 0);        sc->sc_txd.hip.len = htobe16(m->m_pkthdr.len +                                     ETHER_HDR_LEN + ETHER_CRC_LEN);        size = sizeof(sc->sc_txd);        usbd_copy_in(pc, 0, &sc->sc_txd, size);        usbd_m_copy_in(pc, size, m, 0, m->m_pkthdr.len);        usbd_xfer_set_frame_len(xfer, 0, m->m_pkthdr.len +                                size + ETHER_CRC_LEN);        BPF_MTAP(ifp, m);        m_freem(m);        usbd_transfer_submit(xfer);        break;    default:			/* Error */        DPRINTF("USB transfer error, %s/n",                usbd_errstr(error));        if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);        if (error != USB_ERR_CANCELLED) {            usbd_xfer_set_stall(xfer);            if_inc_counter(ifp, IFCOUNTER_IERRORS, 1);            goto tr_setup;        }        break;    }}

static intuhid_attach(device_t dev){	struct usb_attach_arg *uaa = device_get_ivars(dev);	struct uhid_softc *sc = device_get_softc(dev);	int unit = device_get_unit(dev);	int error = 0;	DPRINTFN(10, "sc=%p/n", sc);	device_set_usb_desc(dev);	mtx_init(&sc->sc_mtx, "uhid lock", NULL, MTX_DEF | MTX_RECURSE);	sc->sc_udev = uaa->device;	sc->sc_iface_no = uaa->info.bIfaceNum;	sc->sc_iface_index = uaa->info.bIfaceIndex;	error = usbd_transfer_setup(uaa->device,	    &uaa->info.bIfaceIndex, sc->sc_xfer, uhid_config,	    UHID_N_TRANSFER, sc, &sc->sc_mtx);	if (error) {		DPRINTF("error=%s/n", usbd_errstr(error));		goto detach;	}	if (uaa->info.idVendor == USB_VENDOR_WACOM) {		/* the report descriptor for the Wacom Graphire is broken */		if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE) {			sc->sc_repdesc_size = sizeof(uhid_graphire_report_descr);			sc->sc_repdesc_ptr = (void *)&uhid_graphire_report_descr;			sc->sc_flags |= UHID_FLAG_STATIC_DESC;		} else if (uaa->info.idProduct == USB_PRODUCT_WACOM_GRAPHIRE3_4X5) {			static uint8_t reportbuf[] = {2, 2, 2};			/*			 * The Graphire3 needs 0x0202 to be written to			 * feature report ID 2 before it'll start			 * returning digitizer data.			 */			error = usbd_req_set_report(uaa->device, NULL,			    reportbuf, sizeof(reportbuf),			    uaa->info.bIfaceIndex, UHID_FEATURE_REPORT, 2);			if (error) {				DPRINTF("set report failed, error=%s (ignored)/n",				    usbd_errstr(error));			}			sc->sc_repdesc_size = sizeof(uhid_graphire3_4x5_report_descr);			sc->sc_repdesc_ptr = (void *)&uhid_graphire3_4x5_report_descr;			sc->sc_flags |= UHID_FLAG_STATIC_DESC;		}	} else if ((uaa->info.bInterfaceClass == UICLASS_VENDOR) &&		    (uaa->info.bInterfaceSubClass == UISUBCLASS_XBOX360_CONTROLLER) &&	    (uaa->info.bInterfaceProtocol == UIPROTO_XBOX360_GAMEPAD)) {		/* the Xbox 360 gamepad has no report descriptor */		sc->sc_repdesc_size = sizeof(uhid_xb360gp_report_descr);		sc->sc_repdesc_ptr = (void *)&uhid_xb360gp_report_descr;		sc->sc_flags |= UHID_FLAG_STATIC_DESC;	}	if (sc->sc_repdesc_ptr == NULL) {		error = usbd_req_get_hid_desc(uaa->device, NULL,		    &sc->sc_repdesc_ptr, &sc->sc_repdesc_size,		    M_USBDEV, uaa->info.bIfaceIndex);		if (error) {			device_printf(dev, "no report descriptor/n");			goto detach;		}	}	error = usbd_req_set_idle(uaa->device, NULL,	    uaa->info.bIfaceIndex, 0, 0);	if (error) {		DPRINTF("set idle failed, error=%s (ignored)/n",		    usbd_errstr(error));	}	sc->sc_isize = hid_report_size	    (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_input, &sc->sc_iid);	sc->sc_osize = hid_report_size	    (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_output, &sc->sc_oid);	sc->sc_fsize = hid_report_size	    (sc->sc_repdesc_ptr, sc->sc_repdesc_size, hid_feature, &sc->sc_fid);	if (sc->sc_isize > UHID_BSIZE) {		DPRINTF("input size is too large, "		    "%d bytes (truncating)/n",		    sc->sc_isize);		sc->sc_isize = UHID_BSIZE;	}//.........这里部分代码省略.........

Static intucomopen(dev_t dev, int flag, int mode, usb_proc_ptr p){	int unit = UCOMUNIT(dev);	struct ucom_softc *sc;	usbd_status err;	struct tty *tp;	int s;	int error;	USB_GET_SC_OPEN(ucom, unit, sc);	if (sc->sc_dying)		return (ENXIO);	tp = sc->sc_tty;	DPRINTF(("%s: ucomopen: tp = %p/n", USBDEVNAME(sc->sc_dev), tp));	if (ISSET(tp->t_state, TS_ISOPEN) &&	    ISSET(tp->t_state, TS_XCLUDE) &&	    suser(p))		return (EBUSY);	/*	 * Do the following iff this is a first open.	 */	s = spltty();	while (sc->sc_opening)		tsleep(&sc->sc_opening, PRIBIO, "ucomop", 0);	sc->sc_opening = 1;	if (!ISSET(tp->t_state, TS_ISOPEN)) {		struct termios t;		sc->sc_poll = 0;		sc->sc_lsr = sc->sc_msr = sc->sc_mcr = 0;		tp->t_dev = dev;		/*		 * Initialize the termios status to the defaults.  Add in the		 * sticky bits from TIOCSFLAGS.		 */		t.c_ispeed = 0;		t.c_ospeed = TTYDEF_SPEED;		t.c_cflag = TTYDEF_CFLAG;		/* Make sure ucomparam() will do something. */		tp->t_ospeed = 0;		(void)ucomparam(tp, &t);		tp->t_iflag = TTYDEF_IFLAG;		tp->t_oflag = TTYDEF_OFLAG;		tp->t_lflag = TTYDEF_LFLAG;		ttychars(tp);		ttsetwater(tp);		/*		 * Turn on DTR.  We must always do this, even if carrier is not		 * present, because otherwise we'd have to use TIOCSDTR		 * immediately after setting CLOCAL, which applications do not		 * expect.  We always assert DTR while the device is open		 * unless explicitly requested to deassert it.		 */		(void)ucomctl(sc, TIOCM_DTR | TIOCM_RTS, DMBIS);		/* Device specific open */		if (sc->sc_callback->ucom_open != NULL) {			error = sc->sc_callback->ucom_open(sc->sc_parent,							   sc->sc_portno);			if (error) {				ucom_cleanup(sc);				sc->sc_opening = 0;				wakeup(&sc->sc_opening);				splx(s);				return (error);			}		}		DPRINTF(("ucomopen: open pipes in = %d out = %d/n",			 sc->sc_bulkin_no, sc->sc_bulkout_no));		/* Open the bulk pipes */		/* Bulk-in pipe */		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkin_no, 0,				     &sc->sc_bulkin_pipe);		if (err) {			printf("%s: open bulk out error (addr %d): %s/n",			       USBDEVNAME(sc->sc_dev), sc->sc_bulkin_no, 			       usbd_errstr(err));			error = EIO;			goto fail_0;		}		/* Bulk-out pipe */		err = usbd_open_pipe(sc->sc_iface, sc->sc_bulkout_no,				     USBD_EXCLUSIVE_USE, &sc->sc_bulkout_pipe);		if (err) {			printf("%s: open bulk in error (addr %d): %s/n",			       USBDEVNAME(sc->sc_dev), sc->sc_bulkout_no,			       usbd_errstr(err));			error = EIO;//.........这里部分代码省略.........

Static voiducomreadcb(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;	int (*rint) (int c, struct tty *tp) = linesw[tp->t_line].l_rint;	usbd_status err;	u_int32_t cc;	u_char *cp;	int lostcc;	int s;	DPRINTF(("ucomreadcb: status = %d/n", status));	if (status != USBD_NORMAL_COMPLETION) {		if (!(sc->sc_state & UCS_RXSTOP))			printf("%s: ucomreadcb: %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. */		return;	}	usbd_get_xfer_status(xfer, NULL, (void **)&cp, &cc, NULL);	DPRINTF(("ucomreadcb: got %d chars, tp = %p/n", cc, tp));	if (cc == 0)		goto resubmit;	if (sc->sc_callback->ucom_read != NULL)		sc->sc_callback->ucom_read(sc->sc_parent, sc->sc_portno,					   &cp, &cc);	if (cc > sc->sc_ibufsize) {		printf("%s: invalid receive data size, %d chars/n",		       USBDEVNAME(sc->sc_dev), cc);		goto resubmit;	}	if (cc < 1)		goto resubmit;	s = spltty();	if (tp->t_state & TS_CAN_BYPASS_L_RINT) {		if (tp->t_rawq.c_cc + cc > tp->t_ihiwat		    && (sc->sc_state & UCS_RTS_IFLOW			|| tp->t_iflag & IXOFF)		    && !(tp->t_state & TS_TBLOCK))			ttyblock(tp);		lostcc = b_to_q((char *)cp, cc, &tp->t_rawq);		tp->t_rawcc += cc;		ttwakeup(tp);		if (tp->t_state & TS_TTSTOP		    && (tp->t_iflag & IXANY			|| tp->t_cc[VSTART] == tp->t_cc[VSTOP])) {			tp->t_state &= ~TS_TTSTOP;			tp->t_lflag &= ~FLUSHO;			ucomstart(tp);		}		if (lostcc > 0)			printf("%s: lost %d chars/n", USBDEVNAME(sc->sc_dev),			       lostcc);	} else {		/* Give characters to tty layer. */		while (cc > 0) {			DPRINTFN(7, ("ucomreadcb: char = 0x%02x/n", *cp));			if ((*rint)(*cp, tp) == -1) {				/* XXX what should we do? */				printf("%s: lost %d chars/n",				       USBDEVNAME(sc->sc_dev), cc);				break;			}			cc--;			cp++;		}	}	splx(s);    resubmit:	err = ucomstartread(sc);	if (err) {		printf("%s: read start failed/n", USBDEVNAME(sc->sc_dev));		/* XXX what should we dow now? */	}	if ((sc->sc_state & UCS_RTS_IFLOW) && !ISSET(sc->sc_mcr, UMCR_RTS)	    && !(tp->t_state & TS_TBLOCK))		ucomctl(sc, UMCR_RTS, DMBIS);}