Return to hpmaptype.c CVS log

Up to [CSRG BSD Unix] / 43BSD / sys / stand

Annotation of 43BSD/sys/stand/hpmaptype.c, revision 1.1

1.1     ! root        1: /*
        !             2:  * Copyright (c) 1982, 1986 Regents of the University of California.
        !             3:  * All rights reserved.  The Berkeley software License Agreement
        !             4:  * specifies the terms and conditions for redistribution.
        !             5:  *
        !             6:  *     @(#)hpmaptype.c 7.1 (Berkeley) 6/5/86
        !             7:  */
        !             8: 
        !             9: /*
        !            10:  * RP??/RM?? drive type mapping routine.
        !            11:  */
        !            12: #include "../machine/pte.h"
        !            13: 
        !            14: #include "../h/param.h"
        !            15: #include "../h/inode.h"
        !            16: #include "../h/fs.h"
        !            17: 
        !            18: #include "../vaxmba/hpreg.h"
        !            19: #include "../vaxmba/mbareg.h"
        !            20: 
        !            21: #include "saio.h"
        !            22: #include "savax.h"
        !            23: 
        !            24: /* THIS SHOULD BE READ IN OFF THE PACK, PER DRIVE */
        !            25: short  rp06_off[8] =   { 0, 38, 0, -1, -1, -1, 118, -1 };
        !            26: short  rm03_off[8] =   { 0, 100, 0, -1, -1, -1, 309, -1 };
        !            27: short  rm05_off[8] =   { 0, 27, 0, 562, 589, 681, 562, 82 };
        !            28: short  rm80_off[8] =   { 0, 37, 0, -1, -1, -1, 115, -1 };
        !            29: short  rp07_off[8] =   { 0, 10, 0, 235, 245, 437, 235, 52 };
        !            30: short  ml_off[8] =     { 0, -1, -1, -1, -1, -1, -1, -1 };
        !            31: short  cdc9775_off[8] = { 0, 13, 0, -1, -1, -1, 294, 66 };
        !            32: short  cdc9730_off[8] = { 0, 50, 0, -1, -1, -1, 155, -1 };
        !            33: short  capricorn_off[8] = { 0, 32, 0, 668, 723, 778, 668, 98 };
        !            34: short  eagle_off[8] =  { 0, 17, 0, 391, 408, 728, 391, 87 };
        !            35: short  fj2361_off[8] = { 0, 13, 0, 294, 307, 547, 294, 66 };
        !            36: /* END SHOULD BE READ IN */
        !            37: 
        !            38: /*
        !            39:  * hptypes is used to translate Massbus drive type and other information
        !            40:  * into an index in hpst.  The indices of hptypes and hpst must therefore agree.
        !            41:  */
        !            42: short  hptypes[] = {
        !            43:        MBDT_RM03,
        !            44:        MBDT_RM05,
        !            45:        MBDT_RP06,
        !            46:        MBDT_RM80,
        !            47:        MBDT_RP05,
        !            48:        MBDT_RP07,
        !            49:        MBDT_ML11A,
        !            50:        MBDT_ML11B,
        !            51:        -1,             /* 9755 */
        !            52:        -1,             /* 9730 */
        !            53:        -1,             /* Capricorn */
        !            54:        -1,             /* Eagle */
        !            55:        MBDT_RM02,      /* actually something else */
        !            56:        -1,             /* 9300 */
        !            57:        -1,             /* 9766 */
        !            58:        -1,             /* 2361 */
        !            59:        0
        !            60: };
        !            61: 
        !            62: struct st hpst[] = {
        !            63: #define        HPDT_RM03       0
        !            64:        32,     5,      32*5,   823,    rm03_off,       /* RM03 */
        !            65: #define        HPDT_RM05       1
        !            66:        32,     19,     32*19,  823,    rm05_off,       /* RM05 */
        !            67: #define        HPDT_RP06       2
        !            68:        22,     19,     22*19,  815,    rp06_off,       /* RP06 */
        !            69: #define        HPDT_RM80       3
        !            70:        31,     14,     31*14,  559,    rm80_off,       /* RM80 */
        !            71: #define        HPDT_RP05       4
        !            72:        22,     19,     22*19,  411,    rp06_off,       /* RP05 */
        !            73: #define        HPDT_RP07       5
        !            74:        50,     32,     50*32,  630,    rp07_off,       /* RP07 */
        !            75: #define        HPDT_ML11A      6
        !            76:        1,      1,      1,      1,      ml_off,         /* ML11A */
        !            77: #define        HPDT_ML11B      7
        !            78:        1,      1,      1,      1,      ml_off,         /* ML11B */
        !            79: #define        HPDT_9775       8
        !            80:        32,     40,     32*40,  843,    cdc9775_off,    /* 9775 */
        !            81: #define        HPDT_9730       9
        !            82:        32,     10,     32*10,  823,    cdc9730_off,    /* 9730 */
        !            83: #define        HPDT_CAP        10
        !            84:        32,     16,     32*16,  1024,   capricorn_off,  /* Ampex capricorn */
        !            85: #define        HPDT_EAGLE      11
        !            86:        48,     20,     48*20,  842,    eagle_off,      /* Fuji Eagle */
        !            87: #define        HPDT_RM02       12
        !            88:        32,     5,      32*5,   823,    rm03_off,       /* rm02 - not used */
        !            89: #define        HPDT_9300       13
        !            90:        32,     19,     32*19,  815,    rm05_off,       /* Ampex 9300 */
        !            91: #define        HPDT_9766       14
        !            92:        32,     19,     32*19,  823,    rm05_off,       /* CDC 9766 */
        !            93: #define HPDT_2361      15
        !            94:        64,     20,     64*20,  842,    fj2361_off,     /* Fuji 2361 */
        !            95: };
        !            96: #define        NTYPES  (sizeof(hpst) / sizeof(hpst[0]))
        !            97: 
        !            98: #define        MASKREG(reg)    ((reg)&0xffff)
        !            99: 
        !           100: hpmaptype(hpaddr, type, unit)
        !           101:        register struct hpdevice *hpaddr;
        !           102:        unsigned type;
        !           103:        int unit;
        !           104: {
        !           105:        int hpsn;
        !           106: 
        !           107:        /*
        !           108:         * Handle SI model byte stuff when
        !           109:         * we think it's an RM03 or RM05.
        !           110:         */
        !           111:        if (type == HPDT_RM03 || type == HPDT_RM05) {
        !           112:                hpsn = hpaddr->hpsn;
        !           113:                if ((hpsn & SIMB_LU) != unit)
        !           114:                        return (type);
        !           115:                switch ((hpsn & SIMB_MB) &~ (SIMB_S6|SIRM03|SIRM05)) {
        !           116: 
        !           117:                case SI9775D:
        !           118:                        return (HPDT_9775);
        !           119: 
        !           120:                case SI9730D:
        !           121:                        return (HPDT_9730);
        !           122: 
        !           123:                case SI9766:
        !           124:                        return (HPDT_9766);
        !           125: 
        !           126:                case SI9762:
        !           127:                        return (HPDT_RM03);
        !           128: 
        !           129:                case SICAPD:
        !           130:                        return (HPDT_CAP);
        !           131: 
        !           132:                case SI9751D:
        !           133:                        return (HPDT_EAGLE);
        !           134:                }
        !           135:                return (type);
        !           136:        }
        !           137:        /*
        !           138:         * RM02: EMULEX controller.  Map to correct
        !           139:         * drive type by checking the holding
        !           140:         * register for the disk geometry.
        !           141:         */
        !           142:        if (type == HPDT_RM02) {
        !           143:                int newtype, nsectors, ntracks, ncyl;
        !           144: 
        !           145:                hpaddr->hpcs1 = HP_NOP;
        !           146:                hpaddr->hphr = HPHR_MAXTRAK;
        !           147:                ntracks = MASKREG(hpaddr->hphr) + 1;
        !           148:                DELAY(100);
        !           149:                hpaddr->hpcs1 = HP_NOP;
        !           150:                hpaddr->hphr = HPHR_MAXSECT;
        !           151:                nsectors = MASKREG(hpaddr->hphr) + 1;
        !           152:                DELAY(100);
        !           153:                hpaddr->hpcs1 = HP_NOP;
        !           154:                hpaddr->hphr = HPHR_MAXCYL;
        !           155:                ncyl = MASKREG(hpaddr->hphr) + 1;
        !           156:                for (newtype = 0; newtype < NTYPES; newtype++)
        !           157:                        if (hpst[newtype].nsect == nsectors &&
        !           158:                            hpst[newtype].ntrak == ntracks &&
        !           159:                            hpst[newtype].ncyl == ncyl)
        !           160:                                break;
        !           161: 
        !           162:                if (newtype >= NTYPES) {
        !           163:                        printf("RM02 with %d sectors, %d tracks, %d cylinders?\n",
        !           164:                                nsectors, ntracks, ncyl);
        !           165:                        newtype = type;
        !           166:                }
        !           167:        done:
        !           168:                hpaddr->hpcs1 = HP_DCLR|HP_GO;
        !           169:                return (newtype);
        !           170:        }
        !           171:        /*
        !           172:         * ML11's all map to the same type.
        !           173:         */
        !           174:        if (type == HPDT_ML11A || type == HPDT_ML11B)
        !           175:                return (HPDT_ML11A);
        !           176:        return (type);
        !           177: }

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