fix include to use "ioctl.h" instead of /usr/include/sys/ioctl.h for kernel

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

diff --git a/usr/src/sys/vax/uba/uba.c b/usr/src/sys/vax/uba/uba.c
index 87629a9..2888b37 100644 (file)
--- a/usr/src/sys/vax/uba/uba.c
+++ b/usr/src/sys/vax/uba/uba.c
@@ -1,22 +1,28 @@
-/*     uba.c   4.16    %G%     */
+/*     uba.c   6.1     83/08/21        */

 
 

-#define        DELAY(N)        { register int d; d = N; while (--d > 0); }
+#include "../machine/pte.h"

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

-#include "../h/cpu.h"

 #include "../h/map.h"
 #include "../h/map.h"

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

 #include "../h/buf.h"
 #include "../h/vm.h"
 #include "../h/buf.h"
 #include "../h/vm.h"

-#include "../h/uba.h"

 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/proc.h"
 #include "../h/conf.h"
 #include "../h/dir.h"
 #include "../h/user.h"
 #include "../h/proc.h"
 #include "../h/conf.h"

-#include "../h/mtpr.h"
-#include "../h/nexus.h"

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

+#include "../h/kernel.h"
+
+#include "../vax/cpu.h"
+#include "../vax/mtpr.h"
+#include "../vax/nexus.h"
+#include "../vaxuba/ubareg.h"
+#include "../vaxuba/ubavar.h"
+
+#if VAX780
+char   ubasr_bits[] = UBASR_BITS;
+#endif

 
 /*
  * Do transfer on device argument.  The controller
 
 /*
  * Do transfer on device argument.  The controller


@@ -32,9 +38,9 @@
  * of the request queue is likely to be a disaster.
  */
 ubago(ui)
  * of the request queue is likely to be a disaster.
  */
 ubago(ui)

-       register struct uba_dinfo *ui;
+       register struct uba_device *ui;

 {
 {

-       register struct uba_minfo *um = ui->ui_mi;
+       register struct uba_ctlr *um = ui->ui_mi;

        register struct uba_hd *uh;
        register int s, unit;
 
        register struct uba_hd *uh;
        register int s, unit;
 


@@ -53,14 +59,12 @@ ubago(ui)
        if (ui->ui_dk >= 0) {
                unit = ui->ui_dk;
                dk_busy |= 1<<unit;
        if (ui->ui_dk >= 0) {
                unit = ui->ui_dk;
                dk_busy |= 1<<unit;

+               dk_xfer[unit]++;
+               dk_wds[unit] += um->um_tab.b_actf->b_actf->b_bcount>>6;

        }
        if (uh->uh_actf == ui)
                uh->uh_actf = ui->ui_forw;
        (*um->um_driver->ud_dgo)(um);
        }
        if (uh->uh_actf == ui)
                uh->uh_actf = ui->ui_forw;
        (*um->um_driver->ud_dgo)(um);

-       if (ui->ui_dk >= 0) {
-               dk_xfer[unit]++;
-               dk_wds[unit] += um->um_tab.b_actf->b_bcount>>6;
-       }

        return (1);
 rwait:
        if (uh->uh_actf != ui) {
        return (1);
 rwait:
        if (uh->uh_actf != ui) {


@@ -76,7 +80,7 @@ rwait:
 }
 
 ubadone(um)
 }
 
 ubadone(um)

-       register struct uba_minfo *um;
+       register struct uba_ctlr *um;

 {
        register struct uba_hd *uh = &uba_hd[um->um_ubanum];
 
 {
        register struct uba_hd *uh = &uba_hd[um->um_ubanum];
 


@@ -101,63 +105,63 @@ ubasetup(uban, bp, flags)
        struct buf *bp;
 {
        register struct uba_hd *uh = &uba_hd[uban];
        struct buf *bp;
 {
        register struct uba_hd *uh = &uba_hd[uban];

-       register int temp, i;
+       register int temp;

        int npf, reg, bdp;
        unsigned v;
        register struct pte *pte, *io;
        struct proc *rp;
        int a, o, ubinfo;
 
        int npf, reg, bdp;
        unsigned v;
        register struct pte *pte, *io;
        struct proc *rp;
        int a, o, ubinfo;
 

+#if VAX730
+       if (cpu == VAX_730)
+               flags &= ~UBA_NEEDBDP;
+#endif

        v = btop(bp->b_un.b_addr);
        o = (int)bp->b_un.b_addr & PGOFSET;
        npf = btoc(bp->b_bcount + o) + 1;
        a = spl6();
        v = btop(bp->b_un.b_addr);
        o = (int)bp->b_un.b_addr & PGOFSET;
        npf = btoc(bp->b_bcount + o) + 1;
        a = spl6();

-       while ((reg = malloc(uh->uh_map, npf)) == 0) {
-               if (flags & UBA_CANTWAIT)
+       while ((reg = rmalloc(uh->uh_map, (long)npf)) == 0) {
+               if (flags & UBA_CANTWAIT) {
+                       splx(a);

                        return (0);
                        return (0);

+               }

                uh->uh_mrwant++;
                uh->uh_mrwant++;

-               sleep((caddr_t)uh->uh_map, PSWP);
+               sleep((caddr_t)&uh->uh_mrwant, PSWP);

        }
        bdp = 0;
        if (flags & UBA_NEEDBDP) {
                while ((bdp = ffs(uh->uh_bdpfree)) == 0) {
                        if (flags & UBA_CANTWAIT) {
        }
        bdp = 0;
        if (flags & UBA_NEEDBDP) {
                while ((bdp = ffs(uh->uh_bdpfree)) == 0) {
                        if (flags & UBA_CANTWAIT) {

-                               mfree(uh->uh_map, npf, reg);
+                               rmfree(uh->uh_map, (long)npf, (long)reg);
+                               splx(a);

                                return (0);
                        }
                        uh->uh_bdpwant++;
                                return (0);
                        }
                        uh->uh_bdpwant++;

-                       sleep((caddr_t)uh->uh_map, PSWP);
+                       sleep((caddr_t)&uh->uh_bdpwant, PSWP);

                }
                uh->uh_bdpfree &= ~(1 << (bdp-1));
                }
                uh->uh_bdpfree &= ~(1 << (bdp-1));

-       }
+       } else if (flags & UBA_HAVEBDP)
+               bdp = (flags >> 28) & 0xf;

        splx(a);
        reg--;
        ubinfo = (bdp << 28) | (npf << 18) | (reg << 9) | o;
        splx(a);
        reg--;
        ubinfo = (bdp << 28) | (npf << 18) | (reg << 9) | o;

-       io = &uh->uh_uba->uba_map[reg];
-       temp = (bdp << 21) | UBA_MRV;
-       rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;
+       temp = (bdp << 21) | UBAMR_MRV;

        if (bdp && (o & 01))
        if (bdp && (o & 01))

-               temp |= UBA_BO;
-       if (bp->b_flags & B_UAREA) {
-               for (i = UPAGES - bp->b_bcount / NBPG; i < UPAGES; i++) {
-                       if (rp->p_addr[i].pg_pfnum == 0)
-                               panic("uba: zero upage");
-                       *(int *)io++ = rp->p_addr[i].pg_pfnum | temp;
-               }
-       } else if ((bp->b_flags & B_PHYS) == 0) {
+               temp |= UBAMR_BO;
+       rp = bp->b_flags&B_DIRTY ? &proc[2] : bp->b_proc;
+       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 | temp;
-       } 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("uba zero uentry");
-                       *(int *)io++ = pte++->pg_pfnum | temp;
-               }
+       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 = &uh->uh_uba->uba_map[reg];
+       while (--npf != 0) {
+               if (pte->pg_pfnum == 0)
+                       panic("uba zero uentry");
+               *(int *)io++ = pte++->pg_pfnum | temp;

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


@@ -167,8 +171,9 @@ ubasetup(uban, bp, flags)
  * Non buffer setup interface... set up a buffer and call ubasetup.
  */
 uballoc(uban, addr, bcnt, flags)
  * Non buffer setup interface... set up a buffer and call ubasetup.
  */
 uballoc(uban, addr, bcnt, flags)

+       int uban;

        caddr_t addr;
        caddr_t addr;

-       unsigned short bcnt;
+       int bcnt, flags;

 {
        struct buf ubabuf;
 
 {
        struct buf ubabuf;
 


@@ -212,19 +217,20 @@ ubarelse(uban, amr)
                switch (cpu) {
 #if VAX780
                case VAX_780:
                switch (cpu) {
 #if VAX780
                case VAX_780:

-                       uh->uh_uba->uba_dpr[bdp] |= UBA_BNE;
+                       uh->uh_uba->uba_dpr[bdp] |= UBADPR_BNE;

                        break;
 #endif
 #if VAX750
                case VAX_750:
                        break;
 #endif
 #if VAX750
                case VAX_750:

-                       uh->uh_uba->uba_dpr[bdp] |= UBA_PURGE|UBA_NXM|UBA_UCE;
+                       uh->uh_uba->uba_dpr[bdp] |=
+                           UBADPR_PURGE|UBADPR_NXM|UBADPR_UCE;

                        break;
 #endif
                }
                uh->uh_bdpfree |= 1 << (bdp-1);         /* atomic */
                if (uh->uh_bdpwant) {
                        uh->uh_bdpwant = 0;
                        break;
 #endif
                }
                uh->uh_bdpfree |= 1 << (bdp-1);         /* atomic */
                if (uh->uh_bdpwant) {
                        uh->uh_bdpwant = 0;

-                       wakeup((caddr_t)uh->uh_map);
+                       wakeup((caddr_t)&uh->uh_bdpwant);

                }
        }
        /*
                }
        }
        /*


@@ -235,7 +241,7 @@ ubarelse(uban, amr)
        npf = (mr >> 18) & 0x3ff;
        reg = ((mr >> 9) & 0x1ff) + 1;
        s = spl6();
        npf = (mr >> 18) & 0x3ff;
        reg = ((mr >> 9) & 0x1ff) + 1;
        s = spl6();

-       mfree(uh->uh_map, npf, reg);
+       rmfree(uh->uh_map, (long)npf, (long)reg);

        splx(s);
 
        /*
        splx(s);
 
        /*


@@ -245,14 +251,14 @@ ubarelse(uban, amr)
         */
        if (uh->uh_mrwant) {
                uh->uh_mrwant = 0;
         */
        if (uh->uh_mrwant) {
                uh->uh_mrwant = 0;

-               wakeup((caddr_t)uh->uh_map);
+               wakeup((caddr_t)&uh->uh_mrwant);

        }
        while (uh->uh_actf && ubago(uh->uh_actf))
                ;
 }
 
 ubapurge(um)
        }
        while (uh->uh_actf && ubago(uh->uh_actf))
                ;
 }
 
 ubapurge(um)

-       register struct uba_minfo *um;
+       register struct uba_ctlr *um;

 {
        register struct uba_hd *uh = um->um_hd;
        register int bdp = (um->um_ubinfo >> 28) & 0x0f;
 {
        register struct uba_hd *uh = um->um_hd;
        register int bdp = (um->um_ubinfo >> 28) & 0x0f;


@@ -260,12 +266,35 @@ ubapurge(um)
        switch (cpu) {
 #if VAX780
        case VAX_780:
        switch (cpu) {
 #if VAX780
        case VAX_780:

-               uh->uh_uba->uba_dpr[bdp] |= UBA_BNE;
+               uh->uh_uba->uba_dpr[bdp] |= UBADPR_BNE;

                break;
 #endif
 #if VAX750
        case VAX_750:
                break;
 #endif
 #if VAX750
        case VAX_750:

-               uh->uh_uba->uba_dpr[bdp] |= UBA_PURGE|UBA_NXM|UBA_UCE;
+               uh->uh_uba->uba_dpr[bdp] |= UBADPR_PURGE|UBADPR_NXM|UBADPR_UCE;
+               break;
+#endif
+       }
+}
+
+ubainitmaps(uhp)
+       register struct uba_hd *uhp;
+{
+
+       rminit(uhp->uh_map, (long)NUBMREG, (long)1, "uba", UAMSIZ);
+       switch (cpu) {
+#if VAX780
+       case VAX_780:
+               uhp->uh_bdpfree = (1<<NBDP780) - 1;
+               break;
+#endif
+#if VAX750
+       case VAX_750:
+               uhp->uh_bdpfree = (1<<NBDP750) - 1;
+               break;
+#endif
+#if VAX730
+       case VAX_730:

                break;
 #endif
        }
                break;
 #endif
        }


@@ -287,34 +316,23 @@ ubareset(uban)
        uh->uh_users = 0;
        uh->uh_zvcnt = 0;
        uh->uh_xclu = 0;
        uh->uh_users = 0;
        uh->uh_zvcnt = 0;
        uh->uh_xclu = 0;

-       uh->uh_hangcnt = 0;

        uh->uh_actf = uh->uh_actl = 0;
        uh->uh_bdpwant = 0;
        uh->uh_mrwant = 0;
        uh->uh_actf = uh->uh_actl = 0;
        uh->uh_bdpwant = 0;
        uh->uh_mrwant = 0;

+       ubainitmaps(uh);

        wakeup((caddr_t)&uh->uh_bdpwant);
        wakeup((caddr_t)&uh->uh_mrwant);
        wakeup((caddr_t)&uh->uh_bdpwant);
        wakeup((caddr_t)&uh->uh_mrwant);

-       switch (cpu) {
-#if VAX780
-       case VAX_780:
-               printf("UBA RESET %d:", uban);
-               ubainit(uh->uh_uba);
-               break;
-#endif
-#if VAX750
-       case VAX_750:
-               printf("UNIBUS INIT:");
-               mtpr(IUR, 1);
-               DELAY(100000);
-               break;
-#endif
-       }
-       for (cdp = cdevsw; cdp->d_open; cdp++)
+       printf("uba%d: reset", uban);
+       ubainit(uh->uh_uba);
+       for (cdp = cdevsw; cdp < cdevsw + nchrdev; cdp++)

                (*cdp->d_reset)(uban);
                (*cdp->d_reset)(uban);

+#ifdef INET
+       ifubareset(uban);
+#endif

        printf("\n");
        splx(s);
 }
 
        printf("\n");
        splx(s);
 }
 

-#if VAX780

 /*
  * Init a uba.  This is called with a pointer
  * rather than a virtual address since it is called
 /*
  * Init a uba.  This is called with a pointer
  * rather than a virtual address since it is called


@@ -327,54 +345,35 @@ ubainit(uba)
        register struct uba_regs *uba;
 {
 
        register struct uba_regs *uba;
 {
 

-       uba->uba_cr = UBA_ADINIT;
-       uba->uba_cr = UBA_IFS|UBA_BRIE|UBA_USEFIE|UBA_SUEFIE;
-       while ((uba->uba_cnfgr & UBA_UBIC) == 0)
-               ;
-}
-
-/*
- * Check to make sure the UNIBUS adaptor is not hung,
- * with an interrupt in the register to be presented,
- * but not presenting it for an extended period (5 seconds).
- */
-unhang()
-{
-       register int uban;
-
-       for (uban = 0; uban < numuba; uban++) {
-               register struct uba_hd *uh = &uba_hd[uban];
-               register struct uba_regs *up = uh->uh_uba;
-
-               if (up->uba_sr == 0)
-                       return;
-               uh->uh_hangcnt++;
-               if (uh->uh_hangcnt > 5*HZ) {
-                       uh->uh_hangcnt = 0;
-                       printf("HANG ");
-                       ubareset(uban);
-               }
-       }
-}
-
-/*
- * This is a timeout routine which decrements the ``i forgot to
- * interrupt'' counts, on an 11/780.  This prevents slowly growing
- * counts from causing a UBA reset since we are interested only
- * in hang situations.
- */
-ubawatch()
-{
-       register struct uba_hd *uh;
-       register int uban;
-
-       for (uban = 0; uban < numuba; uban++) {
-               uh = &uba_hd[uban];
-               if (uh->uh_hangcnt)
-                       uh->uh_hangcnt--;
+       switch (cpu) {
+#if VAX780
+       case VAX_780:
+               uba->uba_cr = UBACR_ADINIT;
+               uba->uba_cr = UBACR_IFS|UBACR_BRIE|UBACR_USEFIE|UBACR_SUEFIE;
+               while ((uba->uba_cnfgr & UBACNFGR_UBIC) == 0)
+                       ;
+               break;
+#endif
+#if VAX750
+       case VAX_750:
+#endif
+#if VAX730
+       case VAX_730:
+#endif
+#if defined(VAX750) || defined(VAX730)
+               mtpr(IUR, 0);
+               /* give devices time to recover from power fail */
+/* THIS IS PROBABLY UNNECESSARY */
+               DELAY(500000);
+/* END PROBABLY UNNECESSARY */
+               break;
+#endif

        }
 }
 
        }
 }
 

+#ifdef VAX780
+int    ubawedgecnt = 10;
+int    ubacrazy = 500;

 /*
  * This routine is called by the locore code to
  * process a UBA error on an 11/780.  The arguments are passed
 /*
  * This routine is called by the locore code to
  * process a UBA error on an 11/780.  The arguments are passed


@@ -395,26 +394,100 @@ ubaerror(uban, uh, xx, uvec, uba)
        if (uvec == 0) {
                uh->uh_zvcnt++;
                if (uh->uh_zvcnt > 250000) {
        if (uvec == 0) {
                uh->uh_zvcnt++;
                if (uh->uh_zvcnt > 250000) {

-                       printf("ZERO VECTOR ");
+                       printf("uba%d: too many zero vectors\n");

                        ubareset(uban);
                }
                uvec = 0;
                return;
        }
        if (uba->uba_cnfgr & NEX_CFGFLT) {
                        ubareset(uban);
                }
                uvec = 0;
                return;
        }
        if (uba->uba_cnfgr & NEX_CFGFLT) {

-               printf("UBA%d SBI FAULT sr %x cnfgr %x\n",
-                   uban, uba->uba_sr, uba->uba_cnfgr);
+               printf("uba%d: sbi fault sr=%b cnfgr=%b\n",
+                   uban, uba->uba_sr, ubasr_bits,
+                   uba->uba_cnfgr, NEXFLT_BITS);

                ubareset(uban);
                uvec = 0;
                return;
        }
        sr = uba->uba_sr;
        s = spl7();
                ubareset(uban);
                uvec = 0;
                return;
        }
        sr = uba->uba_sr;
        s = spl7();

-       printf("UBA%d ERROR SR %x FMER %x FUBAR %o\n",
-           uban, uba->uba_sr, uba->uba_fmer, 4*uba->uba_fubar);
+       printf("uba%d: uba error sr=%b fmer=%x fubar=%o\n",
+           uban, uba->uba_sr, ubasr_bits, uba->uba_fmer, 4*uba->uba_fubar);

        splx(s);
        uba->uba_sr = sr;
        splx(s);
        uba->uba_sr = sr;

-       uvec &= UBA_DIV;
+       uvec &= UBABRRVR_DIV;
+       if (++uh->uh_errcnt % ubawedgecnt == 0) {
+               if (uh->uh_errcnt > ubacrazy)
+                       panic("uba crazy");
+               printf("ERROR LIMIT ");
+               ubareset(uban);
+               uvec = 0;
+               return;
+       }

        return;
 }
 #endif
        return;
 }
 #endif

+
+/*
+ * Allocate UNIBUS memory.  Allocates and initializes
+ * sufficient mapping registers for access.  On a 780,
+ * the configuration register is setup to disable UBA
+ * response on DMA transfers to addresses controlled
+ * by the disabled mapping registers.
+ */
+ubamem(uban, addr, npg, doalloc)
+       int uban, addr, npg, doalloc;
+{
+       register struct uba_hd *uh = &uba_hd[uban];
+       register int a;
+
+       if (doalloc) {
+               int s = spl6();
+               a = rmget(uh->uh_map, npg, (addr >> 9) + 1);
+               splx(s);
+       } else
+               a = (addr >> 9) + 1;
+       if (a) {
+               register int i, *m;
+
+               m = (int *)&uh->uh_uba->uba_map[a - 1];
+               for (i = 0; i < npg; i++)
+                       *m++ = 0;       /* All off, especially 'valid' */
+#if VAX780
+               /*
+                * On a 780, set up the map register disable
+                * field in the configuration register.  Beware
+                * of callers that request memory ``out of order''.
+                */
+               if (cpu == VAX_780) {
+                       int cr = uh->uh_uba->uba_cr;
+
+                       i = (addr + npg * 512 + 8191) / 8192;
+                       if (i > (cr >> 26))
+                               uh->uh_uba->uba_cr |= i << 26;
+               }
+#endif
+       }
+       return (a);
+}
+
+#include "ik.h"
+#if NIK > 0
+/*
+ * Map a virtual address into users address space. Actually all we
+ * do is turn on the user mode write protection bits for the particular
+ * page of memory involved.
+ */
+maptouser(vaddress)
+       caddr_t vaddress;
+{
+
+       Sysmap[(((unsigned)(vaddress))-0x80000000) >> 9].pg_prot = (PG_UW>>27);
+}
+
+unmaptouser(vaddress)
+       caddr_t vaddress;
+{
+
+       Sysmap[(((unsigned)(vaddress))-0x80000000) >> 9].pg_prot = (PG_KW>>27);
+}
+#endif