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

intumct_open(void *addr, int portno){	struct umct_softc *sc = addr;	int err, lcr_data;	if (usbd_is_dying(sc->sc_udev))		return (EIO);	DPRINTF(("umct_open: sc=%p/n", sc));	/* initialize LCR */        lcr_data = LCR_DATA_BITS_8 | LCR_PARITY_NONE |	    LCR_STOP_BITS_1;        umct_set_lcr(sc, lcr_data);	if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {		sc->sc_status = 0; /* clear status bit */		sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);		err = usbd_open_pipe_intr(sc->sc_iface, sc->sc_intr_number,			USBD_SHORT_XFER_OK, &sc->sc_intr_pipe, sc,			sc->sc_intr_buf, sc->sc_isize,			umct_intr, USBD_DEFAULT_INTERVAL);		if (err) {			DPRINTF(("%s: cannot open interrupt pipe (addr %d)/n",				sc->sc_dev.dv_xname, sc->sc_intr_number));					return (EIO);		}	}	return (0);}

/* * midi_if stuffs */intumidi_open(void *addr,	   int flags,	   void (*iintr)(void *, int),	   void (*ointr)(void *),	   void *arg){	struct umidi_mididev *mididev = addr;	struct umidi_softc *sc = mididev->sc;	DPRINTF(("%s: sc=%p/n", __func__, sc));	if (!sc)		return ENXIO;	if (mididev->opened)		return EBUSY;	if (usbd_is_dying(sc->sc_udev))		return EIO;	mididev->opened = 1;	mididev->flags = flags;	if ((mididev->flags & FWRITE) && mididev->out_jack)		open_out_jack(mididev->out_jack, arg, ointr);	if ((mididev->flags & FREAD) && mididev->in_jack)		open_in_jack(mididev->in_jack, arg, iintr);	return 0;}

static voidout_intr(struct usbd_xfer *xfer, void *priv, usbd_status status){	struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;	struct umidi_softc *sc = ep->sc;	struct umidi_jack *j;	unsigned pending;		if (usbd_is_dying(sc->sc_udev))		return;	ep->used = 0;	ep->busy = 0;	for (pending = ep->pending; pending > 0; pending--) {		j = SIMPLEQ_FIRST(&ep->intrq);#ifdef DIAGNOSTIC		if (j == NULL) {			printf("umidi: missing intr entry/n");			break;		}#endif		SIMPLEQ_REMOVE_HEAD(&ep->intrq, intrq_entry);		ep->pending--;		j->intr = 0;		mtx_enter(&audio_lock);		if (j->opened && j->u.out.intr)			(*j->u.out.intr)(j->arg);		mtx_leave(&audio_lock);	}}

static voidin_intr(struct usbd_xfer *xfer, void *priv, usbd_status status){	int cn, evlen, remain, i;	unsigned char *buf;	struct umidi_endpoint *ep = (struct umidi_endpoint *)priv;	struct umidi_jack *jack;	if (usbd_is_dying(ep->sc->sc_udev))		return;	usbd_get_xfer_status(xfer, NULL, NULL, &remain, NULL);	if (status != USBD_NORMAL_COMPLETION) {		DPRINTF(("%s: abnormal status: %s/n", __func__, usbd_errstr(status)));		return;	}	buf = ep->buffer;	while (remain >= UMIDI_PACKET_SIZE) {		cn = GET_CN(buf[0]);		if (cn < ep->num_jacks && (jack = ep->jacks[cn]) &&		    jack->binded && jack->opened &&  jack->u.in.intr) {		    	evlen = packet_length[GET_CIN(buf[0])];			mtx_enter(&audio_lock);			for (i=0; i<evlen; i++)				(*jack->u.in.intr)(jack->arg, buf[i+1]);			mtx_leave(&audio_lock);		}		buf += UMIDI_PACKET_SIZE;		remain -= UMIDI_PACKET_SIZE;	}	(void)start_input_transfer(ep);}

voidumct_intr(struct usbd_xfer *xfer, void *priv, usbd_status status){	struct umct_softc *sc = priv;	u_char *buf = sc->sc_intr_buf;	u_char mstatus;	if (usbd_is_dying(sc->sc_udev))		return;	if (status != USBD_NORMAL_COMPLETION) {		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)			return;		DPRINTF(("%s: abnormal status: %s/n", sc->sc_dev.dv_xname,			usbd_errstr(status)));		usbd_clear_endpoint_stall_async(sc->sc_intr_pipe);		return;	}	DPRINTF(("%s: umct status = MSR:%02x, LSR:%02x/n",		 sc->sc_dev.dv_xname, buf[0],buf[1]));	sc->sc_lsr = sc->sc_msr = 0;	mstatus = buf[0];	if (ISSET(mstatus, MSR_DSR))		sc->sc_msr |= UMSR_DSR;	if (ISSET(mstatus, MSR_DCD))		sc->sc_msr |= UMSR_DCD;	ucom_status_change((struct ucom_softc *)sc->sc_subdev);}

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

voidkue_watchdog(struct ifnet *ifp){	struct kue_softc	*sc = ifp->if_softc;	struct kue_chain	*c;	usbd_status		stat;	int			s;	DPRINTFN(5,("%s: %s: enter/n", sc->kue_dev.dv_xname,__func__));	if (usbd_is_dying(sc->kue_udev))		return;	ifp->if_oerrors++;	printf("%s: watchdog timeout/n", sc->kue_dev.dv_xname);	s = splusb();	c = &sc->kue_cdata.kue_tx_chain[0];	usbd_get_xfer_status(c->kue_xfer, NULL, NULL, NULL, &stat);	kue_txeof(c->kue_xfer, c, stat);	if (IFQ_IS_EMPTY(&ifp->if_snd) == 0)		kue_start(ifp);	splx(s);}

intucomopen(dev_t dev, int flag, int mode, struct proc *p){	int unit = UCOMUNIT(dev);	struct ucom_softc *sc;	int error;	if (unit >= ucom_cd.cd_ndevs)		return (ENXIO);	sc = ucom_cd.cd_devs[unit];	if (sc == NULL)		return (ENXIO);	if (usbd_is_dying(sc->sc_uparent))		return (EIO);	if (ISSET(sc->sc_dev.dv_flags, DVF_ACTIVE) == 0)		return (ENXIO);	sc->sc_refcnt++;	error = ucom_do_open(dev, flag, mode, p);	if (--sc->sc_refcnt < 0)		usb_detach_wakeup(&sc->sc_dev);	return (error);}

intumsm_open(void *addr, int portno){	struct umsm_softc *sc = addr;	int err;	if (usbd_is_dying(sc->sc_udev))		return (ENXIO);	if (sc->sc_intr_number != -1 && sc->sc_intr_pipe == NULL) {		sc->sc_intr_buf = malloc(sc->sc_isize, M_USBDEV, M_WAITOK);		err = usbd_open_pipe_intr(sc->sc_iface,		    sc->sc_intr_number,		    USBD_SHORT_XFER_OK,		    &sc->sc_intr_pipe,		    sc,		    sc->sc_intr_buf,		    sc->sc_isize,		    umsm_intr,		    UMSM_INTR_INTERVAL);		if (err) {			printf("%s: cannot open interrupt pipe (addr %d)/n",			    sc->sc_dev.dv_xname,			    sc->sc_intr_number);			return (EIO);		}	}	return (0);}

voidubcmtp_disable(void *v){	struct ubcmtp_softc *sc = v;	if (usbd_is_dying(sc->sc_udev) || !(sc->sc_status & UBCMTP_ENABLED))		return;	sc->sc_status &= ~UBCMTP_ENABLED;	ubcmtp_raw_mode(sc, 0);	if (sc->sc_tp_pipe != NULL) {		usbd_abort_pipe(sc->sc_tp_pipe);		usbd_close_pipe(sc->sc_tp_pipe);		sc->sc_tp_pipe = NULL;	}	if (sc->sc_bt_pipe != NULL) {		usbd_abort_pipe(sc->sc_bt_pipe);		usbd_close_pipe(sc->sc_bt_pipe);		sc->sc_bt_pipe = NULL;	}	if (sc->tp_pkt != NULL) {		free(sc->tp_pkt, M_USBDEV, 0);		sc->tp_pkt = NULL;	}	if (sc->bt_pkt != NULL) {		free(sc->bt_pkt, M_USBDEV, 0);		sc->bt_pkt = NULL;	}}

intmoscom_open(void *vsc, int portno){	struct moscom_softc *sc = vsc;	usb_device_request_t req;	if (usbd_is_dying(sc->sc_udev))		return (EIO);	/* Purge FIFOs or odd things happen */	if (moscom_cmd(sc, MOSCOM_FIFO, 0x00) != 0)		return (EIO);		if (moscom_cmd(sc, MOSCOM_FIFO, MOSCOM_FIFO_EN |	    MOSCOM_FIFO_RXCLR | MOSCOM_FIFO_TXCLR |	    MOSCOM_FIFO_DMA_BLK | MOSCOM_FIFO_RXLVL_MASK) != 0) 		return (EIO);	/* Magic tell device we're ready for data command */	req.bmRequestType = UT_WRITE_VENDOR_DEVICE;	req.bRequest = MOSCOM_WRITE;	USETW(req.wValue, 0x08);	USETW(req.wIndex, MOSCOM_INT);	USETW(req.wLength, 0);	if (usbd_do_request(sc->sc_udev, &req, NULL) != 0)		return (EIO);	return (0);}

intugenpoll(dev_t dev, int events, struct proc *p){	struct ugen_softc *sc;	struct ugen_endpoint *sce;	int revents = 0;	int s;	sc = ugen_cd.cd_devs[UGENUNIT(dev)];	if (usbd_is_dying(sc->sc_udev))		return (POLLERR);	/* XXX always IN */	sce = &sc->sc_endpoints[UGENENDPOINT(dev)][IN];	if (sce == NULL)		return (POLLERR);#ifdef DIAGNOSTIC	if (!sce->edesc) {		printf("ugenpoll: no edesc/n");		return (POLLERR);	}	if (!sce->pipeh) {		printf("ugenpoll: no pipe/n");		return (POLLERR);	}#endif	s = splusb();	switch (sce->edesc->bmAttributes & UE_XFERTYPE) {	case UE_INTERRUPT:		if (events & (POLLIN | POLLRDNORM)) {			if (sce->q.c_cc > 0)				revents |= events & (POLLIN | POLLRDNORM);			else				selrecord(p, &sce->rsel);		}		break;	case UE_ISOCHRONOUS:		if (events & (POLLIN | POLLRDNORM)) {			if (sce->cur != sce->fill)				revents |= events & (POLLIN | POLLRDNORM);			else				selrecord(p, &sce->rsel);		}		break;	case UE_BULK:		/*		 * We have no easy way of determining if a read will		 * yield any data or a write will happen.		 * Pretend they will.		 */		revents |= events &			   (POLLIN | POLLRDNORM | POLLOUT | POLLWRNORM);		break;	default:		break;	}	splx(s);	return (revents);}

static intout_jack_output(struct umidi_jack *j, int d){	struct umidi_endpoint *ep = j->endpoint;	struct umidi_softc *sc = ep->sc;	int s;	if (usbd_is_dying(sc->sc_udev))		return 1;	if (!j->opened)		return 1;	s = splusb();	if (ep->busy) {		if (!j->intr) {			SIMPLEQ_INSERT_TAIL(&ep->intrq, j, intrq_entry);			ep->pending++;			j->intr = 1;		}				splx(s);		return 0;	}	if (!out_build_packet(j->cable_number, &j->packet, d,		ep->buffer + ep->used)) {		splx(s);		return 1;	}	ep->used += UMIDI_PACKET_SIZE;	if (ep->used == ep->packetsize) {		ep->busy = 1;		start_output_transfer(ep);	}	splx(s);	return 1;}

voidwi_usb_intr(struct usbd_xfer *xfer, void *priv, usbd_status status){	struct wi_usb_softc	*sc = priv;	DPRINTFN(2,("%s: %s: enter/n", sc->wi_usb_dev.dv_xname, __func__));	if (usbd_is_dying(sc->wi_usb_udev))		return;	if (status != USBD_NORMAL_COMPLETION) {		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED)			return;		if (status == USBD_STALLED) {			sc->wi_usb_refcnt++;			usbd_clear_endpoint_stall_async(			    sc->wi_usb_ep[WI_USB_ENDPT_RX]);			if (--sc->wi_usb_refcnt < 0)				usb_detach_wakeup(&sc->wi_usb_dev);		}		return;	}	/* XXX oerrors or collisions? */}

intuhid_do_read(struct uhid_softc *sc, struct uio *uio, int flag){	int s;	int error = 0;	int extra;	size_t length;	u_char buffer[UHID_CHUNK];	usbd_status err;	DPRINTFN(1, ("uhidread/n"));	if (sc->sc_state & UHID_IMMED) {		DPRINTFN(1, ("uhidread immed/n"));		extra = sc->sc_hdev.sc_report_id != 0;		err = uhidev_get_report(&sc->sc_hdev, UHID_INPUT_REPORT,		    sc->sc_hdev.sc_report_id, buffer,		    sc->sc_hdev.sc_isize + extra);		if (err)			return (EIO);		return (uiomove(buffer+extra, sc->sc_hdev.sc_isize, uio));	}	s = splusb();	while (sc->sc_q.c_cc == 0) {		if (flag & IO_NDELAY) {			splx(s);			return (EWOULDBLOCK);		}		sc->sc_state |= UHID_ASLP;		DPRINTFN(5, ("uhidread: sleep on %p/n", &sc->sc_q));		error = tsleep(&sc->sc_q, PZERO | PCATCH, "uhidrea", 0);		DPRINTFN(5, ("uhidread: woke, error=%d/n", error));		if (usbd_is_dying(sc->sc_hdev.sc_udev))			error = EIO;		if (error) {			sc->sc_state &= ~UHID_ASLP;			break;		}	}	splx(s);	/* Transfer as many chunks as possible. */	while (sc->sc_q.c_cc > 0 && uio->uio_resid > 0 && !error) {		length = min(sc->sc_q.c_cc, uio->uio_resid);		if (length > sizeof(buffer))			length = sizeof(buffer);		/* Remove a small chunk from the input queue. */		(void) q_to_b(&sc->sc_q, buffer, length);		DPRINTFN(5, ("uhidread: got %lu chars/n", (u_long)length));		/* Copy the data to the user process. */		if ((error = uiomove(buffer, length, uio)) != 0)			break;	}	return (error);}

voiducomreadcb(struct usbd_xfer *xfer, void *p, usbd_status status){	struct ucom_softc *sc = (struct ucom_softc *)p;	struct tty *tp = sc->sc_tty;	int (*rint)(int c, struct tty *tp) = LINESW(tp, l_rint);	usbd_status err;	u_int32_t cc;	u_char *cp;	int s;	DPRINTFN(5,("ucomreadcb: status=%d/n", status));	if (status == USBD_CANCELLED || status == USBD_IOERROR ||	    usbd_is_dying(sc->sc_uparent)) {		DPRINTF(("ucomreadcb: dying/n"));		/* Send something to wake upper layer */		s = spltty();		(*rint)('/n', tp);		ttwakeup(tp);		splx(s);		return;	}	if (status) {		if (sc->sc_bulkin_pipe != NULL) {			usbd_clear_endpoint_stall_async(sc->sc_bulkin_pipe);			/* XXX we should restart after some delay. */			return;		}	}	usbd_get_xfer_status(xfer, NULL, (void *)&cp, &cc, NULL);	DPRINTFN(5,("ucomreadcb: got %d chars, tp=%p/n", cc, tp));	if (sc->sc_methods->ucom_read != NULL)		sc->sc_methods->ucom_read(sc->sc_parent, sc->sc_portno,					  &cp, &cc);	s = spltty();	/* Give characters to tty layer. */	while (cc-- > 0) {		DPRINTFN(7,("ucomreadcb: char=0x%02x/n", *cp));		if ((*rint)(*cp++, tp) == -1) {			/* XXX what should we do? */			printf("%s: lost %d chars/n", sc->sc_dev.dv_xname,			       cc);			break;		}	}	splx(s);	err = ucomstartread(sc);	if (err) {		printf("%s: read start failed/n", sc->sc_dev.dv_xname);		/* XXX what should we dow now? */	}}

voidugl_watchdog(struct ifnet *ifp){	struct ugl_softc	*sc = ifp->if_softc;	if (usbd_is_dying(sc->sc_udev))		return;	ifp->if_oerrors++;	printf("%s: watchdog timeout/n", sc->sc_dev.dv_xname);}

voiduhidev_intr(struct usbd_xfer *xfer, void *addr, usbd_status status){	struct uhidev_softc *sc = addr;	struct uhidev *scd;	u_char *p;	u_int rep;	u_int32_t cc;	if (usbd_is_dying(sc->sc_udev))		return;	usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);#ifdef UHIDEV_DEBUG	if (uhidevdebug > 5) {		u_int32_t i;		DPRINTF(("uhidev_intr: status=%d cc=%d/n", status, cc));		DPRINTF(("uhidev_intr: data ="));		for (i = 0; i < cc; i++)			DPRINTF((" %02x", sc->sc_ibuf[i]));		DPRINTF(("/n"));	}#endif	if (status == USBD_CANCELLED || status == USBD_IOERROR)		return;	if (status != USBD_NORMAL_COMPLETION) {		DPRINTF(("%s: interrupt status=%d/n", DEVNAME(sc), status));		usbd_clear_endpoint_stall_async(sc->sc_ipipe);		return;	}	p = sc->sc_ibuf;	if (sc->sc_nrepid != 1)		rep = *p++, cc--;	else		rep = 0;	if (rep >= sc->sc_nrepid) {		printf("uhidev_intr: bad repid %d/n", rep);		return;	}	scd = sc->sc_subdevs[rep];	DPRINTFN(5,("uhidev_intr: rep=%d, scd=%p state=0x%x/n",		    rep, scd, scd ? scd->sc_state : 0));	if (scd == NULL || !(scd->sc_state & UHIDEV_OPEN))		return;	scd->sc_intr(scd, p, cc);}

voidwi_usb_txeof_frm(struct usbd_xfer *xfer, void *priv,    usbd_status status){	struct wi_usb_chain	*c = priv;	struct wi_usb_softc	*sc = c->wi_usb_sc;	struct wi_softc		*wsc = &sc->sc_wi;	struct ifnet		*ifp = &wsc->sc_ic.ic_if;	int			s;	int			err = 0;	if (usbd_is_dying(sc->wi_usb_udev))		return;	s = splnet();	DPRINTFN(10,("%s: %s: enter status=%d/n", sc->wi_usb_dev.dv_xname,		    __func__, status));	if (status != USBD_NORMAL_COMPLETION) {		if (status == USBD_NOT_STARTED || status == USBD_CANCELLED) {			splx(s);			return;		}		printf("%s: usb error on tx: %s/n", sc->wi_usb_dev.dv_xname,		    usbd_errstr(status));		if (status == USBD_STALLED) {			sc->wi_usb_refcnt++;			usbd_clear_endpoint_stall_async(			    sc->wi_usb_ep[WI_USB_ENDPT_TX]);			if (--sc->wi_usb_refcnt < 0)				usb_detach_wakeup(&sc->wi_usb_dev);		}		splx(s);		return;	}	if (status)		err = WI_EV_TX_EXC;	wi_txeof(wsc, err);	wi_usb_tx_unlock(sc);	if (!IFQ_IS_EMPTY(&ifp->if_snd))		wi_start_usb(ifp);	splx(s);}