Annotation of nono/vm/romimg_x68k.cpp, revision 1.1.1.7

1.1       root        1: //
                      2: // nono
1.1.1.2   root        3: // Copyright (C) 2020 nono project
                      4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
1.1.1.7 ! root        7: // X680x0 の各種 ROM
        !             8: //
        !             9: // IODevice
        !            10: //    |
        !            11: //    +-- ROMDevice (LoadROM()、ウェイト、マスク等を持つ)
        !            12: //    |     |
        !            13: //    |     +-- PROMDevice       (LUNA* の PROM)
        !            14: //    |     |
        !            15: //    |     |  +---------------+
        !            16: //    |     +--| IPLROM1Device | (X680x0 の IPLROM 後半)
        !            17: //    |     |  +---------------+
        !            18: //    |     |
        !            19: //    |     |  +---------------+
        !            20: //    |     +--| IPLROM2Device | (X680x0 の IPLROM 前半)
        !            21: //    |     |  +---------------+
        !            22: //    |     |
        !            23: //    |     |  +-------------+
        !            24: //    |     +--| CGROMDevice |   (X680x0 の CGROM)
        !            25: //    |     |  +-------------+
        !            26: //    |     |
        !            27: //    |     +-- LunaPROMEmuDevice (LUNA PROM エミュレーションの共通部分)
        !            28: //    |           |
        !            29: //    |           +-- Luna1PROMEmuDevice   (LUNA1 の PROM エミュレーション)
        !            30: //    |           +-- Luna88kPROMEmuDevice (LUNA88K の PROM エミュレーション)
        !            31: //    |
        !            32: //    +-- PROM0Device      (LUNA* のブートページ切り替え用プロキシ)
        !            33: //    |
        !            34: //    |  +---------------+
        !            35: //    +--| IPLROM0Device | (X680x0 のブートページ切り替え用プロキシ)
        !            36: //       +---------------+
        !            37: 
1.1       root       38: #include "romimg_x68k.h"
                     39: #include "cgrom.h"
                     40: #include "mainapp.h"
                     41: #include "pluto.h"
                     42: #include "scheduler.h"
                     43: 
1.1.1.3   root       44: std::unique_ptr<CGROMDevice> gCGROM;
1.1.1.5   root       45: std::unique_ptr<IPLROM0Device> gIPLROM0;
1.1.1.3   root       46: std::unique_ptr<IPLROM1Device> gIPLROM1;
                     47: std::unique_ptr<IPLROM2Device> gIPLROM2;
                     48: 
1.1       root       49: //
1.1.1.5   root       50: // IPLROM0 は IPLROM(1) のブートページ担当。
                     51: // これ自身はメモリ領域を持たず IPLROM1 へのプロキシとして動作する。
                     52: //
                     53: // X680x0 のブートページは $000000..$00ffff の 64KB で、
                     54: // ここへのアクセスは $ff0000..$ffffff (IPLROM1 の後半 64KB) が見える。
                     55: // ROM へアクセスがあればブートページを RAM に切り替える。
                     56: // そのため、RAM 側も ROM 側もこいつが応対する必要がある。
                     57: 
                     58: IPLROM0Device::IPLROM0Device()
1.1.1.6   root       59:        : inherited("IPLROM(0)")
1.1.1.5   root       60: {
1.1.1.6   root       61:        ClearAlias();
                     62:        AddAlias("IPLROM0");
1.1.1.5   root       63: }
                     64: 
                     65: IPLROM0Device::~IPLROM0Device()
                     66: {
                     67: }
                     68: 
                     69: bool
                     70: IPLROM0Device::Init()
                     71: {
                     72:        iplrom1 = gIPLROM1.get();
                     73:        return true;
                     74: }
                     75: 
                     76: void
                     77: IPLROM0Device::ResetHard()
                     78: {
1.1.1.7 ! root       79:        gVM->SwitchBootPageToROM(this);
        !            80: }
        !            81: 
        !            82: // Read の共通処理。
        !            83: // アドレスのデコードと RAM への切り替え判定を行う。
        !            84: uint32
        !            85: IPLROM0Device::ReadDecoder(uint32 addr)
        !            86: {
        !            87:        // ROM アドレスがアクセスされたら切り替える
        !            88:        if (addr >= 0xff0000) {
        !            89:                gVM->SwitchBootPageToRAM(this);
        !            90:        }
        !            91: 
        !            92:        // どちらにしてもアクセスは ROM のアドレス
        !            93:        return addr | 0xff0000;
1.1.1.5   root       94: }
                     95: 
                     96: uint64
                     97: IPLROM0Device::Read8(uint32 addr)
                     98: {
1.1.1.7 ! root       99:        addr = ReadDecoder(addr);
        !           100:        return iplrom1->Read8(addr);
1.1.1.5   root      101: }
                    102: 
                    103: uint64
                    104: IPLROM0Device::Read16(uint32 addr)
                    105: {
1.1.1.7 ! root      106:        addr = ReadDecoder(addr);
        !           107:        return iplrom1->Read16(addr);
1.1.1.5   root      108: }
                    109: 
                    110: uint64
                    111: IPLROM0Device::Read32(uint32 addr)
                    112: {
1.1.1.7 ! root      113:        addr = ReadDecoder(addr);
        !           114:        return iplrom1->Read32(addr);
1.1.1.5   root      115: }
                    116: 
                    117: // Write は RAM 領域へも ROM 領域へも発生しないはずなので基底のを使う。
                    118: 
                    119: uint64
                    120: IPLROM0Device::Peek8(uint32 addr)
                    121: {
1.1.1.7 ! root      122:        addr |= 0xff0000;
        !           123:        return iplrom1->Peek8(addr);
1.1.1.5   root      124: }
                    125: 
                    126: 
                    127: //
1.1       root      128: // IPLROM(1)
                    129: //
                    130: 
                    131: IPLROM1Device::IPLROM1Device()
1.1.1.6   root      132:        : inherited("IPLROM(1)")
1.1       root      133: {
1.1.1.6   root      134:        ClearAlias();
                    135:        AddAlias("IPLROM1");
                    136: 
1.1       root      137:        devaddr = 0xfe0000;
                    138:        devlen  = 0x020000;
                    139:        mask = devlen - 1;
1.1.1.7 ! root      140: 
        !           141:        // X680x0 では ROM への書き込みはバスエラー
        !           142:        write_op = -1;
1.1       root      143: }
                    144: 
                    145: IPLROM1Device::~IPLROM1Device()
                    146: {
                    147: }
                    148: 
                    149: bool
                    150: IPLROM1Device::Init()
                    151: {
                    152:        std::string name;
                    153: 
                    154:        if (gMainApp.benchmark_mode != 0) {
                    155:                name = string_format("BENCH%02d.ROM", gMainApp.benchmark_mode);
                    156:        } else {
                    157:                name = "IPLROM30.DAT";
                    158:        }
                    159: 
                    160:        if (LoadROM(name.c_str(), 128 * 1024) == false) {
                    161:                return false;
                    162:        }
                    163:        return true;
                    164: }
                    165: 
                    166: 
                    167: //
                    168: // IPLROM(2)
                    169: //
                    170: 
                    171: IPLROM2Device::IPLROM2Device()
1.1.1.6   root      172:        : inherited("IPLROM(2)")
1.1       root      173: {
1.1.1.6   root      174:        ClearAlias();
                    175:        AddAlias("IPLROM2");
                    176: 
1.1       root      177:        devaddr = 0xfc0000;
                    178:        devlen  = 0x020000;
                    179:        mask = devlen - 1;
1.1.1.7 ! root      180: 
        !           181:        // X680x0 では ROM への書き込みはバスエラー
        !           182:        write_op = -1;
1.1       root      183: }
                    184: 
                    185: IPLROM2Device::~IPLROM2Device()
                    186: {
                    187: }
                    188: 
                    189: bool
                    190: IPLROM2Device::Init()
                    191: {
                    192:        if (gMainApp.benchmark_mode != 0) {
                    193:                return true;
                    194:        }
                    195: 
                    196:        if (LoadROM("ROM30.DAT", 128 * 1024) == false) {
                    197:                return false;
                    198:        }
                    199:        return true;
                    200: }
                    201: 
                    202: 
                    203: //
                    204: // CGROM
                    205: //
                    206: 
                    207: CGROMDevice::CGROMDevice()
1.1.1.6   root      208:        : inherited("CGROM")
1.1       root      209: {
                    210:        devaddr = 0xf00000;
                    211:        devlen  = 768 * 1024;
                    212:        mask = 1024 * 1024 - 1;
1.1.1.7 ! root      213: 
        !           214:        // X680x0 では ROM への書き込みはバスエラー
        !           215:        write_op = -1;
1.1       root      216: }
                    217: 
                    218: CGROMDevice::~CGROMDevice()
                    219: {
                    220: }
                    221: 
                    222: bool
                    223: CGROMDevice::Init()
                    224: {
                    225: #if 0
                    226:        mem = builtin_cgrom;
                    227: #else
                    228:        if (LoadROM("CGROM30.DAT", 768 * 1024) == false) {
                    229:                return false;
                    230:        }
                    231: #endif
                    232:        return true;
                    233: }

unix.superglobalmegacorp.com

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