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

voiducom_cleanup(struct ucom_softc *sc){	DPRINTF(("ucom_cleanup: closing pipes/n"));	sc->sc_open = 0;	ucom_shutdown(sc);	if (sc->sc_bulkin_pipe != NULL) {		usbd_abort_pipe(sc->sc_bulkin_pipe);		usbd_close_pipe(sc->sc_bulkin_pipe);		sc->sc_bulkin_pipe = NULL;	}	if (sc->sc_bulkout_pipe != NULL) {		usbd_abort_pipe(sc->sc_bulkout_pipe);		usbd_close_pipe(sc->sc_bulkout_pipe);		sc->sc_bulkout_pipe = NULL;	}	if (sc->sc_ixfer != NULL) {		if (sc->sc_uhidev == NULL)			usbd_free_xfer(sc->sc_ixfer);		sc->sc_ixfer = NULL;	}	if (sc->sc_oxfer != NULL) {		usbd_free_buffer(sc->sc_oxfer);		if (sc->sc_uhidev == NULL)			usbd_free_xfer(sc->sc_oxfer);		sc->sc_oxfer = NULL;	}}

/* alloc/free pipe */static usbd_statusalloc_pipe(struct umidi_endpoint *ep){	struct umidi_softc *sc = ep->sc;	usbd_status err;	DPRINTF(("%s: alloc_pipe %p/n", sc->sc_dev.dv_xname, ep));	SIMPLEQ_INIT(&ep->intrq);	ep->pending = 0;	ep->busy = 0;	ep->used = 0;	ep->xfer = usbd_alloc_xfer(sc->sc_udev);	if (ep->xfer == NULL)		return USBD_NOMEM;	ep->buffer = usbd_alloc_buffer(ep->xfer, ep->packetsize);	if (ep->buffer == NULL) {		usbd_free_xfer(ep->xfer);		return USBD_NOMEM;	}	err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe);	if (err != USBD_NORMAL_COMPLETION) {		usbd_free_xfer(ep->xfer);		return err;	}	return USBD_NORMAL_COMPLETION;}

inturiowrite(dev_t dev, struct uio *uio, int flag){	struct urio_softc *sc;	usbd_xfer_handle xfer;	usbd_status err;	void *bufp;	u_int32_t n;	int error = 0;	sc = device_lookup_private(&urio_cd, URIOUNIT(dev));	DPRINTFN(5, ("uriowrite: unit=%d, len=%ld/n", URIOUNIT(dev),		     (long)uio->uio_resid));	if (sc->sc_dying)		return (EIO);	xfer = usbd_alloc_xfer(sc->sc_udev);	if (xfer == NULL)		return (ENOMEM);	bufp = usbd_alloc_buffer(xfer, URIO_BSIZE);	if (bufp == NULL) {		usbd_free_xfer(xfer);		return (ENOMEM);	}	sc->sc_refcnt++;	while ((n = min(URIO_BSIZE, uio->uio_resid)) != 0) {		error = uiomove(bufp, n, uio);		if (error)			break;		DPRINTFN(1, ("uriowrite: transfer %d bytes/n", n));		err = usbd_bulk_transfer(xfer, sc->sc_out_pipe, USBD_NO_COPY,			  URIO_RW_TIMEOUT, bufp, &n, "uriowr");		DPRINTFN(2, ("uriowrite: err=%d/n", err));		if (err) {			if (err == USBD_INTERRUPTED)				error = EINTR;			else if (err == USBD_TIMEOUT)				error = ETIMEDOUT;			else				error = EIO;			break;		}	}	usbd_free_xfer(xfer);	if (--sc->sc_refcnt < 0)		usb_detach_wakeupold(sc->sc_dev);	DPRINTFN(5, ("uriowrite: done unit=%d, error=%d/n", URIOUNIT(dev),		     error));	return (error);}

intuirda_close(void *h, int flag, int mode,    struct lwp *l){	struct uirda_softc *sc = h;	DPRINTF(("%s: sc=%p/n", __func__, sc));	if (sc->sc_rd_pipe != NULL) {		usbd_abort_pipe(sc->sc_rd_pipe);		usbd_close_pipe(sc->sc_rd_pipe);		sc->sc_rd_pipe = NULL;	}	if (sc->sc_wr_pipe != NULL) {		usbd_abort_pipe(sc->sc_wr_pipe);		usbd_close_pipe(sc->sc_wr_pipe);		sc->sc_wr_pipe = NULL;	}	if (sc->sc_rd_xfer != NULL) {		usbd_free_xfer(sc->sc_rd_xfer);		sc->sc_rd_xfer = NULL;		sc->sc_rd_buf = NULL;	}	if (sc->sc_wr_xfer != NULL) {		usbd_free_xfer(sc->sc_wr_xfer);		sc->sc_wr_xfer = NULL;		sc->sc_wr_buf = NULL;	}	return (0);}

inturiowrite(dev_t dev, struct uio *uio, int flag){	struct urio_softc *sc;	struct usbd_xfer *xfer;	usbd_status err;	void *bufp;	u_int32_t n;	int error = 0;	sc = urio_cd.cd_devs[URIOUNIT(dev)];	DPRINTFN(5, ("uriowrite: unit=%d, len=%ld/n", URIOUNIT(dev),		     (long)uio->uio_resid));	if (usbd_is_dying(sc->sc_udev))		return (EIO);	xfer = usbd_alloc_xfer(sc->sc_udev);	if (xfer == NULL)		return (ENOMEM);	bufp = usbd_alloc_buffer(xfer, URIO_BSIZE);	if (bufp == NULL) {		usbd_free_xfer(xfer);		return (ENOMEM);	}	sc->sc_refcnt++;	while ((n = min(URIO_BSIZE, uio->uio_resid)) != 0) {		error = uiomove(bufp, n, uio);		if (error)			break;		DPRINTFN(1, ("uriowrite: transfer %d bytes/n", n));		usbd_setup_xfer(xfer, sc->sc_out_pipe, 0, bufp, n,		    USBD_NO_COPY | USBD_SYNCHRONOUS, URIO_RW_TIMEOUT, NULL);		err = usbd_transfer(xfer);		DPRINTFN(2, ("uriowrite: err=%d/n", err));		if (err) {			usbd_clear_endpoint_stall(sc->sc_out_pipe);			if (err == USBD_TIMEOUT)				error = ETIMEDOUT;			else				error = EIO;			break;		}	}	usbd_free_xfer(xfer);	if (--sc->sc_refcnt < 0)		usb_detach_wakeup(&sc->sc_dev);	DPRINTFN(5, ("uriowrite: done unit=%d, error=%d/n", URIOUNIT(dev),		     error));	return (error);}

inturioread(dev_t dev, struct uio *uio, int flag){	struct urio_softc *sc;	usbd_xfer_handle xfer;	usbd_status err;	void *bufp;	u_int32_t n, tn;	int error = 0;	sc = device_lookup_private(&urio_cd, URIOUNIT(dev));	DPRINTFN(5, ("urioread: %d/n", URIOUNIT(dev)));	if (sc->sc_dying)		return (EIO);	xfer = usbd_alloc_xfer(sc->sc_udev);	if (xfer == NULL)		return (ENOMEM);	bufp = usbd_alloc_buffer(xfer, URIO_BSIZE);	if (bufp == NULL) {		usbd_free_xfer(xfer);		return (ENOMEM);	}	sc->sc_refcnt++;	while ((n = min(URIO_BSIZE, uio->uio_resid)) != 0) {		DPRINTFN(1, ("urioread: start transfer %d bytes/n", n));		tn = n;		err = usbd_bulk_transfer(xfer, sc->sc_in_pipe, USBD_NO_COPY,			  URIO_RW_TIMEOUT, bufp, &tn, "uriors");		if (err) {			if (err == USBD_INTERRUPTED)				error = EINTR;			else if (err == USBD_TIMEOUT)				error = ETIMEDOUT;			else				error = EIO;			break;		}		DPRINTFN(1, ("urioread: got %d bytes/n", tn));		error = uiomove(bufp, tn, uio);		if (error || tn < n)			break;	}	usbd_free_xfer(xfer);	if (--sc->sc_refcnt < 0)		usb_detach_wakeupold(sc->sc_dev);	return (error);}

/* * Stop the adapter and free any mbufs allocated to the * RX and TX lists. */voidugl_stop(struct ugl_softc *sc){	struct ifnet		*ifp;	int			i;	DPRINTFN(10,("%s: %s: enter/n", sc->sc_dev.dv_xname,__func__));	ifp = GET_IFP(sc);	ifp->if_timer = 0;	ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);	/* Stop transfers. */	if (sc->sc_ep[UGL_ENDPT_RX] != NULL) {		usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_RX]);		usbd_close_pipe(sc->sc_ep[UGL_ENDPT_RX]);		sc->sc_ep[UGL_ENDPT_RX] = NULL;	}	if (sc->sc_ep[UGL_ENDPT_TX] != NULL) {		usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_TX]);		usbd_close_pipe(sc->sc_ep[UGL_ENDPT_TX]);		sc->sc_ep[UGL_ENDPT_TX] = NULL;	}	if (sc->sc_ep[UGL_ENDPT_INTR] != NULL) {		usbd_abort_pipe(sc->sc_ep[UGL_ENDPT_INTR]);		usbd_close_pipe(sc->sc_ep[UGL_ENDPT_INTR]);		sc->sc_ep[UGL_ENDPT_INTR] = NULL;	}	/* Free RX resources. */	for (i = 0; i < UGL_RX_LIST_CNT; i++) {		if (sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf != NULL) {			m_freem(sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf);			sc->sc_cdata.ugl_rx_chain[i].ugl_mbuf = NULL;		}		if (sc->sc_cdata.ugl_rx_chain[i].ugl_xfer != NULL) {			usbd_free_xfer(sc->sc_cdata.ugl_rx_chain[i].ugl_xfer);			sc->sc_cdata.ugl_rx_chain[i].ugl_xfer = NULL;		}	}	/* Free TX resources. */	for (i = 0; i < UGL_TX_LIST_CNT; i++) {		if (sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf != NULL) {			m_freem(sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf);			sc->sc_cdata.ugl_tx_chain[i].ugl_mbuf = NULL;		}		if (sc->sc_cdata.ugl_tx_chain[i].ugl_xfer != NULL) {			usbd_free_xfer(sc->sc_cdata.ugl_tx_chain[i].ugl_xfer);			sc->sc_cdata.ugl_tx_chain[i].ugl_xfer = NULL;		}	}}

/* alloc/free pipe */static usbd_statusalloc_pipe(struct umidi_endpoint *ep){	struct umidi_softc *sc = ep->sc;	usbd_status err;	usb_endpoint_descriptor_t *epd;		epd = usbd_get_endpoint_descriptor(sc->sc_iface, ep->addr);	/*	 * For output, an improvement would be to have a buffer bigger than	 * wMaxPacketSize by num_jacks-1 additional packet slots; that would	 * allow out_solicit to fill the buffer to the full packet size in	 * all cases. But to use usbd_alloc_buffer to get a slightly larger	 * buffer would not be a good way to do that, because if the addition	 * would make the buffer exceed USB_MEM_SMALL then a substantially	 * larger block may be wastefully allocated. Some flavor of double	 * buffering could serve the same purpose, but would increase the	 * code complexity, so for now I will live with the current slight	 * penalty of reducing max transfer size by (num_open-num_scheduled)	 * packet slots.	 */	ep->buffer_size = UGETW(epd->wMaxPacketSize);	ep->buffer_size -= ep->buffer_size % UMIDI_PACKET_SIZE;	DPRINTF(("%s: alloc_pipe %p, buffer size %u/n",	        USBDEVNAME(sc->sc_dev), ep, ep->buffer_size));	ep->num_scheduled = 0;	ep->this_schedule = 0;	ep->next_schedule = 0;	ep->soliciting = 0;	ep->armed = 0;	ep->xfer = usbd_alloc_xfer(sc->sc_udev);	if (ep->xfer == NULL) {	    err = USBD_NOMEM;	    goto quit;	}	ep->buffer = usbd_alloc_buffer(ep->xfer, ep->buffer_size);	if (ep->buffer == NULL) {	    usbd_free_xfer(ep->xfer);	    err = USBD_NOMEM;	    goto quit;	}	ep->next_slot = ep->buffer;	err = usbd_open_pipe(sc->sc_iface, ep->addr, 0, &ep->pipe);	if (err)	    usbd_free_xfer(ep->xfer);	ep->solicit_cookie = softint_establish(SOFTINT_CLOCK, out_solicit, ep);quit:	return err;}

intugl_rx_list_init(struct ugl_softc *sc){	struct ugl_cdata	*cd;	struct ugl_chain	*c;	int			i;	DPRINTFN(5,("%s: %s: enter/n", sc->sc_dev.dv_xname, __func__));	cd = &sc->sc_cdata;	for (i = 0; i < UGL_RX_LIST_CNT; i++) {		c = &cd->ugl_rx_chain[i];		c->ugl_sc = sc;		c->ugl_idx = i;		if (ugl_newbuf(sc, c, NULL) == ENOBUFS)			return (ENOBUFS);		if (c->ugl_xfer == NULL) {			c->ugl_xfer = usbd_alloc_xfer(sc->sc_udev);			if (c->ugl_xfer == NULL)				return (ENOBUFS);			c->ugl_buf = usbd_alloc_buffer(c->ugl_xfer, UGL_BUFSZ);			if (c->ugl_buf == NULL) {				usbd_free_xfer(c->ugl_xfer);				return (ENOBUFS);			}		}	}	return (0);}

/* ARGSUSED */static intudsir_close(void *h, int flag, int mode, struct lwp *l){	struct udsir_softc *sc = h;	DPRINTFN(0, ("%s: sc=%p/n", __func__, sc));	sc->sc_refcnt++;	sc->sc_rd_readinprogress = 1;	sc->sc_closing = 1;	wakeup(&sc->sc_thread);	while (sc->sc_thread != NULL)		tsleep(&sc->sc_closing, PWAIT, "usircl", 0);	if (sc->sc_rd_pipe != NULL) {		usbd_abort_pipe(sc->sc_rd_pipe);		usbd_close_pipe(sc->sc_rd_pipe);		sc->sc_rd_pipe = NULL;	}	if (sc->sc_wr_pipe != NULL) {		usbd_abort_pipe(sc->sc_wr_pipe);		usbd_close_pipe(sc->sc_wr_pipe);		sc->sc_wr_pipe = NULL;	}	if (sc->sc_rd_xfer != NULL) {		usbd_free_xfer(sc->sc_rd_xfer);		sc->sc_rd_xfer = NULL;		sc->sc_rd_buf = NULL;	}	if (sc->sc_wr_xfer != NULL) {		usbd_free_xfer(sc->sc_wr_xfer);		sc->sc_wr_xfer = NULL;		sc->sc_wr_buf = NULL;	}	if (sc->sc_ur_buf != NULL) {		free(sc->sc_ur_buf, M_USBDEV);		sc->sc_ur_buf = NULL;	}	if (--sc->sc_refcnt < 0)		usb_detach_wakeupold(sc->sc_dev);	return 0;}

intuhidev_get_report_async(struct uhidev_softc *sc, int type, int id, void *data,    int len, void *priv, void (*callback)(void *, int, void *, int)){	struct usbd_xfer *xfer;	usb_device_request_t req;	struct uhidev_async_info *info;	int actlen = len;	char *buf;	xfer = usbd_alloc_xfer(sc->sc_udev);	if (xfer == NULL)		return (-1);	if (id > 0)		len++;	buf = usbd_alloc_buffer(xfer, len);	if (buf == NULL) {		usbd_free_xfer(xfer);		return (-1);	}	info = malloc(sizeof(*info), M_TEMP, M_NOWAIT);	if (info == NULL) {		usbd_free_xfer(xfer);		return (-1);	}	info->callback = callback;	info->priv = priv;	info->data = data;	info->id = id;	req.bmRequestType = UT_READ_CLASS_INTERFACE;	req.bRequest = UR_GET_REPORT;	USETW2(req.wValue, type, id);	USETW(req.wIndex, sc->sc_ifaceno);	USETW(req.wLength, len);	if (usbd_request_async(xfer, &req, info, uhidev_get_report_async_cb)) {		free(info, M_TEMP, sizeof(*info));		actlen = -1;	}	return (actlen);}

static voidfree_pipe(struct umidi_endpoint *ep){	DPRINTF(("%s: %s %p/n", ep->sc->sc_dev.dv_xname, __func__, ep));	usbd_abort_pipe(ep->pipe);	usbd_close_pipe(ep->pipe);	usbd_free_xfer(ep->xfer);}

voiduhidev_close(struct uhidev *scd){	struct uhidev_softc *sc = scd->sc_parent;	if (!(scd->sc_state & UHIDEV_OPEN))		return;	scd->sc_state &= ~UHIDEV_OPEN;	if (--sc->sc_refcnt)		return;	DPRINTF(("uhidev_close: close pipe/n"));	if (sc->sc_oxfer != NULL) {		usbd_free_xfer(sc->sc_oxfer);		sc->sc_oxfer = NULL;	}	if (sc->sc_owxfer != NULL) {		usbd_free_xfer(sc->sc_owxfer);		sc->sc_owxfer = NULL;	}	if (sc->sc_ixfer != NULL) {		usbd_free_xfer(sc->sc_ixfer);		sc->sc_ixfer = NULL;	}	/* Disable interrupts. */	if (sc->sc_opipe != NULL) {		usbd_abort_pipe(sc->sc_opipe);		usbd_close_pipe(sc->sc_opipe);		sc->sc_opipe = NULL;	}	if (sc->sc_ipipe != NULL) {		usbd_abort_pipe(sc->sc_ipipe);		usbd_close_pipe(sc->sc_ipipe);		sc->sc_ipipe = NULL;	}	if (sc->sc_ibuf != NULL) {		free(sc->sc_ibuf, M_USBDEV, 0);		sc->sc_ibuf = NULL;	}}

static voidfree_pipe(struct umidi_endpoint *ep){	DPRINTF(("%s: free_pipe %p/n", USBDEVNAME(ep->sc->sc_dev), ep));	usbd_abort_pipe(ep->pipe);	usbd_close_pipe(ep->pipe);	usbd_free_xfer(ep->xfer);	softint_disestablish(ep->solicit_cookie);}

intugen_do_close(struct ugen_softc *sc, int endpt, int flag){	struct ugen_endpoint *sce;	int dir, i;#ifdef DIAGNOSTIC	if (!sc->sc_is_open[endpt]) {		printf("ugenclose: not open/n");		return (EINVAL);	}#endif	if (endpt == USB_CONTROL_ENDPOINT) {		DPRINTFN(5, ("ugenclose: close control/n"));		sc->sc_is_open[endpt] = 0;		return (0);	}	for (dir = OUT; dir <= IN; dir++) {		if (!(flag & (dir == OUT ? FWRITE : FREAD)))			continue;		sce = &sc->sc_endpoints[endpt][dir];		if (sce == NULL || sce->pipeh == NULL)			continue;		DPRINTFN(5, ("ugenclose: endpt=%d dir=%d sce=%p/n",			     endpt, dir, sce));		usbd_close_pipe(sce->pipeh);		sce->pipeh = NULL;		switch (sce->edesc->bmAttributes & UE_XFERTYPE) {		case UE_INTERRUPT:			ndflush(&sce->q, sce->q.c_cc);			clfree(&sce->q);			break;		case UE_ISOCHRONOUS:			for (i = 0; i < UGEN_NISOREQS; ++i)				usbd_free_xfer(sce->isoreqs[i].xfer);		default:			break;		}		if (sce->ibuf != NULL) {			free(sce->ibuf, M_USBDEV, 0);			sce->ibuf = NULL;		}	}	sc->sc_is_open[endpt] = 0;	return (0);}

voiduscanner_do_close(struct uscanner_softc *sc){	if (sc->sc_bulkin_xfer) {		usbd_free_xfer(sc->sc_bulkin_xfer);		sc->sc_bulkin_xfer = NULL;	}	if (sc->sc_bulkout_xfer) {		usbd_free_xfer(sc->sc_bulkout_xfer);		sc->sc_bulkout_xfer = NULL;	}	if (!(sc->sc_dev_flags & USC_KEEP_OPEN)) {		if (sc->sc_bulkin_pipe != NULL) {			usbd_abort_pipe(sc->sc_bulkin_pipe);			usbd_close_pipe(sc->sc_bulkin_pipe);			sc->sc_bulkin_pipe = NULL;		}		if (sc->sc_bulkout_pipe != NULL) {			usbd_abort_pipe(sc->sc_bulkout_pipe);			usbd_close_pipe(sc->sc_bulkout_pipe);			sc->sc_bulkout_pipe = NULL;		}	}	if (sc->sc_bulkin_buffer) {		free(sc->sc_bulkin_buffer, M_USBDEV);		sc->sc_bulkin_buffer = NULL;	}	if (sc->sc_bulkout_buffer) {		free(sc->sc_bulkout_buffer, M_USBDEV);		sc->sc_bulkout_buffer = NULL;	}	sc->sc_state &= ~USCANNER_OPEN;}

/* Transfer completion callback - passed to the Core for async transfers */static void cdc_data_xfer_complete(usbd_xfer_handle xfer,     usbd_private_handle priv, usbd_status rc){    cdc_cmd_priv_t *xfer_priv = (cdc_cmd_priv_t *)priv;    DECLARE_FNAME("cdc_data_xfer_complete");    KASSERT(xfer, ("%s: Null xfer handle/n", fname));    DBG_V(DHOST_CDC_GENERAL, ("%s: Data xfer %p complete, status %d/n", fname,        xfer, rc));    switch (rc)    {    case 0:        break;    case USBD_CANCELLED:        /* xfer has been canceled (abort_pipe was called) */        DBG_W(DHOST_CDC_GENERAL, ("%s: xfer %p was canceled/n", fname, xfer));        break;    default:        DBG_E(DHOST_CDC_GENERAL, ("%s: xfer completed with %d/n", fname, rc));    }        /* Activate callback */    if (xfer_priv->req_type == GET_DATA || xfer_priv->req_type == SEND_DATA)    {        xfer_priv->cdc_callback.data_cb(xfer_priv->app_ctx,             xfer_priv->app_priv, xfer->buffer, xfer->actlen,             status_to_result(rc));    }#ifdef JDEBUG    else    {        DBG_E(DHOST_CDC_GENERAL, ("%s: Unknown request type %d/n", fname,             xfer_priv->req_type));    }#endif    usbd_free_xfer(xfer);    cdc_uninit_request_priv(xfer_priv);}

/* Build encapsulated cmd / response and transfer it */static jresult_t encapsulated_transfer(cdc_cmd_priv_t *priv, void *membuf,     juint16_t size){    usbd_status status = USBD_NORMAL_COMPLETION;    usbd_xfer_handle xfer = NULL;    jcdc_dev_softc_t *sc = priv->sc;    usb_device_request_t req_t;    jbool_t in_xfer = (priv->req_type == SEND_ENCAP_CMD) ? 0 : 1;    DECLARE_FNAME("encapsulated_transfer");    DBG_X(DHOST_CDC_GENERAL, ("%s: Entered/n", fname));    xfer = usbd_alloc_xfer(sc->device);    if (!xfer)    {        DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer/n", fname));        return JENOMEM;    }    /* Build request according to xfer direction */    req_t.bmRequestType = (in_xfer) ? UT_READ_CLASS_INTERFACE :         UT_WRITE_CLASS_INTERFACE;    req_t.bRequest = (in_xfer) ? CDC_GET_ENC_RESPONSE :         CDC_SEND_ENC_COMMAND;    USETW(req_t.wValue, 0);    USETW(req_t.wIndex, (juint16_t)sc->c_iface->index);    USETW(req_t.wLength, size);    /* setup xfer */    usbd_setup_default_xfer(xfer, priv->sc->device, priv,        CDC_CONTROL_XFER_TIMEOUT, &req_t, membuf, size, 0, jcdc_send_encap_cb);    /* Send the request over default pipe (EP0) */    status = usbd_transfer(xfer);    if (status && status != USBD_IN_PROGRESS)    {        DBG_E(DHOST_CDC_GENERAL, ("%s: Failed transferring control request, "            "error %d/n", j_device_get_nameunit(priv->sc->dev), status));        usbd_free_xfer(xfer);        return status_to_result(status);    }    return 0;}

intuhidev_set_report_async(struct uhidev_softc *sc, int type, int id, void *data,    int len){	struct usbd_xfer *xfer;	usb_device_request_t req;	int actlen = len;	char *buf;	xfer = usbd_alloc_xfer(sc->sc_udev);	if (xfer == NULL)		return (-1);	if (id > 0)		len++;	buf = usbd_alloc_buffer(xfer, len);	if (buf == NULL) {		usbd_free_xfer(xfer);		return (-1);	}	/* Prepend the reportID. */	if (id > 0) {		buf[0] = id;		memcpy(buf + 1, data, len - 1);	} else {		memcpy(buf, data, len);	}	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;	req.bRequest = UR_SET_REPORT;	USETW2(req.wValue, type, id);	USETW(req.wIndex, sc->sc_ifaceno);	USETW(req.wLength, len);	if (usbd_request_async(xfer, &req, NULL, NULL))		actlen = -1;	return (actlen);}

voiduhidev_get_report_async_cb(struct usbd_xfer *xfer, void *priv, usbd_status err){	struct uhidev_async_info *info = priv;	char *buf;	int len = -1;	if (err == USBD_NORMAL_COMPLETION || err == USBD_SHORT_XFER) {		len = xfer->actlen;		buf = KERNADDR(&xfer->dmabuf, 0);		if (info->id > 0) {			len--;			memcpy(info->data, buf + 1, len);		} else {			memcpy(info->data, buf, len);		}	}	info->callback(info->priv, info->id, info->data, len);	free(info, M_TEMP, sizeof(*info));	usbd_free_xfer(xfer);}

/* General CDC asynchronous transfer function */static jresult_t cdc_async_transfer(cdc_cmd_priv_t *priv,     usbd_pipe_handle pipe, void *membuf, juint32_t size,     usbd_xfer_handle xfer){    jresult_t rc;    usbd_status status;    juint16_t flags = USBD_SHORT_XFER_OK | USBD_FORCE_SHORT_XFER;    DECLARE_FNAME("cdc_async_transfer");        DBG_X(DHOST_CDC_GENERAL, ("%s: Entered/n", fname));    /* Allocate a transfer request object and set up a xfer */    xfer = usbd_alloc_xfer(priv->sc->device);    if (!xfer)    {        DBG_E(DHOST_CDC_GENERAL, ("%s: Failed to allocate xfer/n", fname));        rc = JENOMEM;        goto Error;    }    usbd_setup_xfer(xfer, pipe, (void *)priv, membuf, size, flags,         CDC_DATA_XFER_TIMEOUT, cdc_data_xfer_complete);    /* Execute xfer */    status = usbd_transfer(xfer);    if (status && status != USBD_IN_PROGRESS)     {        DBG_W(DHOST_CDC_GENERAL, ("%s: failed to setup transfer, %s/n", fname,             usbd_errstr(status)));        rc = status_to_result(status);        goto Error;    }    return 0;Error:    if (xfer)        usbd_free_xfer(xfer);    return rc;}

static intauvitek_stop_xfer(struct auvitek_softc *sc){	struct auvitek_xfer *ax = &sc->sc_ax;	usbd_status err;	int i;	if (ax->ax_pipe != NULL) {		usbd_abort_pipe(ax->ax_pipe);		usbd_close_pipe(ax->ax_pipe);		ax->ax_pipe = NULL;	}	for (i = 0; i < AUVITEK_NISOC_XFERS; i++) {		struct auvitek_isoc *isoc = &ax->ax_i[i];		if (isoc->i_xfer != NULL) {			usbd_free_buffer(isoc->i_xfer);			usbd_free_xfer(isoc->i_xfer);			isoc->i_xfer = NULL;		}		if (isoc->i_frlengths != NULL) {			kmem_free(isoc->i_frlengths,			    sizeof(isoc->i_frlengths[0]) * ax->ax_nframes);			isoc->i_frlengths = NULL;		}	}	usbd_delay_ms(sc->sc_udev, 1000);	err = usbd_set_interface(sc->sc_isoc_iface, 0);	if (err != USBD_NORMAL_COMPLETION) {		aprint_error_dev(sc->sc_dev,		    "couldn't set zero bw interface: %s/n",		    usbd_errstr(err));		return EIO;	}	return 0;}

/* Command completion callback - passed to the Core for async transfers */static void jcdc_send_encap_cb(usbd_xfer_handle xfer, usbd_private_handle priv,    usbd_status rc){    /* Activate application's callback according to priv */    cdc_cmd_priv_t *cmd_priv = (cdc_cmd_priv_t *)priv;    DECLARE_FNAME("jcdc_send_encap_cb");    DBG_X(DHOST_CDC_GENERAL, ("%s: Entered/n", fname));        if (cmd_priv->req_type == SEND_ENCAP_CMD)    {        cmd_priv->cdc_callback.command_cb(cmd_priv->app_ctx,             cmd_priv->app_priv, status_to_result(rc));    }    else    {        cmd_priv->cdc_callback.data_cb(cmd_priv->app_ctx, cmd_priv->app_priv,             xfer->buffer, xfer->actlen, status_to_result(rc));    }    usbd_free_xfer(xfer);    cdc_uninit_request_priv(cmd_priv);}

//.........这里部分代码省略.........	if (rc) {		printf("%s: Cannot load firmware/n",			device_xname(sc->sc_dev));		return rc;	}	fwsize = firmware_get_size(fh);	printf("%s: Firmware size %lld/n",		device_xname(sc->sc_dev), (long long)fwsize);	buffer = firmware_malloc(fwsize);	if (buffer == NULL) {		printf("%s: Cannot load firmware: out of memory/n",			device_xname(sc->sc_dev));		goto giveup2;	}	rc = firmware_read(fh, 0, buffer, (size_t)fwsize);	if (rc) {		printf("%s: Cannot read firmware/n", device_xname(sc->sc_dev));		goto giveup3;	}	for (p = buffer + sizeof("Product Version:");	    p < buffer + fwsize - 5; p++) {		if (0x1A == *p)			break;	}	if (0x1a != *p || memcmp(p+1, "STMP", 4) != 0) {		/* firmware bad */		printf("%s: Bad firmware/n", device_xname(sc->sc_dev));		goto giveup3;	}	p += 5;	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;	req.bRequest = 2 /* XXX magic */;	USETW(req.wValue, 0);	USETW(req.wIndex, 0);	USETW(req.wLength, 0);	rc = usbd_do_request(sc->sc_udev, &req, 0);	if (rc) {		printf("%s: Cannot switch to f/w d/l mode, error %d/n",			device_xname(sc->sc_dev), rc);		goto giveup3;	}	delay(100000);	rc = usbd_open_pipe(sc->sc_iface, sc->sc_wr_addr, 0, &fwpipe);	if (rc) {		printf("%s: Cannot open pipe, rc=%d/n",		    device_xname(sc->sc_dev), rc);		goto giveup3;	}	fwxfer = usbd_alloc_xfer(sc->sc_udev);	if (fwxfer == NULL) {		printf("%s: Cannot alloc xfer/n", device_xname(sc->sc_dev));		goto giveup4;	}	usbbuf = usbd_alloc_buffer(fwxfer, 1024);	if (usbbuf == NULL) {		printf("%s: Cannot alloc usb buf/n", device_xname(sc->sc_dev));		goto giveup5;	}	n = (buffer + fwsize - p);	while (n > 0) {		if (n > 1023)			n = 1023;		memcpy(usbbuf, p, n);		rc = usbd_bulk_transfer(fwxfer, fwpipe,		    USBD_SYNCHRONOUS|USBD_FORCE_SHORT_XFER,		    5000, usbbuf, &n, "uirda-fw-wr");		printf("%s: write: rc=%d, %d left/n",		    device_xname(sc->sc_dev), rc, n);		if (rc) {			printf("%s: write: rc=%d, %d bytes written/n",			    device_xname(sc->sc_dev), rc, n);			goto giveup4;		}		printf("%s: written %d/n", device_xname(sc->sc_dev), n);		p += n; 		n = (buffer + fwsize - p);	}	delay(100000);	/* TODO: more code here */	rc = 0;	usbd_free_buffer(fwxfer);	giveup5: usbd_free_xfer(fwxfer);		giveup4: usbd_close_pipe(fwpipe);	giveup3: firmware_free(buffer, fwsize);	giveup2: firmware_close(fh);	return rc;		}

/* * Stop */static voidlgue_stop(struct lgue_softc *sc){	struct ifnet *ifp;	usbd_status err;	struct lgue_queue_entry *entry;	if (sc->lgue_dying)		return;	sc->lgue_dying = 1;	ifp = &sc->lgue_arpcom.ac_if;	/* Stop transfers */	if (sc->lgue_ep[LGUE_ENDPT_TX] != NULL) {		err = usbd_abort_pipe(sc->lgue_ep[LGUE_ENDPT_TX]);		if (err) {			if_printf(ifp, "abort tx pipe failed:%s/n",			    usbd_errstr(err));		}		err = usbd_close_pipe(sc->lgue_ep[LGUE_ENDPT_TX]);		if (err) {			if_printf(ifp, "close tx pipe failed:%s/n",			    usbd_errstr(err));		}	}	if (sc->lgue_ep[LGUE_ENDPT_RX] != NULL) {		err = usbd_abort_pipe(sc->lgue_ep[LGUE_ENDPT_RX]);		if (err) {			if_printf(ifp, "abort rx pipe failed:%s/n",			    usbd_errstr(err));		}		err = usbd_close_pipe(sc->lgue_ep[LGUE_ENDPT_RX]);		if (err) {			if_printf(ifp, "close rx pipe failed:%s/n",			    usbd_errstr(err));		}	}	if (sc->lgue_ep[LGUE_ENDPT_INTR] != NULL) {		err = usbd_abort_pipe(sc->lgue_ep[LGUE_ENDPT_INTR]);		if (err) {			if_printf(ifp, "abort intr pipe failed:%s/n",			    usbd_errstr(err));		}		err = usbd_close_pipe(sc->lgue_ep[LGUE_ENDPT_INTR]);		if (err) {			if_printf(ifp, "close intr pipe failed:%s/n",			    usbd_errstr(err));		}	}	/* Free tx buffers */	if (sc->lgue_tx_buf != NULL) {		kfree(sc->lgue_tx_buf, M_USBDEV);		sc->lgue_tx_buf = NULL;	}	if (sc->lgue_tx_xfer != NULL) {		usbd_free_xfer(sc->lgue_tx_xfer);		sc->lgue_tx_xfer = NULL;	}	/* Free rx buffers */	if (sc->lgue_rx_buf != NULL) {		kfree(sc->lgue_rx_buf, M_USBDEV);		sc->lgue_rx_buf = NULL;	}	if (sc->lgue_rx_xfer != NULL) {		usbd_free_xfer(sc->lgue_rx_xfer);		sc->lgue_rx_xfer = NULL;	}	/* Free intr buffer */	if (sc->lgue_intr_buf != NULL) {		kfree(sc->lgue_intr_buf, M_USBDEV);		sc->lgue_intr_buf = NULL;	}	if (sc->lgue_intr_xfer != NULL) {		usbd_free_xfer(sc->lgue_intr_xfer);		sc->lgue_intr_xfer = NULL;	}	/* Clear internal queue */	while (!STAILQ_EMPTY(&sc->lgue_tx_queue)) {		entry = STAILQ_FIRST(&sc->lgue_tx_queue);		STAILQ_REMOVE_HEAD(&sc->lgue_tx_queue, entry_next);		m_freem(entry->entry_mbuf);		kfree(entry, M_USBDEV);	}	ifp->if_flags &= ~IFF_RUNNING;	ifq_clr_oactive(&ifp->if_snd);}