Return to ubadev.c CVS log

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

Annotation of researchv10dc/sys/mkconf/ubadev.c, revision 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.