/*ARGSUSED*/ int m41t00_open(dev_t dev, int flag, int fmt, struct lwp *l) { struct m41t00_softc *sc; if ((sc = device_lookup_private(&m41trtc_cd, minor(dev))) == NULL) return ENXIO; /* XXX: Locking */ if (sc->sc_open) return EBUSY; sc->sc_open = 1; return 0; }
int kbdopen(dev_t dev, int flags, int mode, struct lwp *l) { struct kbd_softc *k; k = device_lookup_private(&kbd_cd, minor(dev)); if (k == NULL) return (ENXIO); if (k->sc_events.ev_io) return (EBUSY); k->sc_events.ev_io = l->l_proc; ev_init(&k->sc_events); return (0); }
void stty_stop(struct tty *tp, int flags) { struct stty_softc *sc = device_lookup_private(&stty_cd, SPIF_CARD(tp->t_dev)); struct stty_port *sp = &sc->sc_port[SPIF_PORT(tp->t_dev)]; int s; s = spltty(); if (ISSET(tp->t_state, TS_BUSY)) { if (!ISSET(tp->t_state, TS_TTSTOP)) SET(tp->t_state, TS_FLUSH); SET(sp->sp_flags, STTYF_STOP); } splx(s); }
static int radioopen(dev_t dev, int flags, int fmt, struct lwp *l) { int unit; struct radio_softc *sc; unit = RADIOUNIT(dev); sc = device_lookup_private(&radio_cd, unit); if (sc == NULL || sc->hw_if == NULL) return (ENXIO); if (sc->hw_if->open != NULL) return (sc->hw_if->open(sc->hw_hdl, flags, fmt, l->l_proc)); else return (0); }
void sabstop(struct tty *tp, int flag) { struct sabtty_softc *sc = device_lookup_private(&sabtty_cd, SABUNIT(tp->t_dev)); int s; s = spltty(); if (tp->t_state & TS_BUSY) { if ((tp->t_state & TS_TTSTOP) == 0) tp->t_state |= TS_FLUSH; sc->sc_flags |= SABTTYF_STOP; sc->sc_imr1 &= ~SAB_IMR1_ALLS; SAB_WRITE(sc, SAB_IMR1, sc->sc_imr1); } splx(s); }
/* * Stop output on a line. */ void at91usart_stop(struct tty *tp, int flag) { struct at91usart_softc *sc = device_lookup_private(&at91usart_cd, COMUNIT(tp->t_dev)); int s; s = spltty(); if (ISSET(tp->t_state, TS_BUSY)) { /* Stop transmitting at the next chunk. */ sc->sc_tbc = 0; if (!ISSET(tp->t_state, TS_TTSTOP)) SET(tp->t_state, TS_FLUSH); } splx(s); }
static int ukclose(dev_t dev, int flag, int fmt, struct lwp *l) { struct uk_softc *uk = device_lookup_private(&uk_cd, minor(dev)); struct scsipi_periph *periph = uk->sc_periph; struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; SC_DEBUG(uk->sc_periph, SCSIPI_DB1, ("closing\n")); scsipi_wait_drain(periph); scsipi_adapter_delref(adapt); periph->periph_flags &= ~PERIPH_OPEN; return 0; }
/*ARGSUSED*/ int maxrtc_open(dev_t dev, int flag, int fmt, struct lwp *l) { struct maxrtc_softc *sc; if ((sc = device_lookup_private(&maxrtc_cd, minor(dev))) == NULL) return (ENXIO); /* XXX: Locking */ if (sc->sc_open) return (EBUSY); sc->sc_open = 1; return (0); }
static int chclose(dev_t dev, int flags, int fmt, struct lwp *l) { struct ch_softc *sc = device_lookup_private(&ch_cd, CHUNIT(dev)); struct scsipi_periph *periph = sc->sc_periph; struct scsipi_adapter *adapt = periph->periph_channel->chan_adapter; scsipi_wait_drain(periph); scsipi_adapter_delref(adapt); sc->sc_events = 0; periph->periph_flags &= ~PERIPH_OPEN; return (0); }
void sscomstart(struct tty *tp) { struct sscom_softc *sc = device_lookup_private(&sscom_cd, SSCOMUNIT(tp->t_dev)); int s; if (SSCOM_ISALIVE(sc) == 0) return; s = spltty(); if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) goto out; if (sc->sc_tx_stopped) goto out; if (!ttypull(tp)) goto out; /* Grab the first contiguous region of buffer space. */ { u_char *tba; int tbc; tba = tp->t_outq.c_cf; tbc = ndqb(&tp->t_outq, 0); (void)splserial(); SSCOM_LOCK(sc); sc->sc_tba = tba; sc->sc_tbc = tbc; } SET(tp->t_state, TS_BUSY); sc->sc_tx_busy = 1; /* Output the first chunk of the contiguous buffer. */ sscom_output_chunk(sc); /* Enable transmit completion interrupts if necessary. */ if ((sc->sc_hwflags & SSCOM_HW_TXINT) == 0) sscom_enable_txint(sc); SSCOM_UNLOCK(sc); out: splx(s); return; }
/*ARGSUSED*/ int grfioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l) { int unit = GRFUNIT(dev); struct grf_softc *gp = device_lookup_private(&grf_cd, GRFUNIT(dev)); int error; if ((gp->g_flags & GF_ALIVE) == 0) return ENXIO; error = 0; switch (cmd) { case GRFIOCGINFO: memcpy(data, (void *)&gp->g_display, sizeof(struct grfinfo)); break; case GRFIOCON: error = grfon(gp); break; case GRFIOCOFF: error = grfoff(gp); break; case GRFIOCMAP: error = grfmap(dev, (void **)data, l->l_proc); break; case GRFIOCUNMAP: error = grfunmap(dev, *(void **)data, l->l_proc); break; case GRFSETVMODE: error = (*gp->g_sw->gd_mode)(gp, GM_GRFSETVMODE, data); if (error == 0) ite_reinit(unit); break; default: error = EINVAL; break; } return error; }
int parclose(dev_t dev, int flags, int mode, struct lwp *l) { int unit = UNIT(dev); int s; struct par_softc *sc = device_lookup_private(&par_cd, unit); sc->sc_flags &= ~(PARF_OPEN|PARF_OWRITE); /* don't allow interrupts any longer */ s = spl1(); intio_set_sicilian_intr(intio_get_sicilian_intr() & ~SICILIAN_INTR_PAR); splx(s); return (0); }
/* * Stop output on a line. */ void clmpccstop(struct tty *tp, int flag) { struct clmpcc_softc *sc = device_lookup_private(&clmpcc_cd, CLMPCCUNIT(tp->t_dev)); struct clmpcc_chan *ch = &sc->sc_chans[CLMPCCCHAN(tp->t_dev)]; int s; s = splserial(); if ( ISSET(tp->t_state, TS_BUSY) ) { if ( ISCLR(tp->t_state, TS_TTSTOP) ) SET(tp->t_state, TS_FLUSH); ch->ch_obuf_size = 0; } splx(s); }
/* * Close: * Turn off event mode, dump the queue, and close the keyboard * unless it is supplying console input. */ int kbdclose(dev_t dev, int flags, int mode, struct lwp *l) { struct kbd_softc *k; k = device_lookup_private(&kbd_cd, minor(dev)); k->k_evmode = 0; ev_fini(&k->k_events); k->k_events.ev_io = NULL; if (k->k_ops != NULL && k->k_ops->close != NULL) { int error; if ((error = (*k->k_ops->close)(k)) != 0) return error; } return 0; }
int wsmouseclose(dev_t dev, int flags, int mode, struct lwp *l) { struct wsmouse_softc *sc = device_lookup_private(&wsmouse_cd, minor(dev)); struct wseventvar *evar = sc->sc_base.me_evp; if (evar == NULL) /* not open for read */ return (0); sc->sc_base.me_evp = NULL; (*sc->sc_accessops->disable)(sc->sc_accesscookie); wsevent_fini(evar); return (0); }
STATIC int gtmpscparam(struct tty *tp, struct termios *t) { struct gtmpsc_softc *sc = device_lookup_private(>mpsc_cd, GTMPSCUNIT(tp->t_dev)); /* Check requested parameters. */ if (compute_cdv(t->c_ospeed) < 0) return EINVAL; if (t->c_ispeed && t->c_ispeed != t->c_ospeed) return EINVAL; /* * If there were no changes, don't do anything. This avoids dropping * input and improves performance when all we did was frob things like * VMIN and VTIME. */ if (tp->t_ospeed == t->c_ospeed && tp->t_cflag == t->c_cflag) return 0; mutex_spin_enter(&sc->sc_lock); /* And copy to tty. */ tp->t_ispeed = 0; tp->t_ospeed = t->c_ospeed; tp->t_cflag = t->c_cflag; sc->sc_baudrate = t->c_ospeed; if (!sc->sc_heldchange) { if (sc->sc_tx_busy) { sc->sc_heldtbc = sc->sc_tbc; sc->sc_tbc = 0; sc->sc_heldchange = 1; } else gtmpsc_loadchannelregs(sc); } mutex_spin_exit(&sc->sc_lock); /* Fake carrier on */ (void) (*tp->t_linesw->l_modem)(tp, 1); return 0; }
int apmpoll(dev_t dev, int events, struct lwp *l) { struct apm_softc *sc = device_lookup_private(&apm_cd, APMUNIT(dev)); int revents = 0; APM_LOCK(sc); if (events & (POLLIN | POLLRDNORM)) { if (sc->sc_event_count) revents |= events & (POLLIN | POLLRDNORM); else selrecord(l, &sc->sc_rsel); } APM_UNLOCK(sc); return (revents); }
int circlose(dev_t dev, int flag, int mode, struct lwp *l) { struct cir_softc *sc; int error; sc = device_lookup_private(&cir_cd, CIRUNIT(dev)); if (sc == NULL) return (ENXIO); if (sc->sc_methods->im_close != NULL) error = sc->sc_methods->im_close(sc->sc_handle, flag, mode, l->l_proc); else error = 0; sc->sc_open = 0; return (error); }
/* * Shut down all `cac' controllers. */ static void cac_shutdown(void *cookie) { extern struct cfdriver cac_cd; struct cac_softc *sc; u_int8_t tbuf[512]; int i; for (i = 0; i < cac_cd.cd_ndevs; i++) { if ((sc = device_lookup_private(&cac_cd, i)) == NULL) continue; memset(tbuf, 0, sizeof(tbuf)); tbuf[0] = 1; cac_cmd(sc, CAC_CMD_FLUSH_CACHE, tbuf, sizeof(tbuf), 0, 0, CAC_CCB_DATA_OUT, NULL); } }
/* * trim the size of the transfer if needed, called by physio * basically the smaller of our min and the scsi driver's minphys */ static void ssminphys(struct buf *bp) { struct ss_softc *ss = device_lookup_private(&ss_cd, SSUNIT(bp->b_dev)); struct scsipi_periph *periph = ss->sc_periph; scsipi_adapter_minphys(periph->periph_channel, bp); /* * trim the transfer further for special devices this is * because some scanners only read multiples of a line at a * time, also some cannot disconnect, so the read must be * short enough to happen quickly */ if (ss->special && ss->special->minphys) (ss->special->minphys)(ss, bp); }
int apmopen(dev_t dev, int flag, int mode, struct lwp *l) { int ctl = APM(dev); int error = 0; struct apm_softc *sc; sc = device_lookup_private(&apm_cd, APMUNIT(dev)); if (!sc) return ENXIO; if (!apm_inited) return ENXIO; DPRINTF(APMDEBUG_DEVICE, ("apmopen: pid %d flag %x mode %x\n", l->l_proc->p_pid, flag, mode)); APM_LOCK(sc); switch (ctl) { case APM_CTL: if (!(flag & FWRITE)) { error = EINVAL; break; } if (sc->sc_flags & SCFLAG_OWRITE) { error = EBUSY; break; } sc->sc_flags |= SCFLAG_OWRITE; break; case APM_NORMAL: if (!(flag & FREAD) || (flag & FWRITE)) { error = EINVAL; break; } sc->sc_flags |= SCFLAG_OREAD; break; default: error = ENXIO; break; } APM_UNLOCK(sc); return (error); }
/* * Open: * Check exclusion, open actual device (_iopen), * setup event channel, clear ASCII repeat stuff. */ int kbdopen(dev_t dev, int flags, int mode, struct lwp *l) { struct kbd_softc *k; int error; /* locate device */ k = device_lookup_private(&kbd_cd, minor(dev)); if (k == NULL) return ENXIO; #if NWSKBD > 0 /* * NB: wscons support: while we can track if wskbd has called * enable(), we can't tell if that's for console input or for * events input, so we should probably just let the open to * always succeed regardless (e.g. Xsun opening /dev/kbd). */ if (!k->k_wsenabled) wssunkbd_enable(k, 1); #endif /* exclusive open required for /dev/kbd */ if (k->k_events.ev_io) return EBUSY; k->k_events.ev_io = l->l_proc; /* stop pending autorepeat of console input */ if (k->k_repeating) { k->k_repeating = 0; callout_stop(&k->k_repeat_ch); } /* open actual underlying device */ if (k->k_ops != NULL && k->k_ops->open != NULL) if ((error = (*k->k_ops->open)(k)) != 0) { k->k_events.ev_io = NULL; return error; } ev_init(&k->k_events); k->k_evmode = 0; /* XXX: OK? */ return 0; }
static void at91dbgu_start(struct tty *tp) { struct at91dbgu_softc *sc = device_lookup_private(&at91dbgu_cd, COMUNIT(tp->t_dev)); int s; if (COM_ISALIVE(sc) == 0) return; s = spltty(); if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) goto out; if (sc->sc_tx_stopped) goto out; if (!ttypull(tp)) goto out; /* Grab the first contiguous region of buffer space. */ { u_char *tba; int tbc; tba = tp->t_outq.c_cf; tbc = ndqb(&tp->t_outq, 0); (void)splserial(); sc->sc_tba = tba; sc->sc_tbc = tbc; } SET(tp->t_state, TS_BUSY); sc->sc_tx_busy = 1; /* Output the first chunk of the contiguous buffer. */ at91dbgu_filltx(sc); SET(sc->sc_ier, DBGU_INT_TXRDY); DBGUREG(DBGU_IER) = DBGU_INT_TXRDY; out: splx(s); return; }
/* * open routine. returns zero if successful, else error code */ int mbppopen(dev_t dev, int flags, int mode, struct lwp *l) { int card = MAGMA_CARD(dev); int port = MAGMA_PORT(dev); struct mbpp_softc *ms; struct mbpp_port *mp; int s; if ((ms = device_lookup_private(&mbpp_cd, card)) == NULL || port >= ms->ms_nports ) return(ENXIO); mp = &ms->ms_port[port]; s = spltty(); if( ISSET(mp->mp_flags, MBPPF_OPEN) ) { splx(s); return(EBUSY); } SET(mp->mp_flags, MBPPF_OPEN); splx(s); /* set defaults */ mp->mp_burst = MBPP_BURST; mp->mp_timeout = mbpp_mstohz(MBPP_TIMEOUT); mp->mp_delay = mbpp_mstohz(MBPP_DELAY); /* init chips */ if( mp->mp_cd1400 ) { /* CD1400 */ struct cd1400 *cd = mp->mp_cd1400; /* set up CD1400 channel */ s = spltty(); cd1400_write_reg(cd, CD1400_CAR, 0); cd1400_write_ccr(cd, CD1400_CCR_CMDRESET); cd1400_write_reg(cd, CD1400_LIVR, (1<<3)); splx(s); } else { /* CD1190 */ mp->mp_flags = 0; return (ENXIO); } return (0); }
static int vndclose(dev_t dev, int flags, int mode, struct lwp *l) { int unit = vndunit(dev); struct vnd_softc *sc; int error = 0, part; #ifdef DEBUG if (vnddebug & VDB_FOLLOW) printf("vndclose(0x%"PRIx64", 0x%x, 0x%x, %p)\n", dev, flags, mode, l); #endif sc = device_lookup_private(&vnd_cd, unit); if (sc == NULL) return ENXIO; if ((error = vndlock(sc)) != 0) return error; part = DISKPART(dev); /* ...that much closer to allowing unconfiguration... */ switch (mode) { case S_IFCHR: sc->sc_dkdev.dk_copenmask &= ~(1 << part); break; case S_IFBLK: sc->sc_dkdev.dk_bopenmask &= ~(1 << part); break; } sc->sc_dkdev.dk_openmask = sc->sc_dkdev.dk_copenmask | sc->sc_dkdev.dk_bopenmask; vndunlock(sc); if ((sc->sc_flags & VNF_INITED) == 0) { if ((error = vnd_destroy(sc->sc_dev)) != 0) { aprint_error_dev(sc->sc_dev, "unable to detach instance\n"); return error; } } return 0; }
static void at91usart_start(struct tty *tp) { struct at91usart_softc *sc = device_lookup_private(&at91usart_cd, COMUNIT(tp->t_dev)); int s; if (COM_ISALIVE(sc) == 0) { DPRINTFN(5, ("%s: %s / COM_ISALIVE == 0\n", device_xname(sc->sc_dev), __FUNCTION__)); return; } s = spltty(); if (ISSET(tp->t_state, TS_BUSY | TS_TIMEOUT | TS_TTSTOP)) { DPRINTFN(5, ("%s: %s: TS_BUSY || TS_TIMEOUT || TS_TTSTOP\n", device_xname(sc->sc_dev), __FUNCTION__)); goto out; } if (!ttypull(tp)) goto out; /* Grab the first contiguous region of buffer space. */ { u_char *tba; int tbc; tba = tp->t_outq.c_cf; tbc = ndqb(&tp->t_outq, 0); sc->sc_tba = tba; sc->sc_tbc = tbc; } SET(tp->t_state, TS_BUSY); /* Output the first chunk of the contiguous buffer. */ at91usart_filltx(sc); at91usart_writereg(sc, US_IER, sc->sc_ier); DPRINTFN(5, ("%s: %s, ier=%08x (csr=%08x)\n", device_xname(sc->sc_dev), __FUNCTION__, sc->sc_ier, at91usart_readreg(sc, US_CSR))); out: splx(s); return; }
int wskbdopen(dev_t dev, int flags, int mode, struct lwp *l) { struct wskbd_softc *sc = device_lookup_private(&wskbd_cd, minor(dev)); struct wseventvar *evar; int error; if (sc == NULL) return (ENXIO); #if NWSMUX > 0 DPRINTF(("wskbdopen: %s mux=%p l=%p\n", device_xname(sc->sc_base.me_dv), sc->sc_base.me_parent, l)); #endif if (sc->sc_dying) return (EIO); if ((flags & (FREAD | FWRITE)) == FWRITE) /* Not opening for read, only ioctl is available. */ return (0); #if NWSMUX > 0 if (sc->sc_base.me_parent != NULL) { /* Grab the keyboard out of the greedy hands of the mux. */ DPRINTF(("wskbdopen: detach\n")); wsmux_detach_sc(&sc->sc_base); } #endif if (sc->sc_base.me_evp != NULL) return (EBUSY); evar = &sc->sc_base.me_evar; wsevent_init(evar, l->l_proc); error = wskbd_do_open(sc, evar); if (error) { DPRINTF(("wskbdopen: %s open failed\n", device_xname(sc->sc_base.me_dv))); sc->sc_base.me_evp = NULL; wsevent_fini(evar); } return (error); }
int satlinkclose(dev_t dev, int flags, int fmt, struct lwp *l) { struct satlink_softc *sc; int s; sc = device_lookup_private(&satlink_cd, minor(dev)); s = splsoftclock(); sc->sc_flags &= ~SATF_ISOPEN; splx(s); isa_dmaabort(sc->sc_ic, sc->sc_drq); callout_stop(&sc->sc_ch); return (0); }
int bmdclose(dev_t dev, int fflag, int devtype, struct lwp *l) { struct bmd_softc *sc = device_lookup_private(&bmd_cd, BMD_UNIT(dev)); DPRINTF(("%s%d\n", __func__, BMD_UNIT(dev))); switch (devtype) { case S_IFCHR: sc->sc_flags &= ~BMD_OPENCHR; break; case S_IFBLK: sc->sc_flags &= ~BMD_OPENBLK; break; } return (0); }
static void dlstart(struct tty *tp) { struct dl_softc *sc = device_lookup_private(&dl_cd, minor(tp->t_dev)); int s = spltty(); if (tp->t_state & (TS_TIMEOUT|TS_BUSY|TS_TTSTOP)) goto out; if (!ttypull(tp)) goto out; if (DL_READ_WORD(DL_UBA_XCSR) & DL_XCSR_TX_READY) { tp->t_state |= TS_BUSY; DL_WRITE_BYTE(DL_UBA_XBUFL, getc(&tp->t_outq)); } out: splx(s); return; }