projects / unix-history / blobdiff
? search:
summary | tags | clone url | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
need to omit qv/qd from bootxx's
[unix-history] / usr / src / sys / vax / stand / hp.c
diff --git a/usr/src/sys/vax/stand/hp.c b/usr/src/sys/vax/stand/hp.c
index ebecd72..d8d4297 100644 (file)
--- a/usr/src/sys/vax/stand/hp.c
+++ b/usr/src/sys/vax/stand/hp.c
@@ -1,501 +1,572 @@
-/*     hp.c    4.1     83/01/16        */
-
 /*
 /*
- * RP??/RM?? disk driver
- * with ECC handling and bad block forwarding.
- * Also supports header io operations and
- * commands to write check header and data.
+ * Copyright (c) 1982, 1986 Regents of the University of California.
+ * All rights reserved.  The Berkeley software License Agreement
+ * specifies the terms and conditions for redistribution.
+ *
+ *     @(#)hp.c        7.9 (Berkeley) %G%
  */
 
  */
 
-#include "../h/param.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/dkbad.h"
+/*
+ * RP??/RM?? disk driver with ECC handling and bad block forwarding.
+ * Also supports header io operations and commands to write check
+ * header and data.
+ */
+#include "param.h"
+#include "inode.h"
+#include "fs.h"
+#include "dkbad.h"
+#include "disklabel.h"
 
 #include "../vax/pte.h"
 
 #include "../vax/pte.h"
+
 #include "../vaxmba/hpreg.h"
 #include "../vaxmba/mbareg.h"
 
 #include "saio.h"
 #include "savax.h"
 
 #include "../vaxmba/hpreg.h"
 #include "../vaxmba/mbareg.h"
 
 #include "saio.h"
 #include "savax.h"
 
+#define        RETRIES         27
+
 #define        MASKREG(reg)    ((reg)&0xffff)
 
 #define        MASKREG(reg)    ((reg)&0xffff)
 
-#define MAXBADDESC     126
-#define SECTSIZ        512     /* sector size in bytes */
-#define HDRSIZ         4       /* number of bytes in sector header */
-#define MAXECC         5       /* the maximum number of bad bits accepted in
-                                * an ecc error when F_ECCLM is set */
-
-char   hp_type[MAXNMBA*8] = { 0 };
-
-/* THIS SHOULD BE READ IN OFF THE PACK, PER DRIVE */
-short  hp6_off[8] =    { 0, 38, 0, -1, -1, -1, 118, -1 };
-short  rm3_off[8] =    { 0, 100, 0, -1, -1, -1, 310, -1 };
-short  rm5_off[8] =    { 0, 27, 0, 562, 589, 681, 562, 82 };
-short  rm80_off[8] =   { 0, 37, 0, -1, -1, -1, 115, 305 };
-short  hp7_off[8] =    { 0, 10, 0, 330, 340, 500, 330, 50 };
-short  ml_off[8] =     { 0, -1, -1, -1, -1, -1, -1, -1 };
-short  si9775_off[8] = { 0, 13, 0, -1, -1, -1, 40, 441 };
-short  si9730_off[8] = { 0, 50, 0, -1, -1, -1, -1, 155 };
-short  hpam_off[8] =   { 0, 32, 0, 668, 723, 778, 668, 98 };
-/* END SHOULD BE READ IN */
-
-short  hptypes[] =
-    { MBDT_RM03, MBDT_RM05, MBDT_RP06, MBDT_RM80, MBDT_RP05, MBDT_RP07,
-      MBDT_ML11A, MBDT_ML11B, -1/*9755*/, -1/*9730*/, -1/*Capr*/, MBDT_RM02, 0};
-
-#define RP06 (hptypes[UNITTODRIVE(unit)] <= MBDT_RP06)
-#define ML11 (hptypes[UNITTODRIVE(unit)] <= MBDT_ML11A)
-#define RM80 (hptypes[UNITTODRIVE(unit)] <= MBDT_RM80)
+#define        MAXBADDESC      126
+#define        SECTSIZ         512     /* sector size in bytes */
+#define        HDRSIZ          4       /* number of bytes in sector header */
+
+char   lbuf[SECTSIZ];
+
+#define        RP06(type) ((type) == MBDT_RP06 || (type) == MBDT_RP05 \
+       || (type) == MBDT_RP04)
+#define        ML11(type) ((type) == MBDT_ML11A)
+#define        RM80(type) ((type) == MBDT_RM80)
 
 u_char hp_offset[16] = {
 
 u_char hp_offset[16] = {
-    HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
-    HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
-    HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
-    0, 0, 0, 0,
+       HPOF_P400, HPOF_M400, HPOF_P400, HPOF_M400,
+       HPOF_P800, HPOF_M800, HPOF_P800, HPOF_M800,
+       HPOF_P1200, HPOF_M1200, HPOF_P1200, HPOF_M1200,
+       0, 0, 0, 0,
 };
 
 };
 
-struct hpst {
-       short   nsect;
-       short   ntrak;
-       short   nspc;
-       short   ncyl;
-       short   *off;
-} hpst[] = {
-       32,     5,      32*5,   823,    rm3_off,        /* RM03 */
-       32,     19,     32*19,  823,    rm5_off,        /* RM05 */
-       22,     19,     22*19,  815,    hp6_off,        /* RP06 */
-       31,     14,     31*14,  559,    rm80_off,       /* RM80 */
-       22,     19,     22*19,  411,    hp6_off,        /* RP06 */
-       50,     32,     50*32,  630,    hp7_off,        /* RP07 */
-       1,      1,      1,      1,      ml_off,         /* ML11A */
-       1,      1,      1,      1,      ml_off,         /* ML11B */
-       32,     40,     32*40,  843,    si9775_off,     /* 9775 */
-       32,     10,     32*10,  823,    si9730_off,     /* 9730 */
-       32,     16,     32*16,  1024,   hpam_off,       /* AMPEX capricorn */
-       1,      1,      1,      1,      0,              /* rm02 - not used */
-};
-struct dkbad hpbad[MAXNMBA*8];
-int sectsiz;
+#define        MAXUNIT         8
+struct disklabel hplabel[MAXNMBA][MAXUNIT];
+#ifndef SMALL
+struct dkbad hpbad[MAXNMBA][MAXUNIT];
+int    sectsiz;
+#endif
+
+struct hp_softc {
+       char    type;
+       char    gottype;
+       char    ssect;                  /* 1 when on track w/skip sector */
+       char    debug;
+#      define  HPF_BSEDEBUG    01      /* debugging bad sector forwarding */
+#      define  HPF_ECCDEBUG    02      /* debugging ecc correction */
+       int     ecclim;
+       int     retries;
+} hp_softc[MAXNMBA][MAXUNIT];
+
+/*
+ * When awaiting command completion, don't hang on to the status register
+ * since this ties up some controllers.
+ */
+#define        HPWAIT(addr) \
+       while ((((addr)->hpds)&HPDS_DRY) == 0) \
+               DELAY(500);
 
 hpopen(io)
        register struct iob *io;
 {
        register unit = io->i_unit;
 
 hpopen(io)
        register struct iob *io;
 {
        register unit = io->i_unit;
-       struct hpdevice *hpaddr = (struct hpdevice *)mbadrv(unit);
-       register struct hpst *st;
-
-       mbainit(UNITTOMBA(unit));
-       if (hp_type[unit] == 0) {
-               register type = hpaddr->hpdt & MBDT_TYPE;
+       register struct hp_softc *sc;
+       register struct disklabel *lp;
+       struct hpdevice *hpaddr;
+       struct disklabel *dlp;
+       int error = 0;
+
+       if ((u_int)io->i_adapt >= MAXNMBA || !mbainit(io->i_adapt))
+               return (EADAPT);
+       if ((u_int)io->i_ctlr)
+               return (ECTLR);
+       if ((u_int)unit >= MAXUNIT)
+               return (EUNIT);
+       hpaddr = (struct hpdevice *)mbadrv(io->i_adapt, unit);
+       sc = &hp_softc[io->i_adapt][unit];
+       lp = &hplabel[io->i_adapt][unit];
+       if (sc->gottype == 0) {
                register int i;
                struct iob tio;
 
                register int i;
                struct iob tio;
 
-               for (i = 0; hptypes[i]; i++)
-                       if (hptypes[i] == type)
-                               goto found;
-               _stop("unknown drive type");
-found:
-               switch (i) {
-               case 0: case 1: {       /* rm03 or rm05 */
-                       register hpsn = hpaddr->hpsn;
-
-                       if ((hpsn & SIMB_LU) != unit)
-                               break;
-                       switch ((hpsn & SIMB_MB) &~ (SIMB_S6|SIRM03|SIRM05)) {
-                       case SI9775D:
-                               i = 8;  /* si9775 */
-                               break;
-                       case SI9730D:
-                               i = 9;  /* si9730 */
-                               break;
-                       case SI9766:
-                               i = 1;  /* rm05 */
-                               hpaddr->hpcs1 = HP_RECAL|HP_GO;
-                               DELAY(100000);
-                               break;
-                       case SI9762:
-                               i = 0;  /* rm03 */
-                               break;
-                       }
-                       break;
-               }
-
-               case 11:                /* rm02 */
-                       hpaddr->hpcs1 = HP_NOP;
-                       hpaddr->hphr = HPHR_MAXTRAK;
-                       if (MASKREG(hpaddr->hphr) == 15)
-                               i = 10;         /* ampex capricorn */
-                       else
-                               i = 0;          /* rm03 */
-                       break;
-               
-               case 6: case 7:         /* ml11a ml11b */
-                       i = 6;                  /* ml11a */
-                       break;
-               }
-               hp_type[unit] = i;
+#ifndef SMALL
+               sc->retries = RETRIES;
+               sc->ecclim = 11;
+               sc->debug = 0;
+#endif
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;          /* init drive */
+               hpaddr->hpcs1 = HP_PRESET|HP_GO;
+#ifndef SMALL
+               if ((hpaddr->hpds & HPDS_DPR) == 0)
+                       return (ENXIO);
+               sc->type = hpaddr->hpdt & MBDT_TYPE;
+               if (sc->type == MBDT_ML11B)
+                       sc->type = MBDT_ML11A;
+               if (!ML11(sc->type))
+#endif
+                       hpaddr->hpof = HPOF_FMT22;
                /*
                /*
-                * Read in the bad sector table:
-                *      copy the contents of the io structure
-                *      to tio for use during the bb pointer
-                *      read operation.
+                * Read in the pack label.
                 */
                 */
-               st = &hpst[hp_type[unit]];
+               lp->d_nsectors = 32;
+               lp->d_secpercyl = 20*32;
                tio = *io;
                tio = *io;
-               tio.i_bn = st->nspc * st->ncyl - st->nsect;
-               tio.i_ma = (char *)&hpbad[tio.i_unit];
-               tio.i_cc = sizeof (hpbad);
+               tio.i_bn = LABELSECTOR;
+               tio.i_ma = lbuf;
+               tio.i_cc = SECTSIZ;
                tio.i_flgs |= F_RDDATA;
                tio.i_flgs |= F_RDDATA;
+               if (hpstrategy(&tio, READ) != SECTSIZ)
+                       error = ERDLAB;
+               dlp = (struct disklabel *)(lbuf + LABELOFFSET);
+               if (error == 0 && (dlp->d_magic != DISKMAGIC ||
+                   dlp->d_magic2 != DISKMAGIC))
+                       error = EUNLAB;
+               if (error == 0)
+                       *lp = *dlp;
+               else
+#ifdef COMPAT_42
+                   if (hpmaptype(hpaddr, hpaddr->hpdt & MBDT_TYPE, unit, lp) == 0)
+#endif
+                       return (error);
+
+#ifndef SMALL
+               /*
+                * Read in the bad sector table.
+                */
+               tio.i_bn = lp->d_secpercyl * lp->d_ncylinders - lp->d_nsectors;
+               tio.i_ma = (char *)&hpbad[io->i_adapt][unit];
+               tio.i_cc = sizeof(struct dkbad);
                for (i = 0; i < 5; i++) {
                for (i = 0; i < 5; i++) {
-                       if (hpstrategy(&tio, READ) == sizeof (hpbad))
+                       if (hpstrategy(&tio, READ) == sizeof(struct dkbad))
                                break;
                        tio.i_bn += 2;
                }
                if (i == 5) {
                                break;
                        tio.i_bn += 2;
                }
                if (i == 5) {
-                       printf("Unable to read bad sector table\n");
+                       printf("hp: can't read bad sector table\n");
                        for (i = 0; i < MAXBADDESC; i++) {
                        for (i = 0; i < MAXBADDESC; i++) {
-                               hpbad[unit].bt_bad[i].bt_cyl = -1;
-                               hpbad[unit].bt_bad[i].bt_trksec = -1;
+                               hpbad[io->i_adapt][unit].bt_bad[i].bt_cyl = -1;
+                               hpbad[io->i_adapt][unit].bt_bad[i].bt_trksec = -1;
                        }
                        }
-               }       
+               }
+#endif
+               sc->gottype = 1;
        }
        }
-       if (io->i_boff < 0 || io->i_boff > 7 ||
-           st->off[io->i_boff]== -1)
-               _stop("hp bad minor");
-       io->i_boff = st->off[io->i_boff] * st->nspc;
+       if (io->i_part >= lp->d_npartitions ||
+           lp->d_partitions[io->i_part].p_size == 0)
+               return (EPART);
+       io->i_boff = lp->d_partitions[io->i_part].p_offset;
+       return (0);
 }
 
 hpstrategy(io, func)
        register struct iob *io;
 {
 }
 
 hpstrategy(io, func)
        register struct iob *io;
 {
-       register unit = io->i_unit;
-       struct mba_regs *mba = mbamba(unit);
-       daddr_t bn;
-       struct hpdevice *hpaddr = (struct hpdevice *)mbadrv(unit);
-       struct hpst *st = &hpst[hp_type[unit]];
-       int cn, tn, sn, bytecnt, bytesleft; 
-       daddr_t startblock;
-       char *membase;
+       register int unit = io->i_unit;
+       register struct hp_softc *sc;
+       register struct disklabel *lp;
+       struct mba_regs *mba;
+       struct hpdevice *hpaddr;
+       daddr_t bn, startblock;
+       int cn, tn, sn, bytecnt, bytesleft, rv;
        int er1, er2, hprecal;
        int er1, er2, hprecal;
+       char *membase;
 
 
+       mba = mbamba(io->i_adapt);
+       hpaddr = (struct hpdevice *)mbadrv(io->i_adapt, unit);
+       sc = &hp_softc[io->i_adapt][unit];
+       lp = &hplabel[io->i_adapt][unit];
+#ifndef SMALL
        sectsiz = SECTSIZ;
        if ((io->i_flgs & (F_HDR|F_HCHECK)) != 0)
                sectsiz += HDRSIZ;
        if ((hpaddr->hpds & HPDS_VV) == 0) {
                hpaddr->hpcs1 = HP_DCLR|HP_GO;
                hpaddr->hpcs1 = HP_PRESET|HP_GO;
        sectsiz = SECTSIZ;
        if ((io->i_flgs & (F_HDR|F_HCHECK)) != 0)
                sectsiz += HDRSIZ;
        if ((hpaddr->hpds & HPDS_VV) == 0) {
                hpaddr->hpcs1 = HP_DCLR|HP_GO;
                hpaddr->hpcs1 = HP_PRESET|HP_GO;
-               if (hp_type[unit] != 6)         /* any but ml11 */
+               if (!ML11(sc->type))
                        hpaddr->hpof = HPOF_FMT22;
        }
        io->i_errcnt = 0;
                        hpaddr->hpof = HPOF_FMT22;
        }
        io->i_errcnt = 0;
-       bytecnt = io->i_cc;
+       sc->ssect = 0;
+       rv = bytecnt = io->i_cc;
        membase = io->i_ma;
        startblock = io->i_bn;
        membase = io->i_ma;
        startblock = io->i_bn;
-       hprecal = 1;
-readmore:
+       hprecal = 0;
+#endif
+
+restart:
        bn = io->i_bn;
        bn = io->i_bn;
-       cn = bn/st->nspc;
-       sn = bn%st->nspc;
-       tn = sn/st->nsect;
-       sn = sn%st->nsect;
-
-       while ((hpaddr->hpds & HPDS_DRY) == 0)
-               ;
-       if (hp_type[unit] == 6)         /* ml11 */
+       cn = bn / lp->d_secpercyl;
+       sn = bn % lp->d_secpercyl;
+       tn = sn / lp->d_nsectors;
+       sn = sn % lp->d_nsectors + sc->ssect;
+
+       HPWAIT(hpaddr);
+       mba->mba_sr = -1;
+       if (ML11(sc->type))
                hpaddr->hpda = bn;
        else {
                hpaddr->hpdc = cn;
                hpaddr->hpda = (tn << 8) + sn;
        }
                hpaddr->hpda = bn;
        else {
                hpaddr->hpdc = cn;
                hpaddr->hpda = (tn << 8) + sn;
        }
-       if (mbastart(io, func) != 0)            /* start transfer */
+#ifdef SMALL
+       mbastart(io, io->i_unit, func);         /* start transfer */
+       HPWAIT(hpaddr);
+       if (hpaddr->hpds & HPDS_ERR) {
+               printf("hp error: sn [%d-%d) ds=%b er1=%b\n",
+                   bn, bn + io->i_cc/SECTSIZ, MASKREG(hpaddr->hpds), HPDS_BITS,
+                   MASKREG(hpaddr->hper1), HPER1_BITS);
                return (-1);
                return (-1);
-
-       while ((hpaddr->hpds & HPDS_DRY) == 0)
-               ;
-       if (((hpaddr->hpds&HPDS_ERR) | (mba->mba_sr&MBSR_EBITS)) == 0 )
-               return(bytecnt);
-
-       /* ------- error handling ------- */
-
-       if (bytesleft = MASKREG(mba->mba_bcr>>16)) 
-               bytesleft |= 0xffff0000;        /* sign ext */
-       bn = io->i_bn + (io->i_cc + bytesleft)/sectsiz;
-       cn = bn/st->nspc;
-       sn = bn%st->nspc;
-       tn = sn/st->nsect;
-       sn = sn%st->nsect;
+       }
+       return (io->i_cc);
+#else
+       if (mbastart(io, io->i_unit, func) != 0) {      /* start transfer */
+               rv = -1;
+               goto done;
+       }
+       HPWAIT(hpaddr);
+       /*
+        * Successful data transfer, return.
+        */
+       if ((hpaddr->hpds&HPDS_ERR) == 0 && (mba->mba_sr&MBSR_EBITS) == 0)
+               goto done;
+
+       /*
+        * Error handling.  Calculate location of error.
+        */
+       bytesleft = MASKREG(mba->mba_bcr);
+       if (bytesleft) 
+               bytesleft |= 0xffff0000;        /* sxt */
+       bn = io->i_bn + (io->i_cc + bytesleft) / sectsiz;
        er1 = MASKREG(hpaddr->hper1);
        er2 = MASKREG(hpaddr->hper2);
        er1 = MASKREG(hpaddr->hper1);
        er2 = MASKREG(hpaddr->hper2);
-#ifdef HPDEBUG
-       printf("hp error: (cyl,trk,sec)=(%d,%d,%d) ds=%b \n",
-               cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
-       printf("er1=%b er2=%b",
-               er1, HPER1_BITS,
-               er2, HPER2_BITS);
-       printf("\n");
-#endif
+       if (er1 & (HPER1_DCK|HPER1_ECH))
+               bn--;   /* Error is in Prev block */
+       cn = bn/lp->d_secpercyl;
+       sn = bn%lp->d_secpercyl;
+       tn = sn/lp->d_nsectors;
+       sn = sn%lp->d_nsectors;
+       if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG)) {
+               printf("hp error: sn%d (cyl,trk,sec)=(%d,%d,%d) ds=%b\n",
+                       bn, cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
+               printf("er1=%b er2=%b\n", er1, HPER1_BITS, er2, HPER2_BITS);
+               printf("bytes left: %d, of 0x%x, da 0x%x\n",-bytesleft,
+                       hpaddr->hpof, hpaddr->hpda);
+       }
        if (er1 & HPER1_HCRC) {
                er1 &= ~(HPER1_HCE|HPER1_FER);
                er2 &= ~HPER2_BSE;
        if (er1 & HPER1_HCRC) {
                er1 &= ~(HPER1_HCE|HPER1_FER);
                er2 &= ~HPER2_BSE;
+               if ((io->i_flgs&F_NBSF) == 0 && hpecc(io, BSE) == 0)
+                       goto success;
        }
        }
+       /*
+        * Give up early if drive write locked.
+        */
        if (er1&HPER1_WLE) {
                printf("hp%d: write locked\n", unit);
        if (er1&HPER1_WLE) {
                printf("hp%d: write locked\n", unit);
-               return(-1);
-       } else if ((er1&0xffff) == HPER1_FER && RP06) {
-               goto badsect;
-
-       } else if (++io->i_errcnt > 27 ||
-                  er1 & HPER1_HARD ||
-                  (!ML11 && (er2 & HPER2_HARD))) {
-               io->i_error = EHER;
-               if ((mba->mba_sr & (MBSR_WCKUP | MBSR_WCKLWR)) != 0)
-                       io->i_error = EWCK;
-hard:
-               io->i_errblk = bn;
-               printf("hp error: (cyl,trk,sec)=(%d,%d,%d) ds=%b \n",
-                          cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
-               printf("er1=%b er2=%b",
-                          er1, HPER1_BITS,
-                          er2, HPER2_BITS);
-               if (hpaddr->hpmr)
-                       printf(" mr=%o", hpaddr->hpmr&0xffff);
-               if (hpaddr->hpmr2)
-                       printf(" mr2=%o", hpaddr->hpmr2&0xffff);
-               printf("\n");
-               return(-1);
-
-       } else if ((er2 & HPER2_BSE) && !ML11) {
-badsect:
-               if ((io->i_flgs & F_NBSF) != 0) {
-                       io->i_error = EBSE;     
+               rv = -1;
+               goto done;
+       }
+       /*
+        * Skip sector handling.
+        */
+       if (RM80(sc->type) && (er2 & HPER2_SSE)) {
+               (void) hpecc(io, SSE);
+               sc->ssect = 1;
+               goto restart;
+       }
+       /*
+        * Attempt to forward bad sectors on anything but an ML11.
+        * Interpret format error bit as a bad block on RP06's.
+        */
+       if (((er2 & HPER2_BSE) && !ML11(sc->type)) ||
+           (MASKREG(er1) == HPER1_FER && RP06(sc->type))) {
+               if (io->i_flgs & F_NBSF) {
+                       io->i_error = EBSE;
                        goto hard;
                }
                if (hpecc(io, BSE) == 0)
                        goto success;
                        goto hard;
                }
                if (hpecc(io, BSE) == 0)
                        goto success;
-               else {
-                       io->i_error = EBSE;
-                       goto hard;
-               }
-       } else if (RM80 && er2&HPER2_SSE) {
-       /* skip sector error */
-               (void) hpecc(io, SSE);
-               goto success;
-       } else if ((er1&(HPER1_DCK|HPER1_ECH))==HPER1_DCK) {
-               if ( hpecc(io, ECC) == 0)
+               io->i_error = EBSE;
+               goto hard;
+       }
+       /*
+        * ECC correction?
+        */
+       if ((er1 & (HPER1_DCK|HPER1_ECH)) == HPER1_DCK) {
+               if (hpecc(io, ECC) == 0)
                        goto success;
                        goto success;
+               io->i_error = EECC;
+               goto hard;
+       } 
+
+       /*
+        * If a hard error, or maximum retry count
+        * exceeded, clear controller state and
+        * pass back error to caller.
+        */
+       if (++io->i_errcnt > sc->retries || (er1 & HPER1_HARD) ||
+           (!ML11(sc->type) && (er2 & HPER2_HARD)) ||
+           (ML11(sc->type) && (io->i_errcnt >= 16))) {
+               io->i_error = EHER;
+               if (mba->mba_sr & (MBSR_WCKUP|MBSR_WCKLWR))
+                       io->i_error = EWCK;
+hard:
+               io->i_errblk = bn + sc->ssect;
+               if (sc->debug & (HPF_BSEDEBUG|HPF_ECCDEBUG))
+                   printf(" dc=%d, da=0x%x",MASKREG(hpaddr->hpdc),
+                         MASKREG(hpaddr->hpda));
                else {
                else {
-                       io->i_error = EECC;
-                       return(1);      
+                   printf("hp error: sn%d (cyl,trk,sec)=(%d,%d,%d) ds=%b \n",
+                          bn, cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
+                   printf("er1=%b er2=%b", er1, HPER1_BITS, er2, HPER2_BITS);
                }
                }
-       } else
-               io->i_active = 0;               /* force retry */
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;
+               printf("\n");
+               rv = -1;
+               goto done;
 
 
-       hpaddr->hpcs1 = HP_DCLR|HP_GO;
-       while ((hpaddr->hpds & HPDS_DRY) == 0)
-               ;
-       if (ML11) {
-               if (io->i_errcnt >= 16)
-                       goto hard;
-       } else if (((io->i_errcnt&07) == 4) && (io->i_active == 0)) {
-               hpaddr->hpcs1 = HP_RECAL|HP_GO;
-               hprecal = 0;
-               goto nextrecal;
        }
        }
-       switch (hprecal) {
+       /* fall thru to retry */
+       hpaddr->hpcs1 = HP_DCLR|HP_GO;
+       HPWAIT(hpaddr);
 
 
-       case 1:
+       /* 
+        * Every fourth retry recalibrate.
+        */
+       if (((io->i_errcnt & 07) == 4) ) {
+               hpaddr->hpcs1 = HP_RECAL|HP_GO;
+               HPWAIT(hpaddr);
                hpaddr->hpdc = cn;
                hpaddr->hpcs1 = HP_SEEK|HP_GO;
                hpaddr->hpdc = cn;
                hpaddr->hpcs1 = HP_SEEK|HP_GO;
-               goto nextrecal;
-       case 2:
-               if (io->i_errcnt < 16 || (func & READ) == 0)
-                       goto donerecal;
+               HPWAIT(hpaddr);
+       }
+
+       if (io->i_errcnt >= 16 && (io->i_flgs & F_READ)) {
                hpaddr->hpof = hp_offset[io->i_errcnt & 017]|HPOF_FMT22;
                hpaddr->hpcs1 = HP_OFFSET|HP_GO;
                hpaddr->hpof = hp_offset[io->i_errcnt & 017]|HPOF_FMT22;
                hpaddr->hpcs1 = HP_OFFSET|HP_GO;
-nextrecal:
-               hprecal++;
-               io->i_active = 1;
-               goto try_again;
-       donerecal:
-       case 3:
-               hprecal = 0;
-               io->i_active = 0;
-               goto try_again;
+               HPWAIT(hpaddr);
        }
        }
-       if (io->i_active) {
-               if (io->i_errcnt >= 16) {
-                       hpaddr->hpcs1 = HP_RTC|HP_GO;
-                       while (hpaddr->hpds & HPDS_PIP)
-                               ;
-               }
-       }
-success:                /* continue with the next block */
+       if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG))
+               printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n",
+                 io->i_bn, io->i_cc, io->i_ma, hprecal);
+       goto restart;
+
+success:
+       /*
+        * On successful error recovery, bump
+        * block number to advance to next portion
+        * of i/o transfer.
+        */
        bn++;
        if ((bn-startblock) * sectsiz < bytecnt) {
        bn++;
        if ((bn-startblock) * sectsiz < bytecnt) {
-
-try_again:             /* re-read same block */
                io->i_bn = bn;
                io->i_bn = bn;
-               mba->mba_sr = -1;
                io->i_ma = membase + (io->i_bn - startblock)*sectsiz;
                io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz;
                io->i_ma = membase + (io->i_bn - startblock)*sectsiz;
                io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz;
-#ifdef HPDEBUG
-               printf("restart: bl %d, byte %d, mem 0x%x %d\n",
-                       io->i_bn, io->i_cc, io->i_ma, io->i_ma);
-#endif
-               goto readmore;
+               if (sc->debug & (HPF_ECCDEBUG|HPF_BSEDEBUG))
+                       printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n",
+                         io->i_bn, io->i_cc, io->i_ma, hprecal);
+               goto restart;
+       }
+done:
+       if (io->i_errcnt >= 16) {
+               hpaddr->hpcs1 = HP_RTC|HP_GO;
+               while (hpaddr->hpds & HPDS_PIP)
+                       ;
        }
        }
-       return (bytecnt);
+       io->i_bn = startblock;          /*reset i_bn to original */
+       io->i_cc = bytecnt;             /*reset i_cc to total count xfered*/
+       io->i_ma = membase;             /*reset i_ma to original */
+       return (rv);
+#endif
 }
 }
+
+#ifndef SMALL
 hpecc(io, flag)
        register struct iob *io;
        int flag;
 {
 hpecc(io, flag)
        register struct iob *io;
        int flag;
 {
-       register unit = io->i_unit;
-       register struct mba_regs *mbp = mbamba(unit);
-       register struct hpdevice *rp = (struct hpdevice *)mbadrv(unit);
-       register struct hpst *st = &hpst[hp_type[unit]];
-       int npf;
-       int bn, cn, tn, sn;
-       int bcr, tad;
-
-       if (bcr = MASKREG(mbp->mba_bcr>>16))
+       register int unit = io->i_unit;
+       register struct mba_regs *mbp;
+       register struct hpdevice *rp;
+       register struct hp_softc *sc;
+       register struct disklabel *lp;
+       int npf, bn, cn, tn, sn, bcr;
+
+       mbp = mbamba(io->i_adapt);
+       rp = (struct hpdevice *)mbadrv(io->i_adapt, unit);
+       sc = &hp_softc[io->i_adapt][unit];
+       lp = &hplabel[io->i_adapt][unit];
+       bcr = MASKREG(mbp->mba_bcr);
+       if (bcr)
                bcr |= 0xffff0000;              /* sxt */
                bcr |= 0xffff0000;              /* sxt */
-       npf = (bcr + io->i_cc)/sectsiz;         /* number of sectors read */
-       switch (flag) {
-       case ECC:
-               {
+       npf = (bcr + io->i_cc) / sectsiz;       /* # sectors read */
+       if (flag == ECC)
+               npf--;          /* Error is in prev block --ghg */
+       bn = io->i_bn + npf + sc->ssect;        /* physical block #*/
+       if (sc->debug & HPF_ECCDEBUG)
+               printf("bcr=%d npf=%d ssect=%d sectsiz=%d i_cc=%d\n",
+                       bcr, npf, sc->ssect, sectsiz, io->i_cc);
+       /*
+        * ECC correction logic.
+        */
+       if (flag == ECC) {
                register int i;
                caddr_t addr;
                register int i;
                caddr_t addr;
-               int bit, byte, mask, ecccnt = 0;
+               int bit, o, mask;
 
 
-               printf("hp%d: soft ecc sn%d\n", unit, io->i_bn + npf);
+               printf("hp%d: soft ecc sn%d\n", unit, bn);
                mask = MASKREG(rp->hpec2);
                mask = MASKREG(rp->hpec2);
-               i = MASKREG(rp->hpec1) - 1;             /* -1 makes 0 origin */
+               for (i = mask, bit = 0; i; i >>= 1)
+                       if (i & 1)
+                               bit++;
+               if (bit > sc->ecclim) {
+                       printf("%d-bit error\n", bit);
+                       return (1);
+               }
+               i = MASKREG(rp->hpec1) - 1;     /* -1 makes 0 origin */
                bit = i&07;
                bit = i&07;
-               i = (i&~07)>>3;
-               byte = i;
+               o = (i & ~07) >> 3;
                rp->hpcs1 = HP_DCLR | HP_GO;
                rp->hpcs1 = HP_DCLR | HP_GO;
-               while (i <sectsiz && npf*sectsiz + i < io->i_cc && bit > -11) {
-                       addr = io->i_ma + (npf*sectsiz) + byte;
-#ifdef HPECCDEBUG
-                       printf("addr %x old:%x ",addr, (*addr&0xff));
-#endif
-                       if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0)
-                               *addr ^= (mask << bit); /* don't 'correct' mem-
-                                                        * ory during Wcheck */
-#ifdef HPECCDEBUG
-                       printf("new:%x\n",(*addr&0xff));
-#endif
-                       byte++;
-                       i++;
-                       bit -= 8;
-                       if ((ecccnt++>=MAXECC) && ((io->i_flgs&F_ECCLM) != 0))
-                               return(1);
-               }
-               return(0);
+               while (o <sectsiz && npf*sectsiz + o < io->i_cc && bit > -11) {
+                       addr = io->i_ma + (npf*sectsiz) + o;
+                       /*
+                        * No data transfer occurs with a write check,
+                        * so don't correct the resident copy of data.
+                        */
+                       if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) {
+                               if (sc->debug & HPF_ECCDEBUG)
+                                       printf("addr=%x old=%x ", addr,
+                                               (*addr & 0xff));
+                               *addr ^= (mask << bit);
+                               if (sc->debug & HPF_ECCDEBUG)
+                                       printf("new=%x\n",(*addr & 0xff));
+                       }
+                       o++, bit -= 8;
                }
                }
+               return (0);
+       }
 
 
-       case SSE:               /* skip sector error */
-                               /* -----this section must be fixed------*/
+       /*
+        * Skip sector error.
+        * Set skip-sector-inhibit and
+        * read next sector
+        */
+       if (flag == SSE) {
                rp->hpcs1 = HP_DCLR | HP_GO;
                rp->hpcs1 = HP_DCLR | HP_GO;
+               HPWAIT(rp);
                rp->hpof |= HPOF_SSEI;
                rp->hpof |= HPOF_SSEI;
-               mbp->mba_bcr = -(io->i_cc - npf*sectsiz);
-               /* presumably the disk address has already
-                * been incremented to point to the next sector */
-               return(0);      
-
-#ifndef NOBADSECT
-       case BSE:
-#ifdef HPDEBUG
-               printf("hpecc: BSE @ bn %d\n", bn);
-#endif
+               return (0);
+       }
+
+       /*
+        * Bad block forwarding.
+        */
+        if (flag == BSE) {
+               int bbn;
+
                rp->hpcs1 = HP_DCLR | HP_GO;
                rp->hpcs1 = HP_DCLR | HP_GO;
-               bcr += SECTSIZ;
-               tad = rp->hpda;
-               if ((bn = isbad(&hpbad[unit], bcr, tad>>8, tad&0x7f)) < 0)
-                       return(1);
-               bn = st->ncyl*st->nspc - st->nsect - 1 - bn;
-               cn = bn/st->nspc;
-               sn = bn%st->nspc;
-               tn = sn/st->nsect;
-               sn %= st->nsect;
-               io->i_cc = -SECTSIZ;
-               io->i_ma = (char *)((io->i_bn + npf -1)*SECTSIZ);
-#ifdef HPDEBUG
-               printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
-#endif
+               if (sc->debug & HPF_BSEDEBUG)
+                       printf("hpecc: BSE @ bn %d\n", bn);
+               cn = bn / lp->d_secpercyl;
+               sn = bn % lp->d_secpercyl;
+               tn = sn / lp->d_nsectors;
+               sn = sn % lp->d_nsectors;
+               bcr += sectsiz;
+               if ((bbn = isbad(&hpbad[io->i_adapt][unit], cn, tn, sn)) < 0)
+                       return (1);
+               bbn = lp->d_ncylinders * lp->d_secpercyl - lp->d_nsectors - 1
+                   - bbn;
+               cn = bbn / lp->d_secpercyl;
+               sn = bbn % lp->d_secpercyl;
+               tn = sn / lp->d_nsectors;
+               sn = sn % lp->d_nsectors;
+               io->i_cc = sectsiz;
+               io->i_ma += npf * sectsiz;
+               if (sc->debug & HPF_BSEDEBUG)
+                       printf("revector to cn %d tn %d sn %d\n", cn, tn, sn);
+               rp->hpof &= ~HPOF_SSEI;
+               mbp->mba_sr = -1;
                rp->hpdc = cn;
                rp->hpda = (tn<<8) + sn;
                rp->hpdc = cn;
                rp->hpda = (tn<<8) + sn;
-               mbp->mba_sr = -1;
-               mbastart(io,io->i_flgs);
-               io->i_errcnt = 0;       /* error has been corrected */
-               while(rp->hpds & HPDS_DRY == 0)
-                       ;
-               if (rp->hpds&HPDS_ERR)
-                       return(1);
-               else
-                       return(0);
+               mbastart(io, io->i_unit, io->i_flgs);
+               io->i_errcnt = 0;
+               HPWAIT(rp);
+               return (rp->hpds&HPDS_ERR);
        }
        }
+       printf("hpecc: flag=%d\n", flag);
+       return (1);
 }
 }
+
 /*ARGSUSED*/
 hpioctl(io, cmd, arg)
        struct iob *io;
        int cmd;
        caddr_t arg;
 {
 /*ARGSUSED*/
 hpioctl(io, cmd, arg)
        struct iob *io;
        int cmd;
        caddr_t arg;
 {
-
-       struct hpst *st = &hpst[hp_type[io->i_unit]];
-       struct mba_drv *drv = mbadrv(io->i_unit);
-       struct devdata *devd;
+       register unit = io->i_unit;
+       register struct hp_softc *sc = &hp_softc[io->i_adapt][unit];
+       register struct disklabel *lp = &hplabel[io->i_adapt][unit];
+       struct mba_drv *drv = mbadrv(io->i_adapt, unit);
 
        switch(cmd) {
 
 
        switch(cmd) {
 
+       case SAIODEBUG:
+               sc->debug = (int)arg;
+               break;
+
        case SAIODEVDATA:
        case SAIODEVDATA:
-               if ((drv->mbd_dt&MBDT_TAP) == 0) {
-                       devd = (struct devdata *)arg;
-                       devd->ncyl = st->ncyl;
-                       devd->ntrak = st->ntrak;
-                       devd->nspc = st->nspc;
-                       devd->nsect = st->nsect;
-                       return(0);
+               if (drv->mbd_dt&MBDT_TAP)
+                       return (ECMD);
+               *(struct disklabel *)arg = *lp;
+               break;
+
+       case SAIOGBADINFO:
+               if (drv->mbd_dt&MBDT_TAP)
+                       return (ECMD);
+               *(struct dkbad *)arg = hpbad[io->i_adapt][unit];
+               break;
+
+       case SAIOECCLIM:
+               sc->ecclim = (int)arg;
+               break;
+
+       case SAIORETRIES:
+               sc->retries = (int)arg;
+               break;
+
+       case SAIOSSI:                   /* skip-sector-inhibit */
+               if (drv->mbd_dt&MBDT_TAP)
+                       return (ECMD);
+               if ((io->i_flgs&F_SSI) == 0) {
+                       /* make sure this is done once only */
+                       io->i_flgs |= F_SSI;
+                       lp->d_nsectors++;
+                       lp->d_secpercyl += lp->d_ntracks;
                }
                }
-               else 
-                       return(ECMD);
+               break;
+
+       case SAIONOSSI:                 /* remove skip-sector-inhibit */
+               if (io->i_flgs & F_SSI) {
+                       io->i_flgs &= ~F_SSI;
+                       drv->mbd_of &= ~HPOF_SSEI;
+                       lp->d_nsectors--;
+                       lp->d_secpercyl -= lp->d_ntracks;
+               }
+               break;
+
+       case SAIOSSDEV:                 /* drive have skip sector? */
+               return (RM80(sc->type) ? 0 : ECMD);
 
        default:
                return (ECMD);
        }
 
        default:
                return (ECMD);
        }
+       return (0);
 }
 }
-
-/* this routine is common to up & hp, move to a separate file */
-
-/*
- * Search the bad sector table looking for
- * the specified sector.  Return index if found.
- * Return -1 if not found.
- */
-
-isbad(bt, st, blno)
-       register struct dkbad *bt;
-       register struct devdata *st;    /* dirty, must be fixed */
-{
-       register int i;
-       register long blk, bblk;
-       int trk, sec;
-
-       sec = blno % st->nspc;
-       trk = sec / st->nsect;
-       sec %= st->nsect;
-       blk = ((long)(blno/st->nspc) << 16) + (trk << 8) + sec;
-       for (i = 0; i < MAXBADDESC; i++) {
-               bblk = ((long)bt->bt_bad[i].bt_cyl << 16) +
-                       bt->bt_bad[i].bt_trksec;
-               if (blk == bblk)
-                       return (i);
-               if (blk < bblk || bblk < 0)
-                       break;
-       }
-       return (-1);
-}
+#endif /* !SMALL */
Continuous source code history from original PDP-7 UNIX to FreeBSD 2, the first fully unencumbered FreeBSD release.