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

static voidcdce_intr_write_callback(struct usb_xfer *xfer, usb_error_t error){	int actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTF("Transferred %d bytes/n", actlen);		/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:#if 0		usbd_xfer_set_frame_len(xfer, 0, XXX);		usbd_transfer_submit(xfer);#endif		break;	default:			/* Error */		if (error != USB_ERR_CANCELLED) {			/* start clear stall */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voiduhso_bs_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct uhso_softc *sc = usbd_xfer_softc(xfer);	struct usb_page_cache *pc;	int actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	UHSO_DPRINTF(3, "status %d, actlen=%d/n", USB_GET_STATE(xfer), actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:	case USB_ST_SETUP:tr_setup:		pc = usbd_xfer_get_frame(xfer, 0);		if (ucom_get_data(&sc->sc_ucom[0], pc, 0, 8192, &actlen)) {			usbd_xfer_set_frame_len(xfer, 0, actlen);			usbd_transfer_submit(xfer);		}		break;	break;	default:		UHSO_DPRINTF(0, "error: %s/n", usbd_errstr(error));		if (error == USB_ERR_CANCELLED)			break;		usbd_xfer_set_stall(xfer);		goto tr_setup;	}}

static voidusie_if_init(void *arg){	struct usie_softc *sc = arg;	struct ifnet *ifp = sc->sc_ifp;	uint8_t i;	mtx_lock(&sc->sc_mtx);	/* write tx descriptor */	sc->sc_txd.hip.id = USIE_HIP_CTX;	sc->sc_txd.hip.param = 0;	/* init value */	sc->sc_txd.desc_type = htobe16(USIE_IP_TX);	for (i = 0; i != USIE_IF_N_XFER; i++)		usbd_xfer_set_stall(sc->sc_if_xfer[i]);	usbd_transfer_start(sc->sc_uc_xfer[USIE_HIP_IF][USIE_UC_RX]);	usbd_transfer_start(sc->sc_if_xfer[USIE_IF_STATUS]);	usbd_transfer_start(sc->sc_if_xfer[USIE_IF_RX]);	/* if not running, initiate the modem */	if (!(ifp->if_drv_flags & IFF_DRV_RUNNING))		usie_cns_req(sc, USIE_CNS_ID_INIT, USIE_CNS_OB_LINK_UPDATE);	mtx_unlock(&sc->sc_mtx);	DPRINTF("ifnet initialized/n");}

static voidg_modem_intr_callback(struct usb_xfer *xfer, usb_error_t error){	int actlen;	int aframes;	usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);	DPRINTF("st=%d aframes=%d actlen=%d bytes/n",	    USB_GET_STATE(xfer), aframes, actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		break;	case USB_ST_SETUP:tr_setup:		break;	default:			/* Error */		DPRINTF("error=%s/n", usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voidcdce_init(struct usb_ether *ue){	struct cdce_softc *sc = uether_getsc(ue);	struct ifnet *ifp = uether_getifp(ue);	CDCE_LOCK_ASSERT(sc, MA_OWNED);	ifp->if_drv_flags |= IFF_DRV_RUNNING;	/* start interrupt transfer */	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);	/*	 * Stall data write direction, which depends on USB mode.	 *	 * Some USB host stacks (e.g. Mac OS X) don't clears stall	 * bit as it should, so set it in our host mode only.	 */	if (usbd_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST)		usbd_xfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);	/* start data transfers */	cdce_start(ue);}

static voidcdce_intr_read_callback(struct usb_xfer *xfer, usb_error_t error){	int actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTF("Received %d bytes/n", actlen);		/* TODO: decode some indications */		/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:			/* Error */		if (error != USB_ERR_CANCELLED) {			/* start clear stall */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voiduhso_mux_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct uhso_softc *sc = usbd_xfer_softc(xfer);	struct usb_page_cache *pc;	struct usb_device_request req;	struct uhso_tty *ht;	int actlen, len;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	UHSO_DPRINTF(3, "status %d/n", USB_GET_STATE(xfer));	ht = usbd_xfer_get_priv(xfer);	UHSO_DPRINTF(3, "ht=%p open=%d/n", ht, ht->ht_open);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		/* Got data, send to ucom */		pc = usbd_xfer_get_frame(xfer, 1);		len = usbd_xfer_frame_len(xfer, 1);		UHSO_DPRINTF(3, "got %d bytes on mux port %d/n", len,		    ht->ht_muxport);		if (len <= 0) {			usbd_transfer_start(sc->sc_xfer[UHSO_MUX_ENDPT_INTR]);			break;		}		/* Deliver data if the TTY is open, discard otherwise */		if (ht->ht_open)			ucom_put_data(&sc->sc_ucom[ht->ht_muxport], pc, 0, len);		/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:		memset(&req, 0, sizeof(struct usb_device_request));		req.bmRequestType = UT_READ_CLASS_INTERFACE;		req.bRequest = UCDC_GET_ENCAPSULATED_RESPONSE;		USETW(req.wValue, 0);		USETW(req.wIndex, ht->ht_muxport);		USETW(req.wLength, 1024);		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_in(pc, 0, &req, sizeof(req));		usbd_xfer_set_frame_len(xfer, 0, sizeof(req));		usbd_xfer_set_frame_len(xfer, 1, 1024);		usbd_xfer_set_frames(xfer, 2);		usbd_transfer_submit(xfer);		break;	default:		UHSO_DPRINTF(0, "error: %s/n", usbd_errstr(error));		if (error == USB_ERR_CANCELLED)			break;		usbd_xfer_set_stall(xfer);		goto tr_setup;	}}

static voidusie_uc_status_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_page_cache *pc;	struct {		struct usb_device_request req;		uint16_t param;	}      st;	uint32_t actlen;	uint16_t param;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTFN(4, "info received, actlen=%u/n", actlen);		if (actlen < sizeof(st)) {			DPRINTF("data too short actlen=%u/n", actlen);			goto tr_setup;		}		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_out(pc, 0, &st, sizeof(st));		if (st.req.bmRequestType == 0xa1 && st.req.bRequest == 0x20) {			struct ucom_softc *ucom = usbd_xfer_softc(xfer);			struct usie_softc *sc = ucom->sc_parent;			param = le16toh(st.param);			DPRINTF("param=%x/n", param);			sc->sc_msr = sc->sc_lsr = 0;			sc->sc_msr |= (param & USIE_DCD) ? SER_DCD : 0;			sc->sc_msr |= (param & USIE_DSR) ? SER_DSR : 0;			sc->sc_msr |= (param & USIE_RI) ? SER_RI : 0;			sc->sc_msr |= (param & USIE_CTS) ? 0 : SER_CTS;			sc->sc_msr |= (param & USIE_RTS) ? SER_RTS : 0;			sc->sc_msr |= (param & USIE_DTR) ? SER_DTR : 0;		}		/* fall though */	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:			/* Error */		DPRINTF("USB transfer error, %s/n",		    usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voidcdce_ncm_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);	uint16_t x;	uint8_t temp;	int actlen;	int aframes;	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);		DPRINTFN(10, "transfer complete: "		    "%u bytes in %u frames/n", actlen, aframes);	case USB_ST_SETUP:		for (x = 0; x != CDCE_NCM_TX_FRAMES_MAX; x++) {			temp = cdce_ncm_fill_tx_frames(xfer, x);			if (temp == 0)				break;			if (temp == 1) {				x++;				break;			}		}		if (x != 0) {#ifdef USB_DEBUG			usbd_xfer_set_interval(xfer, cdce_tx_interval);#endif			usbd_xfer_set_frames(xfer, x);			usbd_transfer_submit(xfer);		}		break;	default:			/* Error */		DPRINTFN(10, "Transfer error: %s/n",		    usbd_errstr(error));		/* update error counter */		if_inc_counter(ifp, IFCOUNTER_OERRORS, 1);		if (error != USB_ERR_CANCELLED) {			if (usbd_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST) {				/* try to clear stall first */				usbd_xfer_set_stall(xfer);				usbd_xfer_set_frames(xfer, 0);				usbd_transfer_submit(xfer);			}		}		break;	}}

static voidusie_uc_rx_callback(struct usb_xfer *xfer, usb_error_t error){	struct ucom_softc *ucom = usbd_xfer_softc(xfer);	struct usie_softc *sc = ucom->sc_parent;	struct usb_page_cache *pc;	uint32_t actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		pc = usbd_xfer_get_frame(xfer, 0);		/* handle CnS response */		if (ucom == sc->sc_ucom && actlen >= USIE_HIPCNS_MIN) {			DPRINTF("transferred=%u/n", actlen);			/* check if it is really CnS reply */			usbd_copy_out(pc, 0, sc->sc_resp_temp, 1);			if (sc->sc_resp_temp[0] == USIE_HIP_FRM_CHR) {				/* verify actlen */				if (actlen > USIE_BUFSIZE)					actlen = USIE_BUFSIZE;				/* get complete message */				usbd_copy_out(pc, 0, sc->sc_resp_temp, actlen);				usie_hip_rsp(sc, sc->sc_resp_temp, actlen);				/* need to fall though */				goto tr_setup;			}			/* else call ucom_put_data() */		}		/* standard ucom transfer */		ucom_put_data(ucom, pc, 0, actlen);		/* fall though */	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:			/* Error */		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voiduhso_bs_intr_callback(struct usb_xfer *xfer, usb_error_t error){	struct uhso_softc *sc = usbd_xfer_softc(xfer);	struct usb_page_cache *pc;	int actlen;	struct usb_cdc_notification cdc;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	UHSO_DPRINTF(3, "status %d, actlen=%d/n", USB_GET_STATE(xfer), actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		if (actlen < UCDC_NOTIFICATION_LENGTH) {			UHSO_DPRINTF(0, "UCDC notification too short: %d/n", actlen);			goto tr_setup;		}		else if (actlen > (int)sizeof(struct usb_cdc_notification)) {			UHSO_DPRINTF(0, "UCDC notification too large: %d/n", actlen);			actlen = sizeof(struct usb_cdc_notification);		}		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_out(pc, 0, &cdc, actlen);		if (UGETW(cdc.wIndex) != sc->sc_iface_no) {			UHSO_DPRINTF(0, "Interface mismatch, got %d expected %d/n",			    UGETW(cdc.wIndex), sc->sc_iface_no);			goto tr_setup;		}		if (cdc.bmRequestType == UCDC_NOTIFICATION &&		    cdc.bNotification == UCDC_N_SERIAL_STATE) {			UHSO_DPRINTF(2, "notify = 0x%02x/n", cdc.data[0]);			sc->sc_msr = 0;			sc->sc_lsr = 0;			if (cdc.data[0] & UCDC_N_SERIAL_RI)				sc->sc_msr |= SER_RI;			if (cdc.data[0] & UCDC_N_SERIAL_DSR)				sc->sc_msr |= SER_DSR;				if (cdc.data[0] & UCDC_N_SERIAL_DCD)				sc->sc_msr |= SER_DCD;			ucom_status_change(&sc->sc_ucom[0]);		}	case USB_ST_SETUP:tr_setup:	default:		if (error == USB_ERR_CANCELLED)			break;		usbd_xfer_set_stall(xfer);		goto tr_setup;	}}

/*------------------------------------------------------------------------* *	usb_handle_request_callback * * This function is the USB callback for generic USB Device control * transfers. *------------------------------------------------------------------------*/voidusb_handle_request_callback(struct usb_xfer *xfer, usb_error_t error){	usb_error_t err;	/* check the current transfer state */	switch (USB_GET_STATE(xfer)) {	case USB_ST_SETUP:	case USB_ST_TRANSFERRED:		/* handle the request */		err = usb_handle_request(xfer);		if (err) {			if (err == USB_ERR_BAD_CONTEXT) {				/* we need to re-setup the control transfer */				usb_needs_explore(xfer->xroot->bus, 0);				break;			}			goto tr_restart;		}		usbd_transfer_submit(xfer);		break;	default:		/* check if a control transfer is active */		if (xfer->flags_int.control_rem != 0xFFFF) {			/* handle the request */			err = usb_handle_request(xfer);		}		if (xfer->error != USB_ERR_CANCELLED) {			/* should not happen - try stalling */			goto tr_restart;		}		break;	}	return;tr_restart:	/*	 * If a control transfer is active, stall it, and wait for the	 * next control transfer.	 */	usbd_xfer_set_frame_len(xfer, 0, sizeof(struct usb_device_request));	xfer->nframes = 1;	xfer->flags.manual_status = 1;	xfer->flags.force_short_xfer = 0;	usbd_xfer_set_stall(xfer);	/* cancel previous transfer, if any */	usbd_transfer_submit(xfer);}

/* * Interrupt callback for the multiplexed serial port. Indicates * which serial port has data waiting. */static voiduhso_mux_intr_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_page_cache *pc;	struct usb_page_search res;	struct uhso_softc *sc = usbd_xfer_softc(xfer);	unsigned int i, mux;	UHSO_DPRINTF(3, "status %d/n", USB_GET_STATE(xfer));	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		/*		 * The multiplexed port number can be found at the first byte.		 * It contains a bit mask, we transform this in to an integer.		 */		pc = usbd_xfer_get_frame(xfer, 0);		usbd_get_page(pc, 0, &res);		i = *((unsigned char *)res.buffer);		mux = 0;		while (i >>= 1) {			mux++;		}		UHSO_DPRINTF(3, "mux port %d (%d)/n", mux, i);		if (mux > UHSO_MPORT_TYPE_NOMAX)			break;		/* Issue a read for this serial port */		usbd_xfer_set_priv(		    sc->sc_tty[mux].ht_xfer[UHSO_CTRL_READ],		    &sc->sc_tty[mux]);		usbd_transfer_start(sc->sc_tty[mux].ht_xfer[UHSO_CTRL_READ]);		break;	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:		UHSO_DPRINTF(0, "error: %s/n", usbd_errstr(error));		if (error == USB_ERR_CANCELLED)			break;		usbd_xfer_set_stall(xfer);		goto tr_setup;	}}

static voidipheth_init(struct usb_ether *ue){	struct ipheth_softc *sc = uether_getsc(ue);	struct ifnet *ifp = uether_getifp(ue);	IPHETH_LOCK_ASSERT(sc, MA_OWNED);	ifp->if_drv_flags |= IFF_DRV_RUNNING;	/* stall data write direction, which depends on USB mode */	usbd_xfer_set_stall(sc->sc_xfer[IPHETH_BULK_TX]);	/* start data transfers */	ipheth_start(ue);}

static voidusie_if_status_callback(struct usb_xfer *xfer, usb_error_t error){	struct usie_softc *sc = usbd_xfer_softc(xfer);	struct usb_page_cache *pc;	struct usb_cdc_notification cdc;	uint32_t actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTFN(4, "info received, actlen=%d/n", actlen);		/* usb_cdc_notification - .data[16] */		if (actlen < (sizeof(cdc) - 16)) {			DPRINTF("data too short %d/n", actlen);			goto tr_setup;		}		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_out(pc, 0, &cdc, (sizeof(cdc) - 16));		DPRINTFN(4, "bNotification=%x/n", cdc.bNotification);		if (cdc.bNotification & UCDC_N_RESPONSE_AVAILABLE) {			taskqueue_enqueue(taskqueue_thread,			    &sc->sc_if_status_task);		}		/* fall though */	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:			/* Error */		DPRINTF("USB transfer error, %s/n",		    usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voidg_modem_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct g_modem_softc *sc = usbd_xfer_softc(xfer);	int actlen;	int aframes;	usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);	DPRINTF("st=%d aframes=%d actlen=%d bytes/n",	    USB_GET_STATE(xfer), aframes, actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		sc->sc_throughput += actlen;		if (sc->sc_mode == G_MODEM_MODE_LOOP) {			sc->sc_tx_busy = 1;			sc->sc_data_len = actlen;			usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_WR]);			break;		}	case USB_ST_SETUP:tr_setup:		if ((sc->sc_mode == G_MODEM_MODE_SILENT) ||		    (sc->sc_tx_busy != 0))			break;		usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, G_MODEM_BUFSIZE);		usbd_xfer_set_frames(xfer, 1);		usbd_transfer_submit(xfer);		break;	default:			/* Error */		DPRINTF("error=%s/n", usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voidcdce_init(struct usb_ether *ue){	struct cdce_softc *sc = uether_getsc(ue);	struct ifnet *ifp = uether_getifp(ue);	CDCE_LOCK_ASSERT(sc, MA_OWNED);	ifp->if_drv_flags |= IFF_DRV_RUNNING;	/* start interrupt transfer */	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_RX]);	usbd_transfer_start(sc->sc_xfer[CDCE_INTR_TX]);	/* stall data write direction, which depends on USB mode */	usbd_xfer_set_stall(sc->sc_xfer[CDCE_BULK_TX]);	/* start data transfers */	cdce_start(ue);}

static voidusie_uc_tx_callback(struct usb_xfer *xfer, usb_error_t error){	struct ucom_softc *ucom = usbd_xfer_softc(xfer);	struct usb_page_cache *pc;	uint32_t actlen;	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:	case USB_ST_SETUP:tr_setup:		pc = usbd_xfer_get_frame(xfer, 0);		/* handle CnS request */		struct mbuf *m = usbd_xfer_get_priv(xfer);		if (m != NULL) {			usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);			usbd_xfer_set_frame_len(xfer, 0, m->m_pkthdr.len);			usbd_xfer_set_priv(xfer, NULL);			usbd_transfer_submit(xfer);			m_freem(m);			break;		}		/* standard ucom transfer */		if (ucom_get_data(ucom, pc, 0, USIE_BUFSIZE, &actlen)) {			usbd_xfer_set_frame_len(xfer, 0, actlen);			usbd_transfer_submit(xfer);		}		break;	default:			/* Error */		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

static voiduhso_ifnet_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct uhso_softc *sc = usbd_xfer_softc(xfer);	struct mbuf *m;		struct usb_page_cache *pc;	int actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	UHSO_DPRINTF(3, "status=%d, actlen=%d/n", USB_GET_STATE(xfer), actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		if (actlen > 0 && (sc->sc_ifp->if_drv_flags & IFF_DRV_RUNNING)) {			pc = usbd_xfer_get_frame(xfer, 0);			m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);			usbd_copy_out(pc, 0, mtod(m, uint8_t *), actlen);			m->m_pkthdr.len = m->m_len = actlen;			/* Enqueue frame for further processing */			_IF_ENQUEUE(&sc->sc_rxq, m);			if (!callout_pending(&sc->sc_c) ||			    !callout_active(&sc->sc_c)) {				callout_schedule(&sc->sc_c, 1);			}		}	/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default:		UHSO_DPRINTF(0, "error: %s/n", usbd_errstr(error));		if (error == USB_ERR_CANCELLED)			break;		usbd_xfer_set_stall(xfer);		goto tr_setup;	}

//.........这里部分代码省略.........		usbd_xfer_set_frame_len(xfer, 0, length);		/* Host mode only ! */		if ((req->bmRequestType &		    (UT_READ | UT_WRITE)) == UT_READ) {			isread = 1;		} else {			isread = 0;		}		n = 1;		offset = sizeof(*req);	} else {		/* Device and Host mode */		if (USB_GET_DATA_ISREAD(xfer)) {			isread = 1;		} else {			isread = 0;		}		n = 0;		offset = 0;	}	rem = usbd_xfer_max_len(xfer);	xfer->nframes = fs_ep.nFrames;	xfer->timeout = fs_ep.timeout;	if (xfer->timeout > 65535) {		xfer->timeout = 65535;	}	if (fs_ep.flags & USB_FS_FLAG_SINGLE_SHORT_OK)		xfer->flags.short_xfer_ok = 1;	else		xfer->flags.short_xfer_ok = 0;	if (fs_ep.flags & USB_FS_FLAG_MULTI_SHORT_OK)		xfer->flags.short_frames_ok = 1;	else		xfer->flags.short_frames_ok = 0;	if (fs_ep.flags & USB_FS_FLAG_FORCE_SHORT)		xfer->flags.force_short_xfer = 1;	else		xfer->flags.force_short_xfer = 0;	if (fs_ep.flags & USB_FS_FLAG_CLEAR_STALL)		usbd_xfer_set_stall(xfer);	else		xfer->flags.stall_pipe = 0;	for (; n != xfer->nframes; n++) {		error = copyin(fs_ep.pLength + n,		    &length, sizeof(length));		if (error) {			break;		}		usbd_xfer_set_frame_len(xfer, n, length);		if (length > rem) {			xfer->error = USB_ERR_INVAL;			goto complete;		}		rem -= length;		if (!isread) {			/* we need to know the source buffer */			error = copyin(fs_ep.ppBuffer + n,			    &uaddr, sizeof(uaddr));			if (error) {				break;			}			if (xfer->flags_int.isochronous_xfr) {				/* get kernel buffer address */				kaddr = xfer->frbuffers[0].buffer;				kaddr = USB_ADD_BYTES(kaddr, offset);			} else {				/* set current frame offset */				usbd_xfer_set_frame_offset(xfer, offset, n);				/* get kernel buffer address */				kaddr = xfer->frbuffers[n].buffer;			}			/* move data */			error = copyin(uaddr, kaddr, length);			if (error) {				break;			}		}		offset += length;	}	return (error);complete:	mtx_lock(f->priv_mtx);	ugen_fs_set_complete(f, ep_index);	mtx_unlock(f->priv_mtx);	return (0);}

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 < (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;	}}

//.........这里部分代码省略.........		/* add a entry to the active queue's tail.  */		InsertTailList((&ne->ne_active), (&nx->nx_next));		KeReleaseSpinLock(&ne->ne_lock, irql);		ip = nx->nx_priv;		urb = usbd_geturb(ip);		vcreq = &urb->uu_vcreq;		switch (urb->uu_hdr.uuh_func) {		case URB_FUNCTION_CLASS_DEVICE:			type = UT_CLASS | UT_DEVICE;			break;		case URB_FUNCTION_CLASS_INTERFACE:			type = UT_CLASS | UT_INTERFACE;			break;		case URB_FUNCTION_CLASS_OTHER:			type = UT_CLASS | UT_OTHER;			break;		case URB_FUNCTION_CLASS_ENDPOINT:			type = UT_CLASS | UT_ENDPOINT;			break;		case URB_FUNCTION_VENDOR_DEVICE:			type = UT_VENDOR | UT_DEVICE;			break;		case URB_FUNCTION_VENDOR_INTERFACE:			type = UT_VENDOR | UT_INTERFACE;			break;		case URB_FUNCTION_VENDOR_OTHER:			type = UT_VENDOR | UT_OTHER;			break;		case URB_FUNCTION_VENDOR_ENDPOINT:			type = UT_VENDOR | UT_ENDPOINT;			break;		default:			/* never reached.  */			break;		}		type |= (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) ?		    UT_READ : UT_WRITE;		type |= vcreq->uvc_reserved1;		req.bmRequestType = type;		req.bRequest = vcreq->uvc_req;		USETW(req.wIndex, vcreq->uvc_idx);		USETW(req.wValue, vcreq->uvc_value);		USETW(req.wLength, vcreq->uvc_trans_buflen);		nx->nx_urbbuf		= vcreq->uvc_trans_buf;		nx->nx_urblen		= vcreq->uvc_trans_buflen;		nx->nx_urbactlen	= 0;		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_in(pc, 0, &req, sizeof(req));		usbd_xfer_set_frame_len(xfer, 0, sizeof(req));		usbd_xfer_set_frames(xfer, 1);		if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {			if (vcreq->uvc_trans_buflen >= USBD_CTRL_READ_BUFFER_SP)				device_printf(sc->ndis_dev,				    "warning: not enough buffer space (%d)./n",				    vcreq->uvc_trans_buflen);			usbd_xfer_set_frame_len(xfer, 1,			    MIN(usbd_xfer_max_len(xfer),				    vcreq->uvc_trans_buflen));			usbd_xfer_set_frames(xfer, 2);		} else {			if (nx->nx_urblen > USBD_CTRL_WRITE_BUFFER_SP)				device_printf(sc->ndis_dev,				    "warning: not enough write buffer space"				    " (%d)./n", nx->nx_urblen);			/*			 * XXX with my local tests there was no cases to require			 * a extra buffer until now but it'd need to update in			 * the future if it needs to be.			 */			if (nx->nx_urblen > 0) {				pc = usbd_xfer_get_frame(xfer, 1);				usbd_copy_in(pc, 0, nx->nx_urbbuf,				    nx->nx_urblen);				usbd_xfer_set_frame_len(xfer, 1, nx->nx_urblen);				usbd_xfer_set_frames(xfer, 2);			}		}		usbd_transfer_submit(xfer);		break;	default:		nx = usbd_aq_getfirst(sc, ne);		if (nx == NULL)			return;		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			device_printf(sc->ndis_dev, "usb xfer warning (%s)/n",			    usbd_errstr(error));		}		usbd_xfer_complete(sc, ne, nx, error);		if (error != USB_ERR_CANCELLED)			goto next;		break;	}}

static voidusbd_non_isoc_callback(struct usb_xfer *xfer, usb_error_t error){	irp *ip;	struct ndis_softc *sc = usbd_xfer_softc(xfer);	struct ndisusb_ep *ne = usbd_xfer_get_priv(xfer);	struct ndisusb_xfer *nx;	struct usbd_urb_bulk_or_intr_transfer *ubi;	struct usb_page_cache *pc;	uint8_t irql;	uint32_t len;	union usbd_urb *urb;	usb_endpoint_descriptor_t *ep;	int actlen, sumlen;	usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		nx = usbd_aq_getfirst(sc, ne);		pc = usbd_xfer_get_frame(xfer, 0);		if (nx == NULL)			return;		/* copy in data with regard to the URB */		if (ne->ne_dirin != 0)			usbd_copy_out(pc, 0, nx->nx_urbbuf, actlen);		nx->nx_urbbuf += actlen;		nx->nx_urbactlen += actlen;		nx->nx_urblen -= actlen;		/* check for short transfer */		if (actlen < sumlen)			nx->nx_urblen = 0;		else {			/* check remainder */			if (nx->nx_urblen > 0) {				KeAcquireSpinLock(&ne->ne_lock, &irql);				InsertHeadList((&ne->ne_active), (&nx->nx_next));				KeReleaseSpinLock(&ne->ne_lock, irql);				ip = nx->nx_priv;				urb = usbd_geturb(ip);				ubi = &urb->uu_bulkintr;				ep = ubi->ubi_epdesc;				goto extra;			}		}		usbd_xfer_complete(sc, ne, nx,		    ((actlen < sumlen) && (nx->nx_shortxfer == 0)) ?		    USB_ERR_SHORT_XFER : USB_ERR_NORMAL_COMPLETION);		/* fall through */	case USB_ST_SETUP:next:		/* get next transfer */		KeAcquireSpinLock(&ne->ne_lock, &irql);		if (IsListEmpty(&ne->ne_pending)) {			KeReleaseSpinLock(&ne->ne_lock, irql);			return;		}		nx = CONTAINING_RECORD(ne->ne_pending.nle_flink,		    struct ndisusb_xfer, nx_next);		RemoveEntryList(&nx->nx_next);		/* add a entry to the active queue's tail.  */		InsertTailList((&ne->ne_active), (&nx->nx_next));		KeReleaseSpinLock(&ne->ne_lock, irql);		ip = nx->nx_priv;		urb = usbd_geturb(ip);		ubi = &urb->uu_bulkintr;		ep = ubi->ubi_epdesc;		nx->nx_urbbuf		= ubi->ubi_trans_buf;		nx->nx_urbactlen	= 0;		nx->nx_urblen		= ubi->ubi_trans_buflen;		nx->nx_shortxfer	= (ubi->ubi_trans_flags &		    USBD_SHORT_TRANSFER_OK) ? 1 : 0;extra:		len = MIN(usbd_xfer_max_len(xfer), nx->nx_urblen);		pc = usbd_xfer_get_frame(xfer, 0);		if (UE_GET_DIR(ep->bEndpointAddress) == UE_DIR_OUT)			usbd_copy_in(pc, 0, nx->nx_urbbuf, len);		usbd_xfer_set_frame_len(xfer, 0, len);		usbd_xfer_set_frames(xfer, 1);		usbd_transfer_submit(xfer);		break;	default:		nx = usbd_aq_getfirst(sc, ne);		if (nx == NULL)			return;		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			device_printf(sc->ndis_dev, "usb xfer warning (%s)/n",			    usbd_errstr(error));		}		usbd_xfer_complete(sc, ne, nx, error);		if (error != USB_ERR_CANCELLED)			goto next;		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_DONTWAIT);				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;	}}

//.........这里部分代码省略.........		    (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 < 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 > (MHLEN - ETHER_ALIGN)) {				m = m_getcl(M_DONTWAIT, MT_DATA, M_PKTHDR);			} else {				m = m_gethdr(M_DONTWAIT, 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;	}}

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, aframes, 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 < 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;	}}

static voidg_modem_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct g_modem_softc *sc = usbd_xfer_softc(xfer);	int actlen;	int aframes;	int mod;	int x;	int max;	usbd_xfer_status(xfer, &actlen, NULL, &aframes, NULL);	DPRINTF("st=%d aframes=%d actlen=%d bytes/n",	    USB_GET_STATE(xfer), aframes, actlen);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		sc->sc_tx_busy = 0;		sc->sc_throughput += actlen;		if (sc->sc_mode == G_MODEM_MODE_LOOP) {			/* start loop */			usbd_transfer_start(sc->sc_xfer[G_MODEM_BULK_RD]);			break;		} else if ((sc->sc_mode == G_MODEM_MODE_PATTERN) && (sc->sc_tx_interval != 0)) {			/* wait for next timeout */			break;		}	case USB_ST_SETUP:tr_setup:		if (sc->sc_mode == G_MODEM_MODE_PATTERN) {			mod = sc->sc_pattern_len;			max = sc->sc_tx_interval ? mod : G_MODEM_BUFSIZE;			if (mod == 0) {				for (x = 0; x != max; x++)					sc->sc_data_buf[x] = x % 255;			} else {				for (x = 0; x != max; x++)					sc->sc_data_buf[x] = sc->sc_pattern[x % mod];			}			usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, max);			usbd_xfer_set_interval(xfer, 0);			usbd_xfer_set_frames(xfer, 1);			usbd_transfer_submit(xfer);		} else if (sc->sc_mode == G_MODEM_MODE_LOOP) {			if (sc->sc_tx_busy == 0)				break;			x = sc->sc_tx_interval;			if (x < 0)				x = 0;			else if (x > 256)				x = 256;			usbd_xfer_set_frame_data(xfer, 0, sc->sc_data_buf, sc->sc_data_len);			usbd_xfer_set_interval(xfer, x);			usbd_xfer_set_frames(xfer, 1);			usbd_transfer_submit(xfer);		} else {			sc->sc_tx_busy = 0;		}		break;	default:			/* Error */		DPRINTF("error=%s/n", usbd_errstr(error));		if (error != USB_ERR_CANCELLED) {			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			goto tr_setup;		}		break;	}}

//.........这里部分代码省略.........			    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);		if (id->bNumEndpoints == 2) {			sc->sc_uc_xfer[sc->sc_nucom][0] = NULL;			start = 1;		} else			start = 0;		err = usbd_transfer_setup(uaa->device, &ifidx,		    sc->sc_uc_xfer[sc->sc_nucom] + start,		    usie_uc_config + start, USIE_UC_N_XFER - start,		    &sc->sc_ucom[sc->sc_nucom], &sc->sc_mtx);		if (err != 0) {			DPRINTF("usbd_transfer_setup error=%s/n", usbd_errstr(err));			continue;		}		mtx_lock(&sc->sc_mtx);		for (; start < USIE_UC_N_XFER; start++)			usbd_xfer_set_stall(sc->sc_uc_xfer[sc->sc_nucom][start]);		mtx_unlock(&sc->sc_mtx);		sc->sc_uc_ifnum[sc->sc_nucom] = id->bInterfaceNumber;		sc->sc_nucom++;		/* found a port */	}	if (sc->sc_nucom == 0) {		device_printf(self, "no comports found/n");		goto detach;	}	err = ucom_attach(&sc->sc_super_ucom, sc->sc_ucom,	    sc->sc_nucom, sc, &usie_uc_callback, &sc->sc_mtx);	if (err != 0) {		DPRINTF("ucom_attach failed/n");		goto detach;	}	DPRINTF("Found %d interfaces./n", sc->sc_nucom);	/* setup ifnet (Direct IP) */	sc->sc_ifp = ifp = if_alloc(IFT_OTHER);	if (ifp == NULL) {		device_printf(self, "Could not allocate a network interface/n");		goto detach;	}	if_initname(ifp, "usie", device_get_unit(self));	ifp->if_softc = sc;	ifp->if_mtu = USIE_MTU_MAX;	ifp->if_flags |= IFF_NOARP;	ifp->if_init = usie_if_init;	ifp->if_ioctl = usie_if_ioctl;	ifp->if_start = usie_if_start;	ifp->if_output = usie_if_output;	IFQ_SET_MAXLEN(&ifp->if_snd, ifqmaxlen);	ifp->if_snd.ifq_drv_maxlen = ifqmaxlen;	IFQ_SET_READY(&ifp->if_snd);	if_attach(ifp);	bpfattach(ifp, DLT_RAW, 0);	if (fwattr & USIE_PM_AUTO) {		usbd_set_power_mode(uaa->device, USB_POWER_MODE_SAVE);		DPRINTF("enabling automatic suspend and resume/n");	} else {		usbd_set_power_mode(uaa->device, USB_POWER_MODE_ON);		DPRINTF("USB power is always ON/n");	}	DPRINTF("device attached/n");	return (0);detach:	usie_detach(self);	return (ENOMEM);}

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_DONTWAIT, MT_DATA, M_PKTHDR,			    MJUMPAGESIZE /* could be bigger than MCLBYTES */ );		}		if (sc->sc_rxm == NULL) {			DPRINTF("could not allocate Rx mbuf/n");			ifp->if_ierrors++;			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);			ifp->if_ierrors++;			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;		ifp->if_opackets++;		/* 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 > (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));		ifp->if_oerrors++;		if (error != USB_ERR_CANCELLED) {			usbd_xfer_set_stall(xfer);			ifp->if_ierrors++;			goto tr_setup;		}		break;	}}