From 6e99aec8788fbc4a0478d9ceca57920aa2d7bcda Mon Sep 17 00:00:00 2001 From: Theo de Raadt Date: Tue, 2 Jun 1998 06:37:19 +0000 Subject: newer fixes from plunky@skate.demon.co.uk --- sys/arch/sparc/dev/bppioctl.h | 61 +++++ sys/arch/sparc/dev/magma.c | 537 +++++++++++++++++++++++++++++++----------- sys/arch/sparc/dev/magmareg.h | 29 ++- 3 files changed, 482 insertions(+), 145 deletions(-) create mode 100644 sys/arch/sparc/dev/bppioctl.h (limited to 'sys') diff --git a/sys/arch/sparc/dev/bppioctl.h b/sys/arch/sparc/dev/bppioctl.h new file mode 100644 index 00000000000..3b1e82703fe --- /dev/null +++ b/sys/arch/sparc/dev/bppioctl.h @@ -0,0 +1,61 @@ +/* + * Copyright (c) 1998 Iain Hibbert + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name Iain Hibbert may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY ``AS IS'' AND ANY EXPRESS OR IMPLIED + * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN + * NO EVENT SHALL I BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF + * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING + * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + * + * bppioctl.h + */ + +#ifndef _IOCTL_ +#include +#endif + +struct bpp_param { + int bp_burst; /* chars to send/recv in one call */ + int bp_timeout; /* timeout: -1 blocking, 0 non blocking >0 ms */ + int bp_delay; /* delay between polls (ms) */ +}; + +#define BPP_BLOCK -1 +#define BPP_NOBLOCK 0 + +/* defaults */ +#define BPP_BURST 1024 +#define BPP_TIMEOUT BPP_BLOCK +#define BPP_DELAY 10 + +/* limits */ +#define BPP_BURST_MIN 1 +#define BPP_BURST_MAX 1024 +#define BPP_DELAY_MIN 0 +#define BPP_DELAY_MAX 30000 + +/* status bits */ +#define BPP_BUSY (1<<0) +#define BPP_PAPER (1<<1) + +/* ioctl commands */ +#define BPPIOCSPARAM _IOW('P', 0x1, struct bpp_param) +#define BPPIOCGPARAM _IOR('P', 0x2, struct bpp_param) +#define BPPIOCGSTAT _IOR('P', 0x4, int) diff --git a/sys/arch/sparc/dev/magma.c b/sys/arch/sparc/dev/magma.c index 4a0fc416a4c..58bb91018da 100644 --- a/sys/arch/sparc/dev/magma.c +++ b/sys/arch/sparc/dev/magma.c @@ -64,6 +64,7 @@ #include #include +#include "bppioctl.h" #include "magmareg.h" /* @@ -470,9 +471,24 @@ int needsoftint = 0; int port = rivr >> 4; if( rivr & (1<<3) ) { /* parallel port */ - struct mbpp_port *mbpp = &sc->ms_mbpp->ms_port[port]; + struct mbpp_port *mbpp; + int n_chars; + mbpp = &sc->ms_mbpp->ms_port[port]; cd = mbpp->mp_cd1400; + + /* don't think we have to handle exceptions */ + n_chars = cd1400_read_reg(cd, CD1400_RDCR); + while( n_chars-- ) { + if( mbpp->mp_cnt == 0 ) { + SET(mbpp->mp_flags, MBPPF_WAKEUP); + needsoftint = 1; + break; + } + *mbpp->mp_ptr = cd1400_read_reg(cd, CD1400_RDSR); + mbpp->mp_ptr++; + mbpp->mp_cnt--; + } } else { /* serial port */ register struct mtty_port *mtty; register u_char *ptr, n_chars, line_stat; @@ -544,27 +560,23 @@ int needsoftint = 0; mbpp = &sc->ms_mbpp->ms_port[port]; cd = mbpp->mp_cd1400; - /* if we have anything to send, then send what we can.. otherwise - * shut off the interrupts and signal for a wakeup (can't be done - * at this spl because its sleeping in spltty() in mbppwrite - */ - - if( mbpp->mp_txc ) { + if( mbpp->mp_cnt ) { int count = 0; - while( count++ < CD1400_PAR_FIFO_SIZE && mbpp->mp_txc ) { - cd1400_write_reg(cd, CD1400_TDR, *mbpp->mp_txp); - mbpp->mp_txc--; - mbpp->mp_txp++; + /* fill the fifo */ + while( mbpp->mp_cnt && count++ < CD1400_PAR_FIFO_SIZE ) { + cd1400_write_reg(cd, CD1400_TDR, *mbpp->mp_ptr); + mbpp->mp_ptr++; + mbpp->mp_cnt--; } } else { - register int srer; - - srer = cd1400_read_reg(cd, CD1400_SRER); - CLR(srer, CD1400_SRER_TXRDY); - cd1400_write_reg(cd, CD1400_SRER, srer); - - SET(mbpp->mp_flags, MBPPF_DONE); + /* fifo is empty and we got no more data to send, so shut + * off interrupts and signal for a wakeup, which can't be + * done here in case we beat mbpp_send to the tsleep call + * (we are running at >spltty) + */ + cd1400_write_reg(cd, CD1400_SRER, 0); + SET(mbpp->mp_flags, MBPPF_WAKEUP); needsoftint = 1; } } else { /* serial port */ @@ -675,78 +687,81 @@ int s, flags; /* * check the tty ports (if any) to see what needs doing */ - if( mtty ) for( port = 0 ; port < mtty->ms_nports ; port++ ) { - struct mtty_port *mp = &mtty->ms_port[port]; - struct tty *tp = mp->mp_tty; + if( mtty ) { + for( port = 0 ; port < mtty->ms_nports ; port++ ) { + struct mtty_port *mp = &mtty->ms_port[port]; + struct tty *tp = mp->mp_tty; - if( !ISSET(tp->t_state, TS_ISOPEN) ) continue; + if( !ISSET(tp->t_state, TS_ISOPEN) ) continue; - /* - * handle any received data - */ - while( mp->mp_rget != mp->mp_rput ) { - u_char stat; - int data; + /* + * handle any received data + */ + while( mp->mp_rget != mp->mp_rput ) { + u_char stat; + int data; - stat = mp->mp_rget[0]; - data = mp->mp_rget[1]; - mp->mp_rget = ((mp->mp_rget + 2) == mp->mp_rend) ? mp->mp_rbuf : (mp->mp_rget + 2); + stat = mp->mp_rget[0]; + data = mp->mp_rget[1]; + mp->mp_rget = ((mp->mp_rget + 2) == mp->mp_rend) ? mp->mp_rbuf : (mp->mp_rget + 2); - if( stat & (CD1400_RDSR_BREAK | CD1400_RDSR_FE) ) - data |= TTY_FE; - if( stat & CD1400_RDSR_PE ) - data |= TTY_PE; + if( stat & (CD1400_RDSR_BREAK | CD1400_RDSR_FE) ) + data |= TTY_FE; + if( stat & CD1400_RDSR_PE ) + data |= TTY_PE; - if( stat & CD1400_RDSR_OE ) - log(LOG_WARNING, "%s%x: fifo overflow\n", mtty->ms_dev.dv_xname, port); + if( stat & CD1400_RDSR_OE ) + log(LOG_WARNING, "%s%x: fifo overflow\n", mtty->ms_dev.dv_xname, port); - (*linesw[tp->t_line].l_rint)(data, tp); - serviced = 1; - } + (*linesw[tp->t_line].l_rint)(data, tp); + serviced = 1; + } - s = splhigh(); /* block out hard interrupt routine */ - flags = mp->mp_flags; - CLR(mp->mp_flags, MTTYF_DONE | MTTYF_CARRIER_CHANGED | MTTYF_RING_OVERFLOW); - splx(s); /* ok */ + s = splhigh(); /* block out hard interrupt routine */ + flags = mp->mp_flags; + CLR(mp->mp_flags, MTTYF_DONE | MTTYF_CARRIER_CHANGED | MTTYF_RING_OVERFLOW); + splx(s); /* ok */ - if( ISSET(flags, MTTYF_CARRIER_CHANGED) ) { - dprintf(("%s%x: cd %s\n", mtty->ms_dev.dv_xname, port, mp->mp_carrier ? "on" : "off")); - (*linesw[tp->t_line].l_modem)(tp, mp->mp_carrier); - serviced = 1; - } + if( ISSET(flags, MTTYF_CARRIER_CHANGED) ) { + dprintf(("%s%x: cd %s\n", mtty->ms_dev.dv_xname, port, mp->mp_carrier ? "on" : "off")); + (*linesw[tp->t_line].l_modem)(tp, mp->mp_carrier); + serviced = 1; + } - if( ISSET(flags, MTTYF_RING_OVERFLOW) ) { - log(LOG_WARNING, "%s%x: ring buffer overflow\n", mtty->ms_dev.dv_xname, port); - serviced = 1; - } + if( ISSET(flags, MTTYF_RING_OVERFLOW) ) { + log(LOG_WARNING, "%s%x: ring buffer overflow\n", mtty->ms_dev.dv_xname, port); + serviced = 1; + } - if( ISSET(flags, MTTYF_DONE) ) { - ndflush(&tp->t_outq, mp->mp_txp - tp->t_outq.c_cf); - CLR(tp->t_state, TS_BUSY); - (*linesw[tp->t_line].l_start)(tp); /* might be some more */ - serviced = 1; - } - } /* for(each mtty...) */ + if( ISSET(flags, MTTYF_DONE) ) { + ndflush(&tp->t_outq, mp->mp_txp - tp->t_outq.c_cf); + CLR(tp->t_state, TS_BUSY); + (*linesw[tp->t_line].l_start)(tp); /* might be some more */ + serviced = 1; + } + } /* for(each mtty...) */ + } /* * check the bpp ports (if any) to see what needs doing */ - if( mbpp ) for( port = 0 ; port < mbpp->ms_nports ; port++ ) { - struct mbpp_port *mp = &mbpp->ms_port[port]; + if( mbpp ) { + for( port = 0 ; port < mbpp->ms_nports ; port++ ) { + struct mbpp_port *mp = &mbpp->ms_port[port]; - if( !ISSET(mp->mp_flags, MBPPF_OPEN) ) continue; + if( !ISSET(mp->mp_flags, MBPPF_OPEN) ) continue; - s = splhigh(); - flags = mp->mp_flags; - CLR(mp->mp_flags, MBPPF_DONE); - splx(s); + s = splhigh(); /* block out hard intr routine */ + flags = mp->mp_flags; + CLR(mp->mp_flags, MBPPF_WAKEUP); + splx(s); - if( ISSET(flags, MBPPF_DONE) ) { - wakeup(mp); - serviced = 1; - } - - } /* for(each mbpp...) */ + if( ISSET(flags, MBPPF_WAKEUP) ) { + wakeup(mp); + serviced = 1; + } + } /* for(each mbpp...) */ + } return(serviced); } @@ -1355,6 +1370,11 @@ int s, opt; * mbppwrite write to mbpp * mbppioctl do ioctl on mbpp * mbppselect do select on mbpp + * mbpp_rw general rw routine + * mbpp_timeout rw timeout + * mbpp_start rw start after delay + * mbpp_send send data + * mbpp_recv recv data */ int @@ -1376,7 +1396,7 @@ void *args; struct magma_softc *sc = (struct magma_softc *)parent; struct mbpp_softc *ms = (struct mbpp_softc *)dev; struct mbpp_port *mp; -int port = 0; +int port; sc->ms_mbpp = ms; dprintf((" addr 0x%x", ms)); @@ -1388,17 +1408,6 @@ int port = 0; mp->mp_cd1190 = &sc->ms_cd1190[port]; else mp->mp_cd1400 = &sc->ms_cd1400[0]; - - mp->mp_txbuf = malloc(MBPP_TXBUF_SIZE, M_DEVBUF, M_NOWAIT); - if( mp->mp_txbuf == NULL ) break; - - /* - * default strobe and timeout settings - */ - mp->mp_read_strobe = 1000; /* 1 microsecond */ - mp->mp_read_timeout = 5 * hz; /* 5 seconds */ - mp->mp_write_strobe = 1000; /* 1 microsecond */ - mp->mp_write_timeout = 5 * hz; /* 5 seconds */ } ms->ms_nports = port; @@ -1419,7 +1428,7 @@ int card = MAGMA_CARD(dev); int port = MAGMA_PORT(dev); struct mbpp_softc *ms; struct mbpp_port *mp; -int error = 0, s; +int s; if( card >= mbpp_cd.cd_ndevs || (ms = mbpp_cd.cd_devs[card]) == NULL || port >= ms->ms_nports ) return(ENXIO); @@ -1434,22 +1443,27 @@ int error = 0, s; SET(mp->mp_flags, MBPPF_OPEN); splx(s); - if( mp->mp_cd1400 ) { /* CD1400 chip */ + /* set defaults */ + mp->mp_burst = BPP_BURST; + mp->mp_timeout = mbpp_mstohz(BPP_TIMEOUT); + mp->mp_delay = mbpp_mstohz(BPP_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_TBPR, (mp->mp_write_strobe * cd->cd_clock / 2000)); cd1400_write_reg(cd, CD1400_LIVR, (1<<3)); - cd1400_write_ccr(cd, CD1400_CCR_CMDCHANCTL | CD1400_CCR_XMTEN); splx(s); - } else { /* CD1190 chip */ - error = ENXIO; + } else { /* CD1190 */ + mp->mp_flags = 0; + return(ENXIO); } - return(error); + return(0); } /* @@ -1465,19 +1479,7 @@ struct proc *p; struct mbpp_softc *ms = mbpp_cd.cd_devs[MAGMA_CARD(dev)]; struct mbpp_port *mp = &ms->ms_port[MAGMA_PORT(dev)]; - if( mp->mp_cd1400 ) { - struct cd1400 *cd = mp->mp_cd1400; - int s; - - s = spltty(); - /* turn off the channel */ - cd1400_write_reg(cd, CD1400_CAR, 0); - cd1400_write_ccr(cd, CD1400_CCR_CMDRESET); - splx(s); - } - mp->mp_flags = 0; - return(0); } @@ -1490,7 +1492,7 @@ dev_t dev; struct uio *uio; int flags; { - return(ENODEV); + return( mbpp_rw(dev, uio) ); } /* @@ -1502,33 +1504,7 @@ dev_t dev; struct uio *uio; int flags; { -struct mbpp_softc *ms = mbpp_cd.cd_devs[MAGMA_CARD(dev)]; -register struct mbpp_port *mp = &ms->ms_port[MAGMA_PORT(dev)]; -int error = 0; -int s; - - while( uio->uio_resid ) { - mp->mp_txc = MIN(uio->uio_resid, MBPP_TXBUF_SIZE); - mp->mp_txp = mp->mp_txbuf; - - error = uiomove((caddr_t)mp->mp_txp, mp->mp_txc, uio); - if( error ) break; - - s = spltty(); - if( mp->mp_cd1400 ) - cd1400_enable_transmitter(mp->mp_cd1400, 0); - error = tsleep(mp, PCATCH | PZERO, "mbppwrite", mp->mp_write_timeout); - splx(s); - - if( error ) break; - } /* while(more to send...) */ - - if( error == EWOULDBLOCK ) { - log(LOG_INFO, "%s%d: write timeout\n", ms->ms_dev.dv_xname, MAGMA_PORT(dev)); - /* XXX check paper out, printer offline etc.. */ - } - - return(error); + return( mbpp_rw(dev, uio) ); } /* @@ -1542,8 +1518,42 @@ caddr_t data; int flags; struct proc *p; { - /* we want to be able to get & set strobe and timeout values */ - return(ENODEV); +struct mbpp_softc *ms = mbpp_cd.cd_devs[MAGMA_CARD(dev)]; +register struct mbpp_port *mp = &ms->ms_port[MAGMA_PORT(dev)]; +struct bpp_param *bp; +int error = 0; +int s; + + switch(cmd) { + case BPPIOCSPARAM: + bp = (struct bpp_param *)data; + if( bp->bp_burst < BPP_BURST_MIN || bp->bp_burst > BPP_BURST_MAX || + bp->bp_delay < BPP_DELAY_MIN || bp->bp_delay > BPP_DELAY_MIN ) { + error = EINVAL; + } else { + mp->mp_burst = bp->bp_burst; + mp->mp_timeout = mbpp_mstohz(bp->bp_timeout); + mp->mp_delay = mbpp_mstohz(bp->bp_delay); + } + break; + case BPPIOCGPARAM: + bp = (struct bpp_param *)data; + bp->bp_burst = mp->mp_burst; + bp->bp_timeout = mbpp_hztoms(mp->mp_timeout); + bp->bp_delay = mbpp_hztoms(mp->mp_delay); + break; + case BPPIOCGSTAT: + /* XXX make this more generic */ + s = spltty(); + cd1400_write_reg(mp->mp_cd1400, CD1400_CAR, 0); + *(int *)data = cd1400_read_reg(mp->mp_cd1400, CD1400_PSVR); + splx(s); + break; + default: + error = ENOTTY; + } + + return(error); } /* @@ -1558,4 +1568,263 @@ struct proc *p; return(ENODEV); } +int +mbpp_rw(dev, uio) +dev_t dev; +struct uio *uio; +{ +int card = MAGMA_CARD(dev); +int port = MAGMA_PORT(dev); +struct mbpp_softc *ms = mbpp_cd.cd_devs[card]; +register struct mbpp_port *mp = &ms->ms_port[port]; +caddr_t buffer, ptr; +int buflen, cnt, len; +int s, error = 0; +int gotdata = 0; + + if( uio->uio_resid == 0 ) + return(0); + + buflen = min(uio->uio_resid, mp->mp_burst); + buffer = malloc(buflen, M_DEVBUF, M_WAITOK); + if( buffer == NULL ) + return(ENOMEM); + + SET(mp->mp_flags, MBPPF_UIO); + + /* + * start timeout, if needed + */ + if( mp->mp_timeout > 0 ) { + SET(mp->mp_flags, MBPPF_TIMEOUT); + timeout(mbpp_timeout, mp, mp->mp_timeout); + } + + len = cnt = 0; + while( uio->uio_resid > 0 ) { + len = min(buflen, uio->uio_resid); + ptr = buffer; + + if( uio->uio_rw == UIO_WRITE ) { + error = uiomove(ptr, len, uio); + if( error ) break; + } +again: /* goto bad */ + /* timed out? */ + if( !ISSET(mp->mp_flags, MBPPF_UIO) ) + break; + + /* + * perform the operation + */ + if( uio->uio_rw == UIO_WRITE ) { + cnt = mbpp_send(mp, ptr, len); + } else { + cnt = mbpp_recv(mp, ptr, len); + } + + if( uio->uio_rw == UIO_READ ) { + if( cnt ) { + error = uiomove(ptr, cnt, uio); + if( error ) break; + gotdata++; + } + else if( gotdata ) /* consider us done */ + break; + } + + /* timed out? */ + if( !ISSET(mp->mp_flags, MBPPF_UIO) ) + break; + + /* + * poll delay? + */ + if( mp->mp_delay > 0 ) { + s = splsoftclock(); + SET(mp->mp_flags, MBPPF_DELAY); + timeout(mbpp_start, mp, mp->mp_delay); + error = tsleep(mp, PCATCH | PZERO, "mbppdelay", 0); + splx(s); + if( error ) break; + } + + /* + * don't call uiomove again until we used all the data we grabbed + */ + if( uio->uio_rw == UIO_WRITE && cnt != len ) { + ptr += cnt; + len -= cnt; + cnt = 0; + goto again; + } + } + + /* + * clear timeouts + */ + s = splsoftclock(); + if( ISSET(mp->mp_flags, MBPPF_TIMEOUT) ) { + untimeout(mbpp_timeout, mp); + CLR(mp->mp_flags, MBPPF_TIMEOUT); + } + if( ISSET(mp->mp_flags, MBPPF_DELAY) ) { + untimeout(mbpp_start, mp); + CLR(mp->mp_flags, MBPPF_DELAY); + } + splx(s); + + /* + * adjust for those chars that we uiomoved but never actually wrote + */ + if( uio->uio_rw == UIO_WRITE && cnt != len ) { + uio->uio_resid += (len - cnt); + } + + free(buffer, M_DEVBUF); + return(error); +} + +void +mbpp_timeout(arg) +void *arg; +{ +struct mbpp_port *mp = arg; + + CLR(mp->mp_flags, MBPPF_UIO | MBPPF_TIMEOUT); + wakeup(mp); +} + +void +mbpp_start(arg) +void *arg; +{ +struct mbpp_port *mp = arg; + + CLR(mp->mp_flags, MBPPF_DELAY); + wakeup(mp); +} + +int +mbpp_send(mp, ptr, len) +struct mbpp_port *mp; +caddr_t ptr; +int len; +{ +int s; +struct cd1400 *cd = mp->mp_cd1400; + + /* set up io information */ + mp->mp_ptr = ptr; + mp->mp_cnt = len; + + /* start transmitting */ + s = spltty(); + if( cd ) { + cd1400_write_reg(cd, CD1400_CAR, 0); + + /* output strobe width ~1microsecond */ + cd1400_write_reg(cd, CD1400_TBPR, 10); + + /* enable channel */ + cd1400_write_ccr(cd, CD1400_CCR_CMDCHANCTL | CD1400_CCR_XMTEN); + cd1400_write_reg(cd, CD1400_SRER, CD1400_SRER_TXRDY); + } + + /* ZZzzz... */ + tsleep(mp, PCATCH | PZERO, "mbpp_send", 0); + + /* stop transmitting */ + if( cd ) { + cd1400_write_reg(cd, CD1400_CAR, 0); + + /* disable transmitter */ + cd1400_write_reg(cd, CD1400_SRER, 0); + cd1400_write_ccr(cd, CD1400_CCR_CMDCHANCTL | CD1400_CCR_XMTDIS); + + /* flush fifo */ + cd1400_write_ccr(cd, CD1400_CCR_CMDRESET | CD1400_CCR_FTF); + } + splx(s); + + /* return number of chars sent */ + return(len - mp->mp_cnt); +} + +int +mbpp_recv(mp, ptr, len) +struct mbpp_port *mp; +caddr_t ptr; +int len; +{ +int s; +struct cd1400 *cd = mp->mp_cd1400; + + /* set up io information */ + mp->mp_ptr = ptr; + mp->mp_cnt = len; + + /* start receiving */ + s = spltty(); + if( cd ) { + int rcor, rbpr; + + cd1400_write_reg(cd, CD1400_CAR, 0); + + /* input strobe at 100kbaud (10microseconds) */ + cd1400_compute_baud(100000, cd->cd_clock, &rcor, &rbpr); + cd1400_write_reg(cd, CD1400_RCOR, rcor); + cd1400_write_reg(cd, CD1400_RBPR, rbpr); + + /* rx threshold */ + cd1400_write_reg(cd, CD1400_COR3, MBPP_RX_FIFO_THRESHOLD); + cd1400_write_ccr(cd, CD1400_CCR_CMDCORCHG | CD1400_CCR_COR3); + + /* enable channel */ + cd1400_write_ccr(cd, CD1400_CCR_CMDCHANCTL | CD1400_CCR_RCVEN); + cd1400_write_reg(cd, CD1400_SRER, CD1400_SRER_RXDATA); + } + + /* ZZzzz... */ + tsleep(mp, PCATCH | PZERO, "mbpp_recv", 0); + + /* stop receiving */ + if( cd ) { + cd1400_write_reg(cd, CD1400_CAR, 0); + + /* disable receiving */ + cd1400_write_reg(cd, CD1400_SRER, 0); + cd1400_write_ccr(cd, CD1400_CCR_CMDCHANCTL | CD1400_CCR_RCVDIS); + } + splx(s); + + /* return number of chars received */ + return(len - mp->mp_cnt); +} + +int +mbpp_hztoms(h) +int h; +{ +int m = h; + + if( m > 0 ) + m = m * 1000 / hz; + return(m); +} + +int +mbpp_mstohz(m) +int m; +{ +int h = m; + + if( h > 0 ) { + h = h * hz / 1000; + if( h == 0 ) + h = 1000 / hz; + } + return(h); +} + #endif /* NMAGMA */ diff --git a/sys/arch/sparc/dev/magmareg.h b/sys/arch/sparc/dev/magmareg.h index 97857dd5a7a..94d9d0a6ecb 100644 --- a/sys/arch/sparc/dev/magmareg.h +++ b/sys/arch/sparc/dev/magmareg.h @@ -158,7 +158,7 @@ struct mtty_softc { struct mtty_port ms_port[MAGMA_MAX_TTY]; }; -#define MBPP_TXBUF_SIZE (CD1400_PAR_FIFO_SIZE * 10) +#define MBPP_RX_FIFO_THRESHOLD 25 struct mbpp_port { struct cd1400 *mp_cd1400; /* for LC2+1Sp card */ @@ -166,19 +166,20 @@ struct mbpp_port { int mp_flags; - int mp_read_strobe; /* strobe width in ns */ - int mp_read_timeout; /* timeout after this many seconds */ + struct bpp_param mp_param; +#define mp_burst mp_param.bp_burst +#define mp_timeout mp_param.bp_timeout +#define mp_delay mp_param.bp_delay - int mp_write_strobe; /* strobe width in ns */ - int mp_write_timeout; /* timeout after this many seconds */ - - u_char *mp_txbuf; /* transmit buffer */ - u_char *mp_txp; /* transmit pointer */ - int mp_txc; /* transmit counter */ + u_char *mp_ptr; /* pointer to io data */ + int mp_cnt; /* count of io chars */ }; #define MBPPF_OPEN (1<<0) -#define MBPPF_DONE (1<<1) +#define MBPPF_TIMEOUT (1<<1) +#define MBPPF_UIO (1<<2) +#define MBPPF_DELAY (1<<3) +#define MBPPF_WAKEUP (1<<4) struct mbpp_softc { struct device ms_dev; /* device info */ @@ -192,7 +193,6 @@ struct mbpp_softc { #define SET(t, f) ((t) |= (f)) #define CLR(t, f) ((t) &= ~(f)) #define ISSET(t, f) ((t) & (f)) -#define MIN(a, b) ((a) < (b) ? (a) : (b)) /* internal function prototypes */ @@ -215,3 +215,10 @@ void mtty_start __P((struct tty *)); int mbpp_match __P((struct device *, void *, void *)); void mbpp_attach __P((struct device *, struct device *, void *)); +int mbpp_rw __P((dev_t, struct uio *)); +void mbpp_timeout __P((void *)); +void mbpp_start __P((void *)); +int mbpp_send __P((struct mbpp_port *, caddr_t, int)); +int mbpp_recv __P((struct mbpp_port *, caddr_t, int)); +int mbpp_hztoms __P((int)); +int mbpp_mstohz __P((int)); -- cgit v1.2.3