Return to nexdev.c CVS log

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

Annotation of researchv10no/sys/mkconf/nexdev.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * nexus device routines;
        !             3:  * both sbi and vaxbi nexus
        !             4:  */
        !             5: 
        !             6: #include "mkconf.h"
        !             7: 
        !             8: /*
        !             9:  * addressing fields
        !            10:  */
        !            11: 
        !            12: static char *sbifields[] = {
        !            13:        "bus", "tr", "voff", NULL
        !            14: };
        !            15: 
        !            16: #define        a_adp   addr[0] /* adapter: which sbi, which vaxbi */
        !            17: #define        a_tr    addr[1] /* nexus number within that adapter */
        !            18: #define        a_svoff addr[2] /* sbi devices (like unibus adapter): vector offset */
        !            19: 
        !            20: static char *vbifields[] = {
        !            21:        "bi", "node", "vec", "voff", NULL
        !            22: };
        !            23: 
        !            24: #define        a_bvec  addr[2] /* vaxbi: vector */
        !            25: #define        a_bvoff addr[3] /* vaxbi adapter devices (like dw): vector offset */
        !            26: 
        !            27: #define        VFMT    "X%s%d%d"       /* name of vector interface routine */
        !            28: 
        !            29: #define        MAXNEX  20      /* this many nexus, not highest hardware tr */
        !            30: 
        !            31: struct nextab {
        !            32:        char adp;
        !            33:        char nex;
        !            34: } nextab[MAXNEX];
        !            35: 
        !            36: int nextnex;
        !            37: 
        !            38: sbisyntax(dp, ap, n)
        !            39: register Dev *dp;
        !            40: char **ap;
        !            41: int n;
        !            42: {
        !            43:        char *p;
        !            44: 
        !            45:        dp->a_svoff = 0;
        !            46:        if ((p = keyread(dp->addr, ap, n, sbifields)) != NULL) {
        !            47:                fprint(STDERR, "%s %d: bad field %s\n", dp->mdev->name, dp->id, p);
        !            48:                errs++;
        !            49:                return (1);
        !            50:        }
        !            51:        dp->vecoff = dp->a_svoff;
        !            52:        return (0);
        !            53: }
        !            54: 
        !            55: vbisyntax(dp, ap, n)
        !            56: register Dev *dp;
        !            57: char **ap;
        !            58: int n;
        !            59: {
        !            60:        char *p;
        !            61: 
        !            62:        dp->a_bvoff = 0;
        !            63:        if ((p = keyread(dp->addr, ap, n, vbifields)) != NULL) {
        !            64:                fprint(STDERR, "%s %d: bad field %s\n", dp->mdev->name, dp->id, p);
        !            65:                errs++;
        !            66:                return (1);
        !            67:        }
        !            68:        dp->vecoff = dp->a_bvoff;
        !            69:        return (0);
        !            70: }
        !            71: 
        !            72: /*
        !            73:  * fixup routine:
        !            74:  * compute and insert our (fixed) interrupt vectors
        !            75:  * insert our entry in the table of nexus
        !            76:  * and replace our `nexus' address with the appropriate index
        !            77:  */
        !            78: int
        !            79: sbifixup(dp)
        !            80: register Dev *dp;
        !            81: {
        !            82:        register int vec;
        !            83:        register int i;
        !            84:        register Mdev *mp;
        !            85:        char vname[20];
        !            86: 
        !            87:        nexparent(dp);
        !            88:        mp = dp->mdev;
        !            89:        if (mp->nvec) {
        !            90:                vec = dp->a_tr*4;       /* honest nexus number, mod 16 */
        !            91:                vec += 0x100;           /* -> br4 vector */
        !            92:                if (dp->parent)
        !            93:                        vec += dp->parent->vecoff;
        !            94:                sprint(vname, VFMT, mp->tag, dp->id, 0);
        !            95:                for (i = 0; i < 4; i++) {
        !            96:                        newvec(vec, SINTR, vname);
        !            97:                        vec += 0x40;
        !            98:                }
        !            99:        }
        !           100:        newnex(dp);
        !           101: }
        !           102: 
        !           103: int
        !           104: vbifixup(dp)
        !           105: register Dev *dp;
        !           106: {
        !           107:        register int vec;
        !           108:        register Mdev *mp;
        !           109:        register int i;
        !           110:        char vname[20];
        !           111: 
        !           112:        nexparent(dp);
        !           113:        mp = dp->mdev;
        !           114:        vec = dp->a_bvec;
        !           115:        if (dp->parent)         /* && vec > 0x200? */
        !           116:                vec += dp->parent->vecoff;
        !           117:        for (i = 0; i < mp->nvec; i++, vec += 4) {
        !           118:                sprint(vname, VFMT, mp->tag, dp->id, i);
        !           119:                newvec(vec, SINTR, vname);
        !           120:        }
        !           121:        newnex(dp);
        !           122: }
        !           123: 
        !           124: newnex(dp)
        !           125: register Dev *dp;
        !           126: {
        !           127:        if (nextnex >= MAXNEX) {
        !           128:                fprint(STDERR, "%s %d: too many nexus\n", dp->mdev->name, dp->id);
        !           129:                errs++;
        !           130:                return;
        !           131:        }
        !           132:        nextab[nextnex].adp = dp->a_adp;
        !           133:        nextab[nextnex].nex = dp->a_tr;
        !           134:        dp->addr[1] = nextnex;
        !           135:        nextnex++;
        !           136: }
        !           137: 
        !           138: nexparent(dp)
        !           139: register Dev *dp;
        !           140: {
        !           141:        register Dev *ep;
        !           142: 
        !           143:        for (ep = dlist; ep; ep = ep->next)
        !           144:                if (ep->mdev->adptype == dp->mdev->atype
        !           145:                &&  ep->id == dp->a_adp)
        !           146:                        break;
        !           147:        dp->parent = ep;
        !           148: }
        !           149: 
        !           150: sbiputaddr(fd, dp)
        !           151: int fd;
        !           152: register Dev *dp;
        !           153: {
        !           154:        register int count;
        !           155:        register Mdev *mp;
        !           156: 
        !           157:        nexputtab(fd);
        !           158:        mp = dp->mdev;
        !           159:        count = 0;
        !           160:        fprint(fd, "struct nxaddr %saddr[] = {\n", mp->tag);
        !           161:        for (mp = dp->mdev; dp && dp->mdev == mp; dp = dp->next) {
        !           162:                while (count++ < dp->id)
        !           163:                        fprint(fd, "\t{-1, 0},\n");
        !           164:                fprint(fd, "\t{%ld, %ld, 0x%lx},\n", dp->a_tr, dp->a_adp, dp->a_svoff);
        !           165:        }
        !           166:        count *= mp->rept;
        !           167:        fprint(fd, "};\nint %scnt = %d;\n", mp->tag, count);
        !           168:        putstrs(fd, mp, count);
        !           169: }
        !           170: 
        !           171: vbiputaddr(fd, dp)
        !           172: int fd;
        !           173: register Dev *dp;
        !           174: {
        !           175:        register int count;
        !           176:        register Mdev *mp;
        !           177: 
        !           178:        nexputtab(fd);
        !           179:        mp = dp->mdev;
        !           180:        count = 0;
        !           181:        fprint(fd, "struct biaddr %saddr[] = {\n", mp->tag);
        !           182:        for (mp = dp->mdev; dp && dp->mdev == mp; dp = dp->next) {
        !           183:                while (count++ < dp->id)
        !           184:                        fprint(fd, "\t{-1},\n");
        !           185:                fprint(fd, "\t{%ld, 0x%lx, 0x%lx, %ld},\n",
        !           186:                        dp->a_tr, dp->a_bvec, dp->a_bvoff, dp->a_adp);
        !           187:        }
        !           188:        count *= mp->rept;
        !           189:        fprint(fd, "};\nint %scnt = %d;\n", mp->tag, count);
        !           190:        putstrs(fd, mp, count);
        !           191: }
        !           192: 
        !           193: /*
        !           194:  * put out nexus tables
        !           195:  */
        !           196: 
        !           197: nexputtab(fd)
        !           198: int fd;
        !           199: {
        !           200:        register int i;
        !           201:        static int done = 0;
        !           202: 
        !           203:        if (done++)
        !           204:                return;
        !           205:        fprint(fd, "\nstruct nextab nextab[] = {\n");
        !           206:        for (i = 0; i < nextnex; i++)
        !           207:                fprint(fd, "\t%d, %d,\n", nextab[i].adp, nextab[i].nex);
        !           208:        fprint(fd, "\t-1\n};\n");
        !           209: }
        !           210: 
        !           211: /*
        !           212:  * put out vectors
        !           213:  */
        !           214: 
        !           215: nexputvec(fd, dp)
        !           216: int fd;
        !           217: register Dev *dp;
        !           218: {
        !           219:        register int i;
        !           220:        char vname[30];
        !           221: 
        !           222:        for (i = 0; i < dp->mdev->nvec; i++) {
        !           223:                sprint(vname, VFMT, dp->mdev->tag, dp->id, i);
        !           224:                stdputvec(fd, dp, vname, i);
        !           225:        }
        !           226: }

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