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

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){	struct cdce_softc *sc = usbd_xfer_softc(xfer);	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 */			if (usbd_get_mode(sc->sc_ue.ue_udev) == USB_MODE_HOST)				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 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_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 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 voidugen_default_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_fifo *f = usbd_xfer_softc(xfer);	struct usb_mbuf *m;	DPRINTFN(4, "actlen=%u, aframes=%u/n", xfer->actlen, xfer->aframes);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		if (xfer->actlen == 0) {			if (f->fifo_zlp != 4) {				f->fifo_zlp++;			} else {				/*				 * Throttle a little bit we have multiple ZLPs				 * in a row!				 */				xfer->interval = 64;	/* ms */			}		} else {			/* clear throttle */			xfer->interval = 0;			f->fifo_zlp = 0;		}		usb_fifo_put_data(f, xfer->frbuffers, 0,		    xfer->actlen, 1);	case USB_ST_SETUP:		if (f->flag_stall) {			usbd_transfer_start(f->xfer[1]);			break;		}		USB_IF_POLL(&f->free_q, m);		if (m) {			usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));			usbd_transfer_submit(xfer);		}		break;	default:			/* Error */		if (xfer->error != USB_ERR_CANCELLED) {			/* send a zero length packet to userland */			usb_fifo_put_data(f, xfer->frbuffers, 0, 0, 1);			f->flag_stall = 1;			f->fifo_zlp = 0;			usbd_transfer_start(f->xfer[1]);		}		break;	}}

/* * 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 voidugen_write_clear_stall_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_fifo *f = usbd_xfer_softc(xfer);	struct usb_xfer *xfer_other = f->xfer[0];	if (f->flag_stall == 0) {		/* nothing to do */		return;	}	if (usbd_clear_stall_callback(xfer, xfer_other)) {		DPRINTFN(5, "f=%p: stall cleared/n", f);		f->flag_stall = 0;		usbd_transfer_start(xfer_other);	}}

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 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 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 voidugen_isoc_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_fifo *f = usbd_xfer_softc(xfer);	usb_frlength_t actlen;	usb_frlength_t offset;	usb_frcount_t n;	DPRINTFN(4, "actlen=%u, aframes=%u/n", xfer->actlen, xfer->aframes);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:	case USB_ST_SETUP:tr_setup:		offset = 0;		for (n = 0; n != xfer->nframes; n++) {			if (usb_fifo_get_data(f, xfer->frbuffers, offset,			    xfer->max_frame_size, &actlen, 1)) {				usbd_xfer_set_frame_len(xfer, n, actlen);				offset += actlen;			} else {				break;			}		}		for (; n != xfer->nframes; n++) {			/* fill in zero frames */			usbd_xfer_set_frame_len(xfer, n, 0);		}		usbd_transfer_submit(xfer);		break;	default:			/* Error */		if (xfer->error == USB_ERR_CANCELLED) {			break;		}		goto tr_setup;	}}

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 voidugen_isoc_read_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_fifo *f = usbd_xfer_softc(xfer);	usb_frlength_t offset;	usb_frcount_t n;	DPRINTFN(4, "actlen=%u, aframes=%u/n", xfer->actlen, xfer->aframes);	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		DPRINTFN(6, "actlen=%d/n", xfer->actlen);		offset = 0;		for (n = 0; n != xfer->aframes; n++) {			usb_fifo_put_data(f, xfer->frbuffers, offset,			    xfer->frlengths[n], 1);			offset += xfer->max_frame_size;		}	case USB_ST_SETUP:tr_setup:		for (n = 0; n != xfer->nframes; n++) {			/* setup size for next transfer */			usbd_xfer_set_frame_len(xfer, n, xfer->max_frame_size);		}		usbd_transfer_submit(xfer);		break;	default:			/* Error */		if (xfer->error == USB_ERR_CANCELLED) {			break;		}		goto tr_setup;	}}

static voidugen_default_write_callback(struct usb_xfer *xfer, usb_error_t error){	struct usb_fifo *f = usbd_xfer_softc(xfer);	usb_frlength_t actlen;	DPRINTFN(4, "actlen=%u, aframes=%u/n", xfer->actlen, xfer->aframes);	switch (USB_GET_STATE(xfer)) {	case USB_ST_SETUP:	case USB_ST_TRANSFERRED:		/*		 * If writing is in stall, just jump to clear stall		 * callback and solve the situation.		 */		if (f->flag_stall) {			usbd_transfer_start(f->xfer[1]);			break;		}		/*		 * Write data, setup and perform hardware transfer.		 */		if (usb_fifo_get_data(f, xfer->frbuffers, 0,		    xfer->max_data_length, &actlen, 0)) {			usbd_xfer_set_frame_len(xfer, 0, actlen);			usbd_transfer_submit(xfer);		}		break;	default:			/* Error */		if (xfer->error != USB_ERR_CANCELLED) {			f->flag_stall = 1;			usbd_transfer_start(f->xfer[1]);		}		break;	}}

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

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 uint8_tcdce_ncm_fill_tx_frames(struct usb_xfer *xfer, uint8_t index){	struct cdce_softc *sc = usbd_xfer_softc(xfer);	struct ifnet *ifp = uether_getifp(&sc->sc_ue);	struct usb_page_cache *pc = usbd_xfer_get_frame(xfer, index);	struct mbuf *m;	uint32_t rem;	uint32_t offset;	uint32_t last_offset;	uint16_t n;	uint8_t retval;	usbd_xfer_set_frame_offset(xfer, index * CDCE_NCM_TX_MAXLEN, index);	offset = sizeof(sc->sc_ncm.hdr) +	    sizeof(sc->sc_ncm.dpt) + sizeof(sc->sc_ncm.dp);	/* Store last valid offset before alignment */	last_offset = offset;	/* Align offset */	offset = CDCE_NCM_ALIGN(sc->sc_ncm.tx_remainder,	    offset, sc->sc_ncm.tx_modulus);	/* Zero pad */	cdce_ncm_tx_zero(pc, last_offset, offset);	/* buffer full */	retval = 2;	for (n = 0; n != sc->sc_ncm.tx_nframe; n++) {		/* check if end of transmit buffer is reached */		if (offset >= sc->sc_ncm.tx_max)			break;		/* compute maximum buffer size */		rem = sc->sc_ncm.tx_max - offset;		IFQ_DRV_DEQUEUE(&(ifp->if_snd), m);		if (m == NULL) {			/* buffer not full */			retval = 1;			break;		}		if (m->m_pkthdr.len > rem) {			if (n == 0) {				/* The frame won't fit in our buffer */				DPRINTFN(1, "Frame too big to be transmitted!/n");				m_freem(m);				ifp->if_oerrors++;				n--;				continue;			}			/* Wait till next buffer becomes ready */			IFQ_DRV_PREPEND(&(ifp->if_snd), m);			break;		}		usbd_m_copy_in(pc, offset, m, 0, m->m_pkthdr.len);		USETW(sc->sc_ncm.dp[n].wFrameLength, m->m_pkthdr.len);		USETW(sc->sc_ncm.dp[n].wFrameIndex, offset);		/* Update offset */		offset += m->m_pkthdr.len;		/* Store last valid offset before alignment */		last_offset = offset;		/* Align offset */		offset = CDCE_NCM_ALIGN(sc->sc_ncm.tx_remainder,		    offset, sc->sc_ncm.tx_modulus);		/* Zero pad */		cdce_ncm_tx_zero(pc, last_offset, offset);		/*		 * If there's a BPF listener, bounce a copy		 * of this frame to him:		 */		BPF_MTAP(ifp, m);		/* Free mbuf */		m_freem(m);		/* Pre-increment interface counter */		ifp->if_opackets++;	}	if (n == 0)		return (0);	rem = (sizeof(sc->sc_ncm.dpt) + (4 * n) + 4);//.........这里部分代码省略.........

static voidusbd_ctrl_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;	uint8_t irql;	union usbd_urb *urb;	struct usbd_urb_vendor_or_class_request *vcreq;	struct usb_page_cache *pc;	uint8_t type = 0;	struct usb_device_request req;	int len;	switch (USB_GET_STATE(xfer)) {	case USB_ST_TRANSFERRED:		nx = usbd_aq_getfirst(sc, ne);		if (nx == NULL)			return;		ip = nx->nx_priv;		urb = usbd_geturb(ip);		vcreq = &urb->uu_vcreq;		if (vcreq->uvc_trans_flags & USBD_TRANSFER_DIRECTION_IN) {			pc = usbd_xfer_get_frame(xfer, 1);			len = usbd_xfer_frame_len(xfer, 1);			usbd_copy_out(pc, 0, vcreq->uvc_trans_buf, len);			nx->nx_urbactlen += len;		}		usbd_xfer_complete(sc, ne, nx, 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);		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));//.........这里部分代码省略.........

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

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