BSD 4_4 release

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

diff --git a/usr/src/sys/vax/mba/mba.c b/usr/src/sys/vax/mba/mba.c
index bc64c1d..0a4d48c 100644 (file)
--- a/usr/src/sys/vax/mba/mba.c
+++ b/usr/src/sys/vax/mba/mba.c
@@ -1,30 +1,42 @@
-/*     mba.c   4.9     81/02/25        */
+/*-
+ * Copyright (c) 1982 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This module is believed to contain source code proprietary to AT&T.
+ * Use and redistribution is subject to the Berkeley Software License
+ * Agreement and your Software Agreement with AT&T (Western Electric).
+ *
+ *     @(#)mba.c       7.6 (Berkeley) 5/8/91
+ */

 
 

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

 /*
 /*

- * Massbus driver; arbitrates massbusses through device driver routines
- * and provides common functions.
+ * Massbus driver, arbitrates a massbus among attached devices.

  */
  */

-int    mbadebug = 0;
-#define        dprintf if (mbadebug) printf
+#include "../include/pte.h"
+
+#include "sys/param.h"
+#include "sys/systm.h"
+#include "sys/dkstat.h"
+#include "sys/buf.h"
+#include "sys/conf.h"
+#include "sys/user.h"
+#include "sys/proc.h"
+#include "sys/map.h"
+#include "../include/mtpr.h"
+#include "sys/vm.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/proc.h"
-#include "../h/map.h"
-#include "../h/pte.h"
-#include "../h/mba.h"
-#include "../h/mtpr.h"
-#include "../h/vm.h"
+#include "mbareg.h"
+#include "mbavar.h"

 
 

-char   mbasr_bits[] = MBASR_BITS;
+/* mbunit should be the same as hpunit, etc.! */
+#define mbunit(dev)    (minor(dev) >> 3)
+
+char   mbsr_bits[] = MBSR_BITS;

 /*
  * Start activity on a massbus device.
 /*
  * Start activity on a massbus device.

- * We are given the device's mba_info structure and activate
+ * We are given the device's mba_device structure and activate

  * the device via the unit start routine.  The unit start
  * routine may indicate that it is finished (e.g. if the operation
  * was a ``sense'' on a tape drive), that the (multi-ported) unit
  * the device via the unit start routine.  The unit start
  * routine may indicate that it is finished (e.g. if the operation
  * was a ``sense'' on a tape drive), that the (multi-ported) unit


@@ -33,13 +45,11 @@ char        mbasr_bits[] = MBASR_BITS;
  * set up a data transfer operation and we should start the massbus adaptor.
  */
 mbustart(mi)
  * set up a data transfer operation and we should start the massbus adaptor.
  */
 mbustart(mi)

-       register struct mba_info *mi;
+       register struct mba_device *mi;

 {
 {

-       register struct mba_drv *mdp;   /* drive registers */

        register struct buf *bp;        /* i/o operation at head of queue */
        register struct mba_hd *mhp;    /* header for mba device is on */
 
        register struct buf *bp;        /* i/o operation at head of queue */
        register struct mba_hd *mhp;    /* header for mba device is on */
 

-       dprintf("enter mbustart\n");

 loop:
        /*
         * Get the first thing to do off device queue.
 loop:
        /*
         * Get the first thing to do off device queue.


@@ -47,16 +57,6 @@ loop:
        bp = mi->mi_tab.b_actf;
        if (bp == NULL)
                return;
        bp = mi->mi_tab.b_actf;
        if (bp == NULL)
                return;

-       mdp = mi->mi_drv;
-       /*
-        * Since we clear attentions on the drive when we are
-        * finished processing it, the fact that an attention
-        * status shows indicated confusion in the hardware or our logic.
-        */
-       if (mdp->mbd_as & (1 << mi->mi_drive)) {
-               printf("mbustart: ata on for %d\n", mi->mi_drive);
-               mdp->mbd_as = 1 << mi->mi_drive;
-       }

        /*
         * Let the drivers unit start routine have at it
         * and then process the request further, per its instructions.
        /*
         * Let the drivers unit start routine have at it
         * and then process the request further, per its instructions.


@@ -64,16 +64,15 @@ loop:
        switch ((*mi->mi_driver->md_ustart)(mi)) {
 
        case MBU_NEXT:          /* request is complete (e.g. ``sense'') */
        switch ((*mi->mi_driver->md_ustart)(mi)) {
 
        case MBU_NEXT:          /* request is complete (e.g. ``sense'') */

-               dprintf("mbu_next\n");

                mi->mi_tab.b_active = 0;
                mi->mi_tab.b_active = 0;

+               mi->mi_tab.b_errcnt = 0;

                mi->mi_tab.b_actf = bp->av_forw;
                mi->mi_tab.b_actf = bp->av_forw;

-               iodone(bp);
+               biodone(bp);

                goto loop;
 
        case MBU_DODATA:        /* all ready to do data transfer */
                goto loop;
 
        case MBU_DODATA:        /* all ready to do data transfer */

-               dprintf("mbu_dodata\n");

                /*
                /*

-                * Queue the device mba_info structure on the massbus
+                * Queue the device mba_device structure on the massbus

                 * mba_hd structure for processing as soon as the
                 * data path is available.
                 */
                 * mba_hd structure for processing as soon as the
                 * data path is available.
                 */


@@ -89,24 +88,24 @@ loop:
                 * In any case the device is ``active'' waiting for the
                 * data to transfer.
                 */
                 * In any case the device is ``active'' waiting for the
                 * data to transfer.
                 */

+               mi->mi_tab.b_active = 1;

                if (mhp->mh_active == 0)
                        mbstart(mhp);
                if (mhp->mh_active == 0)
                        mbstart(mhp);

-               mi->mi_tab.b_active = 1;

                return;
 
        case MBU_STARTED:       /* driver started a non-data transfer */
                return;
 
        case MBU_STARTED:       /* driver started a non-data transfer */

-               dprintf("mbu_started\n");

                /*
                 * Mark device busy during non-data transfer
                 * and count this as a ``seek'' on the device.
                 */
                /*
                 * Mark device busy during non-data transfer
                 * and count this as a ``seek'' on the device.
                 */

-               if (mi->mi_dk >= 0)
+               if (mi->mi_dk >= 0) {

                        dk_seek[mi->mi_dk]++;
                        dk_seek[mi->mi_dk]++;

+                       dk_busy |= (1 << mi->mi_dk);
+               }

                mi->mi_tab.b_active = 1;
                return;
 
        case MBU_BUSY:          /* dual port drive busy */
                mi->mi_tab.b_active = 1;
                return;
 
        case MBU_BUSY:          /* dual port drive busy */

-               dprintf("mbu_busy\n");

                /*
                 * We mark the device structure so that when an
                 * interrupt occurs we will know to restart the unit.
                /*
                 * We mark the device structure so that when an
                 * interrupt occurs we will know to restart the unit.


@@ -129,33 +128,48 @@ loop:
 mbstart(mhp)
        register struct mba_hd *mhp;
 {
 mbstart(mhp)
        register struct mba_hd *mhp;
 {

-       register struct mba_info *mi;
+       register struct mba_device *mi;

        struct buf *bp;
        register struct mba_regs *mbp;
        struct buf *bp;
        register struct mba_regs *mbp;

+       register int com;
+       extern int cold;

 
 

-       dprintf("mbstart\n");

 loop:
        /*
         * Look for an operation at the front of the queue.
         */
        if ((mi = mhp->mh_actf) == NULL) {
 loop:
        /*
         * Look for an operation at the front of the queue.
         */
        if ((mi = mhp->mh_actf) == NULL) {

-               dprintf("nothing to do\n");

                return;
        }
        if ((bp = mi->mi_tab.b_actf) == NULL) {
                return;
        }
        if ((bp = mi->mi_tab.b_actf) == NULL) {

-               dprintf("nothing on actf\n");

                mhp->mh_actf = mi->mi_forw;
                goto loop;
        }
        /*
         * If this device isn't present and on-line, then
         * we screwed up, and can't really do the operation.
                mhp->mh_actf = mi->mi_forw;
                goto loop;
        }
        /*
         * If this device isn't present and on-line, then
         * we screwed up, and can't really do the operation.

+        * Only check for non-tapes because tape drivers check
+        * ONLINE themselves and because TU78 registers are
+        * different.
+        * No complaints during autoconfiguration,
+        * when we try to read disk labels from anything on line.

         */
         */

-       if ((mi->mi_drv->mbd_ds & (MBD_DPR|MBD_MOL)) != (MBD_DPR|MBD_MOL)) {
-               dprintf("not on line ds %x\n", mi->mi_drv->mbd_ds);
+       if (((com = mi->mi_drv->mbd_dt) & MBDT_TAP) == 0)
+       if ((mi->mi_drv->mbd_ds & MBDS_DREADY) != MBDS_DREADY) {
+               if (!cold) {
+                   if ((com & MBDT_TYPE) == 0) {
+                       mi->mi_alive = 0;
+                       printf("%s%d: nonexistent\n", mi->mi_driver->md_dname,
+                           mbunit(bp->b_dev));
+                   } else
+                       printf("%s%d: not ready\n", mi->mi_driver->md_dname,
+                           mbunit(bp->b_dev));
+               }

                mi->mi_tab.b_actf = bp->av_forw;
                mi->mi_tab.b_actf = bp->av_forw;

+               mi->mi_tab.b_errcnt = 0;
+               mi->mi_tab.b_active = 0;

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

-               iodone(bp);
+               biodone(bp);

                goto loop;
        }
        /*
                goto loop;
        }
        /*


@@ -165,26 +179,31 @@ loop:
         * on disks).
         */
        mhp->mh_active = 1;
         * on disks).
         */
        mhp->mh_active = 1;

-       if (mi->mi_driver->md_start) {
-               dprintf("md_start\n");
-               (*mi->mi_driver->md_start)(mi);
-       }
+       if (mi->mi_driver->md_start == (int (*)())0 ||
+           (com = (*mi->mi_driver->md_start)(mi)) == 0)
+               com = (bp->b_flags & B_READ) ? MB_RCOM|MB_GO : MB_WCOM|MB_GO;

 
        /*
         * Setup the massbus control and map registers and start
         * the transfer.
         */
 
        /*
         * Setup the massbus control and map registers and start
         * the transfer.
         */

-       dprintf("start mba\n");

        mbp = mi->mi_mba;
        mbp->mba_sr = -1;       /* conservative */
        mbp = mi->mi_mba;
        mbp->mba_sr = -1;       /* conservative */

-       mbp->mba_var = mbasetup(mi);
-       mbp->mba_bcr = -bp->b_bcount;
-       mi->mi_drv->mbd_cs1 =
-           (bp->b_flags & B_READ) ? MBD_RCOM|MBD_GO : MBD_WCOM|MBD_GO;
+       if (bp->b_bcount >= 0) {
+               mbp->mba_var = mbasetup(mi) + mi->mi_tab.b_bdone;
+               mbp->mba_bcr = -(bp->b_bcount - mi->mi_tab.b_bdone);
+       } else {
+               mbp->mba_var = mbasetup(mi) - bp->b_bcount - mi->mi_tab.b_bdone - 1;
+               mbp->mba_bcr = bp->b_bcount + mi->mi_tab.b_bdone;
+       }
+       mi->mi_drv->mbd_cs1 = com;

        if (mi->mi_dk >= 0) {
                dk_busy |= 1 << mi->mi_dk;
                dk_xfer[mi->mi_dk]++;
        if (mi->mi_dk >= 0) {
                dk_busy |= 1 << mi->mi_dk;
                dk_xfer[mi->mi_dk]++;

-               dk_wds[mi->mi_dk] += bp->b_bcount >> 6;
+               if (bp->b_bcount >= 0)
+                       dk_wds[mi->mi_dk] += bp->b_bcount >> 6;
+               else
+                       dk_wds[mi->mi_dk] += -(bp->b_bcount) >> 6;

        }
 }
 
        }
 }
 


@@ -197,29 +216,28 @@ mbintr(mbanum)
 {
        register struct mba_hd *mhp = &mba_hd[mbanum];
        register struct mba_regs *mbp = mhp->mh_mba;
 {
        register struct mba_hd *mhp = &mba_hd[mbanum];
        register struct mba_regs *mbp = mhp->mh_mba;

-       register struct mba_info *mi;
+       register struct mba_device *mi;

        register struct buf *bp;
        register int drive;
        register struct buf *bp;
        register int drive;

-       int mbastat, as;
+       int mbasr, as;
+       extern struct mba_device *mbaconfig();

        
        /*
         * Read out the massbus status register
         * and attention status register and clear
         * the bits in same by writing them back.
         */
        
        /*
         * Read out the massbus status register
         * and attention status register and clear
         * the bits in same by writing them back.
         */

-       mbastat = mbp->mba_sr;
-       mbp->mba_sr = mbastat;
+       mbasr = mbp->mba_sr;
+       mbp->mba_sr = mbasr;
+#if VAX750
+       if (mbasr&MBSR_CBHUNG) {
+               printf("mba%d: control bus hung\n", mbanum);
+               panic("cbhung");
+       }
+#endif

        /* note: the mbd_as register is shared between drives */
        /* note: the mbd_as register is shared between drives */

-       as = mbp->mba_drv[0].mbd_as;
+       as = mbp->mba_drv[0].mbd_as & 0xff;

        mbp->mba_drv[0].mbd_as = as;
        mbp->mba_drv[0].mbd_as = as;

-       dprintf("mbintr mbastat %x as %x\n", mbastat, as);
-
-       /*
-        * Disable interrupts from the massbus adapter
-        * for the duration of the operation of the massbus
-        * driver, so that spurious interrupts won't be generated.
-        */
-       mbp->mba_cr &= ~MBAIE;

 
        /*
         * If the mba was active, process the data transfer
 
        /*
         * If the mba was active, process the data transfer


@@ -227,32 +245,27 @@ mbintr(mbanum)
         * are now finished.
         */
        if (mhp->mh_active) {
         * are now finished.
         */
        if (mhp->mh_active) {

-               if ((mbastat & MBS_DTCMP) == 0) {
-                       printf("mbintr(%d),b_active,no DTCMP!\n", mbanum);
-                       goto doattn;
-               }

                /*
                 * Clear attention status for drive whose data
                /*
                 * Clear attention status for drive whose data

-                * transfer completed, and give the dtint driver
+                * transfer related operation completed,
+                * and give the dtint driver

                 * routine a chance to say what is next.
                 */
                mi = mhp->mh_actf;
                as &= ~(1 << mi->mi_drive);
                dk_busy &= ~(1 << mi->mi_dk);
                bp = mi->mi_tab.b_actf;
                 * routine a chance to say what is next.
                 */
                mi = mhp->mh_actf;
                as &= ~(1 << mi->mi_drive);
                dk_busy &= ~(1 << mi->mi_dk);
                bp = mi->mi_tab.b_actf;

-               switch((*mi->mi_driver->md_dtint)(mi, mbastat)) {
+               switch ((*mi->mi_driver->md_dtint)(mi, mbasr)) {

 
                case MBD_DONE:          /* all done, for better or worse */
 
                case MBD_DONE:          /* all done, for better or worse */

-                       dprintf("mbd_done\n");

                        /*
                         * Flush request from drive queue.
                         */
                        mi->mi_tab.b_errcnt = 0;
                        mi->mi_tab.b_actf = bp->av_forw;
                        /*
                         * Flush request from drive queue.
                         */
                        mi->mi_tab.b_errcnt = 0;
                        mi->mi_tab.b_actf = bp->av_forw;

-                       iodone(bp);
+                       biodone(bp);

                        /* fall into... */
                case MBD_RETRY:         /* attempt the operation again */
                        /* fall into... */
                case MBD_RETRY:         /* attempt the operation again */

-                       dprintf("mbd_retry\n");

                        /*
                         * Dequeue data transfer from massbus queue;
                         * if there is still a i/o request on the device
                        /*
                         * Dequeue data transfer from massbus queue;
                         * if there is still a i/o request on the device


@@ -266,132 +279,172 @@ mbintr(mbanum)
                                mbustart(mi);
                        break;
 
                                mbustart(mi);
                        break;
 

-               case MBD_RESTARTED:     /* driver restarted op (ecc, e.g.)
-                       dprintf("mbd_restarted\n");
+               case MBD_REPOSITION:    /* driver started repositioning */

                        /*
                        /*

-                        * Note that mp->b_active is still on.
+                        * Drive is repositioning, not doing data transfer.
+                        * Free controller, but don't have to restart drive.
+                        */
+                       mhp->mh_active = 0;
+                       mhp->mh_actf = mi->mi_forw;
+                       break;
+
+               case MBD_RESTARTED:     /* driver restarted op (ecc, e.g.) */
+                       /*
+                        * Note that mhp->mh_active is still on.

                         */
                        break;
 
                default:
                         */
                        break;
 
                default:

-                       panic("mbaintr");
+                       panic("mbintr");

                }
                }

-       } else {
-               dprintf("!dtcmp\n");
-               if (mbastat & MBS_DTCMP)
-                       printf("mbaintr,DTCMP,!b_active\n");

        }
        }

-doattn:

        /*
         * Service drives which require attention
         * after non-data-transfer operations.
         */
        /*
         * Service drives which require attention
         * after non-data-transfer operations.
         */

-       for (drive = 0; as && drive < 8; drive++)
-               if (as & (1 << drive)) {
-                       dprintf("service as %d\n", drive);
-                       as &= ~(1 << drive);
+       while (drive = ffs((long)as)) {
+               drive--;                /* was 1 origin */
+               as &= ~(1 << drive);
+               mi = mhp->mh_mbip[drive];
+               if (mi == NULL || mi->mi_alive == 0) {
+                       struct mba_device fnd;
+                       struct mba_drv *mbd = &mhp->mh_mba->mba_drv[drive];
+                       int dt = mbd->mbd_dt & 0xffff;
+
+                       if (dt == 0 || dt == MBDT_MOH)
+                               continue;
+                       fnd.mi_mba = mhp->mh_mba;
+                       fnd.mi_mbanum = mbanum;
+                       fnd.mi_drive = drive;
+                       if ((mi = mbaconfig(&fnd, dt)) == NULL)
+                               continue;

                        /*
                        /*

-                        * Consistency check the implied attention,
-                        * to make sure the drive should have interrupted.
+                        * If a tape, poke the slave attach routines.
+                        * Otherwise, could be a disk which we want
+                        * to swap on, so make a pass over the swap
+                        * configuration table in case the size of
+                        * the swap area must be determined by drive type.

                         */
                         */

-                       mi = mhp->mh_mbip[drive];
-                       if (mi == NULL)
-                               goto random;            /* no such drive */
-                       if (mi->mi_tab.b_active == 0 &&
-                           (mi->mi_tab.b_flags&B_BUSY) == 0)
-                               goto random;            /* not active */
-                       if ((bp = mi->mi_tab.b_actf) == NULL) {
-                                                       /* nothing doing */
-random:
-                               printf("random mbaintr %d %d\n",mbanum,drive);
-                               continue;
+                       if (dt & MBDT_TAP)
+                               mbaddtape(mi, drive);
+                       else
+                               swapconf();
+               }
+               /*
+                * If driver has a handler for non-data transfer
+                * interrupts, give it a chance to tell us what to do.
+                */
+               if (mi->mi_driver->md_ndint) {
+                       switch ((*mi->mi_driver->md_ndint)(mi)) {
+
+                       case MBN_DONE:          /* operation completed */
+                               mi->mi_tab.b_active = 0;
+                               mi->mi_tab.b_errcnt = 0;
+                               bp = mi->mi_tab.b_actf;
+                               mi->mi_tab.b_actf = bp->av_forw;
+                               biodone(bp);
+                               /* fall into common code */
+                       case MBN_RETRY:         /* operation continues */
+                               if (mi->mi_tab.b_actf)
+                                       mbustart(mi);
+                               break;
+                       case MBN_SKIP:          /* ignore unsol. interrupt */
+                               break;
+                       default:
+                               panic("mbintr");

                        }
                        }

+               } else

                        /*
                        /*

-                        * If this interrupt wasn't a notification that
-                        * a dual ported drive is available, and if the
-                        * driver has a handler for non-data transfer
-                        * interrupts, give it a chance to tell us that
-                        * the operation needs to be redone
+                        * If there is no non-data transfer interrupt
+                        * routine, then we should just
+                        * restart the unit, leading to a mbstart() soon.

                         */
                         */

-                       if ((mi->mi_tab.b_flags&B_BUSY) == 0 &&
-                           mi->mi_driver->md_ndint) {
-                               mi->mi_tab.b_active = 0;
-                               switch((*mi->mi_driver->md_ndint)(mi)) {
-
-                               case MBN_DONE:
-                                       dprintf("mbn_done\n");
-                                       /*
-                                        * Non-data transfer interrupt
-                                        * completed i/o request's processing.
-                                        */
-                                       mi->mi_tab.b_errcnt = 0;
-                                       mi->mi_tab.b_actf = bp->av_forw;
-                                       iodone(bp);
-                                       /* fall into... */
-                               case MBN_RETRY:
-                                       dprintf("mbn_retry\n");
-                                       if (mi->mi_tab.b_actf)
-                                               mbustart(mi);
-                                       break;
-
-                               default:
-                                       panic("mbintr ndint");
-                               }
-                       } else
-                               mbustart(mi);
-               }
+                       mbustart(mi);
+       }

        /*
         * If there is an operation available and
         * the massbus isn't active, get it going.
         */
        if (mhp->mh_actf && !mhp->mh_active)
                mbstart(mhp);
        /*
         * If there is an operation available and
         * the massbus isn't active, get it going.
         */
        if (mhp->mh_actf && !mhp->mh_active)
                mbstart(mhp);

-       mbp->mba_cr |= MBAIE;
+       /* THHHHATS all folks... */
+}
+
+/*
+ * For autoconfig'ng tape drives on the fly.
+ */
+mbaddtape(mi, drive)
+       struct mba_device *mi;
+       int drive;
+{
+       register struct mba_slave *ms;
+
+       for (ms = mbsinit; ms->ms_driver; ms++)
+               if (ms->ms_driver == mi->mi_driver && ms->ms_alive == 0 && 
+                   (ms->ms_ctlr == mi->mi_unit ||
+                    ms->ms_ctlr == '?')) {
+                       if ((*ms->ms_driver->md_slave)(mi, ms, drive)) {
+                               printf("%s%d at %s%d slave %d\n",
+                                   ms->ms_driver->md_sname,
+                                   ms->ms_unit,
+                                   mi->mi_driver->md_dname,
+                                   mi->mi_unit,
+                                   ms->ms_slave);
+                               ms->ms_alive = 1;
+                               ms->ms_ctlr = mi->mi_unit;
+                       }
+               }

 }
 
 /*
  * Setup the mapping registers for a transfer.
  */
 mbasetup(mi)
 }
 
 /*
  * Setup the mapping registers for a transfer.
  */
 mbasetup(mi)

-       register struct mba_info *mi;
+       register struct mba_device *mi;

 {
        register struct mba_regs *mbap = mi->mi_mba;
        struct buf *bp = mi->mi_tab.b_actf;
 {
        register struct mba_regs *mbap = mi->mi_mba;
        struct buf *bp = mi->mi_tab.b_actf;

-       register int i;
-       int npf;
+       register int npf;

        unsigned v;
        register struct pte *pte, *io;
        int o;
        unsigned v;
        register struct pte *pte, *io;
        int o;

-       int vaddr;

        struct proc *rp;
 
        struct proc *rp;
 

-       io = mbap->mba_map;

        v = btop(bp->b_un.b_addr);
        v = btop(bp->b_un.b_addr);

-       o = (int)bp->b_un.b_addr & PGOFSET;
-       npf = btoc(bp->b_bcount + o);
+       o = (int)(bp->b_un.b_addr) & PGOFSET;
+       if (bp->b_bcount >= 0)
+               npf = btoc(bp->b_bcount + o);
+       else
+               npf = btoc(-(bp->b_bcount) + o);

        rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;
        rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;

-       vaddr = o;
-       if (bp->b_flags & B_UAREA) {
-               for (i = 0; i < UPAGES; i++) {
-                       if (rp->p_addr[i].pg_pfnum == 0)
-                               panic("mba: zero upage");
-                       *(int *)io++ = rp->p_addr[i].pg_pfnum | PG_V;
-               }
-       } else if ((bp->b_flags & B_PHYS) == 0) {
+       if ((bp->b_flags & B_PHYS) == 0)

                pte = &Sysmap[btop(((int)bp->b_un.b_addr)&0x7fffffff)];
                pte = &Sysmap[btop(((int)bp->b_un.b_addr)&0x7fffffff)];

-               while (--npf >= 0)
-                       *(int *)io++ = pte++->pg_pfnum | PG_V;
-       } else {
-               if (bp->b_flags & B_PAGET)
-                       pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)];
-               else
-                       pte = vtopte(rp, v);
-               while (--npf >= 0) {
-                       if (pte->pg_pfnum == 0)
-                               panic("mba, zero entry");
-                       *(int *)io++ = pte++->pg_pfnum | PG_V;
-               }
+       else if (bp->b_flags & B_UAREA)
+               pte = &rp->p_addr[v];
+       else if (bp->b_flags & B_PAGET)
+               pte = &Usrptmap[btokmx((struct pte *)bp->b_un.b_addr)];
+       else
+               pte = vtopte(rp, v);
+       io = mbap->mba_map;
+       while (--npf >= 0) {
+               if (pte->pg_pfnum == 0)
+                       panic("mba, zero entry");
+               *(int *)io++ = pte++->pg_pfnum | PG_V;

        }
        *(int *)io++ = 0;
        }
        *(int *)io++ = 0;

-       return (vaddr);
+       return (o);
+}
+
+#if notdef
+/*
+ * Init and interrupt enable a massbus adapter.
+ */
+mbainit(mp)
+       struct mba_regs *mp;
+{
+
+       mp->mba_cr = MBCR_INIT;
+       mp->mba_cr = MBCR_IE;

 }
 }

+#endif
+#endif