Return to dimension.c CVS log

Up to [Previous NeXT emulator] / previous / src / dimension

Annotation of previous/src/dimension/dimension.c, revision 1.1

1.1     ! root        1: #include "main.h"
        !             2: #include "configuration.h"
        !             3: #include "m68000.h"
        !             4: #include "dimension.h"
        !             5: #include "sysdeps.h"
        !             6: #include "nd_mem.h"
        !             7: #include "nd_devs.h"
        !             8: #include "nd_nbic.h"
        !             9: #include "nd_sdl.h"
        !            10: 
        !            11: #if ENABLE_DIMENSION
        !            12: 
        !            13: /* NeXTdimension board and slot memory */
        !            14: #define ND_BOARD_SIZE  0x10000000
        !            15: #define ND_BOARD_MASK  0x0FFFFFFF
        !            16: #define ND_BOARD_BITS   0xF0000000
        !            17: 
        !            18: #define ND_SLOT_SIZE   0x01000000
        !            19: #define ND_SLOT_MASK   0x00FFFFFF
        !            20: #define ND_SLOT_BITS    0x0F000000
        !            21: 
        !            22: #define ND_NBIC_SPACE   0xFFFFFFE8
        !            23: 
        !            24: 
        !            25: /* NeXTdimension slot memory access */
        !            26: Uint32 nd_slot_lget(Uint32 addr) {
        !            27:     addr |= ND_SLOT_BITS;
        !            28:     
        !            29:     if (addr<ND_NBIC_SPACE) {
        !            30:         return nd_longget(addr);
        !            31:     } else {
        !            32:         return nd_nbic_lget(addr);
        !            33:     }
        !            34: }
        !            35: 
        !            36: Uint16 nd_slot_wget(Uint32 addr) {
        !            37:     addr |= ND_SLOT_BITS;
        !            38:     
        !            39:     if (addr<ND_NBIC_SPACE) {
        !            40:         return nd_wordget(addr);
        !            41:     } else {
        !            42:         return nd_nbic_wget(addr);
        !            43:     }
        !            44: }
        !            45: 
        !            46: Uint8 nd_slot_bget(Uint32 addr) {
        !            47:     addr |= ND_SLOT_BITS;
        !            48: 
        !            49:     if (addr<ND_NBIC_SPACE) {
        !            50:         return nd_byteget(addr);
        !            51:     } else {
        !            52:         return nd_nbic_bget(addr);
        !            53:     }
        !            54: }
        !            55: 
        !            56: void nd_slot_lput(Uint32 addr, Uint32 l) {
        !            57:     addr |= ND_SLOT_BITS;
        !            58: 
        !            59:     if (addr<ND_NBIC_SPACE) {
        !            60:         nd_longput(addr, l);
        !            61:     } else {
        !            62:         nd_nbic_lput(addr, l);
        !            63:     }
        !            64: }
        !            65: 
        !            66: void nd_slot_wput(Uint32 addr, Uint16 w) {
        !            67:     addr |= ND_SLOT_BITS;
        !            68: 
        !            69:     if (addr<ND_NBIC_SPACE) {
        !            70:         nd_wordput(addr, w);
        !            71:     } else {
        !            72:         nd_nbic_wput(addr, w);
        !            73:     }
        !            74: }
        !            75: 
        !            76: void nd_slot_bput(Uint32 addr, Uint8 b) {
        !            77:     addr |= ND_SLOT_BITS;
        !            78: 
        !            79:     if (addr<ND_NBIC_SPACE) {
        !            80:         nd_byteput(addr, b);
        !            81:     } else {
        !            82:         nd_nbic_bput(addr, b);
        !            83:     }
        !            84: }
        !            85: 
        !            86: /* NeXTdimension board memory access */
        !            87: 
        !            88: void   nd_board_rd8_be(Uint32 addr, Uint32* val) {
        !            89:     addr  |= ND_BOARD_BITS;
        !            90:     *((Uint8*)val) = nd_byteget(addr);
        !            91: }
        !            92: 
        !            93: void   nd_board_rd16_be(Uint32 addr, Uint32* val) {
        !            94:     addr |= ND_BOARD_BITS;
        !            95:     *((Uint16*)val) = nd_wordget(addr);
        !            96: }
        !            97: 
        !            98: void   nd_board_rd32_be(Uint32 addr, Uint32* val) {
        !            99:     addr  |= ND_BOARD_BITS;
        !           100:     val[0] = nd_longget(addr);
        !           101: }
        !           102: 
        !           103: void   nd_board_rd64_be(Uint32 addr, Uint32* val) {
        !           104:     addr  |= ND_BOARD_BITS;
        !           105:     val[0] = nd_longget(addr+4);
        !           106:     val[1] = nd_longget(addr+0);
        !           107: }
        !           108: 
        !           109: void   nd_board_rd128_be(Uint32 addr, Uint32* val) {
        !           110:     addr   |= ND_BOARD_BITS;
        !           111:     val[0]  = nd_longget(addr+4);
        !           112:     val[1]  = nd_longget(addr+0);
        !           113:     val[2]  = nd_longget(addr+12);
        !           114:     val[3]  = nd_longget(addr+8);
        !           115: }
        !           116: 
        !           117: void   nd_board_wr8_be(Uint32 addr, const Uint32* val) {
        !           118:     addr |= ND_BOARD_BITS;
        !           119:     nd_byteput(addr, *((Uint8*)val));
        !           120: }
        !           121: 
        !           122: void   nd_board_wr16_be(Uint32 addr, const Uint32* val) {
        !           123:     addr |= ND_BOARD_BITS;
        !           124:     nd_wordput(addr, *((Uint16*)val));
        !           125: }
        !           126: 
        !           127: void   nd_board_wr32_be(Uint32 addr, const Uint32* val) {
        !           128:     addr |= ND_BOARD_BITS;
        !           129:     nd_longput(addr, val[0]);
        !           130: }
        !           131: 
        !           132: void   nd_board_wr64_be(Uint32 addr, const Uint32* val) {
        !           133:     addr |= ND_BOARD_BITS;
        !           134:     nd_longput(addr+4, val[0]);
        !           135:     nd_longput(addr+0, val[1]);
        !           136: }
        !           137: 
        !           138: void   nd_board_wr128_be(Uint32 addr, const Uint32* val) {
        !           139:     addr |= ND_BOARD_BITS;
        !           140:     nd_longput(addr+4,  val[0]);
        !           141:     nd_longput(addr+0,  val[1]);
        !           142:     nd_longput(addr+12, val[2]);
        !           143:     nd_longput(addr+8,  val[3]);
        !           144: }
        !           145: 
        !           146: void   nd_board_rd8_le(Uint32 addr, Uint32* val) {
        !           147:     addr  |= ND_BOARD_BITS;
        !           148:     *((Uint8*)val) = nd_byteget(addr^7);
        !           149: }
        !           150: 
        !           151: void   nd_board_rd16_le(Uint32 addr, Uint32* val) {
        !           152:     addr |= ND_BOARD_BITS;
        !           153:     *((Uint16*)val) = nd_wordget(addr^6);
        !           154: }
        !           155: 
        !           156: void   nd_board_rd32_le(Uint32 addr, Uint32* val) {
        !           157:     addr  |= ND_BOARD_BITS;
        !           158:     val[0] = nd_longget(addr^4);
        !           159: }
        !           160: 
        !           161: void   nd_board_rd64_le(Uint32 addr, Uint32* val) {
        !           162:     addr  |= ND_BOARD_BITS;
        !           163:     val[0] = nd_longget(addr+0);
        !           164:     val[1] = nd_longget(addr+4);
        !           165: }
        !           166: 
        !           167: void   nd_board_rd128_le(Uint32 addr, Uint32* val) {
        !           168:     addr   |= ND_BOARD_BITS;
        !           169:     val[0]  = nd_longget(addr+0);
        !           170:     val[1]  = nd_longget(addr+4);
        !           171:     val[2]  = nd_longget(addr+8);
        !           172:     val[3]  = nd_longget(addr+12);
        !           173: }
        !           174: 
        !           175: void   nd_board_wr8_le(Uint32 addr, const Uint32* val) {
        !           176:     addr |= ND_BOARD_BITS;
        !           177:     nd_byteput(addr^7, *((Uint8*)val));
        !           178: }
        !           179: 
        !           180: void   nd_board_wr16_le(Uint32 addr, const Uint32* val) {
        !           181:     addr |= ND_BOARD_BITS;
        !           182:     nd_wordput(addr^6, *((Uint16*)val));
        !           183: }
        !           184: 
        !           185: void   nd_board_wr32_le(Uint32 addr, const Uint32* val) {
        !           186:     addr |= ND_BOARD_BITS;
        !           187:     nd_longput(addr^4, val[0]);
        !           188: }
        !           189: 
        !           190: void   nd_board_wr64_le(Uint32 addr, const Uint32* val) {
        !           191:     addr |= ND_BOARD_BITS;
        !           192:     nd_longput(addr+0, val[0]);
        !           193:     nd_longput(addr+4, val[1]);
        !           194: }
        !           195: 
        !           196: void   nd_board_wr128_le(Uint32 addr, const Uint32* val) {
        !           197:     addr |= ND_BOARD_BITS;
        !           198:     nd_longput(addr+0,  val[0]);
        !           199:     nd_longput(addr+4,  val[1]);
        !           200:     nd_longput(addr+8,  val[2]);
        !           201:     nd_longput(addr+12, val[3]);
        !           202: }
        !           203: 
        !           204: //------
        !           205: 
        !           206: inline Uint32 nd_board_lget(Uint32 addr) {
        !           207:     addr |= ND_BOARD_BITS;
        !           208:     return nd_longget(addr);
        !           209: }
        !           210: 
        !           211: inline Uint16 nd_board_wget(Uint32 addr) {
        !           212:     addr |= ND_BOARD_BITS;
        !           213:     return nd_wordget(addr);
        !           214: }
        !           215: 
        !           216: inline Uint8 nd_board_bget(Uint32 addr) {
        !           217:     addr |= ND_BOARD_BITS;
        !           218:     return nd_byteget(addr);
        !           219: }
        !           220: 
        !           221: inline void nd_board_lput(Uint32 addr, Uint32 l) {
        !           222:     addr |= ND_BOARD_BITS;
        !           223:     nd_longput(addr, l);
        !           224: }
        !           225: 
        !           226: inline void nd_board_put64(Uint32 addr, Uint32 l0, Uint32 l1) {
        !           227:     addr |= ND_BOARD_BITS;
        !           228:     nd_longput(addr+4, l0);
        !           229:     nd_longput(addr+0, l1);
        !           230: }
        !           231: 
        !           232: inline void nd_board_put128(Uint32 addr, Uint32 l0, Uint32 l1, Uint32 l2, Uint32 l3) {
        !           233:     addr |= ND_BOARD_BITS;
        !           234:     nd_longput(addr+4,  l0);
        !           235:     nd_longput(addr+0,  l1);
        !           236:     nd_longput(addr+12, l2);
        !           237:     nd_longput(addr+8,  l3);
        !           238: }
        !           239: 
        !           240: inline void nd_board_wput(Uint32 addr, Uint16 w) {
        !           241:     addr |= ND_BOARD_BITS;
        !           242:     nd_wordput(addr, w);
        !           243: }
        !           244: 
        !           245: inline void nd_board_bput(Uint32 addr, Uint8 b) {
        !           246:     addr |= ND_BOARD_BITS;
        !           247:     nd_byteput(addr, b);
        !           248: }
        !           249: 
        !           250: inline Uint8 nd_board_cs8get(Uint32 addr) {
        !           251:     addr |= ND_BOARD_BITS;
        !           252:     return nd_cs8get(addr);
        !           253: }
        !           254: 
        !           255: /* Reset function */
        !           256: 
        !           257: void dimension_init(void) {
        !           258:     nd_i860_uninit();
        !           259:     nd_nbic_init();
        !           260:     nd_devs_init();
        !           261:     nd_memory_init();
        !           262:     nd_i860_init();
        !           263:     nd_sdl_init();
        !           264: }
        !           265: 
        !           266: void dimension_uninit(void) {
        !           267:        nd_i860_uninit();
        !           268:     nd_sdl_uninit();
        !           269: }
        !           270: 
        !           271: #endif

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