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

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 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 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 voidubt_isoc_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct ubt_softc	*sc = usbd_xfer_softc(xfer);	int			n;	int actlen, nframes;	usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		for (n = 0; n < nframes; n ++)			if (ubt_isoc_read_one_frame(xfer, n) < 0)				break;		/* FALLTHROUGH */	case USB_ST_SETUP:read_next:		for (n = 0; n < nframes; n ++)			usbd_xfer_set_frame_len(xfer, n,			    usbd_xfer_max_framelen(xfer));		usbd_transfer_submit(xfer);		break;	default: /* Error */                if (error != USB_ERR_CANCELLED) {                        UBT_STAT_IERROR(sc);                        goto read_next;                }		/* transfer cancelled */		break;	}} /* ubt_isoc_read_callback */

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 voiduhso_mux_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct uhso_softc *sc = usbd_xfer_softc(xfer);	struct uhso_tty *ht;	struct usb_page_cache *pc;	struct usb_device_request req;	int actlen;	struct usb_page_search res;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	ht = usbd_xfer_get_priv(xfer);	UHSO_DPRINTF(3, "status=%d, using mux port %d/n",	    USB_GET_STATE(xfer), ht->ht_muxport);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		UHSO_DPRINTF(3, "wrote %zd data bytes to muxport %d/n",		    actlen - sizeof(struct usb_device_request) ,		    ht->ht_muxport);		/* FALLTHROUGH */	case USB_ST_SETUP:		pc = usbd_xfer_get_frame(xfer, 1);		if (ucom_get_data(&sc->sc_ucom[ht->ht_muxport], pc,		    0, 32, &actlen)) {			usbd_get_page(pc, 0, &res);			memset(&req, 0, sizeof(struct usb_device_request));			req.bmRequestType = UT_WRITE_CLASS_INTERFACE;			req.bRequest = UCDC_SEND_ENCAPSULATED_COMMAND;			USETW(req.wValue, 0);			USETW(req.wIndex, ht->ht_muxport);			USETW(req.wLength, actlen);			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, actlen);			usbd_xfer_set_frames(xfer, 2);			UHSO_DPRINTF(3, "Prepared %d bytes for transmit "			    "on muxport %d/n", actlen, ht->ht_muxport);			usbd_transfer_submit(xfer);		}		break;	default:		UHSO_DPRINTF(0, "error: %s/n", usbd_errstr(error));		if (error == USB_ERR_CANCELLED)			break;		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;	}}

static struct mbuf *rtwn_report_intr(struct rtwn_usb_softc *uc, struct usb_xfer *xfer,    struct rtwn_data *data){	struct rtwn_softc *sc = &uc->uc_sc;	struct ieee80211com *ic = &sc->sc_ic;	uint8_t *buf;	int len;	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);	if (__predict_false(len < sizeof(struct r92c_rx_stat))) {		counter_u64_add(ic->ic_ierrors, 1);		return (NULL);	}	buf = data->buf;	switch (rtwn_classify_intr(sc, buf, len)) {	case RTWN_RX_DATA:		return (rtwn_rxeof(sc, buf, len));	case RTWN_RX_TX_REPORT:		if (sc->sc_ratectl != RTWN_RATECTL_NET80211) {			/* shouldn't happen */			device_printf(sc->sc_dev,			    "%s called while ratectl = %d!/n",			    __func__, sc->sc_ratectl);			break;		}		RTWN_NT_LOCK(sc);		rtwn_handle_tx_report(sc, buf, len);		RTWN_NT_UNLOCK(sc);#ifdef IEEE80211_SUPPORT_SUPERG		/*		 * NB: this will executed only when 'report' bit is set.		 */		if (sc->sc_tx_n_active > 0 && --sc->sc_tx_n_active <= 1)			rtwn_cmd_sleepable(sc, NULL, 0, rtwn_ff_flush_all);#endif		break;	case RTWN_RX_OTHER:		rtwn_handle_c2h_report(sc, buf, len);		break;	default:		/* NOTREACHED */		KASSERT(0, ("unknown Rx classification code"));		break;	}	return (NULL);}

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

static voidubt_isoc_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct ubt_softc	*sc = usbd_xfer_softc(xfer);	struct usb_page_cache	*pc;	struct mbuf		*m;	int			n, space, offset;	int			actlen, nframes;	usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);	pc = usbd_xfer_get_frame(xfer, 0);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		UBT_INFO(sc, "sent %d bytes to isoc-out pipe/n", actlen);		UBT_STAT_BYTES_SENT(sc, actlen);		UBT_STAT_PCKTS_SENT(sc);		/* FALLTHROUGH */	case USB_ST_SETUP:send_next:		offset = 0;		space = usbd_xfer_max_framelen(xfer) * nframes;		m = NULL;		while (space > 0) {			if (m == NULL) {				UBT_NG_LOCK(sc);				NG_BT_MBUFQ_DEQUEUE(&sc->sc_scoq, m);				UBT_NG_UNLOCK(sc);				if (m == NULL)					break;			}			n = min(space, m->m_pkthdr.len);			if (n > 0) {				usbd_m_copy_in(pc, offset, m,0, n);				m_adj(m, n);				offset += n;				space -= n;			}			if (m->m_pkthdr.len == 0)				NG_FREE_M(m); /* sets m = NULL */		}		/* Put whatever is left from mbuf back on queue */		if (m != NULL) {			UBT_NG_LOCK(sc);			NG_BT_MBUFQ_PREPEND(&sc->sc_scoq, m);			UBT_NG_UNLOCK(sc);		}		/*		 * Calculate sizes for isoc frames.		 * Note that offset could be 0 at this point (i.e. we have		 * nothing to send). That is fine, as we have isoc. transfers		 * going in both directions all the time. In this case it		 * would be just empty isoc. transfer.		 */		for (n = 0; n < nframes; n ++) {			usbd_xfer_set_frame_len(xfer, n,			    min(offset, usbd_xfer_max_framelen(xfer)));			offset -= usbd_xfer_frame_len(xfer, n);		}		usbd_transfer_submit(xfer);		break;	default: /* Error */		if (error != USB_ERR_CANCELLED) {			UBT_STAT_OERROR(sc);			goto send_next;		}		/* transfer cancelled */		break;	}}

static voidcdce_intr_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct cdce_softc *sc = usbd_xfer_softc(xfer);	struct usb_cdc_notification req;	struct usb_page_cache *pc;	uint32_t speed;	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);		switch (sc->sc_notify_state) {		case CDCE_NOTIFY_NETWORK_CONNECTION:			sc->sc_notify_state = CDCE_NOTIFY_SPEED_CHANGE;			break;		case CDCE_NOTIFY_SPEED_CHANGE:			sc->sc_notify_state = CDCE_NOTIFY_DONE;			break;		default:			break;		}		/* FALLTHROUGH */	case USB_ST_SETUP:tr_setup:		/*		 * Inform host about connection. Required according to USB CDC		 * specification and communicating to Mac OS X USB host stack.		 * Some of the values seems ignored by Mac OS X though.		 */		if (sc->sc_notify_state == CDCE_NOTIFY_NETWORK_CONNECTION) {			req.bmRequestType = UCDC_NOTIFICATION;			req.bNotification = UCDC_N_NETWORK_CONNECTION;			req.wIndex[0] = sc->sc_ifaces_index[1];			req.wIndex[1] = 0;			USETW(req.wValue, 1); /* Connected */			USETW(req.wLength, 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);			usbd_transfer_submit(xfer); 		} else if (sc->sc_notify_state == CDCE_NOTIFY_SPEED_CHANGE) {			req.bmRequestType = UCDC_NOTIFICATION;			req.bNotification = UCDC_N_CONNECTION_SPEED_CHANGE;			req.wIndex[0] = sc->sc_ifaces_index[1];			req.wIndex[1] = 0;			USETW(req.wValue, 0);			USETW(req.wLength, 8);			/* Peak theoretical bulk trasfer rate in bits/s */			if (usbd_get_speed(sc->sc_ue.ue_udev) != USB_SPEED_FULL)				speed = (13 * 512 * 8 * 1000 * 8);			else				speed = (19 * 64 * 1 * 1000 * 8);			USETDW(req.data + 0, speed); /* Upstream bit rate */			USETDW(req.data + 4, speed); /* Downstream bit rate */ 			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);			usbd_transfer_submit(xfer); 		}		break;	default:			/* Error */		if (error != USB_ERR_CANCELLED) {			if (usbd_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST) {				/* start clear stall */				usbd_xfer_set_stall(xfer);			}			goto tr_setup;		}		break;	}}

static voidubt_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct ubt_softc	*sc = usbd_xfer_softc(xfer);	struct mbuf		*m;	ng_hci_acldata_pkt_t	*hdr;	struct usb_page_cache	*pc;	int len;	int actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	m = NULL;	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		/* Allocate new mbuf */		MGETHDR(m, M_NOWAIT, MT_DATA);		if (m == NULL) {			UBT_STAT_IERROR(sc);			goto submit_next;		}		if (!(MCLGET(m, M_NOWAIT))) {			UBT_STAT_IERROR(sc);			goto submit_next;		}		/* Add HCI packet type */		*mtod(m, uint8_t *)= NG_HCI_ACL_DATA_PKT;		m->m_pkthdr.len = m->m_len = 1;		if (actlen > MCLBYTES - 1)			actlen = MCLBYTES - 1;		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_out(pc, 0, mtod(m, uint8_t *) + 1, actlen);		m->m_pkthdr.len += actlen;		m->m_len += actlen;		UBT_INFO(sc, "got %d bytes from bulk-in pipe/n",			actlen);		/* Validate packet and send it up the stack */		if (m->m_pkthdr.len < (int)sizeof(*hdr)) {			UBT_INFO(sc, "HCI ACL packet is too short/n");			UBT_STAT_IERROR(sc);			goto submit_next;		}		hdr = mtod(m, ng_hci_acldata_pkt_t *);		len = le16toh(hdr->length);		if (len != (int)(m->m_pkthdr.len - sizeof(*hdr))) {			UBT_ERR(sc, "Invalid ACL packet size, length=%d, " /				"pktlen=%d/n", len, m->m_pkthdr.len);			UBT_STAT_IERROR(sc);			goto submit_next;		}		UBT_INFO(sc, "got complete ACL data packet, pktlen=%d, " /			"length=%d/n", m->m_pkthdr.len, len);		UBT_STAT_PCKTS_RECV(sc);		UBT_STAT_BYTES_RECV(sc, m->m_pkthdr.len);		ubt_fwd_mbuf_up(sc, &m);		/* m == NULL at this point */		/* FALLTHOUGH */	case USB_ST_SETUP:submit_next:		NG_FREE_M(m); /* checks for m != NULL */		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));		usbd_transfer_submit(xfer);		break;	default: /* Error */		if (error != USB_ERR_CANCELLED) {			UBT_WARN(sc, "bulk-in transfer failed: %s/n",				usbd_errstr(error));			/* Try to clear stall first */			usbd_xfer_set_stall(xfer);			goto submit_next;		}			/* transfer cancelled */		break;	}} /* ubt_bulk_read_callback */

static voidubt_ctrl_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct ubt_softc		*sc = usbd_xfer_softc(xfer);	struct usb_device_request	req;	struct mbuf			*m;	struct usb_page_cache		*pc;	int				actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		UBT_INFO(sc, "sent %d bytes to control pipe/n", actlen);		UBT_STAT_BYTES_SENT(sc, actlen);		UBT_STAT_PCKTS_SENT(sc);		/* FALLTHROUGH */	case USB_ST_SETUP:send_next:		/* Get next command mbuf, if any */		UBT_NG_LOCK(sc);		NG_BT_MBUFQ_DEQUEUE(&sc->sc_cmdq, m);		UBT_NG_UNLOCK(sc);		if (m == NULL) {			UBT_INFO(sc, "HCI command queue is empty/n");			break;	/* transfer complete */		}		/* Initialize a USB control request and then schedule it */		bzero(&req, sizeof(req));		req.bmRequestType = UBT_HCI_REQUEST;		USETW(req.wLength, m->m_pkthdr.len);		UBT_INFO(sc, "Sending control request, " /			"bmRequestType=0x%02x, wLength=%d/n",			req.bmRequestType, UGETW(req.wLength));		pc = usbd_xfer_get_frame(xfer, 0);		usbd_copy_in(pc, 0, &req, sizeof(req));		pc = usbd_xfer_get_frame(xfer, 1);		usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);		usbd_xfer_set_frame_len(xfer, 0, sizeof(req));		usbd_xfer_set_frame_len(xfer, 1, m->m_pkthdr.len);		usbd_xfer_set_frames(xfer, 2);		NG_FREE_M(m);		usbd_transfer_submit(xfer);		break;	default: /* Error */		if (error != USB_ERR_CANCELLED) {			UBT_WARN(sc, "control transfer failed: %s/n",				usbd_errstr(error));			UBT_STAT_OERROR(sc);			goto send_next;		}		/* transfer cancelled */		break;	}} /* ubt_ctrl_write_callback */

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 voidubt_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct ubt_softc	*sc = usbd_xfer_softc(xfer);	struct mbuf		*m;	struct usb_page_cache	*pc;	int			actlen;	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		UBT_INFO(sc, "sent %d bytes to bulk-out pipe/n", actlen);		UBT_STAT_BYTES_SENT(sc, actlen);		UBT_STAT_PCKTS_SENT(sc);		/* FALLTHROUGH */	case USB_ST_SETUP:send_next:		/* Get next mbuf, if any */		UBT_NG_LOCK(sc);		NG_BT_MBUFQ_DEQUEUE(&sc->sc_aclq, m);		UBT_NG_UNLOCK(sc);		if (m == NULL) {			UBT_INFO(sc, "ACL data queue is empty/n");			break; /* transfer completed */		}		/*		 * Copy ACL data frame back to a linear USB transfer buffer		 * and schedule transfer		 */		pc = usbd_xfer_get_frame(xfer, 0);		usbd_m_copy_in(pc, 0, m, 0, m->m_pkthdr.len);		usbd_xfer_set_frame_len(xfer, 0, m->m_pkthdr.len);		UBT_INFO(sc, "bulk-out transfer has been started, len=%d/n",			m->m_pkthdr.len);		NG_FREE_M(m);		usbd_transfer_submit(xfer);		break;	default: /* Error */		if (error != USB_ERR_CANCELLED) {			UBT_WARN(sc, "bulk-out transfer failed: %s/n",				usbd_errstr(error));			UBT_STAT_OERROR(sc);			/* try to clear stall first */			usbd_xfer_set_stall(xfer);			goto send_next;		}			/* transfer cancelled */		break;	}} /* ubt_bulk_write_callback */

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

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

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 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 voidcdce_ncm_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct cdce_softc *sc = usbd_xfer_softc(xfer);	struct usb_page_cache *pc = usbd_xfer_get_frame(xfer, 0);	struct ifnet *ifp = uether_getifp(&sc->sc_ue);	struct mbuf *m;	int sumdata;	int sumlen;	int actlen;	int aframes;	int temp;	int nframes;	int x;	int offset;	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		usbd_xfer_status(xfer, &actlen, &sumlen, &aframes, NULL);		DPRINTFN(1, "received %u bytes in %u frames/n",		    actlen, aframes);		if (actlen < (sizeof(sc->sc_ncm.hdr) +		    sizeof(sc->sc_ncm.dpt))) {			DPRINTFN(1, "frame too short/n");			goto tr_setup;		}		usbd_copy_out(pc, 0, &(sc->sc_ncm.hdr),		    sizeof(sc->sc_ncm.hdr));		if ((sc->sc_ncm.hdr.dwSignature[0] != 'N') ||		    (sc->sc_ncm.hdr.dwSignature[1] != 'C') ||		    (sc->sc_ncm.hdr.dwSignature[2] != 'M') ||		    (sc->sc_ncm.hdr.dwSignature[3] != 'H')) {			DPRINTFN(1, "invalid HDR signature: "			    "0x%02x:0x%02x:0x%02x:0x%02x/n",			    sc->sc_ncm.hdr.dwSignature[0],			    sc->sc_ncm.hdr.dwSignature[1],			    sc->sc_ncm.hdr.dwSignature[2],			    sc->sc_ncm.hdr.dwSignature[3]);			goto tr_stall;		}		temp = UGETW(sc->sc_ncm.hdr.wBlockLength);		if (temp > sumlen) {			DPRINTFN(1, "unsupported block length %u/%u/n",			    temp, sumlen);			goto tr_stall;		}		temp = UGETW(sc->sc_ncm.hdr.wDptIndex);		if ((temp + sizeof(sc->sc_ncm.dpt)) > actlen) {			DPRINTFN(1, "invalid DPT index: 0x%04x/n", temp);			goto tr_stall;		}		usbd_copy_out(pc, temp, &(sc->sc_ncm.dpt),		    sizeof(sc->sc_ncm.dpt));		if ((sc->sc_ncm.dpt.dwSignature[0] != 'N') ||		    (sc->sc_ncm.dpt.dwSignature[1] != 'C') ||		    (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) ||//.........这里部分代码省略.........

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

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