Return to dimension.cpp CVS log

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

Annotation of previous_trunk/src/dimension/dimension.cpp, revision 1.1

1.1     ! root        1: #include "configuration.h"
        !             2: #include "m68000.h"
        !             3: #include "dimension.hpp"
        !             4: #include "nd_nbic.hpp"
        !             5: #include "nd_mem.hpp"
        !             6: #include "nd_sdl.hpp"
        !             7: 
        !             8: NextDimension::NextDimension(int slot) :
        !             9:     NextBusBoard(slot),
        !            10:     sdl(slot, (Uint32*)vram),
        !            11:     i860(this),
        !            12:     nbic(slot, ND_NBIC_ID),
        !            13:     mc(this),
        !            14:     dp(this),
        !            15:     dmcd(this),
        !            16:     dcsc0(this, 0),
        !            17:     dcsc1(this, 1),
        !            18:     rom_command(0),
        !            19:     rom_last_addr(0)
        !            20: {
        !            21:     i860.uninit();
        !            22:     nbic.init();
        !            23:     mc.init();
        !            24:     dp.init();
        !            25:     mem_init();
        !            26:     i860.init();
        !            27:     sdl.init();
        !            28: }
        !            29: 
        !            30: NextDimension::~NextDimension() {
        !            31:     i860.uninit();
        !            32:     sdl.destroy();
        !            33: }
        !            34: 
        !            35: void NextDimension::reset(void) {
        !            36:     i860.set_run_func();
        !            37:     sdl.start_interrupts();
        !            38: }
        !            39: 
        !            40: void NextDimension::pause(bool pause) {
        !            41:     i860.pause(pause);
        !            42:     sdl.pause(pause);
        !            43: }
        !            44: 
        !            45: /* NeXTdimension board memory access (m68k) */
        !            46: 
        !            47:  Uint32 NextDimension::board_lget(Uint32 addr) {
        !            48:     addr |= ND_BOARD_BITS;
        !            49:     Uint32 result = nd68k_longget(addr);
        !            50:     // (SC) delay m68k read on csr0 while in ROM (CS8=1)to give ND some time to start up.
        !            51:     if(addr == 0xFF800000 && (result & 0x02))
        !            52:         M68000_AddCycles(ConfigureParams.System.nCpuFreq * 100);
        !            53:     return result;
        !            54: }
        !            55: 
        !            56:  Uint16 NextDimension::board_wget(Uint32 addr) {
        !            57:     addr |= ND_BOARD_BITS;
        !            58:     return nd68k_wordget(addr);
        !            59: }
        !            60: 
        !            61:  Uint8 NextDimension::board_bget(Uint32 addr) {
        !            62:     addr |= ND_BOARD_BITS;
        !            63:     return nd68k_byteget(addr);
        !            64: }
        !            65: 
        !            66:  void NextDimension::board_lput(Uint32 addr, Uint32 l) {
        !            67:     addr |= ND_BOARD_BITS;
        !            68:     nd68k_longput(addr, l);
        !            69: }
        !            70: 
        !            71:  void NextDimension::board_wput(Uint32 addr, Uint16 w) {
        !            72:     addr |= ND_BOARD_BITS;
        !            73:     nd68k_wordput(addr, w);
        !            74: }
        !            75: 
        !            76:  void NextDimension::board_bput(Uint32 addr, Uint8 b) {
        !            77:     addr |= ND_BOARD_BITS;
        !            78:     nd68k_byteput(addr, b);
        !            79: }
        !            80: 
        !            81: /* NeXTdimension slot memory access */
        !            82: Uint32 NextDimension::slot_lget(Uint32 addr) {
        !            83:     addr |= ND_SLOT_BITS;
        !            84:     
        !            85:     if (addr<ND_NBIC_SPACE) {
        !            86:         return nd68k_longget(addr);
        !            87:     } else {
        !            88:         return nbic.lget(addr);
        !            89:     }
        !            90: }
        !            91: 
        !            92: Uint16 NextDimension::slot_wget(Uint32 addr) {
        !            93:     addr |= ND_SLOT_BITS;
        !            94:     
        !            95:     if (addr<ND_NBIC_SPACE) {
        !            96:         return nd68k_wordget(addr);
        !            97:     } else {
        !            98:         return nbic.wget(addr);
        !            99:     }
        !           100: }
        !           101: 
        !           102: Uint8 NextDimension::slot_bget(Uint32 addr) {
        !           103:     addr |= ND_SLOT_BITS;
        !           104:     
        !           105:     if (addr<ND_NBIC_SPACE) {
        !           106:         return nd68k_byteget(addr);
        !           107:     } else {
        !           108:         return nbic.bget(addr);
        !           109:     }
        !           110: }
        !           111: 
        !           112: void NextDimension::slot_lput(Uint32 addr, Uint32 l) {
        !           113:     addr |= ND_SLOT_BITS;
        !           114:     
        !           115:     if (addr<ND_NBIC_SPACE) {
        !           116:         nd68k_longput(addr, l);
        !           117:     } else {
        !           118:         nbic.lput(addr, l);
        !           119:     }
        !           120: }
        !           121: 
        !           122: void NextDimension::slot_wput(Uint32 addr, Uint16 w) {
        !           123:     addr |= ND_SLOT_BITS;
        !           124:     
        !           125:     if (addr<ND_NBIC_SPACE) {
        !           126:         nd68k_wordput(addr, w);
        !           127:     } else {
        !           128:         nbic.wput(addr, w);
        !           129:     }
        !           130: }
        !           131: 
        !           132: void NextDimension::slot_bput(Uint32 addr, Uint8 b) {
        !           133:     addr |= ND_SLOT_BITS;
        !           134:     
        !           135:     if (addr<ND_NBIC_SPACE) {
        !           136:         nd68k_byteput(addr, b);
        !           137:     } else {
        !           138:         nbic.bput(addr, b);
        !           139:     }
        !           140: }
        !           141: 
        !           142: void NextDimension::send_msg(int msg) {
        !           143:     host_lock(&m_port_lock);
        !           144:     m_port |= msg;
        !           145:     host_unlock(&m_port_lock);
        !           146: }
        !           147: 
        !           148: /* NeXTdimension board memory access (i860) */
        !           149: 
        !           150: Uint8  NextDimension::i860_cs8get(NextDimension* nd, Uint32 addr) {
        !           151:     addr |= ND_BOARD_BITS;
        !           152:     return nd_cs8get(addr);
        !           153: }
        !           154: 
        !           155: void   NextDimension::i860_rd8_be(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           156:     addr  |= ND_BOARD_BITS;
        !           157:     *((Uint8*)val) = nd_byteget(addr);
        !           158: }
        !           159: 
        !           160: void   NextDimension::i860_rd16_be(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           161:     addr |= ND_BOARD_BITS;
        !           162:     *((Uint16*)val) = nd_wordget(addr);
        !           163: }
        !           164: 
        !           165: void   NextDimension::i860_rd32_be(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           166:     addr  |= ND_BOARD_BITS;
        !           167:     val[0] = nd_longget(addr);
        !           168: }
        !           169: 
        !           170: void   NextDimension::i860_rd64_be(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           171:     addr  |= ND_BOARD_BITS;
        !           172:     val[0] = nd_longget(addr+4);
        !           173:     val[1] = nd_longget(addr+0);
        !           174: }
        !           175: 
        !           176: void   NextDimension::i860_rd128_be(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           177:     addr   |= ND_BOARD_BITS;
        !           178:     val[0]  = nd_longget(addr+4);
        !           179:     val[1]  = nd_longget(addr+0);
        !           180:     val[2]  = nd_longget(addr+12);
        !           181:     val[3]  = nd_longget(addr+8);
        !           182: }
        !           183: 
        !           184: void   NextDimension::i860_wr8_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           185:     addr |= ND_BOARD_BITS;
        !           186:     nd_byteput(addr, *((const Uint8*)val));
        !           187: }
        !           188: 
        !           189: void   NextDimension::i860_wr16_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           190:     addr |= ND_BOARD_BITS;
        !           191:     nd_wordput(addr, *((const Uint16*)val));
        !           192: }
        !           193: 
        !           194: void   NextDimension::i860_wr32_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           195:     addr |= ND_BOARD_BITS;
        !           196:     nd_longput(addr, val[0]);
        !           197: }
        !           198: 
        !           199: void   NextDimension::i860_wr64_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           200:     addr |= ND_BOARD_BITS;
        !           201:     nd_longput(addr+4, val[0]);
        !           202:     nd_longput(addr+0, val[1]);
        !           203: }
        !           204: 
        !           205: void   NextDimension::i860_wr128_be(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           206:     addr |= ND_BOARD_BITS;
        !           207:     nd_longput(addr+4,  val[0]);
        !           208:     nd_longput(addr+0,  val[1]);
        !           209:     nd_longput(addr+12, val[2]);
        !           210:     nd_longput(addr+8,  val[3]);
        !           211: }
        !           212: 
        !           213: void   NextDimension::i860_rd8_le(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           214:     addr  |= ND_BOARD_BITS;
        !           215:     *((Uint8*)val) = nd_byteget(addr^7);
        !           216: }
        !           217: 
        !           218: void   NextDimension::i860_rd16_le(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           219:     addr |= ND_BOARD_BITS;
        !           220:     *((Uint16*)val) = nd_wordget(addr^6);
        !           221: }
        !           222: 
        !           223: void   NextDimension::i860_rd32_le(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           224:     addr  |= ND_BOARD_BITS;
        !           225:     val[0] = nd_longget(addr^4);
        !           226: }
        !           227: 
        !           228: void   NextDimension::i860_rd64_le(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           229:     addr  |= ND_BOARD_BITS;
        !           230:     val[0] = nd_longget(addr+0);
        !           231:     val[1] = nd_longget(addr+4);
        !           232: }
        !           233: 
        !           234: void   NextDimension::i860_rd128_le(NextDimension* nd, Uint32 addr, Uint32* val) {
        !           235:     addr   |= ND_BOARD_BITS;
        !           236:     val[0]  = nd_longget(addr+0);
        !           237:     val[1]  = nd_longget(addr+4);
        !           238:     val[2]  = nd_longget(addr+8);
        !           239:     val[3]  = nd_longget(addr+12);
        !           240: }
        !           241: 
        !           242: void   NextDimension::i860_wr8_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           243:     addr |= ND_BOARD_BITS;
        !           244:     nd_byteput(addr^7, *((const Uint8*)val));
        !           245: }
        !           246: 
        !           247: void   NextDimension::i860_wr16_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           248:     addr |= ND_BOARD_BITS;
        !           249:     nd_wordput(addr^6, *((const Uint16*)val));
        !           250: }
        !           251: 
        !           252: void   NextDimension::i860_wr32_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           253:     addr |= ND_BOARD_BITS;
        !           254:     nd_longput(addr^4, val[0]);
        !           255: }
        !           256: 
        !           257: void   NextDimension::i860_wr64_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           258:     addr |= ND_BOARD_BITS;
        !           259:     nd_longput(addr+0, val[0]);
        !           260:     nd_longput(addr+4, val[1]);
        !           261: }
        !           262: 
        !           263: void   NextDimension::i860_wr128_le(NextDimension* nd, Uint32 addr, const Uint32* val) {
        !           264:     addr |= ND_BOARD_BITS;
        !           265:     nd_longput(addr+0,  val[0]);
        !           266:     nd_longput(addr+4,  val[1]);
        !           267:     nd_longput(addr+8,  val[2]);
        !           268:     nd_longput(addr+12, val[3]);
        !           269: }
        !           270: 
        !           271: /* Message disaptcher - executed on i860 thread, safe to call i860 methods */
        !           272: bool NextDimension::handle_msgs(void) {
        !           273:     host_lock(&m_port_lock);
        !           274:     int msg = m_port;
        !           275:     m_port = 0;
        !           276:     host_unlock(&m_port_lock);
        !           277:     
        !           278:     if(msg & MSG_DISPLAY_BLANK)
        !           279:         set_blank_state(ND_DISPLAY, host_blank_state(slot, ND_DISPLAY));
        !           280:     if(msg & MSG_VIDEO_BLANK)
        !           281:         set_blank_state(ND_VIDEO, host_blank_state(slot, ND_VIDEO));
        !           282: 
        !           283:     return i860.handle_msgs(msg);
        !           284: }
        !           285: 
        !           286: void nd_start_debugger(void) {
        !           287:     FOR_EACH_SLOT(slot) {
        !           288:         IF_NEXT_DIMENSION(slot, nd) {
        !           289:             nd->send_msg(MSG_DBG_BREAK);
        !           290:         }
        !           291:     }
        !           292: }
        !           293: 
        !           294: extern "C" {
        !           295:     void nd_display_blank(int slot) {
        !           296:         ((NextDimension*)nextbus[slot])->send_msg(MSG_DISPLAY_BLANK);
        !           297:     }
        !           298: 
        !           299:     void nd_video_blank(int slot) {
        !           300:         ((NextDimension*)nextbus[slot])->send_msg(MSG_VIDEO_BLANK);
        !           301:     }
        !           302: 
        !           303:     const char* nd_reports(int slot, double realTime, double hostTime) {
        !           304:         return ((NextDimension*)nextbus[slot])->i860.reports(realTime, hostTime);
        !           305:     }
        !           306:     
        !           307:     Uint32* nd_vram_for_slot(int slot) {
        !           308:         IF_NEXT_DIMENSION(slot, nd)
        !           309:             return (Uint32*)nd->vram;
        !           310:         else
        !           311:             return NULL;
        !           312:     }
        !           313: }
        !           314: 
        !           315: 
        !           316: 

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