Return to ubadev.c CVS log

Up to [Research Unix] / researchv10no / sys / mkconf

Annotation of researchv10no/sys/mkconf/ubadev.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * routines for unibus devices
                      3:  */
                      4: 
                      5: #include "mkconf.h"
                      6: 
                      7: /*
                      8:  * address parts
                      9:  */
                     10: 
                     11: static char *ubafields[] = {
                     12:        "ub", "reg", "vec", NULL
                     13: };
                     14: 
                     15: #define        a_adp   addr[0]         /* adapter number */
                     16: #define        a_addr  addr[1]         /* UNIBUS address */
                     17: #define        a_vec   addr[2]         /* UNIBUS vector */
                     18: 
                     19: #define        VFMT    "X%s%d%d"
                     20: 
                     21: /*
                     22:  * syntax checks
                     23:  */
                     24: 
                     25: int
                     26: ubasyntax(dp, ap, n)
                     27: register Dev *dp;
                     28: char **ap;
                     29: int n;
                     30: {
                     31:        char *p;
                     32: 
                     33:        dp->a_vec = 0;
                     34:        if ((p = keyread(dp->addr, ap, n, ubafields)) != NULL) {
                     35:                fprint(STDERR, "%s %d: bad field %s\n", dp->mdev->name, dp->id, p);
                     36:                errs++;
                     37:                return (1);
                     38:        }
                     39:        if (dp->a_addr == 0) {
                     40:                fprint(STDERR, "%s %d: no address\n", dp->mdev->name, dp->id);
                     41:                return (1);
                     42:        }
                     43:        dp->a_addr |= 0760000;  /* 16->18 bit language */
                     44:        return (0);
                     45: }
                     46: 
                     47: /*
                     48:  * intermediate fixups:
                     49:  *     find the parent
                     50:  *     store the vector
                     51:  */
                     52: 
                     53: int
                     54: ubafixup(dp)
                     55: register Dev *dp;
                     56: {
                     57:        register int vec;
                     58:        register int i;
                     59:        char vname[30];
                     60: 
                     61:        ubaparent(dp);
                     62:        if (dp->parent == NULL) {
                     63:                fprint(STDERR, "%s %d: no unibus adapter %ld\n",
                     64:                        dp->mdev->name, dp->id, dp->a_adp);
                     65:                errs++;
                     66:                return;
                     67:        }
                     68:        if (dp->a_vec) {
                     69:                vec = dp->parent->vecoff + dp->a_vec;
                     70:                for (i = 0; i < dp->mdev->nvec; i++, vec += 4) {
                     71:                        sprint(vname, VFMT, dp->mdev->tag, dp->id, i);
                     72:                        newvec(vec, SINTR, vname);
                     73:                }
                     74:        }
                     75: }
                     76: 
                     77: ubaparent(dp)
                     78: register Dev *dp;
                     79: {
                     80:        register Dev *ep;
                     81: 
                     82:        for (ep = dlist; ep; ep = ep->next)
                     83:                if (ep->mdev->adptype == dp->mdev->atype
                     84:                &&  ep->id == dp->a_adp)
                     85:                        break;
                     86:        dp->parent = ep;
                     87: }
                     88: 
                     89: ubaputaddr(fd, dp)
                     90: register Dev *dp;
                     91: {
                     92:        register int count;
                     93:        register Mdev *mp;
                     94: 
                     95:        mp = dp->mdev;
                     96:        count = 0;
                     97:        fprint(fd, "struct ubaddr %saddr[] = {\n", mp->tag);
                     98:        for (mp = dp->mdev; dp && dp->mdev == mp; dp = dp->next) {
                     99:                while (count++ < dp->id)
                    100:                        fprint(fd, "\t{-1, -1, -1},\n");
                    101:                fprint(fd, "\t{0%lo, 0%lo, %ld},\n",
                    102:                        dp->a_addr, dp->a_vec, dp->a_adp);
                    103:        }
                    104:        count *= mp->rept;
                    105:        fprint(fd, "};\nint %scnt = %d;\n", mp->tag, count);
                    106:        putstrs(fd, mp, count);
                    107: 
                    108: }
                    109: 
                    110: ubaputvec(fd, dp)
                    111: register Dev *dp;
                    112: {
                    113:        register int i;
                    114:        char vname[30];
                    115: 
                    116:        if (dp->a_vec == 0)
                    117:                return;
                    118:        for (i = 0; i < dp->mdev->nvec; i++) {
                    119:                sprint(vname, VFMT, dp->mdev->tag, dp->id, i);
                    120:                stdputvec(fd, dp, vname, i);
                    121:        }
                    122: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.