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

/* * Process context for USB function tasks. */voidusbf_task_thread(void *arg){	struct usbf_softc *sc = arg;	struct usbf_task *task;	int s;	DPRINTF(0,("usbf_task_thread: start (pid %d)/n", curproc->p_pid));	s = splusb();	while (!sc->sc_dying) {		task = TAILQ_FIRST(&sc->sc_tskq);		if (task == NULL) {			tsleep(&sc->sc_tskq, PWAIT, "usbtsk", 0);			task = TAILQ_FIRST(&sc->sc_tskq);		}		DPRINTF(1,("usbf_task_thread: woke up task=%p/n", task));		if (task != NULL) {			TAILQ_REMOVE(&sc->sc_tskq, task, next);			task->onqueue = 0;			splx(s);			task->fun(task->arg);			s = splusb();			DPRINTF(1,("usbf_task_thread: done task=%p/n", task));		}	}	splx(s);	DPRINTF(0,("usbf_task_thread: exit/n"));	kthread_exit(0);}

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

intuirda_poll(void *h, int events, struct lwp *l){	struct uirda_softc *sc = h;	int revents = 0;	int s;	DPRINTFN(1,("%s: sc=%p/n", __func__, sc));	s = splusb();	if (events & (POLLOUT | POLLWRNORM))		revents |= events & (POLLOUT | POLLWRNORM);	if (events & (POLLIN | POLLRDNORM)) {		if (sc->sc_rd_count != 0) {			DPRINTFN(2,("%s: have data/n", __func__));			revents |= events & (POLLIN | POLLRDNORM);		} else {			DPRINTFN(2,("%s: recording select/n", __func__));			selrecord(l, &sc->sc_rd_sel);		}	}	splx(s);	return (revents);}

static intauvitek_start_transfer(void *opaque){	struct auvitek_softc *sc = opaque;	int error, s;	uint16_t vpos = 0, hpos = 0;	uint16_t hres = 720 * 2;	uint16_t vres = 484 / 2;	auvitek_write_1(sc, AU0828_REG_SENSORVBI_CTL, 0x00);	/* program video position and size */	auvitek_write_1(sc, AU0828_REG_HPOS_LO, hpos & 0xff);	auvitek_write_1(sc, AU0828_REG_HPOS_HI, hpos >> 8);	auvitek_write_1(sc, AU0828_REG_VPOS_LO, vpos & 0xff);	auvitek_write_1(sc, AU0828_REG_VPOS_HI, vpos >> 8);	auvitek_write_1(sc, AU0828_REG_HRES_LO, hres & 0xff);	auvitek_write_1(sc, AU0828_REG_HRES_HI, hres >> 8);	auvitek_write_1(sc, AU0828_REG_VRES_LO, vres & 0xff);	auvitek_write_1(sc, AU0828_REG_VRES_HI, vres >> 8);	auvitek_write_1(sc, AU0828_REG_SENSOR_CTL, 0xb3);	auvitek_write_1(sc, AU0828_REG_AUDIOCTL, 0x01);	s = splusb();	error = auvitek_start_xfer(sc);	splx(s);	if (error)		auvitek_stop_transfer(sc);	return error;}

voidohci_voyager_attach_deferred(struct device *self){	struct ohci_voyager_softc *sc = (struct ohci_voyager_softc *)self;	usbd_status r;	int s;	s = splusb();	sc->sc.sc_bus.dying = 0;		r = ohci_init(&sc->sc);	if (r != USBD_NORMAL_COMPLETION) {		printf("%s: init failed, error=%d/n",		    sc->sc.sc_bus.bdev.dv_xname, r);		bus_space_unmap(sc->sc.iot, sc->sc.ioh, sc->sc.sc_size);		splx(s);		return;	}	splx(s);	/* Attach usb device. */	config_found(self, &sc->sc.sc_bus, usbctlprint);}

static intudsir_kqfilter(void *h, struct knote *kn){	struct udsir_softc *sc = h;	struct klist *klist;	int s;	switch (kn->kn_filter) {	case EVFILT_READ:		klist = &sc->sc_rd_sel.sel_klist;		kn->kn_fop = &udsirread_filtops;		break;	case EVFILT_WRITE:		klist = &sc->sc_wr_sel.sel_klist;		kn->kn_fop = &udsirwrite_filtops;		break;	default:		return (EINVAL);	}	kn->kn_hook = sc;	s = splusb();	SLIST_INSERT_HEAD(klist, kn, kn_selnext);	splx(s);	return (0);}

intulpt_detach(struct device *self, int flags){	struct ulpt_softc *sc = (struct ulpt_softc *)self;	int s;	int maj, mn;	DPRINTF(("ulpt_detach: sc=%p/n", sc));	if (sc->sc_out_pipe != NULL)		usbd_abort_pipe(sc->sc_out_pipe);	if (sc->sc_in_pipe != NULL)		usbd_abort_pipe(sc->sc_in_pipe);	s = splusb();	if (--sc->sc_refcnt >= 0) {		/* There is noone to wake, aborting the pipe is enough */		/* Wait for processes to go away. */		usb_detach_wait(&sc->sc_dev);	}	splx(s);	/* locate the major number */	for (maj = 0; maj < nchrdev; maj++)		if (cdevsw[maj].d_open == ulptopen)			break;	/* Nuke the vnodes for any open instances (calls close). */	mn = self->dv_unit;	vdevgone(maj, mn, mn, VCHR);	vdevgone(maj, mn | ULPT_NOPRIME , mn | ULPT_NOPRIME, VCHR);	return (0);}

intuirda_read(void *h, struct uio *uio, int flag){	struct uirda_softc *sc = h;	usbd_status err;	int s;	int error;	u_int n;	DPRINTFN(1,("%s: sc=%p/n", __func__, sc));	if (sc->sc_dying)		return (EIO);#ifdef DIAGNOSTIC	if (sc->sc_rd_buf == NULL)		return (EINVAL);#endif	sc->sc_refcnt++;	do {		s = splusb();		while (sc->sc_rd_count == 0) {			DPRINTFN(5,("uirda_read: calling tsleep()/n"));			error = tsleep(&sc->sc_rd_count, PZERO | PCATCH,				       "uirdrd", 0);			if (sc->sc_dying)				error = EIO;			if (error) {				splx(s);				DPRINTF(("uirda_read: tsleep() = %d/n", error));				goto ret;			}		}		splx(s);		mutex_enter(&sc->sc_rd_buf_lk);		n = sc->sc_rd_count - sc->sc_hdszi;		DPRINTFN(1,("%s: sc=%p n=%u, hdr=0x%02x/n", __func__,			    sc, n, sc->sc_rd_buf[0]));		if (n > uio->uio_resid)			error = EINVAL;		else			error = uiomove(sc->sc_rd_buf + sc->sc_hdszi, n, uio);		sc->sc_rd_count = 0;		mutex_exit(&sc->sc_rd_buf_lk);		err = uirda_start_read(sc);		/* XXX check err */	} while (n == 0);	DPRINTFN(1,("uirda_read: return %d/n", error)); ret:	if (--sc->sc_refcnt < 0)		usb_detach_wakeup(USBDEV(sc->sc_dev));	return (error);}

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

intugl_detach(struct device *self, int flags){	struct ugl_softc	*sc = (struct ugl_softc *)self;	struct ifnet		*ifp = GET_IFP(sc);	int			s;	DPRINTFN(2,("%s: %s: enter/n", sc->sc_dev.dv_xname, __func__));	s = splusb();	if (ifp->if_flags & IFF_RUNNING)		ugl_stop(sc);	if (ifp->if_softc != NULL)		if_detach(ifp);#ifdef DIAGNOSTIC	if (sc->sc_ep[UGL_ENDPT_TX] != NULL ||	    sc->sc_ep[UGL_ENDPT_RX] != NULL ||	    sc->sc_ep[UGL_ENDPT_INTR] != NULL)		printf("%s: detach has active endpoints/n",		       sc->sc_dev.dv_xname);#endif	splx(s);	return (0);}

usbd_statususbd_intr_transfer(usbd_xfer_handle xfer, usbd_pipe_handle pipe,    u_int16_t flags, u_int32_t timeout, void *buf, u_int32_t *size, char *lbl){	usbd_status err;	int s, error;	usbd_setup_xfer(xfer, pipe, 0, buf, *size, flags, timeout,	    usbd_intr_transfer_cb);	DPRINTFN(1, ("usbd_intr_transfer: start transfer %d bytes/n", *size));	s = splusb();		/* don't want callback until tsleep() */	err = usbd_transfer(xfer);	if (err != USBD_IN_PROGRESS) {		splx(s);		return (err);	}	error = tsleep(xfer, PZERO | PCATCH, lbl, 0);	splx(s);	if (error) {		DPRINTF(("usbd_intr_transfer: tsleep=%d/n", error));		usbd_abort_pipe(pipe);		return (USBD_INTERRUPTED);	}	usbd_get_xfer_status(xfer, NULL, NULL, size, &err);	DPRINTFN(1,("usbd_intr_transfer: transferred %d/n", *size));	if (err) {		DPRINTF(("usbd_intr_transfer: error=%d/n", err));		usbd_clear_endpoint_stall(pipe);	}	return (err);}

intuhidpoll(dev_t dev, int events, usb_proc_ptr p){	struct uhid_softc *sc;	int revents = 0;	int s;	USB_GET_SC(uhid, UHIDUNIT(dev), sc);	if (sc->sc_dying)		return (EIO);	s = splusb();	if (events & (POLLOUT | POLLWRNORM))		revents |= events & (POLLOUT | POLLWRNORM);	if (events & (POLLIN | POLLRDNORM)) {		if (sc->sc_q.c_cc > 0)			revents |= events & (POLLIN | POLLRDNORM);		else			selrecord(p, &sc->sc_rsel);	}	splx(s);	return (revents);}

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

voidfilt_ugenrdetach(struct knote *kn){	struct ugen_endpoint *sce = (void *)kn->kn_hook;	int s;	s = splusb();	SLIST_REMOVE(&sce->rsel.si_note, kn, knote, kn_selnext);	splx(s);}

/* disallow the access to the device */static intukbd_disable(keyboard_t *kbd){	int s;	s = splusb();	KBD_DEACTIVATE(kbd);	splx(s);	return 0;}

voidumass_io_put(void *cookie, void *io){	struct umass_scsi_softc *scbus = cookie;	int s;	s = splusb();	scbus->sc_open = 0;	splx(s);}

static voidfilt_udsirwdetach(struct knote *kn){	struct udsir_softc *sc = kn->kn_hook;	int s;	s = splusb();	SLIST_REMOVE(&sc->sc_wr_sel.sel_klist, kn, knote, kn_selnext);	splx(s);}

static intout_jack_output(struct umidi_jack *out_jack, u_char *src, int len, int cin){	struct umidi_endpoint *ep = out_jack->endpoint;	struct umidi_softc *sc = ep->sc;	unsigned char *packet;	int s;	int plen;	int poff;	if (sc->sc_dying)		return EIO;	if (!out_jack->opened)		return ENODEV; /* XXX as it was, is this the right errno? */#ifdef UMIDI_DEBUG	if ( umididebug >= 100 )		microtime(&umidi_tv);#endif	DPRINTFN(100, ("umidi out: %lu.%06lus ep=%p cn=%d len=%d cin=%#x/n",	    umidi_tv.tv_sec%100, umidi_tv.tv_usec,	    ep, out_jack->cable_number, len, cin));		s = splusb();	packet = *ep->next_slot++;	KASSERT(ep->buffer_size >=	    (ep->next_slot - ep->buffer) * sizeof *ep->buffer);	memset(packet, 0, UMIDI_PACKET_SIZE);	if (UMQ_ISTYPE(sc, UMQ_TYPE_MIDIMAN_GARBLE)) {		if (NULL != out_jack->midiman_ppkt) { /* fill out a prev pkt */			poff = 0x0f & (out_jack->midiman_ppkt[3]);			plen = 3 - poff;			if (plen > len)				plen = len;			memcpy(out_jack->midiman_ppkt+poff, src, plen);			src += plen;			len -= plen;			plen += poff;			out_jack->midiman_ppkt[3] =			    MIX_CN_CIN(out_jack->cable_number, plen);			DPR_PACKET(out+, sc, out_jack->midiman_ppkt);			if (3 == plen)				out_jack->midiman_ppkt = NULL; /* no more */		}		if (0 == len)			ep->next_slot--; /* won't be needed, nevermind */		else {			memcpy(packet, src, len);			packet[3] = MIX_CN_CIN(out_jack->cable_number, len);			DPR_PACKET(out, sc, packet);			if (len < 3)				out_jack->midiman_ppkt = packet;		}	} else { /* the nice simple USB class-compliant case */

/* detach */inturl_detach(device_t self, int flags){	struct url_softc *sc = device_private(self);	struct ifnet *ifp = GET_IFP(sc);	int s;	DPRINTF(("%s: %s: enter/n", device_xname(sc->sc_dev), __func__));	/* Detached before attached finished */	if (!sc->sc_attached)		return (0);	callout_stop(&sc->sc_stat_ch);	/* Remove any pending tasks */	usb_rem_task(sc->sc_udev, &sc->sc_tick_task);	usb_rem_task(sc->sc_udev, &sc->sc_stop_task);	s = splusb();	if (--sc->sc_refcnt >= 0) {		/* Wait for processes to go away */		usb_detach_waitold(sc->sc_dev);	}	if (ifp->if_flags & IFF_RUNNING)		url_stop(GET_IFP(sc), 1);	rnd_detach_source(&sc->rnd_source);	mii_detach(&sc->sc_mii, MII_PHY_ANY, MII_OFFSET_ANY);	ifmedia_delete_instance(&sc->sc_mii.mii_media, IFM_INST_ANY);	ether_ifdetach(ifp);	if_detach(ifp);#ifdef DIAGNOSTIC	if (sc->sc_pipe_tx != NULL)		aprint_debug_dev(self, "detach has active tx endpoint./n");	if (sc->sc_pipe_rx != NULL)		aprint_debug_dev(self, "detach has active rx endpoint./n");	if (sc->sc_pipe_intr != NULL)		aprint_debug_dev(self, "detach has active intr endpoint./n");#endif	sc->sc_attached = 0;	splx(s);	rw_destroy(&sc->sc_mii_rwlock);	usbd_add_drv_event(USB_EVENT_DRIVER_DETACH, sc->sc_udev,			   sc->sc_dev);	return (0);}

voidoctohci_attach(struct device *parent, struct device *self, void *aux){	struct octohci_softc *sc = (struct octohci_softc *)self;	struct octuctl_attach_args *aa = aux;	char *devname;	uint64_t port_ctl;	int rc;	int s;	sc->sc_ohci.iot = aa->aa_bust;	sc->sc_ohci.sc_bus.pipe_size = sizeof(struct usbd_pipe);	sc->sc_ohci.sc_bus.dmatag = aa->aa_dmat;	rc = bus_space_map(sc->sc_ohci.iot, UCTL_OHCI_BASE, UCTL_OHCI_SIZE,	    0, &sc->sc_ohci.ioh);	KASSERT(rc == 0);	port_ctl = bus_space_read_8(aa->aa_octuctl_bust, aa->aa_ioh,	    UCTL_OHCI_CTL);	port_ctl &= ~UCTL_OHCI_CTL_L2C_ADDR_MSB_MASK;	port_ctl |= (1 << UCTL_OHCI_CTL_L2C_DESC_EMOD_SHIFT);	port_ctl |= (1 << UCTL_OHCI_CTL_L2C_BUFF_EMOD_SHIFT);	bus_space_write_8(aa->aa_octuctl_bust, aa->aa_ioh, UCTL_OHCI_CTL,	    port_ctl);	s = splusb();	sc->sc_ohci.sc_id_vendor = 0;	strlcpy(sc->sc_ohci.sc_vendor, "Octeon", sizeof(sc->sc_ohci.sc_vendor));	sc->sc_ih = octeon_intr_establish(CIU_INT_USB, IPL_USB, ohci_intr,	    (void *)&sc->sc_ohci, devname);	KASSERT(sc->sc_ih != NULL);	if ((ohci_checkrev(&sc->sc_ohci) != USBD_NORMAL_COMPLETION) ||	    (ohci_handover(&sc->sc_ohci) != USBD_NORMAL_COMPLETION))		goto failed;	/* ignore interrupts for now */	sc->sc_ohci.sc_bus.dying = 1;	config_defer(self, octohci_attach_deferred);	splx(s);	return;failed:	octeon_intr_disestablish(sc->sc_ih);	bus_space_unmap(sc->sc_ohci.iot, sc->sc_ohci.ioh, UCTL_OHCI_SIZE);	splx(s);	return;}

static voidfree_all_jacks(struct umidi_softc *sc){	int s, jacks = sc->sc_in_num_jacks + sc->sc_out_num_jacks;	s = splusb();	if (sc->sc_out_jacks) {		free(sc->sc_jacks, M_USBDEV, jacks * sizeof(*sc->sc_out_jacks));		sc->sc_jacks = sc->sc_in_jacks = sc->sc_out_jacks = NULL;		sc->sc_out_num_jacks = sc->sc_in_num_jacks = 0;	}	splx(s);}

voidukbd_cnpollc(void *v, int on){	struct ukbd_softc *sc = v;	DPRINTFN(2,("ukbd_cnpollc: sc=%p on=%d/n", v, on));	if (on)		sc->sc_spl = splusb();	else		splx(sc->sc_spl);	usbd_set_polling(sc->sc_hdev.sc_udev, on);}