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 4330fda..d8d4297 100644 (file)
--- a/usr/src/sys/vax/stand/hp.c
+++ b/usr/src/sys/vax/stand/hp.c
@@ -1,180 +1,241 @@
-/*     hp.c    6.1     83/07/29        */
+/*
+ * 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%
+ */

 
 /*
 
 /*

- * RP??/RM?? disk driver
- * with ECC handling and bad block forwarding.
- * Also supports header io operations and
- * commands to write check header and data.
+ * 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 "../h/param.h"
-#include "../h/inode.h"
-#include "../h/fs.h"
-#include "../h/dkbad.h"
+#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        MAXBADDESC      126
 #define        SECTSIZ         512     /* sector size in bytes */
 #define        HDRSIZ          4       /* number of bytes in sector header */
 #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       /* max # bits allow in ecc error w/ F_ECCLM */
-
-char   hp_type[MAXNMBA*8] = { 0 };
-extern struct st hpst[];
-
-short  hptypes[] = {
-       MBDT_RM03,
-       MBDT_RM05,
-       MBDT_RP06,
-       MBDT_RM80,
-       MBDT_RP05,
-       MBDT_RP07,
-       MBDT_ML11A,
-       MBDT_ML11B,
-       -1,             /* 9755 */
-       -1,             /* 9730 */
-       -1,             /* Capricorn */
-       -1,             /* Eagle */
-       MBDT_RM02,      /* actually something else */
-       -1,             /* 9300 */
-       0
-};

 
 

-#define        RP06 (hptypes[hp_type[unit]] <= MBDT_RP06)
-#define        ML11 (hptypes[hp_type[unit]] == MBDT_ML11A)
-#define        RM80 (hptypes[hp_type[unit]] == MBDT_RM80)
+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 dkbad hpbad[MAXNMBA*8];
-int    ssect[MAXNMBA*8];               /* 1 when on track w/skip sector */
-
-int    hpdebug[MAXNMBA*8];
-#define        HPF_BSEDEBUG    01      /* debugging bad sector forwarding */
-#define        HPF_ECCDEBUG    02      /* debugging ecc correction */
-
+#define        MAXUNIT         8
+struct disklabel hplabel[MAXNMBA][MAXUNIT];
+#ifndef SMALL
+struct dkbad hpbad[MAXNMBA][MAXUNIT];

 int    sectsiz;
 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.
+ * When awaiting command completion, don't hang on to the status register
+ * since this ties up some controllers.

  */
 #define        HPWAIT(addr) \
  */
 #define        HPWAIT(addr) \

-       while ((((addr)->hpds)&HPDS_DRY)==0) DELAY(500);
+       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 st *st;
-
-       mbainit(UNITTOMBA(unit));
-       if (hp_type[unit] == 0) {
-               register i, 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;
 
                struct iob tio;
 

-               for (i = 0; hptypes[i]; i++)
-                       if (hptypes[i] == type)
-                               goto found;
-               _stop("unknown drive type");
-found:
+#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;
                hpaddr->hpcs1 = HP_DCLR|HP_GO;          /* init drive */
                hpaddr->hpcs1 = HP_PRESET|HP_GO;

-               if (!ML11)
+#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;
                        hpaddr->hpof = HPOF_FMT22;

-               hp_type[unit] = hpmaptype(hpaddr, i, unit);

                /*
                /*

-                * Read in the bad sector table.
+                * 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[unit];
-               tio.i_cc = sizeof (struct dkbad);
+               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 (struct dkbad))
+                       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);
+       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;
        daddr_t bn, startblock;

-       struct hpdevice *hpaddr = (struct hpdevice *)mbadrv(unit);
-       struct st *st = &hpst[hp_type[unit]];
-       int cn, tn, sn, bytecnt, bytesleft; 
-       char *membase;
+       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 (!ML11)
+               if (!ML11(sc->type))

                        hpaddr->hpof = HPOF_FMT22;
        }
        io->i_errcnt = 0;
                        hpaddr->hpof = HPOF_FMT22;
        }
        io->i_errcnt = 0;

-       ssect[unit] = 0;
-       bytecnt = io->i_cc;
+       sc->ssect = 0;
+       rv = bytecnt = io->i_cc;

        membase = io->i_ma;
        startblock = io->i_bn;
        hprecal = 0;
        membase = io->i_ma;
        startblock = io->i_bn;
        hprecal = 0;

+#endif

 
 restart:
        bn = io->i_bn;
 
 restart:
        bn = io->i_bn;

-       cn = bn/st->nspc;
-       sn = bn%st->nspc;
-       tn = sn/st->nsect;
-       sn = sn%st->nsect + ssect[unit];
+       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;
 
        HPWAIT(hpaddr);
        mba->mba_sr = -1;

-       if (ML11)
+       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);

+       }
+       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)
        HPWAIT(hpaddr);
        /*
         * Successful data transfer, return.
         */
        if ((hpaddr->hpds&HPDS_ERR) == 0 && (mba->mba_sr&MBSR_EBITS) == 0)

-               return (bytecnt);
+               goto done;

 
        /*
         * Error handling.  Calculate location of error.
 
        /*
         * Error handling.  Calculate location of error.


@@ -183,15 +244,17 @@ restart:
        if (bytesleft) 
                bytesleft |= 0xffff0000;        /* sxt */
        bn = io->i_bn + (io->i_cc + bytesleft) / sectsiz;
        if (bytesleft) 
                bytesleft |= 0xffff0000;        /* sxt */
        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;

        er1 = MASKREG(hpaddr->hper1);
        er2 = MASKREG(hpaddr->hper2);
        er1 = MASKREG(hpaddr->hper1);
        er2 = MASKREG(hpaddr->hper2);

-       if (hpdebug[unit] & (HPF_ECCDEBUG|HPF_BSEDEBUG)) {
-               printf("hp error: (cyl,trk,sec)=(%d,%d,%d) ds=%b\n",
-                       cn, tn, sn, MASKREG(hpaddr->hpds), HPDS_BITS);
+       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);
                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);


@@ -199,63 +262,33 @@ restart:
        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);
        }
        /*
         * Give up early if drive write locked.
         */
        if (er1&HPER1_WLE) {
                printf("hp%d: write locked\n", unit);

-               return (-1);
+               rv = -1;
+               goto done;

        }
        /*
        }
        /*

-        * Interpret format error bit as a bad block on RP06's.
-        */
-       if (MASKREG(er1) == HPER1_FER && RP06)
-               goto badsect;
-
-       /*
-        * If a hard error, or maximum retry count
-        * exceeded, clear controller state and
-        * pass back error to caller.
+        * Skip sector handling.

         */
         */

-       if (++io->i_errcnt > 27 || (er1 & HPER1_HARD) ||
-           (!ML11 && (er2 & HPER2_HARD))) {
-               if ((io->i_flgs&F_NBSF) == 0 && hpecc(io, BSE) == 0)
-                       goto success;
-hard0:
-               io->i_error = EHER;
-               if (mba->mba_sr & (MBSR_WCKUP|MBSR_WCKLWR))
-                       io->i_error = EWCK;
-hard:
-               io->i_errblk = bn + ssect[unit];
-               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(" mr1=%o", MASKREG(hpaddr->hpmr));
-               if (hpaddr->hpmr2)
-                       printf(" mr2=%o", MASKREG(hpaddr->hpmr2));
-               if (hpdebug[unit] & (HPF_BSEDEBUG|HPF_ECCDEBUG))
-                       printf(" dc=%d, da=0x%x",MASKREG(hpaddr->hpdc),
-                         MASKREG(hpaddr->hpda));
-               hpaddr->hpcs1 = HP_DCLR|HP_GO;
-               printf("\n");
-               return (-1);
-
+       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.  If drive
-        * supports skip sector handling, try to
-        * use it first; otherwise try the
-        * bad sector table.
+        * 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) {
-badsect:
-               if (!ssect[unit] && (er2&HPER2_SSE))
-                       goto skipsect;
+       if (((er2 & HPER2_BSE) && !ML11(sc->type)) ||
+           (MASKREG(er1) == HPER1_FER && RP06(sc->type))) {

                if (io->i_flgs & F_NBSF) {
                if (io->i_flgs & F_NBSF) {

-                       io->i_error = EBSE;     
+                       io->i_error = EBSE;

                        goto hard;
                }
                if (hpecc(io, BSE) == 0)
                        goto hard;
                }
                if (hpecc(io, BSE) == 0)


@@ -263,16 +296,6 @@ badsect:
                io->i_error = EBSE;
                goto hard;
        }
                io->i_error = EBSE;
                goto hard;
        }

-
-       /*
-        * Skip sector handling.
-        */
-       if (RM80 && (er2 & HPER2_SSE)) {
-skipsect:
-               (void) hpecc(io, SSE);
-               ssect[unit] = 1;
-               goto success;
-       }

        /*
         * ECC correction?
         */
        /*
         * ECC correction?
         */


@@ -280,10 +303,36 @@ skipsect:
                if (hpecc(io, ECC) == 0)
                        goto success;
                io->i_error = EECC;
                if (hpecc(io, ECC) == 0)
                        goto success;
                io->i_error = EECC;

-               return (-1);    
+               goto hard;

        } 
        } 

-       if (ML11 && (io->i_errcnt >= 16))
-               goto hard0;
+
+       /*
+        * 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 {
+                   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);
+               }
+               hpaddr->hpcs1 = HP_DCLR|HP_GO;
+               printf("\n");
+               rv = -1;
+               goto done;
+
+       }

        /* fall thru to retry */
        hpaddr->hpcs1 = HP_DCLR|HP_GO;
        HPWAIT(hpaddr);
        /* fall thru to retry */
        hpaddr->hpcs1 = HP_DCLR|HP_GO;
        HPWAIT(hpaddr);


@@ -293,40 +342,21 @@ skipsect:
         */
        if (((io->i_errcnt & 07) == 4) ) {
                hpaddr->hpcs1 = HP_RECAL|HP_GO;
         */
        if (((io->i_errcnt & 07) == 4) ) {
                hpaddr->hpcs1 = HP_RECAL|HP_GO;

-               hprecal = 1;
-               goto again;
-       }
-
-       /*
-        * Recalibration state machine.
-        */
-       switch (hprecal) {
-
-       case 1:
+               HPWAIT(hpaddr);

                hpaddr->hpdc = cn;
                hpaddr->hpcs1 = HP_SEEK|HP_GO;
                hpaddr->hpdc = cn;
                hpaddr->hpcs1 = HP_SEEK|HP_GO;

-               hprecal = 2;
-               goto again;
+               HPWAIT(hpaddr);
+       }

 
 

-       case 2:
-               if (io->i_errcnt < 16 || (io->i_flgs & F_READ) == 0)
-                       goto donerecal;
+       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;

-               hprecal = 3;
-               goto again;
-
-       case 3:
-       donerecal:
-               hprecal = 0;
-               goto again;
+               HPWAIT(hpaddr);

        }
        }

-       if (io->i_errcnt >= 16) {
-               hpaddr->hpcs1 = HP_RTC|HP_GO;
-               while (hpaddr->hpds & HPDS_PIP)
-                       ;
-       }
-       goto again;
+       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:
        /*
 
 success:
        /*


@@ -336,46 +366,70 @@ success:
         */
        bn++;
        if ((bn-startblock) * sectsiz < bytecnt) {
         */
        bn++;
        if ((bn-startblock) * sectsiz < bytecnt) {

-again:

                io->i_bn = bn;
                io->i_ma = membase + (io->i_bn - startblock)*sectsiz;
                io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz;
                io->i_bn = bn;
                io->i_ma = membase + (io->i_bn - startblock)*sectsiz;
                io->i_cc = bytecnt - (io->i_bn - startblock)*sectsiz;

-               if (hpdebug[unit] & (HPF_ECCDEBUG|HPF_BSEDEBUG))
+               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;
        }
                        printf("restart: bn=%d, cc=%d, ma=0x%x hprecal=%d\n",
                          io->i_bn, io->i_cc, io->i_ma, hprecal);
                goto restart;
        }

-       return (bytecnt);
+done:
+       if (io->i_errcnt >= 16) {
+               hpaddr->hpcs1 = HP_RTC|HP_GO;
+               while (hpaddr->hpds & HPDS_PIP)
+                       ;
+       }
+       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 st *st = &hpst[hp_type[unit]];
+       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;
 
        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 */
        npf = (bcr + io->i_cc) / sectsiz;       /* # sectors read */
        bcr = MASKREG(mbp->mba_bcr);
        if (bcr)
                bcr |= 0xffff0000;              /* sxt */
        npf = (bcr + io->i_cc) / sectsiz;       /* # sectors read */

-       bn = io->i_bn + npf + ssect[unit];      /* physical block #*/
-       if (hpdebug[unit]&HPF_ECCDEBUG)
+       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",
                printf("bcr=%d npf=%d ssect=%d sectsiz=%d i_cc=%d\n",

-                       bcr, npf, ssect[unit], sectsiz, io->i_cc);
+                       bcr, npf, sc->ssect, sectsiz, io->i_cc);

        /*
         * ECC correction logic.
         */
        if (flag == ECC) {
                register int i;
                caddr_t addr;
        /*
         * ECC correction logic.
         */
        if (flag == ECC) {
                register int i;
                caddr_t addr;

-               int bit, o, mask, ecccnt = 0;
+               int bit, o, mask;

 
                printf("hp%d: soft ecc sn%d\n", unit, bn);
                mask = MASKREG(rp->hpec2);
 
                printf("hp%d: soft ecc sn%d\n", unit, bn);
                mask = MASKREG(rp->hpec2);

+               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;
                o = (i & ~07) >> 3;
                i = MASKREG(rp->hpec1) - 1;     /* -1 makes 0 origin */
                bit = i&07;
                o = (i & ~07) >> 3;


@@ -387,16 +441,14 @@ hpecc(io, flag)
                         * so don't correct the resident copy of data.
                         */
                        if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) {
                         * so don't correct the resident copy of data.
                         */
                        if ((io->i_flgs & (F_CHECK|F_HCHECK)) == 0) {

-                               if (hpdebug[unit] & HPF_ECCDEBUG)
+                               if (sc->debug & HPF_ECCDEBUG)

                                        printf("addr=%x old=%x ", addr,
                                                (*addr & 0xff));
                                *addr ^= (mask << bit);
                                        printf("addr=%x old=%x ", addr,
                                                (*addr & 0xff));
                                *addr ^= (mask << bit);

-                               if (hpdebug[unit] & HPF_ECCDEBUG)
+                               if (sc->debug & HPF_ECCDEBUG)

                                        printf("new=%x\n",(*addr & 0xff));
                        }
                        o++, bit -= 8;
                                        printf("new=%x\n",(*addr & 0xff));
                        }
                        o++, bit -= 8;

-                       if ((io->i_flgs & F_ECCLM) && ecccnt++ >= MAXECC)
-                               return (1);

                }
                return (0);
        }
                }
                return (0);
        }


@@ -410,7 +462,7 @@ hpecc(io, flag)
                rp->hpcs1 = HP_DCLR | HP_GO;
                HPWAIT(rp);
                rp->hpof |= HPOF_SSEI;
                rp->hpcs1 = HP_DCLR | HP_GO;
                HPWAIT(rp);
                rp->hpof |= HPOF_SSEI;

-               return (0);     
+               return (0);

        }
 
        /*
        }
 
        /*


@@ -420,29 +472,30 @@ hpecc(io, flag)
                int bbn;
 
                rp->hpcs1 = HP_DCLR | HP_GO;
                int bbn;
 
                rp->hpcs1 = HP_DCLR | HP_GO;

-               if (hpdebug[unit] & HPF_BSEDEBUG)
+               if (sc->debug & HPF_BSEDEBUG)

                        printf("hpecc: BSE @ bn %d\n", bn);
                        printf("hpecc: BSE @ bn %d\n", bn);

-               cn = bn/st->nspc;
-               sn = bn%st->nspc;
-               tn = sn/st->nsect;
-               sn = sn%st->nsect;
+               cn = bn / lp->d_secpercyl;
+               sn = bn % lp->d_secpercyl;
+               tn = sn / lp->d_nsectors;
+               sn = sn % lp->d_nsectors;

                bcr += sectsiz;
                bcr += sectsiz;

-               if ((bbn = isbad(&hpbad[unit], cn, tn, sn)) < 0)
+               if ((bbn = isbad(&hpbad[io->i_adapt][unit], cn, tn, sn)) < 0)

                        return (1);
                        return (1);

-               bbn = st->ncyl*st->nspc - st->nsect - 1 - bbn;
-               cn = bbn/st->nspc;
-               sn = bbn%st->nspc;
-               tn = sn/st->nsect;
-               sn = sn%st->nsect;
+               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_cc = sectsiz;

-               io->i_ma += npf*sectsiz;
-               if (hpdebug[unit] & HPF_BSEDEBUG)
+               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;
                        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;

-               mbastart(io,io->i_flgs);
+               mbastart(io, io->i_unit, io->i_flgs);

                io->i_errcnt = 0;
                HPWAIT(rp);
                return (rp->hpds&HPDS_ERR);
                io->i_errcnt = 0;
                HPWAIT(rp);
                return (rp->hpds&HPDS_ERR);


@@ -458,27 +511,35 @@ hpioctl(io, cmd, arg)
        caddr_t arg;
 {
        register unit = io->i_unit;
        caddr_t arg;
 {
        register unit = io->i_unit;

-       struct st *st = &hpst[hp_type[unit]], *tmp;
-       struct mba_drv *drv = mbadrv(unit);
-       int flag;
+       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) {
 
        case SAIODEBUG:
 
        switch(cmd) {
 
        case SAIODEBUG:

-               flag = (int)arg;
-               if (flag > 0)
-                       hpdebug[unit] |= flag;
-               else
-                       hpdebug[unit] &= ~flag;
-               return (0);
+               sc->debug = (int)arg;
+               break;

 
        case SAIODEVDATA:
 
        case SAIODEVDATA:

-               if ((drv->mbd_dt&MBDT_TAP) == 0) {
-                       tmp = (struct st *)arg;
-                       *tmp = *st;
-                       return (0);
-               }
-               return (ECMD);
+               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)
 
        case SAIOSSI:                   /* skip-sector-inhibit */
                if (drv->mbd_dt&MBDT_TAP)


@@ -486,22 +547,26 @@ hpioctl(io, cmd, arg)
                if ((io->i_flgs&F_SSI) == 0) {
                        /* make sure this is done once only */
                        io->i_flgs |= F_SSI;
                if ((io->i_flgs&F_SSI) == 0) {
                        /* make sure this is done once only */
                        io->i_flgs |= F_SSI;

-                       st->nsect++;
-                       st->nspc += st->ntrak;
+                       lp->d_nsectors++;
+                       lp->d_secpercyl += lp->d_ntracks;

                }
                }

-               return (0);
+               break;

 
        case SAIONOSSI:                 /* remove skip-sector-inhibit */
                if (io->i_flgs & F_SSI) {
                        io->i_flgs &= ~F_SSI;
                        drv->mbd_of &= ~HPOF_SSEI;
 
        case SAIONOSSI:                 /* remove skip-sector-inhibit */
                if (io->i_flgs & F_SSI) {
                        io->i_flgs &= ~F_SSI;
                        drv->mbd_of &= ~HPOF_SSEI;

-                       st->nsect--;
-                       st->nspc -= st->ntrak;
+                       lp->d_nsectors--;
+                       lp->d_secpercyl -= lp->d_ntracks;

                }
                }

-               return(0);
+               break;

 
        case SAIOSSDEV:                 /* drive have skip sector? */
 
        case SAIOSSDEV:                 /* drive have skip sector? */

-               return (RM80 ? 0 : ECMD);
+               return (RM80(sc->type) ? 0 : ECMD);
+
+       default:
+               return (ECMD);

        }
        }

-       return (ECMD);
+       return (0);

 }
 }

+#endif /* !SMALL */