/*
* Process context for USB function tasks.
*/
void
usbf_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);
}
usbd_status
usb_allocmem(usbd_bus_handle bus, size_t size, size_t align, usb_dma_t *p)
{
bus_dma_tag_t tag = bus->parent_dmatag;
usbd_status err;
struct usb_frag_dma *f;
usb_dma_block_t *b;
int i;
int s;
/* compat w/ Net/OpenBSD */
if (align == 0)
align = 1;
/* If the request is large then just use a full block. */
if (size > USB_MEM_SMALL || align > USB_MEM_SMALL) {
DPRINTFN(1, ("usb_allocmem: large alloc %d\n", (int)size));
size = (size + USB_MEM_BLOCK - 1) & ~(USB_MEM_BLOCK - 1);
err = usb_block_allocmem(tag, size, align, &p->block);
if (!err) {
p->block->fullblock = 1;
p->offs = 0;
p->len = size;
}
return (err);
}
s = splusb();
/* Check for free fragments. */
for (f = LIST_FIRST(&usb_frag_freelist); f; f = LIST_NEXT(f, next))
if (f->block->tag == tag)
break;
if (f == NULL) {
DPRINTFN(1, ("usb_allocmem: adding fragments\n"));
err = usb_block_allocmem(tag, USB_MEM_BLOCK, USB_MEM_SMALL,&b);
if (err) {
splx(s);
return (err);
}
b->fullblock = 0;
/* XXX - override the tag, ok since we never free it */
b->tag = tag;
KASSERT(sizeof *f <= USB_MEM_SMALL, ("USB_MEM_SMALL(%d) is too small for struct usb_frag_dma(%zd)\n",
USB_MEM_SMALL, sizeof *f));
for (i = 0; i < USB_MEM_BLOCK; i += USB_MEM_SMALL) {
f = (struct usb_frag_dma *)((char *)b->kaddr + i);
f->block = b;
f->offs = i;
LIST_INSERT_HEAD(&usb_frag_freelist, f, next);
}
f = LIST_FIRST(&usb_frag_freelist);
}
p->block = f->block;
p->offs = f->offs;
p->len = USB_MEM_SMALL;
LIST_REMOVE(f, next);
splx(s);
DPRINTFN(5, ("usb_allocmem: use frag=%p size=%d\n", f, (int)size));
return (USBD_NORMAL_COMPLETION);
}
static int
out_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;
}
int
uirda_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 int
auvitek_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;
}
void
ohci_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);
}
int
uhid_detach(struct device *self, int flags)
{
struct uhid_softc *sc = (struct uhid_softc *)self;
int s;
int maj, mn;
DPRINTF(("uhid_detach: sc=%p flags=%d\n", sc, flags));
if (sc->sc_hdev.sc_state & UHIDEV_OPEN) {
s = splusb();
if (--sc->sc_refcnt >= 0) {
/* Wake everyone */
wakeup(&sc->sc_q);
/* Wait for processes to go away. */
usb_detach_wait(&sc->sc_hdev.sc_dev);
}
splx(s);
}
/* locate the major number */
for (maj = 0; maj < nchrdev; maj++)
if (cdevsw[maj].d_open == uhidopen)
break;
/* Nuke the vnodes for any open instances (calls close). */
mn = self->dv_unit;
vdevgone(maj, mn, mn, VCHR);
return (0);
}
void
kue_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 (sc->kue_dying)
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);
}
static int
udsir_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);
}
void
ohci_pci_attach_deferred(struct device *self)
{
struct ohci_pci_softc *sc = (struct ohci_pci_softc *)self;
usbd_status r;
int s;
s = splusb();
sc->sc.sc_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;
}
sc->sc.sc_powerhook = powerhook_establish(ohci_power, &sc->sc);
if (sc->sc.sc_powerhook == NULL)
printf("%s: unable to establish powerhook\n",
sc->sc.sc_bus.bdev.dv_xname);
splx(s);
/* Attach usb device. */
sc->sc.sc_child = config_found((void *)sc, &sc->sc.sc_bus,
usbctlprint);
}
int
ulpt_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);
}
int
uhidkqfilter(dev_t dev, struct knote *kn)
{
struct uhid_softc *sc;
struct klist *klist;
int s;
sc = uhid_cd.cd_devs[UHIDUNIT(dev)];
if (sc->sc_dying)
return (EIO);
switch (kn->kn_filter) {
case EVFILT_READ:
klist = &sc->sc_rsel.si_note;
kn->kn_fop = &uhidread_filtops;
break;
case EVFILT_WRITE:
klist = &sc->sc_rsel.si_note;
kn->kn_fop = &uhid_seltrue_filtops;
break;
default:
return (1);
}
kn->kn_hook = (void *)sc;
s = splusb();
SLIST_INSERT_HEAD(klist, kn, kn_selnext);
splx(s);
return (0);
}
int
uirda_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);
}
int
ugenpoll(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);
}
int
ugl_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_status
usbd_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);
}
int
uhidpoll(dev_t dev, int events, struct proc *p)
{
struct uhid_softc *sc;
int revents = 0;
int s;
sc = uhid_cd.cd_devs[UHIDUNIT(dev)];
if (sc->sc_dying)
return (POLLERR);
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);
}
int
uhidpoll(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);
}
int
uhid_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);
}
void
filt_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 int
ukbd_disable(keyboard_t *kbd)
{
int s;
s = splusb();
KBD_DEACTIVATE(kbd);
splx(s);
return 0;
}
void
filt_uhidrdetach(struct knote *kn)
{
struct uhid_softc *sc = (void *)kn->kn_hook;
int s;
s = splusb();
SLIST_REMOVE(&sc->sc_rsel.si_note, kn, knote, kn_selnext);
splx(s);
}
void
umass_io_put(void *cookie, void *io)
{
struct umass_scsi_softc *scbus = cookie;
int s;
s = splusb();
scbus->sc_open = 0;
splx(s);
}
static void
filt_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 int
out_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 */
/*
* Do not free the memory unconditionally since we might be called
* from an interrupt context and that is BAD.
* XXX when should we really free?
*/
static void
usb_block_freemem(usb_dma_block_t *p)
{
int s;
DPRINTFN(6, ("usb_block_freemem: size=%lu\n", (u_long)p->size));
s = splusb();
LIST_INSERT_HEAD(&usb_blk_freelist, p, next);
usb_blk_nfree++;
splx(s);
}
/* detach */
int
url_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);
}
void
octohci_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 void
free_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);
}
void
ukbd_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);
}
