spelling sn%d not bn%d

[unix-history] / usr / src / sys / vax / mba / hp.c

diff --git a/usr/src/sys/vax/mba/hp.c b/usr/src/sys/vax/mba/hp.c
index 9e25ff1..8fd8113 100644 (file)
--- a/usr/src/sys/vax/mba/hp.c
+++ b/usr/src/sys/vax/mba/hp.c
@@ -1,9 +1,16 @@
-/*     hp.c    4.8     81/02/10        */
+/*     hp.c    4.23    81/03/06        */

 
 #include "hp.h"
 #if NHP > 0
 /*
 
 #include "hp.h"
 #if NHP > 0
 /*

- * RP/RM disk driver
+ * HP disk driver for RP0x+RM0x
+ *
+ * TODO:
+ *     Check RM80 skip sector handling, esp when ECC's occur later
+ *     Add reading of bad sector information and disk layout from sector 1
+ *     Add bad sector forwarding code
+ *     Check interaction with tape driver on same mba
+ *     Check multiple drive handling

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


@@ -91,14 +98,13 @@ struct hpst {
        31,     14,     31*14,  559,    rm80_sizes      /* RM80 */
 };
 
        31,     14,     31*14,  559,    rm80_sizes      /* RM80 */
 };
 

-int    hp_offset[16] = {
-       P400, M400, P400, M400,
-       P800, M800, P800, M800,
-       P1200, M1200, P1200, M1200,
-       0, 0, 0, 0,
+u_char hp_offset[16] = {
+    HP_P400, HP_M400, HP_P400, HP_M400, HP_P800, HP_M800, HP_P800, HP_M800,
+    HP_P1200, HP_M1200, HP_P1200, HP_M1200, 0, 0, 0, 0,

 };
 
 };
 

-struct buf     rhpbuf;
+struct buf     rhpbuf[NHP];
+char   hprecal[NHP];

 
 #define        b_cylin b_resid
  
 
 #define        b_cylin b_resid
  


@@ -106,6 +112,17 @@ struct     buf     rhpbuf;
 daddr_t dkblock();
 #endif
  
 daddr_t dkblock();
 #endif
  

+int    hpseek;
+
+hpdkinit(mi)
+       struct mba_info *mi;
+{
+       register struct hpst *st = &hpst[mi->mi_type];
+
+       if (mi->mi_dk >= 0)
+               dk_mspw[mi->mi_dk] = 1.0 / 60 / (st->nsect * 256);
+}
+

 hpstrategy(bp)
        register struct buf *bp;
 {
 hpstrategy(bp)
        register struct buf *bp;
 {


@@ -144,45 +161,42 @@ bad:
 hpustart(mi)
        register struct mba_info *mi;
 {
 hpustart(mi)
        register struct mba_info *mi;
 {

-       register struct device *hpaddr = (struct device *)mi->mi_drv;
+       register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;

        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st;
        daddr_t bn;
        int sn, dist, flags;
 
        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st;
        daddr_t bn;
        int sn, dist, flags;
 

-       if ((hpaddr->hpcs1&DVA) == 0)
+       if ((hpaddr->hpcs1&HP_DVA) == 0)

                return (MBU_BUSY);
                return (MBU_BUSY);

-       if ((hpaddr->hpds & VV) == 0) {
-               hpaddr->hpcs1 = DCLR|GO;
-               hpaddr->hpcs1 = PRESET|GO;
-               hpaddr->hpof = FMT22;
+       if ((hpaddr->hpds & HP_VV) == 0) {
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;
+               hpaddr->hpcs1 = HP_PRESET|HP_GO;
+               hpaddr->hpof = HP_FMT22;

        }
        }

-       if (mi->mi_tab.b_active)
-               return (MBU_DODATA);
-       if ((hpaddr->hpds & (DPR|MOL)) != (DPR|MOL))
+       if (mi->mi_tab.b_active || mi->mi_hd->mh_ndrive == 1)

                return (MBU_DODATA);
                return (MBU_DODATA);

-       if (flags&MH_NOSEEK)
+       if ((hpaddr->hpds & (HP_DPR|HP_MOL)) != (HP_DPR|HP_MOL))

                return (MBU_DODATA);
                return (MBU_DODATA);

-       hpaddr->hpdc = bp->b_cylin;

        st = &hpst[mi->mi_type];
        bn = dkblock(bp);
        sn = bn%st->nspc;
        sn = (sn+st->nsect-hpSDIST)%st->nsect;
        st = &hpst[mi->mi_type];
        bn = dkblock(bp);
        sn = bn%st->nspc;
        sn = (sn+st->nsect-hpSDIST)%st->nsect;

-       flags = mi->mi_hd->mh_flags;

        if (bp->b_cylin == (hpaddr->hpdc & 0xffff)) {
        if (bp->b_cylin == (hpaddr->hpdc & 0xffff)) {

-               if (flags&MH_NOSEARCH)
+               if (hpseek)

                        return (MBU_DODATA);
                dist = ((hpaddr->hpla & 0xffff)>>6) - st->nsect + 1;
                if (dist < 0)
                        dist += st->nsect;
                if (dist > st->nsect - hpRDIST)
                        return (MBU_DODATA);
                        return (MBU_DODATA);
                dist = ((hpaddr->hpla & 0xffff)>>6) - st->nsect + 1;
                if (dist < 0)
                        dist += st->nsect;
                if (dist > st->nsect - hpRDIST)
                        return (MBU_DODATA);

-       }
-       if (flags&MH_NOSEARCH)
-               hpaddr->hpcs1 = SEEK|GO;
+       } else
+               hpaddr->hpdc = bp->b_cylin;
+       if (hpseek)
+               hpaddr->hpcs1 = HP_SEEK|HP_GO;

        else {
                hpaddr->hpda = sn;
        else {
                hpaddr->hpda = sn;

-               hpaddr->hpcs1 = SEARCH|GO;
+               hpaddr->hpcs1 = HP_SEARCH|HP_GO;

        }
        return (MBU_STARTED);
 }
        }
        return (MBU_STARTED);
 }


@@ -190,7 +204,7 @@ hpustart(mi)
 hpstart(mi)
        register struct mba_info *mi;
 {
 hpstart(mi)
        register struct mba_info *mi;
 {

-       register struct device *hpaddr = (struct device *)mi->mi_drv;
+       register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;

        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st = &hpst[mi->mi_type];
        daddr_t bn;
        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st = &hpst[mi->mi_type];
        daddr_t bn;


@@ -201,9 +215,9 @@ hpstart(mi)
        tn = sn/st->nsect;
        sn %= st->nsect;
        if (mi->mi_tab.b_errcnt >= 16 && (bp->b_flags&B_READ) != 0) {
        tn = sn/st->nsect;
        sn %= st->nsect;
        if (mi->mi_tab.b_errcnt >= 16 && (bp->b_flags&B_READ) != 0) {

-               hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017] | FMT22;
-               hpaddr->hpcs1 = OFFSET|GO;
-               while (hpaddr->hpds & PIP)
+               hpaddr->hpof = hp_offset[mi->mi_tab.b_errcnt & 017] | HP_FMT22;
+               hpaddr->hpcs1 = HP_OFFSET|HP_GO;
+               while (hpaddr->hpds & HP_PIP)

                        ;
                mbclrattn(mi);
        }
                        ;
                mbclrattn(mi);
        }


@@ -211,60 +225,91 @@ hpstart(mi)
        hpaddr->hpda = (tn << 8) + sn;
 }
 
        hpaddr->hpda = (tn << 8) + sn;
 }
 

-hpdtint(mi, mbastat)
+hpdtint(mi, mbasr)

        register struct mba_info *mi;
        register struct mba_info *mi;

-       int mbastat;
+       int mbasr;

 {
 {

-       register struct device *hpaddr = (struct device *)mi->mi_drv;
+       register struct hpdevice *hpaddr = (struct hpdevice *)mi->mi_drv;

        register struct buf *bp = mi->mi_tab.b_actf;
        register struct buf *bp = mi->mi_tab.b_actf;

+       int retry = 0;

 
 

-       while ((hpaddr->hpds & DRY) == 0)       /* shouldn't happen */
-               printf("hp dry not set\n");
-       if (hpaddr->hpds & ERR || mbastat & MBAEBITS)
-               if (++mi->mi_tab.b_errcnt < 28 && (hpaddr->hper1&WLE) == 0) {
-                       if ((hpaddr->hper1&0xffff) != DCK) {
-                               hpaddr->hpcs1 = DCLR|GO;
-                               if ((mi->mi_tab.b_errcnt&07) == 4) {
-                                       hpaddr->hpcs1 = RECAL|GO;
-                                       while (hpaddr->hpds & PIP)
-                                               ;
-                                       mbclrattn(mi);
-                               }
-                               return (MBD_RETRY);
-                       } else if (hpecc(mi))
-                               return (MBD_RESTARTED);
-               } else {
-                       deverror(bp, mbastat, hpaddr->hper1);
+       if (hpaddr->hpds&HP_ERR || mbasr&MBAEBITS) {
+               if (hpaddr->hper1&HP_WLE) {
+                       printf("hp%d: write locked\n", dkunit(bp));
+                       bp->b_flags |= B_ERROR;
+               } else if (++mi->mi_tab.b_errcnt > 27 ||
+                   mbasr & MBASR_HARD ||
+                   hpaddr->hper1 & HPER1_HARD ||
+                   hpaddr->hper2 & HPER2_HARD) {
+                       harderr(bp, "hp");
+                       printf("mbasr=%b er1=%b er2=%b\n",
+                           mbasr, mbasr_bits,
+                           hpaddr->hper1, HPER1_BITS,
+                           hpaddr->hper2, HPER2_BITS);

                        bp->b_flags |= B_ERROR;
                        bp->b_flags |= B_ERROR;

+#ifdef notdef
+               } else if (hpaddr->hper2&HP_SSE) {
+                       hpecc(mi, 1);
+                       return (MBD_RESTARTED);
+#endif
+               } else if ((hpaddr->hper1&(HP_DCK|HP_ECH)) == HP_DCK) {
+                       if (hpecc(mi, 0))
+                               return (MBD_RESTARTED);
+                       /* else done */
+               } else
+                       retry = 1;
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;
+               if ((mi->mi_tab.b_errcnt&07) == 4) {
+                       hpaddr->hpcs1 = HP_RECAL|HP_GO;
+                       hprecal[mi->mi_unit] = 1;
+                       return (MBD_RESTARTED);

                }
                }

+               if (retry)
+                       return (MBD_RETRY);
+       }
+       if (hprecal[mi->mi_unit]) {
+               hprecal[mi->mi_unit] = 0;
+               return (MBD_RETRY);
+       }

        bp->b_resid = -(mi->mi_mba->mba_bcr) & 0xffff;
        bp->b_resid = -(mi->mi_mba->mba_bcr) & 0xffff;

-       if (mi->mi_tab.b_errcnt) {
-               hpaddr->hpcs1 = RTC|GO;
-               while (hpaddr->hpds & PIP)
+       if (mi->mi_tab.b_errcnt > 16) {
+               hpaddr->hpcs1 = HP_RTC|HP_GO;
+               while (hpaddr->hpds & HP_PIP)

                        ;
                mbclrattn(mi);
        }
                        ;
                mbclrattn(mi);
        }

-       hpaddr->hpcs1 = RELEASE|GO;
+       hpaddr->hpcs1 = HP_RELEASE|HP_GO;

        return (MBD_DONE);
 }
 
 hpread(dev)
        return (MBD_DONE);
 }
 
 hpread(dev)

+       dev_t dev;

 {
 {

+       register int unit = minor(dev) >> 3;

 
 

-       physio(hpstrategy, &rhpbuf, dev, B_READ, minphys);
+       if (unit >= NHP)
+               u.u_error = ENXIO;
+       else
+               physio(hpstrategy, &rhpbuf[unit], dev, B_READ, minphys);

 }
 
 hpwrite(dev)
 }
 
 hpwrite(dev)

+       dev_t dev;

 {
 {

+       register int unit = minor(dev) >> 3;

 
 

-       physio(hpstrategy, &rhpbuf, dev, B_WRITE, minphys);
+       if (unit >= NHP)
+               u.u_error = ENXIO;
+       else
+               physio(hpstrategy, &rhpbuf[unit], dev, B_WRITE, minphys);

 }
 
 }
 

-hpecc(mi)
+hpecc(mi, rm80sse)

        register struct mba_info *mi;
        register struct mba_info *mi;

+       int rm80sse;

 {
        register struct mba_regs *mbp = mi->mi_mba;
 {
        register struct mba_regs *mbp = mi->mi_mba;

-       register struct device *rp = (struct device *)mi->mi_drv;
+       register struct hpdevice *rp = (struct hpdevice *)mi->mi_drv;

        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st;
        register int i;
        register struct buf *bp = mi->mi_tab.b_actf;
        register struct hpst *st;
        register int i;


@@ -274,42 +319,26 @@ hpecc(mi)
        struct pte mpte;
        int bcr;
 
        struct pte mpte;
        int bcr;
 

-       /*
-        * Npf is the number of sectors transferred before the sector
-        * containing the ECC error, and reg is the MBA register
-        * mapping (the first part of)the transfer.
-        * O is offset within a memory page of the first byte transferred.
-        */

        bcr = mbp->mba_bcr & 0xffff;
        if (bcr)
                bcr |= 0xffff0000;              /* sxt */
        npf = btop(bcr + bp->b_bcount) - 1;
        reg = npf;
        bcr = mbp->mba_bcr & 0xffff;
        if (bcr)
                bcr |= 0xffff0000;              /* sxt */
        npf = btop(bcr + bp->b_bcount) - 1;
        reg = npf;

+#ifdef notdef
+       if (rm80sse) {
+               rp->hpof |= HP_SSEI;
+               reg--;          /* compensate in advance for reg-- below */
+               goto sse;
+       }
+#endif

        o = (int)bp->b_un.b_addr & PGOFSET;
        o = (int)bp->b_un.b_addr & PGOFSET;

-       printf("%D ", bp->b_blkno + npf);
-       prdev("ECC", bp->b_dev);
+       printf("hp%d%c: soft ecc sn%d\n", dkunit(bp),
+           'a'+(minor(bp->b_dev)&07), bp->b_blkno + npf);

        mask = rp->hpec2&0xffff;
        mask = rp->hpec2&0xffff;

-       if (mask == 0) {
-               rp->hpof = FMT22;
-               return (0);
-       }
-
-       /*
-        * Compute the byte and bit position of the error.
-        * The variable i is the byte offset in the transfer,
-        * the variable byte is the offset from a page boundary
-        * in main memory.
-        */

        i = (rp->hpec1&0xffff) - 1;             /* -1 makes 0 origin */
        bit = i&07;
        i = (i&~07)>>3;
        byte = i + o;
        i = (rp->hpec1&0xffff) - 1;             /* -1 makes 0 origin */
        bit = i&07;
        i = (i&~07)>>3;
        byte = i + o;

-       /*
-        * Correct while possible bits remain of mask.  Since mask
-        * contains 11 bits, we continue while the bit offset is > -11.
-        * Also watch out for end of this block and the end of the whole
-        * transfer.
-        */

        while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
                mpte = mbp->mba_map[reg+btop(byte)];
                addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET);
        while (i < 512 && (int)ptob(npf)+i < bp->b_bcount && bit > -11) {
                mpte = mbp->mba_map[reg+btop(byte)];
                addr = ptob(mpte.pg_pfnum) + (byte & PGOFSET);


@@ -318,16 +347,17 @@ hpecc(mi)
                i++;
                bit -= 8;
        }
                i++;
                bit -= 8;
        }

-       mi->mi_hd->mh_active++;         /* Either complete or continuing */

        if (bcr == 0)
                return (0);
        if (bcr == 0)
                return (0);

-       /*
-        * Have to continue the transfer... clear the drive,
-        * and compute the position where the transfer is to continue.
-        * We have completed npf+1 sectores of the transfer already;
-        * restart at offset o of next sector (i.e. in MBA register reg+1).
-        */
-       rp->hpcs1 = DCLR|GO;
+#ifdef notdef
+sse:
+       if (rpof&HP_SSEI)
+               rp->hpda = rp->hpda + 1;
+       rp->hper1 = 0;
+       rp->hpcs1 = HP_RCOM|HP_GO;
+#else
+sse:
+       rp->hpcs1 = HP_DCLR|HP_GO;

        bn = dkblock(bp);
        st = &hpst[mi->mi_type];
        cn = bp->b_cylin;
        bn = dkblock(bp);
        st = &hpst[mi->mi_type];
        cn = bp->b_cylin;


@@ -336,11 +366,16 @@ hpecc(mi)
        sn %= st->nsect;
        cn += tn/st->ntrak;
        tn %= st->ntrak;
        sn %= st->nsect;
        cn += tn/st->ntrak;
        tn %= st->ntrak;

+#ifdef notdef
+       if (rp->hpof&SSEI)
+               sn++;
+#endif

        rp->hpdc = cn;
        rp->hpda = (tn<<8) + sn;
        mbp->mba_sr = -1;
        mbp->mba_var = (int)ptob(reg+1) + o;
        rp->hpdc = cn;
        rp->hpda = (tn<<8) + sn;
        mbp->mba_sr = -1;
        mbp->mba_var = (int)ptob(reg+1) + o;

-       rp->hpcs1 = RCOM|GO;
+       rp->hpcs1 = HP_RCOM|HP_GO;
+#endif

        return (1);
 }
 
        return (1);
 }
 


@@ -351,7 +386,7 @@ hpdump(dev)
 {
        register struct mba_info *mi;
        register struct mba_regs *mba;
 {
        register struct mba_info *mi;
        register struct mba_regs *mba;

-       struct device *hpaddr;
+       struct hpdevice *hpaddr;

        char *start;
        int num, unit;
        register struct hpst *st;
        char *start;
        int num, unit;
        register struct hpst *st;


@@ -359,29 +394,23 @@ hpdump(dev)
        num = maxfree;
        start = 0;
        unit = minor(dev) >> 3;
        num = maxfree;
        start = 0;
        unit = minor(dev) >> 3;

-       if (unit >= NHP) {
-               printf("bad unit\n");
-               return (-1);
-       }
+       if (unit >= NHP)
+               return (ENXIO);

 #define        phys(a,b)       ((b)((int)(a)&0x7fffffff))
        mi = phys(hpinfo[unit],struct mba_info *);
 #define        phys(a,b)       ((b)((int)(a)&0x7fffffff))
        mi = phys(hpinfo[unit],struct mba_info *);

-       if (mi->mi_alive == 0) {
-               printf("dna\n");
-               return (-1);
-       }
+       if (mi == 0 || mi->mi_alive == 0)
+               return (ENXIO);

        mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
        mba->mba_cr = MBAINIT;
        mba = phys(mi->mi_hd, struct mba_hd *)->mh_physmba;
        mba->mba_cr = MBAINIT;

-       hpaddr = (struct device *)&mba->mba_drv[mi->mi_drive];
-       if ((hpaddr->hpds & VV) == 0) {
-               hpaddr->hpcs1 = DCLR|GO;
-               hpaddr->hpcs1 = PRESET|GO;
-               hpaddr->hpof = FMT22;
+       hpaddr = (struct hpdevice *)&mba->mba_drv[mi->mi_drive];
+       if ((hpaddr->hpds & HP_VV) == 0) {
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;
+               hpaddr->hpcs1 = HP_PRESET|HP_GO;
+               hpaddr->hpof = HP_FMT22;

        }
        st = &hpst[mi->mi_type];
        }
        st = &hpst[mi->mi_type];

-       if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks) {
-               printf("oor\n");
-               return (-1);
-       }
+       if (dumplo < 0 || dumplo + num >= st->sizes[minor(dev)&07].nblocks)
+               return (EINVAL);

        while (num > 0) {
                register struct pte *hpte = mba->mba_map;
                register int i;
        while (num > 0) {
                register struct pte *hpte = mba->mba_map;
                register int i;


@@ -401,22 +430,14 @@ hpdump(dev)
                mba->mba_sr = -1;
                mba->mba_bcr = -(blk*NBPG);
                mba->mba_var = 0;
                mba->mba_sr = -1;
                mba->mba_bcr = -(blk*NBPG);
                mba->mba_var = 0;

-               hpaddr->hpcs1 = WCOM | GO;
-               while ((hpaddr->hpds & DRY) == 0)
+               hpaddr->hpcs1 = HP_WCOM | HP_GO;
+               while ((hpaddr->hpds & HP_DRY) == 0)

                        ;
                        ;

-               if (hpaddr->hpds&ERR) {
-                       printf("dskerr: (%d,%d,%d) ds=%x er=%x\n",
-                           cn, tn, sn, hpaddr->hpds, hpaddr->hper1);
-                       return (-1);
-               }
+               if (hpaddr->hpds&HP_ERR)
+                       return (EIO);

                start += blk*NBPG;
                num -= blk;
        }
        return (0);
 }
                start += blk*NBPG;
                num -= blk;
        }
        return (0);
 }

-
-hpdkinit()
-{
-       /* I don't really care what this does .. kre */
-}

 #endif
 #endif