void
ptcwakeup(struct tty *tp, int flag)
{
struct pt_softc *pti = pt_softc[minor(tp->t_dev)];
if (flag & FREAD) {
selwakeup(&pti->pt_selr);
wakeup(&tp->t_outq.c_cf);
}
if (flag & FWRITE) {
selwakeup(&pti->pt_selw);
wakeup(&tp->t_rawq.c_cf);
}
}
void
drm_handle_vblank_events(struct drm_device *dev, int crtc)
{
struct drmevlist *list;
struct drm_pending_event *ev, *tmp;
struct drm_pending_vblank_event *vev;
struct timeval now;
u_int seq;
list = &dev->vblank->vb_crtcs[crtc].vbl_events;
microtime(&now);
seq = drm_vblank_count(dev, crtc);
mtx_enter(&dev->event_lock);
for (ev = TAILQ_FIRST(list); ev != TAILQ_END(list); ev = tmp) {
tmp = TAILQ_NEXT(ev, link);
vev = (struct drm_pending_vblank_event *)ev;
if ((seq - vev->event.sequence) > (1 << 23))
continue;
DPRINTF("%s: got vblank event on crtc %d, value %d\n",
__func__, crtc, seq);
vev->event.sequence = seq;
vev->event.tv_sec = now.tv_sec;
vev->event.tv_usec = now.tv_usec;
drm_vblank_put(dev, crtc);
TAILQ_REMOVE(list, ev, link);
TAILQ_INSERT_TAIL(&ev->file_priv->evlist, ev, link);
wakeup(&ev->file_priv->evlist);
selwakeup(&ev->file_priv->rsel);
}
mtx_leave(&dev->event_lock);
}
void
uhid_intr(struct uhidev *addr, void *data, u_int len)
{
struct uhid_softc *sc = (struct uhid_softc *)addr;
#ifdef UHID_DEBUG
if (uhiddebug > 5) {
u_int32_t i;
DPRINTF(("uhid_intr: data ="));
for (i = 0; i < len; i++)
DPRINTF((" %02x", ((u_char *)data)[i]));
DPRINTF(("\n"));
}
#endif
(void)b_to_q(data, len, &sc->sc_q);
if (sc->sc_state & UHID_ASLP) {
sc->sc_state &= ~UHID_ASLP;
DPRINTFN(5, ("uhid_intr: waking %p\n", &sc->sc_q));
wakeup(&sc->sc_q);
}
selwakeup(&sc->sc_rsel);
if (sc->sc_async != NULL) {
DPRINTFN(3, ("uhid_intr: sending SIGIO %p\n", sc->sc_async));
prsignal(sc->sc_async, SIGIO);
}
}
void
ugenintr(struct usbd_xfer *xfer, void *addr, usbd_status status)
{
struct ugen_endpoint *sce = addr;
/*struct ugen_softc *sc = sce->sc;*/
u_int32_t count;
u_char *ibuf;
if (status == USBD_CANCELLED)
return;
if (status != USBD_NORMAL_COMPLETION) {
DPRINTF(("ugenintr: status=%d\n", status));
if (status == USBD_STALLED)
usbd_clear_endpoint_stall_async(sce->pipeh);
return;
}
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
ibuf = sce->ibuf;
DPRINTFN(5, ("ugenintr: xfer=%p status=%d count=%d\n",
xfer, status, count));
DPRINTFN(5, (" data = %02x %02x %02x\n",
ibuf[0], ibuf[1], ibuf[2]));
(void)b_to_q(ibuf, count, &sce->q);
if (sce->state & UGEN_ASLP) {
sce->state &= ~UGEN_ASLP;
DPRINTFN(5, ("ugen_intr: waking %p\n", sce));
wakeup(sce);
}
selwakeup(&sce->rsel);
}
int
vldcp_tx_intr(void *arg)
{
struct vldcp_softc *sc = arg;
struct ldc_conn *lc = &sc->sc_lc;
uint64_t tx_head, tx_tail, tx_state;
int err;
err = hv_ldc_tx_get_state(lc->lc_id, &tx_head, &tx_tail, &tx_state);
if (err != H_EOK) {
printf("%s: hv_ldc_tx_get_state %d\n", __func__, err);
return (0);
}
if (tx_state != lc->lc_tx_state) {
switch (tx_state) {
case LDC_CHANNEL_DOWN:
DPRINTF(("Tx link down\n"));
break;
case LDC_CHANNEL_UP:
DPRINTF(("Tx link up\n"));
break;
case LDC_CHANNEL_RESET:
DPRINTF(("Tx link reset\n"));
break;
}
lc->lc_tx_state = tx_state;
}
cbus_intr_setenabled(sc->sc_tx_sysino, INTR_DISABLED);
selwakeup(&sc->sc_wsel);
wakeup(lc->lc_txq);
return (1);
}
int
drm_queue_vblank_event(struct drm_device *dev, int crtc,
union drm_wait_vblank *vblwait, struct drm_file *file_priv)
{
struct drm_pending_vblank_event *vev;
struct timeval now;
u_int seq;
vev = drm_calloc(1, sizeof(*vev));
if (vev == NULL)
return (ENOMEM);
vev->event.base.type = DRM_EVENT_VBLANK;
vev->event.base.length = sizeof(vev->event);
vev->event.user_data = vblwait->request.signal;
vev->base.event = &vev->event.base;
vev->base.file_priv = file_priv;
vev->base.destroy = (void (*) (struct drm_pending_event *))drm_free;
microtime(&now);
mtx_enter(&dev->event_lock);
if (file_priv->event_space < sizeof(vev->event)) {
mtx_leave(&dev->event_lock);
drm_free(vev);
return (ENOMEM);
}
seq = drm_vblank_count(dev, crtc);
file_priv->event_space -= sizeof(vev->event);
DPRINTF("%s: queueing event %d on crtc %d\n", __func__, seq, crtc);
if ((vblwait->request.type & _DRM_VBLANK_NEXTONMISS) &&
(seq - vblwait->request.sequence) <= (1 << 23)) {
vblwait->request.sequence = seq + 1;
vblwait->reply.sequence = vblwait->request.sequence;
}
vev->event.sequence = vblwait->request.sequence;
if ((seq - vblwait->request.sequence) <= (1 << 23)) {
vev->event.tv_sec = now.tv_sec;
vev->event.tv_usec = now.tv_usec;
DPRINTF("%s: already passed, dequeuing: crtc %d, value %d\n",
__func__, crtc, seq);
drm_vblank_put(dev, crtc);
TAILQ_INSERT_TAIL(&file_priv->evlist, &vev->base, link);
wakeup(&file_priv->evlist);
selwakeup(&file_priv->rsel);
} else {
TAILQ_INSERT_TAIL(&dev->vblank->vb_crtcs[crtc].vbl_events,
&vev->base, link);
}
mtx_leave(&dev->event_lock);
return (0);
}
void VbgdNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
{
LogFlow((DEVICE_NAME "::NativeISRMousePollEvent:\n"));
/*
* Wake up poll waiters.
*/
selwakeup(&g_SelInfo);
}
void VGDrvNativeISRMousePollEvent(PVBOXGUESTDEVEXT pDevExt)
{
LogFlow(("VGDrvNativeISRMousePollEvent:\n"));
/*
* Wake up poll waiters.
*/
selwakeup(&g_SelInfo);
}
static void
zsttystart(struct tty *tp)
{
struct zstty_softc *sc;
uint8_t c;
sc = tp->t_dev->si_drv1;
if ((tp->t_state & TS_TBLOCK) != 0)
/* XXX clear RTS */;
else
/* XXX set RTS */;
if ((tp->t_state & (TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) != 0) {
ttwwakeup(tp);
return;
}
if (tp->t_outq.c_cc <= tp->t_olowat) {
if ((tp->t_state & TS_SO_OLOWAT) != 0) {
tp->t_state &= ~TS_SO_OLOWAT;
wakeup(TSA_OLOWAT(tp));
}
selwakeup(&tp->t_wsel);
if (tp->t_outq.c_cc == 0) {
if ((tp->t_state & (TS_BUSY | TS_SO_OCOMPLETE)) ==
TS_SO_OCOMPLETE && tp->t_outq.c_cc == 0) {
tp->t_state &= ~TS_SO_OCOMPLETE;
wakeup(TSA_OCOMPLETE(tp));
}
return;
}
}
sc->sc_ocnt = q_to_b(&tp->t_outq, sc->sc_obuf, sizeof(sc->sc_obuf));
if (sc->sc_ocnt == 0)
return;
c = sc->sc_obuf[0];
sc->sc_oget = sc->sc_obuf + 1;
sc->sc_ocnt--;
tp->t_state |= TS_BUSY;
sc->sc_tx_busy = 1;
/*
* Enable transmit interrupts if necessary and send the first
* character to start up the transmitter.
*/
if ((sc->sc_preg[1] & ZSWR1_TIE) == 0) {
sc->sc_preg[1] |= ZSWR1_TIE;
sc->sc_creg[1] = sc->sc_preg[1];
ZS_WRITE_REG(sc, 1, sc->sc_creg[1]);
}
ZS_WRITE(sc, sc->sc_data, c);
ttwwakeup(tp);
}
static void
ptsdrv_inwakeup(struct tty *tp)
{
struct pts_softc *psc = tty_softc(tp);
cv_broadcast(&psc->pts_inwait);
selwakeup(&psc->pts_inpoll);
KNOTE_LOCKED(&psc->pts_inpoll.si_note, 0);
}
void
ugen_isoc_rintr(struct usbd_xfer *xfer, void *addr, usbd_status status)
{
struct isoreq *req = addr;
struct ugen_endpoint *sce = req->sce;
u_int32_t count, n;
int i, isize;
/* Return if we are aborting. */
if (status == USBD_CANCELLED)
return;
usbd_get_xfer_status(xfer, NULL, NULL, &count, NULL);
DPRINTFN(5,("%s: xfer %ld, count=%d\n", __func__, req - sce->isoreqs,
count));
/* throw away oldest input if the buffer is full */
if(sce->fill < sce->cur && sce->cur <= sce->fill + count) {
sce->cur += count;
if(sce->cur >= sce->limit)
sce->cur = sce->ibuf + (sce->limit - sce->cur);
DPRINTFN(5, ("%s: throwing away %d bytes\n", __func__, count));
}
isize = UGETW(sce->edesc->wMaxPacketSize);
for (i = 0; i < UGEN_NISORFRMS; i++) {
u_int32_t actlen = req->sizes[i];
char const *buf = (char const *)req->dmabuf + isize * i;
/* copy data to buffer */
while (actlen > 0) {
n = min(actlen, sce->limit - sce->fill);
memcpy(sce->fill, buf, n);
buf += n;
actlen -= n;
sce->fill += n;
if(sce->fill == sce->limit)
sce->fill = sce->ibuf;
}
/* setup size for next transfer */
req->sizes[i] = isize;
}
usbd_setup_isoc_xfer(xfer, sce->pipeh, req, req->sizes, UGEN_NISORFRMS,
USBD_NO_COPY, ugen_isoc_rintr);
(void)usbd_transfer(xfer);
if (sce->state & UGEN_ASLP) {
sce->state &= ~UGEN_ASLP;
DPRINTFN(5, ("ugen_isoc_rintr: waking %p\n", sce));
wakeup(sce);
}
selwakeup(&sce->rsel);
}
static void
uvfs_dev_readwakeup (void *_st)
{
uvfs_softc *st = _st;
if (st->flags & UVFS_RSEL) {
st->flags &= ~UVFS_RSEL;
selwakeup(&st->sel);
}
wakeup(st);
}
/*
* If there are processes sleeping on this descriptor, wake them up.
*/
static __inline void
bpf_wakeup(struct bpf_d *d)
{
wakeup((caddr_t)d);
if (d->bd_async && d->bd_sig)
csignal(d->bd_pgid, d->bd_sig,
d->bd_siguid, d->bd_sigeuid);
selwakeup(&d->bd_sel);
KNOTE(&d->bd_sel.si_note, 0);
}
void
pipeselwakeup(struct pipe *cpipe)
{
if (cpipe->pipe_state & PIPE_SEL) {
cpipe->pipe_state &= ~PIPE_SEL;
selwakeup(&cpipe->pipe_sel);
} else
KNOTE(&cpipe->pipe_sel.si_note, 0);
if ((cpipe->pipe_state & PIPE_ASYNC) && cpipe->pipe_pgid != NO_PID)
gsignal(cpipe->pipe_pgid, SIGIO);
}
void
imxuart_start(struct tty *tp)
{
struct imxuart_softc *sc = imxuart_cd.cd_devs[DEVUNIT(tp->t_dev)];
bus_space_tag_t iot = sc->sc_iot;
bus_space_handle_t ioh = sc->sc_ioh;
int s;
s = spltty();
if (ISSET(tp->t_state, TS_BUSY)) {
splx(s);
return;
}
if (ISSET(tp->t_state, TS_TIMEOUT | TS_TTSTOP))
goto stopped;
#ifdef DAMNFUCKSHIT
/* clear to send (IE the RTS pin on this shit) is not directly \
* readable - skip check for now
*/
if (ISSET(tp->t_cflag, CRTSCTS) && !ISSET(sc->sc_msr, IMXUART_CTS))
goto stopped;
#endif
if (tp->t_outq.c_cc <= tp->t_lowat) {
if (ISSET(tp->t_state, TS_ASLEEP)) {
CLR(tp->t_state, TS_ASLEEP);
wakeup(&tp->t_outq);
}
if (tp->t_outq.c_cc == 0)
goto stopped;
selwakeup(&tp->t_wsel);
}
SET(tp->t_state, TS_BUSY);
if (!ISSET(sc->sc_ucr1, IMXUART_CR1_TXMPTYEN)) {
SET(sc->sc_ucr1, IMXUART_CR1_TXMPTYEN);
bus_space_write_2(iot, ioh, IMXUART_UCR1, sc->sc_ucr1);
}
{
u_char buf[32];
int n = q_to_b(&tp->t_outq, buf, 32/*XXX*/);
int i;
for (i = 0; i < n; i++)
bus_space_write_1(iot, ioh, IMXUART_UTXD, buf[i]);
}
splx(s);
return;
stopped:
if (ISSET(sc->sc_ucr1, IMXUART_CR1_TXMPTYEN)) {
CLR(sc->sc_ucr1, IMXUART_CR1_TXMPTYEN);
bus_space_write_2(iot, ioh, IMXUART_UCR1, sc->sc_ucr1);
}
splx(s);
}
/*
* If there are processes sleeping on this descriptor, wake them up.
*/
void
bpf_wakeup(struct bpf_d *d)
{
wakeup((caddr_t)d);
if (d->bd_async && d->bd_sig)
csignal(d->bd_pgid, d->bd_sig,
d->bd_siguid, d->bd_sigeuid);
selwakeup(&d->bd_sel);
/* XXX */
d->bd_sel.si_selpid = 0;
}
void
midi_out_stop(struct midi_softc *sc)
{
sc->isbusy = 0;
if (sc->wchan) {
sc->wchan = 0;
wakeup(&sc->wchan);
}
selwakeup(&sc->wsel);
if (sc->async)
psignal(sc->async, SIGIO);
}
void psmintr(int unit)
{
struct psm_softc *sc = &psm_softc[unit];
int ioport = psmaddr[unit];
sc->inq.queue[sc->inq.last++ % MSBSZ] = inb(ioport+PSM_DATA);
sc->inq.count++;
if (sc -> state & PSM_ASLP) {
sc->state &= ~PSM_ASLP;
wakeup((caddr_t)sc);
}
selwakeup(&sc->rsel);
}
/*
* If there are processes sleeping on this descriptor, wake them up.
*/
static void
bpf_wakeup(struct bpf_d *d)
{
wakeup((caddr_t)d);
if (d->bd_async && d->bd_sig && d->bd_sigio)
pgsigio(d->bd_sigio, d->bd_sig);
#if BSD >= 199103
selwakeup(&d->bd_sel);
KNOTE(&d->bd_sel.si_note, 1);
#ifndef __APPLE__
/* XXX */
d->bd_sel.si_pid = 0;
#endif
#else
if (d->bd_selproc) {
selwakeup(d->bd_selproc, (int)d->bd_selcoll);
d->bd_selcoll = 0;
d->bd_selproc = 0;
}
#endif
}
void
drm_event_wakeup(struct drm_pending_event *e)
{
struct drm_file *file_priv;
struct drm_device *dev;
file_priv = e->file_priv;
dev = file_priv->dev;
mtx_assert(&dev->event_lock, MA_OWNED);
wakeup(&file_priv->event_space);
selwakeup(&file_priv->event_poll);
}
void
video_intr(void *addr)
{
struct video_softc *sc = (struct video_softc *)addr;
DPRINTF(("video_intr sc=%p\n", sc));
if (sc->sc_vidmode != VIDMODE_NONE)
sc->sc_frames_ready++;
else
printf("%s: interrupt but no streams!\n", __func__);
if (sc->sc_vidmode == VIDMODE_READ)
wakeup(sc);
selwakeup(&sc->sc_rsel);
}
int
mididetach(struct device *self, int flags)
{
struct midi_softc *sc = (struct midi_softc *)self;
int maj, mn;
/* locate the major number */
for (maj = 0; maj < nchrdev; maj++) {
if (cdevsw[maj].d_open == midiopen) {
/* Nuke the vnodes for any open instances (calls close). */
mn = self->dv_unit;
vdevgone(maj, mn, mn, VCHR);
}
}
/*
* The close() method did nothing (device_lookup() returns
* NULL), so quickly halt transfers (normally parent is already
* gone, and code below is no-op), and wake-up user-land blocked
* in read/write/ioctl, which return EIO.
*/
if (sc->flags) {
if (sc->flags & FREAD) {
sc->rchan = 0;
wakeup(&sc->rchan);
selwakeup(&sc->rsel);
}
if (sc->flags & FWRITE) {
sc->wchan = 0;
wakeup(&sc->wchan);
selwakeup(&sc->wsel);
}
sc->hw_if->close(sc->hw_hdl);
sc->flags = 0;
}
return 0;
}
/*
* This is the main kvp kernel process that interacts with both user daemon
* and the host
*/
static void
hv_kvp_send_msg_to_daemon(hv_kvp_sc *sc)
{
struct hv_kvp_msg *hmsg = sc->host_kvp_msg;
struct hv_kvp_msg *umsg = &sc->daemon_kvp_msg;
/* Prepare kvp_msg to be sent to user */
hv_kvp_convert_hostmsg_to_usermsg(hmsg, umsg);
/* Send the msg to user via function deamon_read - setting sema */
sema_post(&sc->dev_sema);
/* We should wake up the daemon, in case it's doing poll() */
selwakeup(&sc->hv_kvp_selinfo);
}
/*
* Wakeup processes waiting on a socket buffer.
* Do asynchronous notification via SIGIO
* if the socket has the SS_ASYNC flag set.
*/
void
sowakeup(struct socket *so, struct sockbuf *sb)
{
int s = splsoftnet();
selwakeup(&sb->sb_sel);
sb->sb_flagsintr &= ~SB_SEL;
if (sb->sb_flagsintr & SB_WAIT) {
sb->sb_flagsintr &= ~SB_WAIT;
wakeup(&sb->sb_cc);
}
splx(s);
if (so->so_state & SS_ASYNC)
csignal(so->so_pgid, SIGIO, so->so_siguid, so->so_sigeuid);
}
static void send_vblank_event(struct drm_device *dev,
struct drm_pending_vblank_event *e,
unsigned long seq, struct timeval *now)
{
struct drm_file *file_priv = e->base.file_priv;
MUTEX_ASSERT_LOCKED(&dev->event_lock);
e->event.sequence = seq;
e->event.tv_sec = now->tv_sec;
e->event.tv_usec = now->tv_usec;
TAILQ_INSERT_TAIL(&file_priv->evlist, &e->base, link);
wakeup(&file_priv->evlist);
selwakeup(&file_priv->rsel);
#if 0
trace_drm_vblank_event_delivered(e->base.pid, e->pipe,
e->event.sequence);
#endif
}
void
uhid_intr(usbd_xfer_handle xfer, usbd_private_handle addr, usbd_status status)
{
struct uhid_softc *sc = addr;
#ifdef USB_DEBUG
if (uhiddebug > 5) {
u_int32_t cc, i;
usbd_get_xfer_status(xfer, NULL, NULL, &cc, NULL);
DPRINTF(("uhid_intr: status=%d cc=%d\n", status, cc));
DPRINTF(("uhid_intr: data ="));
for (i = 0; i < cc; i++)
DPRINTF((" %02x", sc->sc_ibuf[i]));
DPRINTF(("\n"));
}
#endif
if (status == USBD_CANCELLED)
return;
if (status != USBD_NORMAL_COMPLETION) {
DPRINTF(("uhid_intr: status=%d\n", status));
if (status == USBD_STALLED)
sc->sc_state |= UHID_NEEDCLEAR;
return;
}
(void) b_to_q(sc->sc_ibuf, sc->sc_isize, &sc->sc_q);
if (sc->sc_state & UHID_ASLP) {
sc->sc_state &= ~UHID_ASLP;
DPRINTFN(5, ("uhid_intr: waking %p\n", &sc->sc_q));
wakeup(&sc->sc_q);
}
selwakeup(&sc->sc_rsel);
if (sc->sc_async != NULL) {
DPRINTFN(3, ("uhid_intr: sending SIGIO %p\n", sc->sc_async));
PROC_LOCK(sc->sc_async);
psignal(sc->sc_async, SIGIO);
PROC_UNLOCK(sc->sc_async);
}
}
/*
* Notify if possible receive data ready. Must be called
* with sc->mutex held (cyapa_lock(sc)).
*/
static void
cyapa_notify(struct cyapa_softc *sc)
{
CYAPA_LOCK_ASSERT(sc);
if (sc->data_signal || !fifo_empty(sc, &sc->rfifo)) {
KNOTE_LOCKED(&sc->selinfo.si_note, 0);
if (sc->blocked || sc->isselect) {
if (sc->blocked) {
sc->blocked = 0;
wakeup(&sc->blocked);
}
if (sc->isselect) {
sc->isselect = 0;
selwakeup(&sc->selinfo);
}
}
}
}
static void
at91_pio_intr(void *xsc)
{
struct at91_pio_softc *sc = xsc;
uint32_t status;
int i;
/* Reading the status also clears the interrupt. */
status = RD4(sc, PIO_ISR) & RD4(sc, PIO_IMR);
if (status != 0) {
AT91_PIO_LOCK(sc);
for (i = 0; status != 0 && sc->buflen < MAX_CHANGE; ++i) {
if (status & 1)
sc->buf[sc->buflen++] = (uint8_t)i;
status >>= 1;
}
AT91_PIO_UNLOCK(sc);
wakeup(sc);
selwakeup(&sc->selp);
}
/*
* Wakeup processes waiting on a socket buffer.
* Do asynchronous notification via SIGIO
* if the socket has the SS_ASYNC flag set.
*/
void
sowakeup(struct socket *so, struct sockbuf *sb)
{
sb->sb_flags &= ~SB_SEL;
selwakeup(&sb->sb_sel);
if (sb->sb_flags & SB_WAIT) {
sb->sb_flags &= ~SB_WAIT;
wakeup((caddr_t)&sb->sb_cc);
}
#if 0 // Intentially commented
if (so->so_state & SS_ASYNC) {
if (so->so_pgid < 0)
gsignal(-so->so_pgid, SIGIO);
else if (so->so_pgid > 0)
proc_signal(so->so_pgid, SIGIO);
}
if (sb->sb_flags & SB_KNOTE) {
KNOTE(&sb->sb_sel.si_note, SO_FILT_HINT_LOCKED);
}
if (sb->sb_flags & SB_UPCALL) {
void (*so_upcall)(struct socket *, caddr_t, int);
caddr_t so_upcallarg;
so_upcall = so->so_upcall;
so_upcallarg = so->so_upcallarg;
/* Let close know that we're about to do an upcall */
so->so_flags |= SOF_UPCALLINUSE;
socket_unlock(so, 0);
(*so_upcall)(so, so_upcallarg, M_DONTWAIT);
socket_lock(so, 0);
so->so_flags &= ~SOF_UPCALLINUSE;
/* Tell close that it's safe to proceed */
if (so->so_flags & SOF_CLOSEWAIT)
wakeup((caddr_t)&so->so_upcall);
}
#endif
}
void
uirda_rd_cb(usbd_xfer_handle xfer, usbd_private_handle priv,
usbd_status status)
{
struct uirda_softc *sc = priv;
u_int32_t size;
DPRINTFN(1,("%s: sc=%p\n", __FUNCTION__, sc));
if (status == USBD_CANCELLED) /* this is normal */
return;
if (status) {
size = UIRDA_INPUT_HEADER_SIZE;
sc->sc_rd_err = 1;
} else {
usbd_get_xfer_status(xfer, NULL, NULL, &size, NULL);
}
DPRINTFN(1,("%s: sc=%p size=%u, err=%d\n", __FUNCTION__, sc, size,
sc->sc_rd_err));
sc->sc_rd_count = size;
wakeup(&sc->sc_rd_count); /* XXX should use flag */
selwakeup(&sc->sc_rd_sel);
}