simpler, cleaner iostat interface

[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 ece66f8..c7fcf8e 100644 (file)
--- a/usr/src/sys/vax/mba/hp.c
+++ b/usr/src/sys/vax/mba/hp.c
@@ -1,21 +1,24 @@
-/*     hp.c    3.4     %G%     */
+/*     hp.c    3.14    %G%     */

 
 /*
 
 /*

- * RP04/RP06/RM03 disk driver
+ * RP06/RM03/RM05 disk driver

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

+#include "../h/dk.h"

 #include "../h/buf.h"
 #include "../h/conf.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/map.h"
 #include "../h/buf.h"
 #include "../h/conf.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/map.h"

+#include "../h/pte.h"

 #include "../h/mba.h"
 #include "../h/mtpr.h"
 #include "../h/mba.h"
 #include "../h/mtpr.h"

-#include "../h/pte.h"
+#include "../h/vm.h"

 
 #define        DK_N    0
 
 #define        DK_N    0

+#define        DK_NMAX 1

 
 struct device
 {
 
 struct device
 {


@@ -37,16 +40,24 @@ struct      device
        int     hpec2;          /* Burst error bit pattern */
 };
 
        int     hpec2;          /* Burst error bit pattern */
 };
 

-#define        HPADDR  ((struct device *)(MBA0 + MBA_ERB))
-#define        NHP     1
+#define        HPMBA           MBA0
+#define        HPMBANUM        0
+
+#define        NHP     2

 #define        RP      022
 #define        RM      024
 #define        RP      022
 #define        RM      024

+#define        RM5     027

 #define        NSECT   22
 #define        NTRAC   19
 #define        NRMSECT 32
 #define        NRMTRAC 5
 #define        NSECT   22
 #define        NTRAC   19
 #define        NRMSECT 32
 #define        NRMTRAC 5

-#define        SDIST   2
-#define        RDIST   6
+
+#define        _hpSDIST        3
+#define        _hpRDIST        6
+
+int    hpSDIST = _hpSDIST;
+int    hpRDIST = _hpRDIST;
+int    hpseek;

 
 struct size
 {
 
 struct size
 {


@@ -54,31 +65,32 @@ struct      size
        int     cyloff;
 } hp_sizes[8] =
 {
        int     cyloff;
 } hp_sizes[8] =
 {

-       15884,  0,              /* cyl 0 thru 37 */
-       33440,  38,             /* cyl 38 thru 117 */
-       8360,   98,             /* cyl 98 thru 117 */
-#ifdef ERNIE
-       15884,  118,            /* cyl 118 thru 155 */
-       66880,  156,            /* cyl 156 thru 315 */
+       15884,  0,              /* A=cyl 0 thru 37 */
+       33440,  38,             /* B=cyl 38 thru 117 */
+       340670, 0,              /* C=cyl 0 thru 814 */

        0,      0,
        0,      0,

-       291346, 118,            /* cyl 118 thru 814, (like distrib) */
-       208582, 316,            /* cyl 316 thru 814 */
-#else

        0,      0,
        0,      0,
        0,      0,
        0,      0,

+       291346, 118,            /* G=cyl 118 thru 814 */

        0,      0,
        0,      0,

-       291346, 118,            /* cyl 118 thru 814 */
-       0,      0,
-#endif

 }, rm_sizes[8] = {
 }, rm_sizes[8] = {

-       15884,  0,              /* cyl 0 thru 99 */
-       33440,  100,            /* cyl 100 thru 309 */
-       0,      0,
+       15884,  0,              /* A=cyl 0 thru 99 */
+       33440,  100,            /* B=cyl 100 thru 309 */
+       131680, 0,              /* C=cyl 0 thru 822 */

        0,      0,
        0,      0,
        0,      0,
        0,      0,
        0,      0,
        0,      0,

-       82080,  310,            /* cyl 310 thru 822 */
+       82080,  310,            /* G=cyl 310 thru 822 */

        0,      0,
        0,      0,

+}, rm5_sizes[8] = {
+       15884,  0,              /* A=cyl 0 thru 26 */
+       33440,  27,             /* B=cyl 27 thru 81 */
+       500992, 0,              /* C=cyl 0 thru 823 */
+       15884,  562,            /* D=cyl 562 thru 588 */
+       55936,  589,            /* E=cyl 589 thru 680 */
+       86944,  681,            /* F=cyl 681 thru 823 */
+       159296, 562,            /* G=cyl 562 thru 823 */
+       291346, 82,             /* H=cyl 82 thru 561 */

 };
 
 #define        P400    020
 };
 
 #define        P400    020


@@ -104,6 +116,7 @@ char        hp_type[NHP];   /* drive type */
 #define        PRESET  020
 #define        RTC     016
 #define        OFFSET  014
 #define        PRESET  020
 #define        RTC     016
 #define        OFFSET  014

+#define        SEEK    04

 #define        SEARCH  030
 #define        RECAL   06
 #define        DCLR    010
 #define        SEARCH  030
 #define        RECAL   06
 #define        DCLR    010


@@ -137,6 +150,8 @@ register struct buf *bp;
        long sz, bn;
        struct size *sizes;
 
        long sz, bn;
        struct size *sizes;
 

+       if ((mbaact&(1<<HPMBANUM)) == 0)
+               mbainit(HPMBANUM);

        xunit = minor(bp->b_dev) & 077;
        sz = bp->b_bcount;
        sz = (sz+511) >> 9;
        xunit = minor(bp->b_dev) & 077;
        sz = bp->b_bcount;
        sz = (sz+511) >> 9;


@@ -145,15 +160,27 @@ register struct buf *bp;
                struct device *hpaddr;
 
                /* determine device type */
                struct device *hpaddr;
 
                /* determine device type */

-               hpaddr = (struct device *)((int*)HPADDR + 32*unit);
+               hpaddr = mbadev(HPMBA, unit);

                hp_type[unit] = hpaddr->hpdt;
        }
                hp_type[unit] = hpaddr->hpdt;
        }

-       if (hp_type[unit] == RM) {
+       switch (hp_type[unit]) {
+
+       case RM:

                sizes = rm_sizes;
                nspc = NRMSECT*NRMTRAC;
                sizes = rm_sizes;
                nspc = NRMSECT*NRMTRAC;

-       } else {
+               break;
+       case RM5:
+               sizes = rm5_sizes;
+               nspc = NRMSECT*NTRAC;
+               break;
+       case RP:

                sizes = hp_sizes;
                nspc = NSECT*NTRAC;
                sizes = hp_sizes;
                nspc = NSECT*NTRAC;

+               break;
+       default:
+               printf("hp: unknown device type 0%o\n", hp_type[unit]);
+               u.u_error = ENXIO;
+               unit = NHP+1;   /* force error */

        }
        if (unit >= NHP ||
            bp->b_blkno < 0 ||
        }
        if (unit >= NHP ||
            bp->b_blkno < 0 ||


@@ -183,17 +210,17 @@ register unit;
        int sn, cn, csn;
 
        ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;
        int sn, cn, csn;
 
        ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;

-       HPADDR->hpas = 1<<unit;
+       hpaddr = mbadev(HPMBA, 0);
+       hpaddr->hpas = 1<<unit;

 
        if(unit >= NHP)
                return;
 
        if(unit >= NHP)
                return;

-/*
-       dk_busy &= ~(1<<(unit+DK_N));
-*/
+       if (unit+DK_N <= DK_NMAX)
+               dk_busy &= ~(1<<(unit+DK_N));

        dp = &hputab[unit];
        if((bp=dp->b_actf) == NULL)
                return;
        dp = &hputab[unit];
        if((bp=dp->b_actf) == NULL)
                return;

-       hpaddr = (struct device *)((int *)HPADDR + 32*unit);
+       hpaddr = mbadev(HPMBA, unit);

        if((hpaddr->hpds & VV) == 0) {
                hpaddr->hpcs1 = PRESET|GO;
                hpaddr->hpof = FMT22;
        if((hpaddr->hpds & VV) == 0) {
                hpaddr->hpcs1 = PRESET|GO;
                hpaddr->hpof = FMT22;


@@ -206,37 +233,54 @@ register unit;
 
        bn = dkblock(bp);
        cn = bp->b_cylin;
 
        bn = dkblock(bp);
        cn = bp->b_cylin;

-       if(hp_type[unit] == RM) {
+       switch (hp_type[unit]) {
+
+       case RM:

                sn = bn%(NRMSECT*NRMTRAC);
                sn = bn%(NRMSECT*NRMTRAC);

-               sn = (sn+NRMSECT-SDIST)%NRMSECT;
-       } else {
+               sn = (sn+NRMSECT-hpSDIST)%NRMSECT;
+               break;
+       case RM5:
+               sn = bn%(NRMSECT*NTRAC);
+               sn = (sn+NRMSECT-hpSDIST)%NRMSECT;
+               break;
+       case RP:

                sn = bn%(NSECT*NTRAC);
                sn = bn%(NSECT*NTRAC);

-               sn = (sn+NSECT-SDIST)%NSECT;
+               sn = (sn+NSECT-hpSDIST)%NSECT;
+               break;
+       default:
+               panic("hpustart");

        }
 
        if(cn - (hpaddr->hpdc & 0xffff))
                goto search;
        }
 
        if(cn - (hpaddr->hpdc & 0xffff))
                goto search;

-       csn = ((hpaddr->hpla & 0xffff)>>6) - sn + SDIST - 1;
+       else if (hpseek)
+               goto done;
+       csn = ((hpaddr->hpla & 0xffff)>>6) - sn + 1;

        if(csn < 0)
                csn += NSECT;
        if(csn < 0)
                csn += NSECT;

-       if(csn > NSECT-RDIST)
+       if(csn > NSECT-hpRDIST)

                goto done;
 
 search:
        hpaddr->hpdc = cn;
                goto done;
 
 search:
        hpaddr->hpdc = cn;

-       hpaddr->hpda = sn;
-       hpaddr->hpcs1 = SEARCH|GO;
-/*
+       if (hpseek)
+               hpaddr->hpcs1 = SEEK|GO;
+       else {
+               hpaddr->hpda = sn;
+               hpaddr->hpcs1 = SEARCH|GO;
+       }

        unit += DK_N;
        unit += DK_N;

-       dk_busy |= 1<<unit;
-       dk_numb[unit] += 1;
-*/
+       if (unit <= DK_NMAX && DK_N+NHP <= DK_NMAX) {
+               dk_busy |= 1<<unit;
+               dk_numb[unit]++;
+       }

        return;
 
 done:
        dp->b_forw = NULL;
        if(hptab.b_actf == NULL)
        return;
 
 done:
        dp->b_forw = NULL;
        if(hptab.b_actf == NULL)

-               hptab.b_actf = dp; else
+               hptab.b_actf = dp;
+       else

                hptab.b_actl->b_forw = dp;
        hptab.b_actl = dp;
 }
                hptab.b_actl->b_forw = dp;
        hptab.b_actl = dp;
 }


@@ -260,21 +304,31 @@ loop:
        unit = minor(bp->b_dev) & 077;
        dn = dkunit(bp);
        bn = dkblock(bp);
        unit = minor(bp->b_dev) & 077;
        dn = dkunit(bp);
        bn = dkblock(bp);

-       if (hp_type[dn] == RM) {
+       switch (hp_type[dn]) {
+       case RM:

                nspc = NRMSECT*NRMTRAC;
                ns = NRMSECT;
                cn = rm_sizes[unit&07].cyloff;
                nspc = NRMSECT*NRMTRAC;
                ns = NRMSECT;
                cn = rm_sizes[unit&07].cyloff;

-       } else {
+               break;
+       case RM5:
+               nspc = NRMSECT*NTRAC;
+               ns = NRMSECT;
+               cn = rm5_sizes[unit&07].cyloff;
+               break;
+       case RP:

                nspc = NSECT*NTRAC;
                ns = NSECT;
                cn = hp_sizes[unit&07].cyloff;
                nspc = NSECT*NTRAC;
                ns = NSECT;
                cn = hp_sizes[unit&07].cyloff;

+               break;
+       default:
+               panic("hpstart");

        }
        cn += bn/nspc;
        sn = bn%nspc;
        tn = sn/ns;
        sn = sn%ns;
 
        }
        cn += bn/nspc;
        sn = bn%nspc;
        tn = sn/ns;
        sn = sn%ns;
 

-       hpaddr =  (struct device *)((int *)HPADDR + 32*dn);
+       hpaddr = mbadev(HPMBA, dn);

        if ((hpaddr->hpds & (DPR|MOL)) != (DPR|MOL)) {
                hptab.b_active = 0;
                hptab.b_errcnt = 0;
        if ((hpaddr->hpds & (DPR|MOL)) != (DPR|MOL)) {
                hptab.b_active = 0;
                hptab.b_errcnt = 0;


@@ -283,22 +337,26 @@ loop:
                iodone(bp);
                goto loop;
        }
                iodone(bp);
                goto loop;
        }

-       if(hptab.b_errcnt >= 16) {
+       if(hptab.b_errcnt >= 16 && (bp->b_flags&B_WRITE) == 0) {

                hpaddr->hpof = hp_offset[hptab.b_errcnt & 017] | FMT22;
                hpaddr->hpof = hp_offset[hptab.b_errcnt & 017] | FMT22;

-               ((struct mba_regs *)MBA0)->mba_cr &= ~MBAIE;
+               HPMBA->mba_cr &= ~MBAIE;

                hpaddr->hpcs1 = OFFSET|GO;
                while(hpaddr->hpds & PIP)
                        ;
                hpaddr->hpcs1 = OFFSET|GO;
                while(hpaddr->hpds & PIP)
                        ;

-               ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;
+               HPMBA->mba_cr |= MBAIE;

        }
        hpaddr->hpdc = cn;
        hpaddr->hpda = (tn << 8) + sn;
        mbastart(bp, (int *)hpaddr);
 
        }
        hpaddr->hpdc = cn;
        hpaddr->hpda = (tn << 8) + sn;
        mbastart(bp, (int *)hpaddr);
 

-       dk_busy |= 1<<(DK_N /*+NHP*/);
-       dk_numb[DK_N /*+NHP*/] += 1;
-       unit = bp->b_bcount>>6;
-       dk_wds[DK_N /*+NHP*/] += unit;
+       unit = dn+DK_N;
+       if (NHP+DK_N == DK_NMAX)
+               unit = NHP+DK_N;
+       if (unit <= DK_NMAX) {
+               dk_busy |= 1<<unit;
+               dk_numb[unit]++;
+               dk_wds[unit] += bp->b_bcount>>6;
+       }

 }
 
 hpintr(mbastat, as)
 }
 
 hpintr(mbastat, as)


@@ -308,16 +366,20 @@ hpintr(mbastat, as)
        register struct device *hpaddr;
 
        if(hptab.b_active) {
        register struct device *hpaddr;
 
        if(hptab.b_active) {

-               dk_busy &= ~(1<<(DK_N /*+NHP*/));

                dp = hptab.b_actf;
                bp = dp->b_actf;
                unit = dkunit(bp);
                dp = hptab.b_actf;
                bp = dp->b_actf;
                unit = dkunit(bp);

-               hpaddr = (struct device *)((int *)HPADDR + 32*unit);
-               if (hpaddr->hpds & ERR || mbastat & MBAEBITS) {         /* error bit */
+               if (DK_N+NHP == DK_NMAX)
+                       dk_busy &= ~(1<<(DK_N+NHP));
+               else if (DK_N+unit <= DK_NMAX)
+                       dk_busy &= ~(1<<(DK_N+unit));
+               hpaddr = mbadev(HPMBA, unit);
+               if (hpaddr->hpds & ERR || mbastat & MBAEBITS) {

                        while((hpaddr->hpds & DRY) == 0)
                                ;
                        if(++hptab.b_errcnt > 28 || hpaddr->hper1&WLE)
                        while((hpaddr->hpds & DRY) == 0)
                                ;
                        if(++hptab.b_errcnt > 28 || hpaddr->hper1&WLE)

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

                                hptab.b_active = 0;
                        if(hptab.b_errcnt > 27)
                                deverror(bp, mbastat, hpaddr->hper1);
                                hptab.b_active = 0;
                        if(hptab.b_errcnt > 27)
                                deverror(bp, mbastat, hpaddr->hper1);


@@ -327,20 +389,20 @@ hpintr(mbastat, as)
                        }
                        hpaddr->hpcs1 = DCLR|GO;
                        if((hptab.b_errcnt&07) == 4) {
                        }
                        hpaddr->hpcs1 = DCLR|GO;
                        if((hptab.b_errcnt&07) == 4) {

-                               ((struct mba_regs *)MBA0)->mba_cr &= ~MBAIE;
+                               HPMBA->mba_cr &= ~MBAIE;

                                hpaddr->hpcs1 = RECAL|GO;
                                while(hpaddr->hpds & PIP)
                                        ;
                                hpaddr->hpcs1 = RECAL|GO;
                                while(hpaddr->hpds & PIP)
                                        ;

-                               ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;
+                               HPMBA->mba_cr |= MBAIE;

                        }
                }
                if(hptab.b_active) {
                        if(hptab.b_errcnt) {
                        }
                }
                if(hptab.b_active) {
                        if(hptab.b_errcnt) {

-                               ((struct mba_regs *)MBA0)->mba_cr &= ~MBAIE;
+                               HPMBA->mba_cr &= ~MBAIE;

                                hpaddr->hpcs1 = RTC|GO;
                                while(hpaddr->hpds & PIP)
                                        ;
                                hpaddr->hpcs1 = RTC|GO;
                                while(hpaddr->hpds & PIP)
                                        ;

-                               ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;
+                               HPMBA->mba_cr |= MBAIE;

                        }
                        hptab.b_active = 0;
                        hptab.b_errcnt = 0;
                        }
                        hptab.b_active = 0;
                        hptab.b_errcnt = 0;


@@ -348,7 +410,7 @@ hpintr(mbastat, as)
                        dp->b_active = 0;
                        dp->b_errcnt = 0;
                        dp->b_actf = bp->av_forw;
                        dp->b_active = 0;
                        dp->b_errcnt = 0;
                        dp->b_actf = bp->av_forw;

-                       bp->b_resid = -(((struct mba_regs *)MBA0)->mba_bcr) & 0xffff;
+                       bp->b_resid = -HPMBA->mba_bcr & 0xffff;

                        iodone(bp);
                        if(dp->b_actf)
                                hpustart(unit);
                        iodone(bp);
                        if(dp->b_actf)
                                hpustart(unit);


@@ -356,7 +418,7 @@ hpintr(mbastat, as)
                as &= ~(1<<unit);
        } else {
                if(as == 0)
                as &= ~(1<<unit);
        } else {
                if(as == 0)

-                       ((struct mba_regs *)MBA0)->mba_cr |= MBAIE;
+                       HPMBA->mba_cr |= MBAIE;

        }
        for(unit=0; unit<NHP; unit++)
                if(as & (1<<unit))
        }
        for(unit=0; unit<NHP; unit++)
                if(as & (1<<unit))


@@ -380,89 +442,96 @@ hpecc(rp, bp)
 register struct device *rp;
 register struct buf *bp;
 {
 register struct device *rp;
 register struct buf *bp;
 {

-       register i;
-       register b, n, map, mix;
-       register char *cp;
-       register mask;
-       short piget();
+       struct mba_regs *mbp = HPMBA;
+       register int i;
+       caddr_t addr;
+       int reg, bit, byte, npf, mask, o;
+       int dn, bn, cn, tn, sn, ns, nt;

        extern char buffers[NBUF][BSIZE];
        extern char buffers[NBUF][BSIZE];

-
-       b = (((((struct mba_regs *)MBA0)->mba_bcr&0xffff) +
-               (bp->b_bcount) - 1)>>9)&0177;
-       printf("%D ", bp->b_blkno+b);
+       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;
+       printf("bcr %d npf %d\n", bcr, npf);
+       if (bp->b_flags&B_PHYS)
+               reg = 128 + npf;
+       else
+               reg = btop(bp->b_un.b_addr - buffers[0]) + npf;
+       o = (int)bp->b_un.b_addr & PGOFSET;
+       printf("%D ", bp->b_blkno + npf);

        prdev("ECC", bp->b_dev);
        mask = rp->hpec2&0xffff;
        if (mask == 0) {
                rp->hpof = FMT22;
        prdev("ECC", bp->b_dev);
        mask = rp->hpec2&0xffff;
        if (mask == 0) {
                rp->hpof = FMT22;

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

        }
        }

-       i = (rp->hpec1&0xffff) - 1;
-       n = i&017;
-       i = (i&~017)>>3;
-       if (bp->b_flags&B_PHYS)
-               map = 128 + b;
-       else
-               map = ((bp->b_un.b_addr - (char *)buffers)>>9) + b;
-       mix = i + ((int)bp->b_un.b_addr&0x1ff);
-       i += b<<9;
-       if ( i < bp->b_bcount) {
-               cp = (char *)((((int *)MBA0_MAP)[map+(mix>>9)]&0x1fffff)<<9)+(mix&0x1ff);
-               piput((int)cp,piget((int)cp)^(mask<<n));
+
+       /*
+        * 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;
+       /*
+        * 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);
+               putmemc(addr, getmemc(addr)^(mask<<bit));
+               byte++;
+               i++;
+               bit -= 8;

        }
        }

-       mix += 2;
-       i += 2;
-       if (i < bp->b_bcount) {
-               cp = (char *)((((int *)MBA0_MAP)[map+(mix>>9)]&0x1fffff)<<9)+(mix&0x1ff);
-               piput((int)cp,piget((int)cp)^(mask>>(16-n)));
+       hptab.b_active++;               /* Either complete or continuing */
+       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;
+       dn = dkunit(bp);
+       bn = dkblock(bp);
+       switch (hp_type[dn]) {
+
+       case RM:
+               ns = NRMSECT; nt = NRMTRAC; break;
+       case RM5:
+               ns = NRMSECT; nt = NTRAC; break;
+       case RP:
+               ns = NSECT; nt = NTRAC; break;
+       default:
+               panic("hpecc");

        }
        }

-       hptab.b_active++;
-       if (((struct mba_regs *)MBA0)->mba_bcr) {
-               i = bp->b_blkno%(NSECT*NTRAC);
-               i = ((i/NSECT)<<8)+(i%NSECT);
-               i = NSECT*(i>>8) + (i&0377) + b + 1;
-               if (i >= NSECT*NTRAC) {
-                       i -= NSECT*NTRAC;
-                       rp->hpdc = bp->b_cylin + 1;
-               } else
-                       rp->hpdc = bp->b_cylin;
-               rp->hpda = ((i/NSECT)<<8) + (i%NSECT);
-               rp->hpcs1 = DCLR|GO;
-               ((struct mba_regs *)MBA0)->mba_sr = -1;
-               ((struct mba_regs *)MBA0)->mba_var =
-                       ((map+1)<<9)|((int)bp->b_un.b_addr&0x1ff);
-               rp->hpcs1 = RCOM|GO;
-               return(1);
-       } else
-               return(0);
-}
-
-short
-piget(pad)
-{
-       register b, savemap;
-       register short s;
-
-       savemap = (int)mmap;
-       b = (pad>>9)&0x7fffff;
-       *(int *)mmap = b|(PG_V|PG_KR);
-       mtpr(TBIS, vmmap);
-       s = *(short *)&vmmap[pad&0x1ff];
-       *(int *)mmap = savemap;
-       mtpr(TBIS, vmmap);
-       return(s);
-}
-
-piput(pad, val)
-{
-       register b, savemap;
-       register short *p;
-
-       savemap = (int)mmap;
-       b = (pad>>9)&0x7fffff;
-       *(int *)mmap = b|(PG_V|PG_KW);
-       mtpr(TBIS, vmmap);
-       p = (short *)&vmmap[pad&0x1ff];
-       *p = val;
-       *(int *)mmap = savemap;
-       mtpr(TBIS, vmmap);
+       cn = bp->b_cylin;
+       sn = bn%(ns*nt) + npf + 1;
+       tn = sn/ns;
+       sn %= ns;
+       cn += tn/nt;
+       tn %= nt;
+       rp->hpdc = cn;
+       rp->hpda = (tn<<8) + sn;
+       mbp->mba_sr = -1;
+       mbp->mba_var = (int)ptob(reg+1) + o;
+       rp->hpcs1 = RCOM|GO;
+       return (1);

 }
 }