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