fully uio()'d

SCCS-vsn: sys/kern/kern_physio.c 4.32
SCCS-vsn: sys/vax/uba/ad.c 4.4
SCCS-vsn: sys/kern/tty_bk.c 4.4
SCCS-vsn: sys/vax/uba/ct.c 4.9
SCCS-vsn: sys/vax/mba/hp.c 4.53
SCCS-vsn: sys/vax/uba/dh.c 4.49
SCCS-vsn: sys/vax/mba/ht.c 4.27
SCCS-vsn: sys/vax/uba/dmf.c 4.7
SCCS-vsn: sys/vax/mba/mba.c 4.28
SCCS-vsn: sys/vax/uba/dn.c 4.6
SCCS-vsn: sys/vax/uba/dz.c 4.42
SCCS-vsn: sys/vax/mba/mt.c 4.8
SCCS-vsn: sys/vax/uba/idc.c 4.4
SCCS-vsn: sys/vax/uba/lp.c 4.27
SCCS-vsn: sys/vax/uba/lpa.c 4.5
SCCS-vsn: sys/vax/uba/ps.c 4.5
SCCS-vsn: sys/vax/uba/rk.c 4.44
SCCS-vsn: sys/vax/vax/cons.c 4.15
SCCS-vsn: sys/kern/tty_tb.c 4.4
SCCS-vsn: sys/vax/uba/tm.c 4.53
SCCS-vsn: sys/vax/vax/flp.c 4.7
SCCS-vsn: sys/vax/vax/mem.c 4.4
SCCS-vsn: sys/vax/vax/tu.c 4.7
SCCS-vsn: sys/vax/uba/ts.c 4.28
SCCS-vsn: sys/vax/uba/uba.c 4.49

diff --git a/usr/src/sys/kern/kern_physio.c b/usr/src/sys/kern/kern_physio.c
index 61ab1a9..5ec3792 100644 (file)
--- a/usr/src/sys/kern/kern_physio.c
+++ b/usr/src/sys/kern/kern_physio.c
@@ -1,4 +1,4 @@
-/*     kern_physio.c   4.31    82/08/13        */
+/*     kern_physio.c   4.32    82/08/22        */

 
 #include "../h/param.h"
 #include "../h/systm.h"
 
 #include "../h/param.h"
 #include "../h/systm.h"


@@ -174,35 +174,16 @@ physio(strat, bp, dev, rw, mincnt, uio)
        unsigned (*mincnt)();
        struct uio *uio;
 {
        unsigned (*mincnt)();
        struct uio *uio;
 {

+       register struct iovec *iov = uio->uio_iov;

        register int c;
        register int c;

-       struct uio auio;
-       register struct iovec *iov;
-       struct iovec aiov;

        char *a;
        int s, error = 0;
 
        char *a;
        int s, error = 0;
 

-       if (uio == 0) {
-               uio = &auio;
-               uio->uio_iov = &aiov;
-               uio->uio_iovcnt = 1;
-               uio->uio_offset = u.u_offset;
-               uio->uio_segflg = u.u_segflg;
-               iov = &aiov;
-               iov->iov_base = u.u_base;
-               iov->iov_len = u.u_count;
-               uio->uio_resid = iov->iov_len;
-       } else
-               iov = uio->uio_iov;

 nextiov:
 nextiov:

-       if (uio->uio_iovcnt == 0) {
-               u.u_count = uio->uio_resid;
+       if (uio->uio_iovcnt == 0)

                return (0);
                return (0);

-       }
-       if (useracc(iov->iov_base,iov->iov_len,rw==B_READ?B_WRITE:B_READ) == NULL) {
-               u.u_count = uio->uio_resid;
-               u.u_error = EFAULT;
+       if (useracc(iov->iov_base,(u_int)iov->iov_len,rw==B_READ?B_WRITE:B_READ) == NULL)

                return (EFAULT);
                return (EFAULT);

-       }

        s = spl6();
        while (bp->b_flags&B_BUSY) {
                bp->b_flags |= B_WANTED;
        s = spl6();
        while (bp->b_flags&B_BUSY) {
                bp->b_flags |= B_WANTED;


@@ -240,11 +221,8 @@ nextiov:
        }
        bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS);
        error = geterror(bp);
        }
        bp->b_flags &= ~(B_BUSY|B_WANTED|B_PHYS);
        error = geterror(bp);

-       if (error) {
-               u.u_error = error;
-               u.u_count = uio->uio_resid;
+       if (error)

                return (error);
                return (error);

-       }

        uio->uio_iov++;
        uio->uio_iovcnt--;
        goto nextiov;
        uio->uio_iov++;
        uio->uio_iovcnt--;
        goto nextiov;

diff --git a/usr/src/sys/kern/tty_bk.c b/usr/src/sys/kern/tty_bk.c
index 88ef679..83ade9c 100644 (file)
--- a/usr/src/sys/kern/tty_bk.c
+++ b/usr/src/sys/kern/tty_bk.c
@@ -1,4 +1,4 @@
-/*     tty_bk.c        4.3     82/08/13        */
+/*     tty_bk.c        4.4     82/08/22        */

 
 #include "bk.h"
 
 
 #include "bk.h"
 


@@ -100,7 +100,7 @@ bkread(tp, uio)
        splx(s);
        if (tp->t_line != NETLDISC)
                return (-1);
        splx(s);
        if (tp->t_line != NETLDISC)
                return (-1);

-       u.u_error = copyuout(uio, tp->t_bufp->b_un.b_addr, tp->t_inbuf);
+       u.u_error = uiomove(tp->t_bufp->b_un.b_addr, tp->t_inbuf, UIO_READ, uio);

        tp->t_cp = (char *)tp->t_bufp->b_un.b_addr;
        tp->t_inbuf = 0;
        tp->t_rec = 0;
        tp->t_cp = (char *)tp->t_bufp->b_un.b_addr;
        tp->t_inbuf = 0;
        tp->t_rec = 0;

diff --git a/usr/src/sys/kern/tty_tb.c b/usr/src/sys/kern/tty_tb.c
index 0ac3075..23cb9b7 100644 (file)
--- a/usr/src/sys/kern/tty_tb.c
+++ b/usr/src/sys/kern/tty_tb.c
@@ -1,4 +1,4 @@
-/*     tty_tb.c        4.3     82/08/13        */
+/*     tty_tb.c        4.4     82/08/22        */

 
 #include "tb.h"
 #if NTB > 0
 
 #include "tb.h"
 #if NTB > 0


@@ -101,7 +101,7 @@ tbread(tp, uio)
 
        if ((tp->t_state&TS_CARR_ON)==0)
                return (-1);
 
        if ((tp->t_state&TS_CARR_ON)==0)
                return (-1);

-       u.u_error = copyuout(uio, &tp->t_rocount, sizeof tbposition);
+       u.u_error = iomove(&tp->t_rocount, sizeof tbposition, UIO_READ, uio);

        if (u.u_error)
                return (-1);
        return (0);
        if (u.u_error)
                return (-1);
        return (0);

diff --git a/usr/src/sys/vax/mba/hp.c b/usr/src/sys/vax/mba/hp.c
index 7c5d607..ca7a8db 100644 (file)
--- a/usr/src/sys/vax/mba/hp.c
+++ b/usr/src/sys/vax/mba/hp.c
@@ -1,4 +1,4 @@
-/*     hp.c    4.52    82/08/13        */
+/*     hp.c    4.53    82/08/22        */

 
 #ifdef HPDEBUG
 int    hpdebug;
 
 #ifdef HPDEBUG
 int    hpdebug;


@@ -636,15 +636,16 @@ hpread(dev, uio)
                physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys, uio);
 }
 
                physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys, uio);
 }
 

-hpwrite(dev)
+hpwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NHP)
                u.u_error = ENXIO;
        else
 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NHP)
                u.u_error = ENXIO;
        else

-               physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys, 0);
+               physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys, uio);

 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/

diff --git a/usr/src/sys/vax/mba/ht.c b/usr/src/sys/vax/mba/ht.c
index 6e68866..75d5d10 100644 (file)
--- a/usr/src/sys/vax/mba/ht.c
+++ b/usr/src/sys/vax/mba/ht.c
@@ -1,4 +1,4 @@
-/*     ht.c    4.26    82/08/13        */
+/*     ht.c    4.27    82/08/22        */

 
 #include "tu.h"
 #if NHT > 0
 
 #include "tu.h"
 #if NHT > 0


@@ -425,10 +425,10 @@ htread(dev, uio)
 htwrite(dev)
 {
 
 htwrite(dev)
 {
 

-       htphys(dev, 0);
+       u.u_error = htphys(dev, uio);

        if (u.u_error)
                return;
        if (u.u_error)
                return;

-       physio(htstrategy, &rhtbuf[HTUNIT(dev)], dev, B_WRITE, minphys, 0);
+       physio(htstrategy, &rhtbuf[HTUNIT(dev)], dev, B_WRITE, minphys, uio);

 }
 
 htphys(dev, uio)
 }
 
 htphys(dev, uio)


@@ -441,14 +441,9 @@ htphys(dev, uio)
        daddr_t a;
 
        htunit = HTUNIT(dev);
        daddr_t a;
 
        htunit = HTUNIT(dev);

-       if (htunit >= NHT || (mi = htinfo[htunit]) == 0 || mi->mi_alive == 0) {
-               u.u_error = ENXIO;
+       if (htunit >= NHT || (mi = htinfo[htunit]) == 0 || mi->mi_alive == 0)

                return (ENXIO);
                return (ENXIO);

-       }
-       if (uio)
-               a = uio->uio_offset >> 9;
-       else
-               a = u.u_offset >> 9;
+       a = uio->uio_offset >> 9;

        sc = &tu_softc[TUUNIT(dev)];
        sc->sc_blkno = bdbtofsb(a);
        sc->sc_nxrec = bdbtofsb(a)+1;
        sc = &tu_softc[TUUNIT(dev)];
        sc->sc_blkno = bdbtofsb(a);
        sc->sc_nxrec = bdbtofsb(a)+1;

diff --git a/usr/src/sys/vax/mba/mba.c b/usr/src/sys/vax/mba/mba.c
index 433f5c1..38a1e4a 100644 (file)
--- a/usr/src/sys/vax/mba/mba.c
+++ b/usr/src/sys/vax/mba/mba.c
@@ -1,4 +1,4 @@
-/*     mba.c   4.27    82/08/13        */
+/*     mba.c   4.28    82/08/22        */

 
 #include "mba.h"
 #if NMBA > 0
 
 #include "mba.h"
 #if NMBA > 0

diff --git a/usr/src/sys/vax/mba/mt.c b/usr/src/sys/vax/mba/mt.c
index 7af3351..e73dd75 100644 (file)
--- a/usr/src/sys/vax/mba/mt.c
+++ b/usr/src/sys/vax/mba/mt.c
@@ -1,4 +1,4 @@
-/*     mt.c    4.7     82/08/13        */
+/*     mt.c    4.8     82/08/22        */

 
 #include "mu.h"
 #if NMT > 0
 
 #include "mu.h"
 #if NMT > 0


@@ -465,13 +465,15 @@ mtread(dev, uio)
        physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_READ, minphys, uio);
 }
 
        physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_READ, minphys, uio);
 }
 

-mtwrite(dev)
+mtwrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
 
 {
 

-       mtphys(dev, 0);
+       u.u_error = mtphys(dev, uio);

        if (u.u_error)
                return;
        if (u.u_error)
                return;

-       physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_WRITE, minphys, 0);
+       physio(mtstrategy, &rmtbuf[MTUNIT(dev)], dev, B_WRITE, minphys, uio);

 }
 
 mtphys(dev, uio)
 }
 
 mtphys(dev, uio)


@@ -484,14 +486,9 @@ mtphys(dev, uio)
        daddr_t a;
 
        mtunit = MTUNIT(dev);
        daddr_t a;
 
        mtunit = MTUNIT(dev);

-       if (mtunit >= NMT || (mi = mtinfo[mtunit]) == 0 || mi->mi_alive == 0) {
-               u.u_error = ENXIO;
+       if (mtunit >= NMT || (mi = mtinfo[mtunit]) == 0 || mi->mi_alive == 0)

                return (ENXIO);
                return (ENXIO);

-       }
-       if (uio)
-               a = uio->uio_offset >> 9;
-       else
-               a = u.u_offset >> 9;
+       a = uio->uio_offset >> 9;

        sc = &mu_softc[MUUNIT(dev)];
        sc->sc_blkno = bdbtofsb(a);
        sc->sc_nxrec = bdbtofsb(a)+1;
        sc = &mu_softc[MUUNIT(dev)];
        sc->sc_blkno = bdbtofsb(a);
        sc->sc_nxrec = bdbtofsb(a)+1;

diff --git a/usr/src/sys/vax/uba/ad.c b/usr/src/sys/vax/uba/ad.c
index fb20aa9..33a3f76 100644 (file)
--- a/usr/src/sys/vax/uba/ad.c
+++ b/usr/src/sys/vax/uba/ad.c
@@ -1,4 +1,4 @@
-/*     ad.c    4.3     82/08/01        */
+/*     ad.c    4.4     82/08/22        */

 
 #include "ad.h"
 #if NAD > 0
 
 #include "ad.h"
 #if NAD > 0

diff --git a/usr/src/sys/vax/uba/ct.c b/usr/src/sys/vax/uba/ct.c
index 362d085..b9521eb 100644 (file)
--- a/usr/src/sys/vax/uba/ct.c
+++ b/usr/src/sys/vax/uba/ct.c
@@ -1,4 +1,4 @@
-/*     ct.c    4.8     82/07/15        */
+/*     ct.c    4.9     82/08/22        */

 
 #include "ct.h"
 #if NCT > 0
 
 #include "ct.h"
 #if NCT > 0


@@ -90,13 +90,14 @@ ctclose(dev)
        ctintr(dev);
 }
 
        ctintr(dev);
 }
 

-ctwrite(dev)
+ctwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
        register int c;
 
 {
        register struct ct_softc *sc = &ct_softc[CTUNIT(dev)];
        register int c;
 

-       while ((c=cpass()) >= 0) {
+       while ((c=cupass(uio)) >= 0) {

                (void) spl5();
                while (sc->sc_oq.c_cc > CATHIWAT)
                        sleep((caddr_t)&sc->sc_oq, PCAT);
                (void) spl5();
                while (sc->sc_oq.c_cc > CATHIWAT)
                        sleep((caddr_t)&sc->sc_oq, PCAT);

diff --git a/usr/src/sys/vax/uba/dh.c b/usr/src/sys/vax/uba/dh.c
index 2fc93ae..681f8b4 100644 (file)
--- a/usr/src/sys/vax/uba/dh.c
+++ b/usr/src/sys/vax/uba/dh.c
@@ -1,4 +1,4 @@
-/*     dh.c    4.48    82/08/13        */
+/*     dh.c    4.49    82/08/22        */

 
 #include "dh.h"
 #if NDH > 0
 
 #include "dh.h"
 #if NDH > 0


@@ -319,13 +319,14 @@ dhread(dev, uio)
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
 
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
 

-dhwrite(dev)
+dhwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register struct tty *tp;
 
        tp = &dh11[minor(dev)];
 {
        register struct tty *tp;
 
        tp = &dh11[minor(dev)];

-       (*linesw[tp->t_line].l_write)(tp);
+       (*linesw[tp->t_line].l_write)(tp, uio);

 }
 
 /*
 }
 
 /*

diff --git a/usr/src/sys/vax/uba/dmf.c b/usr/src/sys/vax/uba/dmf.c
index 60a34b7..fa8b00b 100644 (file)
--- a/usr/src/sys/vax/uba/dmf.c
+++ b/usr/src/sys/vax/uba/dmf.c
@@ -1,4 +1,4 @@
-/*     dmf.c   4.6     82/08/13        */
+/*     dmf.c   4.7     82/08/22        */

 
 #include "dmf.h"
 #if NDMF > 0
 
 #include "dmf.h"
 #if NDMF > 0


@@ -309,13 +309,14 @@ dmfread(dev, uio)
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
 
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
 

-dmfwrite(dev)
+dmfwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register struct tty *tp;
 
        tp = &dmf_tty[minor(dev)];
 {
        register struct tty *tp;
 
        tp = &dmf_tty[minor(dev)];

-       (*linesw[tp->t_line].l_write)(tp);
+       (*linesw[tp->t_line].l_write)(tp, uio);

 }
 
 /*
 }
 
 /*

diff --git a/usr/src/sys/vax/uba/dn.c b/usr/src/sys/vax/uba/dn.c
index 0e7ea1c..d55beb5 100644 (file)
--- a/usr/src/sys/vax/uba/dn.c
+++ b/usr/src/sys/vax/uba/dn.c
@@ -1,4 +1,4 @@
-/*     dn.c    4.5     82/07/15        */
+/*     dn.c    4.6     82/08/22        */

 
 #include "dn.h"
 #if NDN > 0
 
 #include "dn.h"
 #if NDN > 0


@@ -109,8 +109,9 @@ dnclose(dev, flag)
        dp->dn_reg[DNREG(dev)] = MENABLE;
 }
 
        dp->dn_reg[DNREG(dev)] = MENABLE;
 }
 

-dnwrite(dev)
+dnwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register u_short *dnreg;
        register int cc;
 {
        register u_short *dnreg;
        register int cc;


@@ -121,9 +122,9 @@ dnwrite(dev)
 
        dp = (struct dndevice *)dninfo[DNUNIT(dev)]->ui_addr;
        dnreg = &(dp->dn_reg[DNREG(dev)]);
 
        dp = (struct dndevice *)dninfo[DNUNIT(dev)]->ui_addr;
        dnreg = &(dp->dn_reg[DNREG(dev)]);

-       cc = MIN(u.u_count, OBUFSIZ);
+       cc = MIN(uio->uio_resid, OBUFSIZ);

        cp = buf;
        cp = buf;

-       iomove(cp, (unsigned)cc, B_WRITE);
+       u.u_error = uiomove(cp, (unsigned)cc, UIO_WRITE, uio);

        if (u.u_error)
                return;
        while ((*dnreg & (PWI|ACR|DSS)) == 0 && cc >= 0) {
        if (u.u_error)
                return;
        while ((*dnreg & (PWI|ACR|DSS)) == 0 && cc >= 0) {

diff --git a/usr/src/sys/vax/uba/dz.c b/usr/src/sys/vax/uba/dz.c
index 4d897f8..4c71762 100644 (file)
--- a/usr/src/sys/vax/uba/dz.c
+++ b/usr/src/sys/vax/uba/dz.c
@@ -1,4 +1,4 @@
-/*     dz.c    4.41    82/08/13        */
+/*     dz.c    4.42    82/08/22        */

 
 #include "dz.h"
 #if NDZ > 0
 
 #include "dz.h"
 #if NDZ > 0


@@ -268,13 +268,14 @@ dzread(dev, uio)
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
  
        return ((*linesw[tp->t_line].l_read)(tp, uio));
 }
  

-dzwrite(dev)
+dzwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register struct tty *tp;
  
        tp = &dz_tty[minor(dev)];
 {
        register struct tty *tp;
  
        tp = &dz_tty[minor(dev)];

-       (*linesw[tp->t_line].l_write)(tp);
+       (*linesw[tp->t_line].l_write)(tp, uio);

 }
  
 /*ARGSUSED*/
 }
  
 /*ARGSUSED*/

diff --git a/usr/src/sys/vax/uba/idc.c b/usr/src/sys/vax/uba/idc.c
index 1e130c0..a86735b 100644 (file)
--- a/usr/src/sys/vax/uba/idc.c
+++ b/usr/src/sys/vax/uba/idc.c
@@ -1,4 +1,4 @@
-/*     idc.c   4.3     82/08/13        */
+/*     idc.c   4.4     82/08/22        */

 
 #include "rb.h"
 #if NIDC > 0
 
 #include "rb.h"
 #if NIDC > 0


@@ -640,15 +640,16 @@ idcread(dev, uio)
                physio(idcstrategy, &ridcbuf[unit], dev, B_READ, minphys, uio);
 }
 
                physio(idcstrategy, &ridcbuf[unit], dev, B_READ, minphys, uio);
 }
 

-idcwrite(dev)
+idcwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NRB)
                u.u_error = ENXIO;
        else
 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NRB)
                u.u_error = ENXIO;
        else

-               physio(idcstrategy, &ridcbuf[unit], dev, B_WRITE, minphys, 0);
+               physio(idcstrategy, &ridcbuf[unit], dev, B_WRITE, minphys, uio);

 }
 
 idcecc(ui)
 }
 
 idcecc(ui)

diff --git a/usr/src/sys/vax/uba/lp.c b/usr/src/sys/vax/uba/lp.c
index 9729923..554a376 100644 (file)
--- a/usr/src/sys/vax/uba/lp.c
+++ b/usr/src/sys/vax/uba/lp.c
@@ -1,4 +1,4 @@
-/*     lp.c    4.26    82/07/15        */
+/*     lp.c    4.27    82/08/22        */

 
 #include "lp.h"
 #if NLP > 0
 
 #include "lp.h"
 #if NLP > 0


@@ -143,16 +143,19 @@ lpclose(dev, flag)
        sc->sc_state &= ~OPEN;
 }
 
        sc->sc_state &= ~OPEN;
 }
 

-lpwrite(dev)
+lpwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register unsigned n;
        register char *cp;
        register struct lp_softc *sc = &lp_softc[LPUNIT(dev)];
 
 {
        register unsigned n;
        register char *cp;
        register struct lp_softc *sc = &lp_softc[LPUNIT(dev)];
 

-       while (n = min(512, u.u_count)) {
+       while (n = min(512, uio->uio_resid)) {

                cp = sc->sc_inbuf->b_un.b_addr;
                cp = sc->sc_inbuf->b_un.b_addr;

-               iomove(cp, n, B_WRITE);
+               u.u_error = uiomove(cp, n, UIO_WRITE, uio);
+               if (u.u_error)
+                       break;

                do
                        lpcanon(dev, *cp++);
                while (--n);
                do
                        lpcanon(dev, *cp++);
                while (--n);

diff --git a/usr/src/sys/vax/uba/lpa.c b/usr/src/sys/vax/uba/lpa.c
index 7bc289a..be3aca5 100644 (file)
--- a/usr/src/sys/vax/uba/lpa.c
+++ b/usr/src/sys/vax/uba/lpa.c
@@ -1,4 +1,4 @@
-/*     lpa.c   4.4     82/08/13        */
+/*     lpa.c   4.5     82/08/22        */

 #include "lpa.h"
 #if NLPA > 0
 
 #include "lpa.h"
 #if NLPA > 0
 


@@ -292,8 +292,9 @@ TRACER("CLOSE\n");
  *             first write is the microcode
  *             second write is the dispatch table
  */
  *             first write is the microcode
  *             second write is the dispatch table
  */

-lpawrite(dev)
-dev_t dev;
+lpawrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
        register int unit = LPAUNIT(dev);
        register struct lpa_softc *sc = &lpa_softc[unit];
 {
        register int unit = LPAUNIT(dev);
        register struct lpa_softc *sc = &lpa_softc[unit];


@@ -308,27 +309,28 @@ TRACER("WRITE\n");
                return;
        }
        if ((f & MCODE) == 0) {
                return;
        }
        if ((f & MCODE) == 0) {

-               lpamcode(lpaaddr, sc);
+               lpamcode(lpaaddr, sc, uio);

                return;
        }
        if ((f & DMDT) == 0) {
                return;
        }
        if ((f & DMDT) == 0) {

-               lpadmdt(lpaaddr, sc, ui->ui_ubanum);
+               lpadmdt(lpaaddr, sc, ui->ui_ubanum, uio);

                return;
        }
        /* writes are only for microcode and dedicated mode dispatch table */
        u.u_error = ENXIO;
 }
 
                return;
        }
        /* writes are only for microcode and dedicated mode dispatch table */
        u.u_error = ENXIO;
 }
 

-lpamcode(lpaaddr, sc)
-register struct lpadevice *lpaaddr;
-register struct lpa_softc *sc;
+lpamcode(lpaaddr, sc, uio)
+       register struct lpadevice *lpaaddr;
+       register struct lpa_softc *sc;
+       struct uio *uio;

 {
        short v, r;
        register int mcaddr;
 
        mcaddr = 0;
 {
        short v, r;
        register int mcaddr;
 
        mcaddr = 0;

-       while (u.u_count) {
-               iomove(&v, 2, B_WRITE);         /* get next microcode word */
+       while (uio->uio_resid) {
+               uiomove(&v, 2, UIO_WRITE, uio); /* get next microcode word */

                lpaaddr->lcim = 0;              /* load microcode word */
                lpaaddr->lrda = mcaddr;
                lpaaddr->lms = v;
                lpaaddr->lcim = 0;              /* load microcode word */
                lpaaddr->lrda = mcaddr;
                lpaaddr->lms = v;


@@ -352,10 +354,11 @@ register struct lpa_softc *sc;
 TRACER("MCODE\n");
 }
 
 TRACER("MCODE\n");
 }
 

-lpadmdt(lpaaddr, sc, ubanum)
-register struct lpadevice *lpaaddr;
-register struct lpa_softc *sc;
-register short ubanum;
+lpadmdt(lpaaddr, sc, ubanum, uio)
+       register struct lpadevice *lpaaddr;
+       register struct lpa_softc *sc;
+       register short ubanum;
+       struct uio *uio;

 {
        register short *p;
        register int n;
 {
        register short *p;
        register int n;


@@ -372,8 +375,8 @@ register short ubanum;
        *p++ = ADIO3;
        *p++ = ADIO4;
        *p++ = ADIO5;
        *p++ = ADIO3;
        *p++ = ADIO4;
        *p++ = ADIO5;

-       n = min(u.u_count, 256);        /* dedicated mode dispatch table */
-       iomove((char *) p, n, B_WRITE);
+       n = min(uio->uio_resid, 256);   /* dedicated mode dispatch table */
+       uiomove((char *)p, n, UIO_WRITE, uio);

        n >>= 1;
        p += n;
        while (n++ < 128)
        n >>= 1;
        p += n;
        while (n++ < 128)


@@ -477,12 +480,11 @@ TRACER("IOCTL OUT\n");
 }
 
 /*
 }
 
 /*

- *     read
- *             read 1 character only - the next available buffer number
+ * Lparead reads 1 character only -- the next available buffer number.

  */
 lparead(dev, uio)
  */
 lparead(dev, uio)

-dev_t dev;
-struct uio *uio;
+       dev_t dev;
+       struct uio *uio;

 {
        register int unit = LPAUNIT(dev);
        register struct lpa_softc *sc = &lpa_softc[unit];
 {
        register int unit = LPAUNIT(dev);
        register struct lpa_softc *sc = &lpa_softc[unit];


@@ -518,17 +520,17 @@ TRACER("SLEEP\n");
                (void) spl0();
        }
 TRACERN("READ %d\n", sc->sc_ubufn);
                (void) spl0();
        }
 TRACERN("READ %d\n", sc->sc_ubufn);

-       uiomove(&sc->sc_ubufn, 1, B_READ, uio);
+       uiomove(&sc->sc_ubufn, 1, UIO_READ, uio);

 }
 
 /*
 }
 
 /*

- *     execute a command and wait for completion
+ * Execute a lpa command and wait for completion.

  */
 lpacmd(bp, lpaaddr, sc, ubanum)
  */
 lpacmd(bp, lpaaddr, sc, ubanum)

-register struct buf *bp;
-register struct lpadevice *lpaaddr;
-register struct lpa_softc *sc;
-register short ubanum;
+       register struct buf *bp;
+       register struct lpadevice *lpaaddr;
+       register struct lpa_softc *sc;
+       register short ubanum;

 {
        int ubareg;
 
 {
        int ubareg;
 

diff --git a/usr/src/sys/vax/uba/ps.c b/usr/src/sys/vax/uba/ps.c
index 74bb527..9ab61eb 100644 (file)
--- a/usr/src/sys/vax/uba/ps.c
+++ b/usr/src/sys/vax/uba/ps.c
@@ -1,4 +1,4 @@
-/*     ps.c    4.4     82/08/13        */
+/*     ps.c    4.5     82/08/22        */

 
 /*
  * Evans and Sutherland Picture System 2 driver
 
 /*
  * Evans and Sutherland Picture System 2 driver

diff --git a/usr/src/sys/vax/uba/rk.c b/usr/src/sys/vax/uba/rk.c
index 7b923e8..c205b49 100644 (file)
--- a/usr/src/sys/vax/uba/rk.c
+++ b/usr/src/sys/vax/uba/rk.c
@@ -1,6 +1,6 @@
 #define        RKDEBUG
 #define RKBDEBUG
 #define        RKDEBUG
 #define RKBDEBUG

-/*     rk.c    4.43    82/08/13        */
+/*     rk.c    4.44    82/08/22        */

 
 #include "rk.h"
 #if NHK > 0
 
 #include "rk.h"
 #if NHK > 0


@@ -526,15 +526,16 @@ rkread(dev, uio)
                physio(rkstrategy, &rrkbuf[unit], dev, B_READ, minphys, uio);
 }
 
                physio(rkstrategy, &rrkbuf[unit], dev, B_READ, minphys, uio);
 }
 

-rkwrite(dev)
+rkwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NRK)
                u.u_error = ENXIO;
        else
 {
        register int unit = minor(dev) >> 3;
 
        if (unit >= NRK)
                u.u_error = ENXIO;
        else

-               physio(rkstrategy, &rrkbuf[unit], dev, B_WRITE, minphys, 0);
+               physio(rkstrategy, &rrkbuf[unit], dev, B_WRITE, minphys, uio);

 }
 
 rkecc(ui, flag)
 }
 
 rkecc(ui, flag)

diff --git a/usr/src/sys/vax/uba/tm.c b/usr/src/sys/vax/uba/tm.c
index 9368ec7..835e67a 100644 (file)
--- a/usr/src/sys/vax/uba/tm.c
+++ b/usr/src/sys/vax/uba/tm.c
@@ -1,4 +1,4 @@
-/*     tm.c    4.52    82/08/13        */
+/*     tm.c    4.53    82/08/22        */

 
 #include "te.h"
 #include "ts.h"
 
 #include "te.h"
 #include "ts.h"


@@ -753,14 +753,15 @@ tmread(dev, uio)
        physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_READ, minphys, uio);
 }
 
        physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_READ, minphys, uio);
 }
 

-tmwrite(dev)
+tmwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
 
 {
 

-       tmphys(dev, 0);
+       u.u_error = tmphys(dev, uio);

        if (u.u_error)
                return;
        if (u.u_error)
                return;

-       physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_WRITE, minphys, 0);
+       physio(tmstrategy, &rtmbuf[TMUNIT(dev)], dev, B_WRITE, minphys, uio);

 }
 
 /*
 }
 
 /*


@@ -777,15 +778,10 @@ tmphys(dev, uio)
        register struct te_softc *sc;
        register struct uba_device *ui;
 
        register struct te_softc *sc;
        register struct uba_device *ui;
 

-       if (teunit >= NTE || (ui=tedinfo[teunit]) == 0 || ui->ui_alive == 0) {
-               u.u_error = ENXIO;
+       if (teunit >= NTE || (ui=tedinfo[teunit]) == 0 || ui->ui_alive == 0)

                return (ENXIO);
                return (ENXIO);

-       }

        sc = &te_softc[teunit];
        sc = &te_softc[teunit];

-       if (uio)
-               a = bdbtofsb(uio->uio_offset >> 9);
-       else
-               a = bdbtofsb(u.u_offset >> 9);
+       a = bdbtofsb(uio->uio_offset >> 9);

        sc->sc_blkno = a;
        sc->sc_nxrec = a + 1;
        return (0);
        sc->sc_blkno = a;
        sc->sc_nxrec = a + 1;
        return (0);

diff --git a/usr/src/sys/vax/uba/ts.c b/usr/src/sys/vax/uba/ts.c
index 3a6b887..74224e9 100644 (file)
--- a/usr/src/sys/vax/uba/ts.c
+++ b/usr/src/sys/vax/uba/ts.c
@@ -1,4 +1,4 @@
-/*     ts.c    4.27    82/08/13        */
+/*     ts.c    4.28    82/08/22        */

 
 #include "ts.h"
 #if NTS > 0
 
 #include "ts.h"
 #if NTS > 0


@@ -701,14 +701,15 @@ tsread(dev, uio)
        physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_READ, minphys, uio);
 }
 
        physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_READ, minphys, uio);
 }
 

-tswrite(dev)
+tswrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
 
 {
 

-       tsphys(dev, 0);
+       u.u_error = tsphys(dev, uio);

        if (u.u_error)
                return;
        if (u.u_error)
                return;

-       physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_WRITE, minphys, 0);
+       physio(tsstrategy, &rtsbuf[TSUNIT(dev)], dev, B_WRITE, minphys, uio);

 }
 
 /*
 }
 
 /*


@@ -725,15 +726,10 @@ tsphys(dev, uio)
        register struct ts_softc *sc;
        register struct uba_device *ui;
 
        register struct ts_softc *sc;
        register struct uba_device *ui;
 

-       if (tsunit >= NTS || (ui=tsdinfo[tsunit]) == 0 || ui->ui_alive == 0) {
-               u.u_error = ENXIO;
+       if (tsunit >= NTS || (ui=tsdinfo[tsunit]) == 0 || ui->ui_alive == 0)

                return (ENXIO);
                return (ENXIO);

-       }

        sc = &ts_softc[tsunit];
        sc = &ts_softc[tsunit];

-       if (uio)
-               a = bdbtofsb(uio->uio_offset >> 9);
-       else
-               a = bdbtofsb(u.u_offset >> 9);
+       a = bdbtofsb(uio->uio_offset >> 9);

        sc->sc_blkno = a;
        sc->sc_nxrec = a + 1;
        return (0);
        sc->sc_blkno = a;
        sc->sc_nxrec = a + 1;
        return (0);

diff --git a/usr/src/sys/vax/vax/cons.c b/usr/src/sys/vax/vax/cons.c
index 8e7988a..aca50c4 100644 (file)
--- a/usr/src/sys/vax/vax/cons.c
+++ b/usr/src/sys/vax/vax/cons.c
@@ -1,4 +1,4 @@
-/*     cons.c  4.14    82/08/13        */
+/*     cons.c  4.15    82/08/22        */

 
 /*
  * Vax console driver and floppy interface
 
 /*
  * Vax console driver and floppy interface


@@ -68,13 +68,14 @@ struct uio *uio;
 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/

-cnwrite(dev)
-dev_t dev;
+cnwrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
        register struct tty *tp;
 
        tp = &cons;
 {
        register struct tty *tp;
 
        tp = &cons;

-       (*linesw[tp->t_line].l_write)(tp);
+       (*linesw[tp->t_line].l_write)(tp, uio);

 }
 
 /*
 }
 
 /*

diff --git a/usr/src/sys/vax/vax/flp.c b/usr/src/sys/vax/vax/flp.c
index b9d394d..963681a 100644 (file)
--- a/usr/src/sys/vax/vax/flp.c
+++ b/usr/src/sys/vax/vax/flp.c
@@ -1,4 +1,4 @@
-/*     flp.c   4.6     82/06/14        */
+/*     flp.c   4.7     82/08/22        */

 
 #if VAX780
 #include "../h/flp.h"
 
 #if VAX780
 #include "../h/flp.h"


@@ -11,6 +11,7 @@
 #include "../h/buf.h"
 #include "../h/cons.h"
 #include "../h/cpu.h"
 #include "../h/buf.h"
 #include "../h/cons.h"
 #include "../h/cpu.h"

+#include "../h/uio.h"

 
 struct {
        short   fl_state;               /* open and busy flags */
 
 struct {
        short   fl_state;               /* open and busy flags */


@@ -52,11 +53,12 @@ flclose(dev, flag)
        fltab.fl_state = 0;
 }
 
        fltab.fl_state = 0;
 }
 

-flstrategy(rw)
-       int rw;
+floperation(rw, uio)
+       enum uio_rw rw;
+       struct uio *uio;

 {
        register struct buf *bp;
 {
        register struct buf *bp;

-       register unsigned i;
+       register int i;

 
        /*
         * Assume one block read/written for each call - 
 
        /*
         * Assume one block read/written for each call - 


@@ -67,7 +69,7 @@ flstrategy(rw)
         *
         *      track# * (sectors/track) + sector #
         */
         *
         *      track# * (sectors/track) + sector #
         */

-       if (u.u_count == 0) 
+       if (uio->uio_resid == 0) 

                return;
        (void) spl4();
        while (fltab.fl_state & FL_BUSY)
                return;
        (void) spl4();
        while (fltab.fl_state & FL_BUSY)


@@ -76,20 +78,20 @@ flstrategy(rw)
        (void) spl0();
 
        bp = fltab.fl_buf;
        (void) spl0();
 
        bp = fltab.fl_buf;

-       while ((i = min(RXBYSEC, u.u_count)) != 0) {
-               bp->b_blkno = u.u_offset>>7;
-               if (bp->b_blkno >= MAXSEC || (u.u_offset & 0177) != 0) {
+       while ((i = imin(RXBYSEC, uio->uio_resid)) > 0) {
+               bp->b_blkno = uio->uio_offset>>7;
+               if (bp->b_blkno >= MAXSEC || (uio->uio_offset & 0177) != 0) {

                        /* block number out of range */
                        /* or offset in middle of block */
                        u.u_error = ENXIO;
                        break;  
                }
                        /* block number out of range */
                        /* or offset in middle of block */
                        u.u_error = ENXIO;
                        break;  
                }

-               if (rw == B_WRITE) {
-                       iomove(bp->b_un.b_addr, i, B_WRITE);
-                       if (u.u_error != 0)
+               if (rw == UIO_WRITE) {
+                       u.u_error = uiomove(bp->b_un.b_addr, i, UIO_WRITE, uio);
+                       if (u.u_error)

                                break;
                }
                                break;
                }

-               bp->b_flags = rw;
+               bp->b_flags = rw == UIO_WRITE ? B_WRITE : B_READ;

                (void) spl4(); 
                flstart();
                while ((bp->b_flags & B_DONE) == 0)
                (void) spl4(); 
                flstart();
                while ((bp->b_flags & B_DONE) == 0)


@@ -99,31 +101,32 @@ flstrategy(rw)
                        u.u_error = EIO;
                        break;
                }
                        u.u_error = EIO;
                        break;
                }

-               if (rw == B_READ) {
-                       iomove(bp->b_un.b_addr, i, B_READ);
-                       if (u.u_error != 0)
+               if (rw == UIO_READ) {
+                       u.u_error = uiomove(bp->b_un.b_addr, i, UIO_READ, uio);
+                       if (u.u_error)

                                break;
                }
        }
                                break;
                }
        }

-       u.u_count = bp->b_resid;

        fltab.fl_state &= ~FL_BUSY;
        wakeup((caddr_t)&fltab);
 }
 
 /*ARGSUSED*/
        fltab.fl_state &= ~FL_BUSY;
        wakeup((caddr_t)&fltab);
 }
 
 /*ARGSUSED*/

-flread(dev)
+flread(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
 
 {
 

-       flstrategy(B_READ);
+       floperation(UIO_READ, uio);

 }
 
 /*ARGSUSED*/
 }
 
 /*ARGSUSED*/

-flwrite(dev)
+flwrite(dev, uio)

        dev_t dev;
        dev_t dev;

+       struct uio *uio;

 {
 
 {
 

-       flstrategy(B_WRITE);
+       floperation(UIO_WRITE, uio);

 }
 
 flstart()
 }
 
 flstart()

diff --git a/usr/src/sys/vax/vax/mem.c b/usr/src/sys/vax/vax/mem.c
index 64af457..ef491a9 100644 (file)
--- a/usr/src/sys/vax/vax/mem.c
+++ b/usr/src/sys/vax/vax/mem.c
@@ -1,11 +1,7 @@
-/*     mem.c   4.3     81/03/09        */
+/*     mem.c   4.4     82/08/22        */

 
 /*
  * Memory special file
 
 /*
  * Memory special file

- *     minor device 0 is physical memory
- *     minor device 1 is kernel memory 
- *     minor device 2 is EOF/RATHOLE
- *     minor device 3 is unibus memory (addressed by shorts)

  */
 
 #include "../h/param.h"
  */
 
 #include "../h/param.h"


@@ -18,124 +14,101 @@
 #include "../h/mtpr.h"
 #include "../h/vm.h"
 #include "../h/cmap.h"
 #include "../h/mtpr.h"
 #include "../h/vm.h"
 #include "../h/cmap.h"

+#include "../h/uio.h"

 
 

-mmread(dev)
+mmread(dev, uio)
+       dev_t dev;
+       struct uio *uio;

 {
 {

-       register int o;
-       register unsigned c, v;
-
-       switch (minor(dev)) {

 
 

-       case 0:
-               while (u.u_count != 0 && u.u_error == 0) {
-                       if (fubyte(u.u_base) == -1)
-                               goto fault;
-                       v = btop(u.u_offset);
-                       if (v >= physmem)
-                               goto fault;
-                       *(int *)mmap = v | (PG_V | PG_KR);
-                       mtpr(TBIS, vmmap);
-                       o = (int)u.u_offset & PGOFSET;
-                       c = min((unsigned)(NBPG - o), u.u_count);
-                       c = min(c, (unsigned)(NBPG - ((int)u.u_base&PGOFSET)));
-                       if (copyout((caddr_t)&vmmap[o], u.u_base, c))
-                               goto fault;
-                       u.u_count -= c;
-                       u.u_base += c;
-                       u.u_offset += c;
-               }
-               return;
-
-       case 1:
-               if ((caddr_t)u.u_offset < (caddr_t)&umbabeg &&
-                   (caddr_t)u.u_offset + u.u_count >= (caddr_t)&umbabeg)
-                       goto fault;
-               if ((caddr_t)u.u_offset >= (caddr_t)&umbabeg &&
-                   (caddr_t)u.u_offset < (caddr_t)&umbaend)
-                       goto fault;
-               if (!kernacc((caddr_t)u.u_offset, u.u_count, B_READ))
-                       goto fault;
-               if (copyout((caddr_t)u.u_offset, u.u_base, u.u_count))
-                       goto fault;
-               c = u.u_count;
-               u.u_count = 0;
-               u.u_base += c;
-               u.u_offset += c;
-               return;
+       mmrw(dev, uio, UIO_READ);
+}

 
 

-       case 2:
-               return;
+mmwrite(dev, uio)
+       dev_t dev;
+       struct uio *uio;
+{

 
 

-       case 3:
-               if (!kernacc((caddr_t)u.u_offset, u.u_count, B_READ))
-                       goto fault;
-               if (!useracc(u.u_base, u.u_count, B_WRITE))
-                       goto fault;
-               UNIcpy((caddr_t)u.u_offset, u.u_base, u.u_count, B_READ);
-               c = u.u_count;
-               u.u_count = 0;
-               u.u_base += c;
-               u.u_offset += c;
-               return;
-       }
-fault:
-       u.u_error = EFAULT;
-       return;
+       mmrw(dev, uio, UIO_WRITE);

 }
 
 }
 

-mmwrite(dev)
+mmrw(dev, uio, rw)
+       dev_t dev;
+       struct uio *uio;
+       enum uio_rw rw;

 {
        register int o;
        register unsigned c, v;
 {
        register int o;
        register unsigned c, v;

+       register struct iovec *iov;

 
 

-       switch (minor(dev)) {
+       while (uio->uio_resid > 0 && u.u_error == 0) {
+               iov = uio->uio_iov;
+               if (iov->iov_len == 0) {
+                       uio->uio_iov++;
+                       uio->uio_iovcnt--;
+                       if (uio->uio_iovcnt < 0)
+                               panic("mmrw");
+                       continue;
+               }
+               switch (minor(dev)) {

 
 

-       case 0:
-               while (u.u_count != 0 && u.u_error == 0) {
-                       if (fubyte(u.u_base) == -1)
-                               goto fault;
-                       v = btop(u.u_offset);
+/* minor device 0 is physical memory */
+               case 0:
+                       v = btop(uio->uio_offset);

                        if (v >= physmem)
                                goto fault;
                        if (v >= physmem)
                                goto fault;

-                       *(int *)mmap = v | (PG_V | PG_KW);
+                       *(int *)mmap = v | (PG_V | PG_KR);

                        mtpr(TBIS, vmmap);
                        mtpr(TBIS, vmmap);

-                       o = (int)u.u_offset & PGOFSET;
-                       c = min((unsigned)(NBPG - o), u.u_count);
-                       c = min(c, (unsigned)(NBPG - ((int)u.u_base&PGOFSET)));
-                       if (copyin(u.u_base, (caddr_t)&vmmap[o], c))
+                       o = (int)uio->uio_offset & PGOFSET;
+                       c = min((unsigned)(NBPG - o), iov->iov_len);
+                       c = min(c, (unsigned)(NBPG - ((int)iov->iov_base&PGOFSET)));
+                       u.u_error = uiomove((caddr_t)&vmmap[o], c, rw, uio);
+                       if (u.u_error)

                                goto fault;
                                goto fault;

-                       u.u_count -= c;
-                       u.u_base += c;
-                       u.u_offset += c;
-               }
-               return;
+                       continue;

 
 

-       case 1:
-               if (!kernacc((caddr_t)u.u_offset, u.u_count, B_WRITE))
-                       goto fault;
-               if (copyin(u.u_base, (caddr_t)u.u_offset, u.u_count))
-                       goto fault;
-               u.u_base += u.u_count;
-               u.u_offset += u.u_count;
-               u.u_count = 0;
-               return;
+/* minor device 1 is kernel memory */
+               case 1:
+                       if ((caddr_t)uio->uio_offset < (caddr_t)&umbabeg &&
+                           (caddr_t)uio->uio_offset + uio->uio_resid >= (caddr_t)&umbabeg)
+                               goto fault;
+                       if ((caddr_t)uio->uio_offset >= (caddr_t)&umbabeg &&
+                           (caddr_t)uio->uio_offset < (caddr_t)&umbaend)
+                               goto fault;
+                       c = iov->iov_len;
+                       if (!kernacc((caddr_t)uio->uio_offset, c, rw == UIO_READ ? B_READ : B_WRITE))
+                               goto fault;
+                       u.u_error = uiomove((caddr_t)uio->uio_offset, c, rw, uio);
+                       if (u.u_error)
+                               goto fault;
+                       continue;

 
 

-       case 2:
-               u.u_offset += u.u_count;
-               u.u_count = 0;
-               return;
+/* minor device 2 is EOF/RATHOLE */
+               case 2:
+                       if (rw == UIO_READ)
+                               return;
+                       c = iov->iov_len;
+                       break;

 
 

-       case 3:
-               if (!kernacc((caddr_t)u.u_offset, u.u_count, B_WRITE))
-                       goto fault;
-               if (!useracc(u.u_base, u.u_count, B_READ))
+/* minor device 3 is unibus memory (addressed by shorts) */
+               case 3:
+                       c = iov->iov_len;
+                       if (!kernacc((caddr_t)uio->uio_offset, c, rw == UIO_READ ? B_READ : B_WRITE))
+                               goto fault;
+                       if (!useracc(iov->iov_base, c, rw == UIO_READ ? B_WRITE : B_READ))
+                               goto fault;
+                       UNIcpy((caddr_t)uio->uio_offset, iov->iov_base,
+                           c, rw);
+                       break;
+               }
+               if (u.u_error)

                        goto fault;
                        goto fault;

-               UNIcpy((caddr_t)u.u_offset, u.u_base, u.u_count, B_WRITE);
-               u.u_base += u.u_count;
-               u.u_offset += u.u_count;
-               u.u_count = 0;
-               return;
+               iov->iov_base += c;
+               iov->iov_len -= c;
+               uio->uio_offset += c;
+               uio->uio_resid -= c;

        }
        }

+       return;

 fault:
        u.u_error = EFAULT;
        return;
 fault:
        u.u_error = EFAULT;
        return;


@@ -144,20 +117,21 @@ fault:
 /*
  * UNIBUS Address Space <--> User Space transfer
  */
 /*
  * UNIBUS Address Space <--> User Space transfer
  */

-UNIcpy(uniadd, usradd, bknt, direct)
+UNIcpy(uniadd, usradd, cnt, rw)

        caddr_t uniadd, usradd;
        caddr_t uniadd, usradd;

-       unsigned bknt;
+       int cnt;
+       enum uio_rw rw;

 {
        register short *from, *to;
        register int i;
  
 {
        register short *from, *to;
        register int i;
  

-       if (direct == B_READ) {
-               from = (short *) uniadd;
-               to = (short *) usradd;
+       if (rw == UIO_READ) {
+               from = (short *)uniadd;
+               to = (short *)usradd;

        } else {
        } else {

-               from = (short *) usradd;
-               to = (short *) uniadd;
+               from = (short *)usradd;
+               to = (short *)uniadd;

        }
        }

-       for (i = (bknt>>1); i > 0; i--)
+       for (i = (cnt>>1); i > 0; i--)

                *to++ = *from++;
 }
                *to++ = *from++;
 }

diff --git a/usr/src/sys/vax/vax/tu.c b/usr/src/sys/vax/vax/tu.c
index b5a9c28..0590a99 100644 (file)
--- a/usr/src/sys/vax/vax/tu.c
+++ b/usr/src/sys/vax/vax/tu.c
@@ -1,4 +1,4 @@
-/*     tu.c    4.6     82/05/27        */
+/*     tu.c    4.7     82/08/22        */

 
 #if defined(VAX750) || defined(VAX730)
 /*
 
 #if defined(VAX750) || defined(VAX730)
 /*


@@ -30,7 +30,9 @@ int   tudebug;        /* printd */
 
 #define        NTU     ((cpu == VAX_750) ? 1 : 2)
 #define DNUM    01      /* mask for drive number (should match NTU) */
 
 #define        NTU     ((cpu == VAX_750) ? 1 : 2)
 #define DNUM    01      /* mask for drive number (should match NTU) */

+#ifndef MRSP

 #define        MRSP    (cpu != VAX_750)
 #define        MRSP    (cpu != VAX_750)

+#endif

 #define        NTUBLK  512             /* number of blocks on a TU58 cassette */
 #define WRV     02              /* bit in minor dev => write w. read verify */
 #define NTUQ    2               /* # of blocks which can be queued up */
 #define        NTUBLK  512             /* number of blocks on a TU58 cassette */
 #define WRV     02              /* bit in minor dev => write w. read verify */
 #define NTUQ    2               /* # of blocks which can be queued up */


@@ -67,36 +69,47 @@ struct packet tudata;               /* a command or data returned from TU58 */
  * State information
  */
 struct tu {
  * State information
  */
 struct tu {

-       u_char  *rbptr;         /* pointer to buffer for read */
-       int     rcnt;           /* how much to read */
-       u_char  *wbptr;         /* pointer to buffer for write */
-       int     wcnt;           /* how much to write */
-       int     state;          /* current state of tansfer operation */
-       int     flag;           /* read in progress flag */
-       char    *addr;          /* real buffer data address */
-       int     count;          /* real requested count */
-       int     serrs;          /* count of soft errors */
-       int     cerrs;          /* count of checksum errors */
-       int     herrs;          /* count of hard errors */
-       char    dopen[2];       /* drive is open */
+       u_char  *tu_rbptr;      /* pointer to buffer for read */
+       int     tu_rcnt;        /* how much to read */
+       u_char  *tu_wbptr;      /* pointer to buffer for write */
+       int     tu_wcnt;        /* how much to write */
+       int     tu_state;       /* current tu_state of tansfer operation */
+       int     tu_flag;        /* read in progress flag */
+       char    *tu_addr;       /* real buffer data address */
+       int     tu_count;       /* real requested count */
+       int     tu_serrs;       /* count of soft errors */
+       int     tu_cerrs;       /* count of checksum errors */
+       int     tu_herrs;       /* count of hard errors */
+       char    tu_dopen[2];    /* drive is open */

 } tu;
 
 /*
  * States
  */
 } tu;
 
 /*
  * States
  */

-#define        INIT1   0               /* sending nulls */
-#define        INIT2   1               /* sending inits */
-#define        IDLE    2               /* initialized, no transfer in progress */
-#define        SENDH   3               /* sending header */
-#define        SENDD   4               /* sending data */
-#define        SENDC   5               /* sending checksum */
-#define        SENDR   6               /* sending read command packet */
-#define        SENDW   7               /* sending write command packet */
-#define        GETH    8               /* reading header */
-#define        GETD    9               /* reading data */
-#define        GETC    10              /* reading checksum */
-#define        GET     11              /* reading an entire packet */
-#define        WAIT    12              /* waiting for continue */
+#define        TUS_INIT1       0       /* sending nulls */
+#define        TUS_INIT2       1       /* sending inits */
+#define        TUS_IDLE        2       /* initialized, no transfer in progress */
+#define        TUS_SENDH       3       /* sending header */
+#define        TUS_SENDD       4       /* sending data */
+#define        TUS_SENDC       5       /* sending checksum */
+#define        TUS_SENDR       6       /* sending read command packet */
+#define        TUS_SENDW       7       /* sending write command packet */
+#define        TUS_GETH        8       /* reading header */
+#define        TUS_GETD        9       /* reading data */
+#define        TUS_GETC        10      /* reading checksum */
+#define        TUS_GET         11      /* reading an entire packet */
+#define        TUS_WAIT        12      /* waiting for continue */
+
+#define        TUS_NSTATES     13
+char *tustates[TUS_NSTATES] = {
+       "INIT1", "INIT2", "IDLE", "SENDH", "SENDD", "SENDC", "SENDR",
+       "SENDW", "GETH", "GETD", "GETC", "GET", "WAIT"
+};
+#define        printstate(state) \
+       if ((state) < TUS_NSTATES) \
+               printf("%s", tustates[(state)]); \
+       else \
+               printf("%d", (state));

 
 /*
  * Packet Flags
 
 /*
  * Packet Flags


@@ -145,7 +158,7 @@ tuopen(dev, flag)
 #ifdef lint
        turintr(); tuwintr();
 #endif
 #ifdef lint
        turintr(); tuwintr();
 #endif

-       if ((minor(dev)&DNUM) >= NTU || tu.dopen[minor(dev)&DNUM]) {
+       if ((minor(dev)&DNUM) >= NTU || tu.tu_dopen[minor(dev)&DNUM]) {

                u.u_error = ENXIO;
                return;
        }
                u.u_error = ENXIO;
                return;
        }


@@ -153,22 +166,33 @@ tuopen(dev, flag)
                tutimer++;
                timeout(tuwatch, (caddr_t)0, hz);
        }
                tutimer++;
                timeout(tuwatch, (caddr_t)0, hz);
        }

-       tu.dopen[minor(dev)&DNUM]++;
+       tu.tu_dopen[minor(dev)&DNUM]++;

        s = splx(TUIPL);
        s = splx(TUIPL);

-       if (tu.state != IDLE) {
-               tureset();
-               sleep((caddr_t)&tu, PZERO+1);
-               tutab.b_active = NULL;
-               if (tu.state != IDLE) {         /* couldn't initialize */
-                       u.u_error = ENXIO;
-                       tu.state = INIT1;
-                       tu.dopen[minor(dev)&DNUM] = 0;
-                       tu.rcnt = tu.wcnt = 0;
-                       mtpr(CSTS, 0);
-                       mtpr(CSRS, 0);
-               }
-       } else
+       /*
+        * If the cassette's already initialized,
+        * just enable interrupts and return.
+        */
+       if (tu.tu_state == TUS_IDLE) {

                mtpr(CSRS, IE);
                mtpr(CSRS, IE);

+               splx(s);
+               return;
+       }
+
+       /* 
+        * Must initialize, reset the cassette
+        * and wait for things to settle down.
+        */
+       tureset();
+       sleep((caddr_t)&tu, PZERO+1);
+       tutab.b_active = NULL;
+       if (tu.tu_state != TUS_IDLE) {
+               u.u_error = ENXIO;
+               tu.tu_state = TUS_INIT1;
+               tu.tu_dopen[minor(dev)&DNUM] = 0;
+               tu.tu_rcnt = tu.tu_wcnt = 0;
+               mtpr(CSTS, 0);
+               mtpr(CSRS, 0);
+       }

        splx(s);
 }
 
        splx(s);
 }
 


@@ -182,13 +206,17 @@ tuclose(dev)
                mtpr(CSRS, 0);
                tutimer = 0;
        }
                mtpr(CSRS, 0);
                tutimer = 0;
        }

-       if (tu.serrs + tu.cerrs + tu.herrs != 0) {      /* any errors ? */
+       if (tu.tu_serrs + tu.tu_cerrs + tu.tu_herrs != 0) {
+               /*
+                * A tu58 is like nothing ever seen before;
+                * I guess this is appropriate then...
+                */

                uprintf(
                   "tu%d: %d soft errors, %d chksum errors, %d hard errors\n",
                uprintf(
                   "tu%d: %d soft errors, %d chksum errors, %d hard errors\n",

-                       minor(dev), tu.serrs, tu.cerrs, tu.herrs);
-               tu.serrs = tu.cerrs = tu.herrs = 0;
+                       minor(dev), tu.tu_serrs, tu.tu_cerrs, tu.tu_herrs);
+               tu.tu_serrs = tu.tu_cerrs = tu.tu_herrs = 0;

        }
        }

-       tu.dopen[minor(dev)&DNUM] = 0;
+       tu.tu_dopen[minor(dev)&DNUM] = 0;

 }
 
 /*
 }
 
 /*


@@ -197,11 +225,11 @@ tuclose(dev)
 tureset()
 {
 
 tureset()
 {
 

-       tu.state = INIT1;
-       tu.wbptr = tunull;
-       tu.wcnt = sizeof tunull;
+       tu.tu_state = TUS_INIT1;
+       tu.tu_wbptr = tunull;
+       tu.tu_wcnt = sizeof (tunull);

        tucmd.pk_flag = TUF_CMD;
        tucmd.pk_flag = TUF_CMD;

-       tucmd.pk_mcount = sizeof tucmd - 4;
+       tucmd.pk_mcount = sizeof (tucmd) - 4;

        tucmd.pk_mod = 0;
        tucmd.pk_seq = 0;
        tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;
        tucmd.pk_mod = 0;
        tucmd.pk_seq = 0;
        tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;


@@ -209,7 +237,6 @@ tureset()
        mtpr(CSRS, 0);
        mtpr(CSTS, IE|BREAK);
        tuxintr();              /* start output */
        mtpr(CSRS, 0);
        mtpr(CSTS, IE|BREAK);
        tuxintr();              /* start output */

-       return;

 }
 
 /*
 }
 
 /*


@@ -220,7 +247,7 @@ tustrategy(bp)
 {
        register int s;
 
 {
        register int s;
 

-       if (bp->b_blkno >= NTUBLK) {    /* block number out of range? */
+       if (bp->b_blkno >= NTUBLK) {

                bp->b_flags |= B_ERROR;
                iodone(bp);
                return;
                bp->b_flags |= B_ERROR;
                iodone(bp);
                return;


@@ -248,7 +275,7 @@ tustart()
 
        if ((bp = tutab.b_actf) == NULL)
                return;
 
        if ((bp = tutab.b_actf) == NULL)
                return;

-       if (tu.state != IDLE) {
+       if (tu.tu_state != TUS_IDLE) {

                tureset();
                return;
        }
                tureset();
                return;
        }


@@ -259,16 +286,16 @@ tustart()
            TUMD_WRV : 0;
        tucmd.pk_unit = (minor(bp->b_dev)&DNUM);
        tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;
            TUMD_WRV : 0;
        tucmd.pk_unit = (minor(bp->b_dev)&DNUM);
        tucmd.pk_sw = MRSP ? TUSW_MRSP : 0;

-       tucmd.pk_count = tu.count = bp->b_bcount;
+       tucmd.pk_count = tu.tu_count = bp->b_bcount;

        tucmd.pk_block = bp->b_blkno;
        tucmd.pk_chksum =
            tuchk(*((short *)&tucmd), (caddr_t)&tucmd.pk_op,
                (int)tucmd.pk_mcount);
        tucmd.pk_block = bp->b_blkno;
        tucmd.pk_chksum =
            tuchk(*((short *)&tucmd), (caddr_t)&tucmd.pk_op,
                (int)tucmd.pk_mcount);

-       tu.state = bp->b_flags&B_READ ? SENDR : SENDW;
-       tu.addr = bp->b_un.b_addr;
-       tu.count = bp->b_bcount;
-       tu.wbptr = (u_char *)&tucmd;
-       tu.wcnt = sizeof tucmd;
+       tu.tu_state = bp->b_flags&B_READ ? TUS_SENDR : TUS_SENDW;
+       tu.tu_addr = bp->b_un.b_addr;
+       tu.tu_count = bp->b_bcount;
+       tu.tu_wbptr = (u_char *)&tucmd;
+       tu.tu_wcnt = sizeof (tucmd);

        tuxintr();
 }
 
        tuxintr();
 }
 


@@ -286,103 +313,115 @@ turintr()
                        ;
                mtpr(CSTD, TUF_CONT);   /* ACK */
        }
                        ;
                mtpr(CSTD, TUF_CONT);   /* ACK */
        }

-       if (tu.rcnt) {                  /* still waiting for data? */
-               *tu.rbptr++ = c;        /* yup, put it there */
-               if (--tu.rcnt)          /* decrement count, any left? */
+       if (tu.tu_rcnt) {               /* still waiting for data? */
+               *tu.tu_rbptr++ = c;     /* yup, put it there */
+               if (--tu.tu_rcnt)       /* decrement count, any left? */

                        return;         /* get some more */
        }
 
        /*
         * We got all the data we were expecting for now,
                        return;         /* get some more */
        }
 
        /*
         * We got all the data we were expecting for now,

-        * switch on the state of the transfer.
+        * switch on the tu_state of the transfer.
+        */
+       switch(tu.tu_state) {
+
+       /*
+        * If we get an unexpected "continue",
+        * start all over again...

         */
         */

-       switch(tu.state) {
-
-       case INIT2:
-               if (c == TUF_CONT)      /* did we get the expected continue? */
-                       tu.state = IDLE;
-               else
-                       tu.state = INIT1;       /* bad news... */
-               tu.flag = 0;
+       case TUS_INIT2:
+               tu.tu_state = c == TUF_CONT ? TUS_IDLE : TUS_INIT1;
+               tu.tu_flag = 0;

                wakeup((caddr_t)&tu);
                tustart();
                break;
 
                wakeup((caddr_t)&tu);
                tustart();
                break;
 

-       case WAIT:                      /* waiting for continue */
+       /*
+        * Only transition from this state
+        * is on a "continue", so if we don't
+        * get it, reset the world.
+        */
+       case TUS_WAIT:                  /* waiting for continue */

                if (c != TUF_CONT) {
                if (c != TUF_CONT) {

-                       tu.state = INIT1;       /* bad news... */
+                       tu.tu_state = TUS_INIT1;

                        break;
                }
                        break;
                }

-               tu.flag = 0;
+               tu.tu_flag = 0;

                tudata.pk_flag = TUF_DATA;
                tudata.pk_flag = TUF_DATA;

-               tudata.pk_mcount = MIN(128, tu.count);
+               tudata.pk_mcount = MIN(128, tu.tu_count);

                tudata.pk_chksum =
                tudata.pk_chksum =

-                   tuchk(*((short *)&tudata), (caddr_t)tu.addr,
+                   tuchk(*((short *)&tudata), (caddr_t)tu.tu_addr,

                        (int)tudata.pk_mcount);
                        (int)tudata.pk_mcount);

-               tu.state = SENDH;
-               tu.wbptr = (u_char *)&tudata;
-               tu.wcnt = 2;
+               tu.tu_state = TUS_SENDH;
+               tu.tu_wbptr = (u_char *)&tudata;
+               tu.tu_wcnt = 2;

                tuxintr();
                break;
 
                tuxintr();
                break;
 

-       case SENDW:
-               if (c == TUF_CONT) {
-                       tureset();
-                       break;
-               } else
+       case TUS_SENDW:
+               if (c != TUF_CONT)

                        goto bad;
                        goto bad;

+               tureset();
+               break;

 
 

-       case GETH:              /* got header, get data */
-               if (tudata.pk_flag == TUF_DATA)         /* data message? */
-                       tu.rbptr = (u_char *)tu.addr;   /* yes put in buffer */
-               tu.rcnt = tudata.pk_mcount;             /* amount to get */
-               tu.state = GETD;
+       /*
+        * Got header, now get data; amount to
+        * fetch is include in packet.
+        */
+       case TUS_GETH:
+               if (tudata.pk_flag == TUF_DATA)
+                       tu.tu_rbptr = (u_char *)tu.tu_addr;
+               tu.tu_rcnt = tudata.pk_mcount;
+               tu.tu_state = TUS_GETD;

                break;
 
                break;
 

-       case GETD:              /* got data, get checksum */
-               tu.rbptr = (u_char *)&tudata.pk_chksum;
-               tu.rcnt = sizeof tudata.pk_chksum;
-               tu.state = GETC;
+       /*
+        * Got the data, now fetch the checksum.
+        */
+       case TUS_GETD:
+               tu.tu_rbptr = (u_char *)&tudata.pk_chksum;
+               tu.tu_rcnt = sizeof (tudata.pk_chksum);
+               tu.tu_state = TUS_GETC;

                break;
 
                break;
 

-       case GET:
-       case GETC:              /* got entire packet */
+       case TUS_GET:
+       case TUS_GETC:
+               /* got entire packet */

 #ifdef notdef
                if (tudata.pk_chksum !=
                    tuchk(*((short *)&tudata),
 #ifdef notdef
                if (tudata.pk_chksum !=
                    tuchk(*((short *)&tudata),

-                    tudata.pk_flag == TUF_DATA ? tu.addr : &tudata.pk_op,
+                    tudata.pk_flag == TUF_DATA ? tu.tu_addr : &tudata.pk_op,

                     (int)tudata.pk_mcount))
                     (int)tudata.pk_mcount))

-                       tu.cerrs++;
+                       tu.tu_cerrs++;

 #endif
                if (tudata.pk_flag == TUF_DATA) {
                        /* data packet, advance to next */
 #endif
                if (tudata.pk_flag == TUF_DATA) {
                        /* data packet, advance to next */

-                       tu.addr += tudata.pk_mcount;
-                       tu.count -= tudata.pk_mcount;
-                       tu.state = GETH;
-                       tu.rbptr = (u_char *)&tudata;   /* next packet */
-                       tu.rcnt = 2;
+                       tu.tu_addr += tudata.pk_mcount;
+                       tu.tu_count -= tudata.pk_mcount;
+                       tu.tu_state = TUS_GETH;
+                       tu.tu_rbptr = (u_char *)&tudata; /* next packet */
+                       tu.tu_rcnt = 2;

                } else if (tudata.pk_flag==TUF_CMD && tudata.pk_op==TUOP_END) {
                        /* end packet, idle and reenable transmitter */
                } else if (tudata.pk_flag==TUF_CMD && tudata.pk_op==TUOP_END) {
                        /* end packet, idle and reenable transmitter */

-                       tu.state = IDLE;
-                       tu.flag = 0;
+                       tu.tu_state = TUS_IDLE;
+                       tu.tu_flag = 0;

                        mtpr(CSTS, IE);
                        printd("ON ");
                        if ((bp = tutab.b_actf) == NULL) {
                        mtpr(CSTS, IE);
                        printd("ON ");
                        if ((bp = tutab.b_actf) == NULL) {

-                               printf("tu: no bp!\n");
-                               printf("active %d\n", tutab.b_active);
+                               printf("tu: no bp, active %d\n",tutab.b_active);

                                tustart();
                                return;
                        }
                        if (tudata.pk_mod > 1) {        /* hard error */
                                bp->b_flags |= B_ERROR;
                                tustart();
                                return;
                        }
                        if (tudata.pk_mod > 1) {        /* hard error */
                                bp->b_flags |= B_ERROR;

-                               tu.herrs++;
+                               tu.tu_herrs++;

                                harderr(bp, "tu");
                                printf("  pk_mod %o\n", tudata.pk_mod&0377);
                        } else if (tudata.pk_mod > 0)   /* soft error */
                                harderr(bp, "tu");
                                printf("  pk_mod %o\n", tudata.pk_mod&0377);
                        } else if (tudata.pk_mod > 0)   /* soft error */

-                               tu.serrs++;
+                               tu.tu_serrs++;

                        tutab.b_active = NULL;
                        tutab.b_actf = bp->av_forw;
                        tutab.b_active = NULL;
                        tutab.b_actf = bp->av_forw;

-                       bp->b_resid = tu.count;
+                       bp->b_resid = tu.tu_count;

                        if ((bp->b_flags&B_READ) == 0)
                                tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
                        iodone(bp);
                        if ((bp->b_flags&B_READ) == 0)
                                tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
                        iodone(bp);


@@ -391,19 +430,20 @@ turintr()
                        printf("neither data nor end: %o %o\n",
                            tudata.pk_flag&0xff, tudata.pk_op&0xff);
                        mtpr(CSRS, 0);          /* flush the rest */
                        printf("neither data nor end: %o %o\n",
                            tudata.pk_flag&0xff, tudata.pk_op&0xff);
                        mtpr(CSRS, 0);          /* flush the rest */

-                       tu.state = INIT1;
+                       tu.tu_state = TUS_INIT1;

                }
                break;
 
                }
                break;
 

-       case IDLE:
-       case INIT1:
+       case TUS_IDLE:
+       case TUS_INIT1:

                break;
 
                break;
 

-       bad:

        default:
        default:

+bad:

                if (c == TUF_INITF) {
                if (c == TUF_INITF) {

-                       printf("TU protocol error, state %d\n", tu.state);
-                       printf("%o %d %d\n",
+                       printf("tu protocol error, state=");
+                       printstate(tu.tu_state);
+                       printf(", op=%x, cnt=%d, block=%d\n",

                            tucmd.pk_op, tucmd.pk_count, tucmd.pk_block);
                        tutab.b_active = NULL;
                        if (bp = tutab.b_actf) {
                            tucmd.pk_op, tucmd.pk_count, tucmd.pk_block);
                        tutab.b_active = NULL;
                        if (bp = tutab.b_actf) {


@@ -413,10 +453,13 @@ turintr()
                                        tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
                                iodone(bp);
                        }
                                        tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
                                iodone(bp);
                        }

-                       tu.state = INIT1;
+                       tu.tu_state = TUS_INIT1;

                } else {
                } else {

-                       printf("TU receive state error %d %o\n", tu.state, c);
-               /*      tu.state = INIT1; */
+                       printf("tu receive state error, state=");
+                       printf(", byte=%x\n", c);
+#ifdef notdef
+                       tu.tu_state = TUS_INIT1; */
+#endif

                        wakeup((caddr_t)&tu);
                }
        }
                        wakeup((caddr_t)&tu);
                }
        }


@@ -429,89 +472,126 @@ tuxintr()
 {
 
 top:
 {
 
 top:

-       if (tu.wcnt) {
+       if (tu.tu_wcnt) {

                /* still stuff to send, send one byte */
                while ((mfpr(CSTS) & READY) == 0)
                        ;
                /* still stuff to send, send one byte */
                while ((mfpr(CSTS) & READY) == 0)
                        ;

-               mtpr(CSTD, *tu.wbptr++);
-               tu.wcnt--;
+               mtpr(CSTD, *tu.tu_wbptr++);
+               tu.tu_wcnt--;

                return;
        }
 
        /*
         * Last message byte was sent out.
                return;
        }
 
        /*
         * Last message byte was sent out.

-        * Switch on state of transfer.
+        * Switch on tu_state of transfer.

         */
         */

-       printd("tuxintr: state %d\n", tu.state);
-       switch(tu.state) {
+       if (tudebug) {
+               printf("tuxintr: state=");
+               printstate(tu.tu_state);
+       }
+       switch(tu.tu_state) {

 
 

-       case INIT1:             /* two nulls sent, remove break, send inits */
+       /*
+        * Two nulls have been sent, remove break, and send inits
+        */
+       case TUS_INIT1: 

                mtpr(CSTS, IE);
                printd("ON2 ");
                mtpr(CSTS, IE);
                printd("ON2 ");

-               tu.state = INIT2;
-               tu.wbptr = tuinit;
-               tu.wcnt = sizeof tuinit;
+               tu.tu_state = TUS_INIT2;
+               tu.tu_wbptr = tuinit;
+               tu.tu_wcnt = sizeof (tuinit);

                goto top;
 
                goto top;
 

-       case INIT2:             /* inits sent, wait for continue */
+       /*
+        * Inits have been sent, wait for a continue msg.
+        */
+       case TUS_INIT2: 

                (void) mfpr(CSRD);
                mtpr(CSRS, IE);
                (void) mfpr(CSRD);
                mtpr(CSRS, IE);

-               tu.flag = 1;
+               tu.tu_flag = 1;

                break;
 
                break;
 

-       case IDLE:              /* stray interrupt? */
+       case TUS_IDLE:          /* stray interrupt? */

                break;
 
                break;
 

-       case SENDR:             /* read cmd packet sent, get ready for data */
-               tu.state = GETH;
-               tu.rbptr = (u_char *)&tudata;
-               tu.rcnt = 2;
-               tu.flag = 1;
+       /*
+        * Read cmd packet sent, get ready for data
+        */
+       case TUS_SENDR:
+               tu.tu_state = TUS_GETH;
+               tu.tu_rbptr = (u_char *)&tudata;
+               tu.tu_rcnt = 2;
+               tu.tu_flag = 1;

                mtpr(CSTS, 0);  /* disable transmitter interrupts */
                printd("OFF ");
                break;
 
                mtpr(CSTS, 0);  /* disable transmitter interrupts */
                printd("OFF ");
                break;
 

-       case SENDW:             /* write cmd packet sent, wait for continue */
-               tu.state = WAIT;
-               tu.flag = 1;
+       /*
+        * Write cmd packet sent, wait for continue
+        */
+       case TUS_SENDW: 
+               tu.tu_state = TUS_WAIT;
+               tu.tu_flag = 1;

                if ((mfpr(CSRS)&IE) == 0) {
                        printf("NO IE\n");
                        mtpr(CSRS, IE);
                }
                break;
 
                if ((mfpr(CSRS)&IE) == 0) {
                        printf("NO IE\n");
                        mtpr(CSRS, IE);
                }
                break;
 

-       case SENDH:             /* header sent, send data */
-               tu.state = SENDD;
-               tu.wbptr = (u_char *)tu.addr;
-               tu.wcnt = tudata.pk_mcount;
+       /*
+        * Header sent, send data.
+        */
+       case TUS_SENDH:
+               tu.tu_state = TUS_SENDD;
+               tu.tu_wbptr = (u_char *)tu.tu_addr;
+               tu.tu_wcnt = tudata.pk_mcount;

                goto top;
 
                goto top;
 

-       case SENDD:             /* data sent, send checksum */
-               tu.state = SENDC;
-               tu.wbptr = (u_char *)&tudata.pk_chksum;
-               tu.wcnt = sizeof tudata.pk_chksum;
+       /*
+        * Data sent, follow with checksum.
+        */
+       case TUS_SENDD: 
+               tu.tu_state = TUS_SENDC;
+               tu.tu_wbptr = (u_char *)&tudata.pk_chksum;
+               tu.tu_wcnt = sizeof tudata.pk_chksum;

                goto top;
 
                goto top;
 

-       case SENDC:             /* checksum sent, wait for continue */
-               tu.addr += tudata.pk_mcount;    /* update buffer address */
-               tu.count -= tudata.pk_mcount;   /* and count */
-               if (tu.count == 0) {            /* all done? */
-                       tu.state = GET;         /* set up to get end packet */
-                       tu.rbptr = (u_char *)&tudata;
-                       tu.rcnt = sizeof tudata;
-                       tu.flag = 1;
-                       mtpr(CSTS, 0);
-                       printd("OFF2 ");
-               } else {
-                       tu.state = WAIT;        /* wait for continue */
-                       tu.flag = 1;
+       /* 
+        * Checksum sent, wait for continue.
+        */
+       case TUS_SENDC:
+               /*
+                * Updata buffer address and count.
+                */
+               tu.tu_addr += tudata.pk_mcount;
+               tu.tu_count -= tudata.pk_mcount;
+               if (tu.tu_count) {
+                       tu.tu_state = TUS_WAIT;
+                       tu.tu_flag = 1;
+                       break;

                }
                }

+
+               /*
+                * End of transmission, get ready for end packet.
+                */
+               tu.tu_state = TUS_GET;
+               tu.tu_rbptr = (u_char *)&tudata;
+               tu.tu_rcnt = sizeof (tudata);
+               tu.tu_flag = 1;
+               mtpr(CSTS, 0);
+               printd("OFF2 ");

                break;
 
                break;
 

-       default:        /* random interrupt, probably from MRSP ACK */
+       /*
+        * Random interrupt, probably from MRSP ACK
+        */
+       default:

                break;
        }
                break;
        }

-       printd("  new state %d\n", tu.state);
+       if (tudebug) {
+               printd("  new tu_state=");
+               printstate(tu.tu_state);
+       }

 }
 
 /*
 }
 
 /*


@@ -560,59 +640,63 @@ tuwatch()
        register struct buf *bp;
 
        if (tutimer == 0) {
        register struct buf *bp;
 
        if (tutimer == 0) {

-               tu.flag = 0;
+               tu.tu_flag = 0;

                return;
        }
                return;
        }

-       if (tu.flag)
-               tu.flag++;
-       if (tu.flag > 40) {
-               printf("tu: read stalled\n");
-               printf("%X %X %X %X %X %X %X %X\n", tu.rbptr, tu.rcnt,
-               tu.wbptr, tu.wcnt, tu.state, tu.flag, tu.addr, tu.count);
-               tu.flag = 0;
-               s = splx(TUIPL);
-               (void) mfpr(CSRD);
-               mtpr(CSRS, IE);         /* in case we were flushing */
-               mtpr(CSTS, IE);
-               tu.state = IDLE;
-               if (tutab.b_active) {
-                       if (++tutab.b_errcnt > 1) {
-                               if (bp = tutab.b_actf) {
-                                       bp->b_flags |= B_ERROR;
-                                       if ((bp->b_flags&B_READ) == 0)
-                                               tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
-                                       iodone(bp);
-                               }
-                       } else
-                               tustart();
-               } else
-                       wakeup((caddr_t)&tu);
-               splx(s);
+       if (tu.tu_flag)
+               tu.tu_flag++;
+       if (tu.tu_flag <= 40) {
+               timeout(tuwatch, (caddr_t)0, hz);
+               return;
+       }
+       printf("tu: read stalled\n");
+       printf("%X %X %X %X %X %X %X %X\n", tu.tu_rbptr, tu.tu_rcnt,
+               tu.tu_wbptr, tu.tu_wcnt, tu.tu_state, tu.tu_flag,
+               tu.tu_addr, tu.tu_count);
+       tu.tu_flag = 0;
+       s = splx(TUIPL);
+       (void) mfpr(CSRD);
+       mtpr(CSRS, IE);         /* in case we were flushing */
+       mtpr(CSTS, IE);
+       tu.tu_state = TUS_IDLE;
+       if (!tutab.b_active) {
+               wakeup((caddr_t)&tu);
+               goto retry;

        }
        }

+       if (++tutab.b_errcnt <= 1) {
+               tustart();
+               goto retry;
+       }
+       if (bp = tutab.b_actf) {
+               bp->b_flags |= B_ERROR;
+               if ((bp->b_flags&B_READ) == 0)
+                       tu_vee(&pcnt[minor(bp->b_dev)&DNUM]);
+               iodone(bp);
+       }
+retry:
+       splx(s);

        timeout(tuwatch, (caddr_t)0, hz);
 }
 
 tu_pee(cp)
        timeout(tuwatch, (caddr_t)0, hz);
 }
 
 tu_pee(cp)

-char *cp;
+       char *cp;

 {
        register int s;
 
        s = splx(TUIPL);
 {
        register int s;
 
        s = splx(TUIPL);

-       if (++(*cp) > NTUQ) {
+       if (++(*cp) > NTUQ)

                sleep(cp, PRIBIO);
                sleep(cp, PRIBIO);

-       }

        splx(s);
 }
 
 tu_vee(cp)
        splx(s);
 }
 
 tu_vee(cp)

-char *cp;
+       char *cp;

 {
        register int s;
 
        s = splx(TUIPL);
 {
        register int s;
 
        s = splx(TUIPL);

-       if (--(*cp) <= NTUQ) {
+       if (--(*cp) <= NTUQ)

                wakeup(cp);
                wakeup(cp);

-       }

        splx(s);
 }
 #endif
        splx(s);
 }
 #endif