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

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: 
                      7: #include "romimg_x68k.h"
                      8: #include "cgrom.h"
                      9: #include "mainapp.h"
                     10: #include "pluto.h"
                     11: #include "scheduler.h"
                     12: 
1.1.1.3   root       13: std::unique_ptr<CGROMDevice> gCGROM;
1.1.1.5   root       14: std::unique_ptr<IPLROM0Device> gIPLROM0;
1.1.1.3   root       15: std::unique_ptr<IPLROM1Device> gIPLROM1;
                     16: std::unique_ptr<IPLROM2Device> gIPLROM2;
                     17: 
1.1       root       18: //
1.1.1.5   root       19: // IPLROM0 は IPLROM(1) のブートページ担当。
                     20: // これ自身はメモリ領域を持たず IPLROM1 へのプロキシとして動作する。
                     21: //
                     22: // X680x0 のブートページは $000000..$00ffff の 64KB で、
                     23: // ここへのアクセスは $ff0000..$ffffff (IPLROM1 の後半 64KB) が見える。
                     24: // ROM へアクセスがあればブートページを RAM に切り替える。
                     25: // そのため、RAM 側も ROM 側もこいつが応対する必要がある。
                     26: 
                     27: IPLROM0Device::IPLROM0Device()
1.1.1.6 ! root       28:        : inherited("IPLROM(0)")
1.1.1.5   root       29: {
1.1.1.6 ! root       30:        ClearAlias();
        !            31:        AddAlias("IPLROM0");
        !            32: 
1.1.1.5   root       33:        mask = 0x10000 - 1;
                     34: }
                     35: 
                     36: IPLROM0Device::~IPLROM0Device()
                     37: {
                     38: }
                     39: 
                     40: bool
                     41: IPLROM0Device::Init()
                     42: {
                     43:        iplrom1 = gIPLROM1.get();
                     44:        return true;
                     45: }
                     46: 
                     47: void
                     48: IPLROM0Device::ResetHard()
                     49: {
                     50:        gVM->SwitchBootPage(this, true);
                     51: }
                     52: 
                     53: uint64
                     54: IPLROM0Device::Read8(uint32 addr)
                     55: {
                     56:        if (addr < 0x10000) {
                     57:                return iplrom1->Read8(addr + 0x10000);
                     58:        } else {
                     59:                gVM->SwitchBootPage(this, false);
                     60:                return iplrom1->Read8(addr);
                     61:        }
                     62: }
                     63: 
                     64: uint64
                     65: IPLROM0Device::Read16(uint32 addr)
                     66: {
                     67:        if (addr < 0x10000) {
                     68:                return iplrom1->Read16(addr + 0x10000);
                     69:        } else {
                     70:                gVM->SwitchBootPage(this, false);
                     71:                return iplrom1->Read16(addr);
                     72:        }
                     73: }
                     74: 
                     75: uint64
                     76: IPLROM0Device::Read32(uint32 addr)
                     77: {
                     78:        if (addr < 0x10000) {
                     79:                return iplrom1->Read32(addr + 0x10000);
                     80:        } else {
                     81:                gVM->SwitchBootPage(this, false);
                     82:                return iplrom1->Read32(addr);
                     83:        }
                     84: }
                     85: 
                     86: // Write は RAM 領域へも ROM 領域へも発生しないはずなので基底のを使う。
                     87: 
                     88: uint64
                     89: IPLROM0Device::Peek8(uint32 addr)
                     90: {
                     91:        if (addr < 0x10000) {
                     92:                return iplrom1->Peek8(addr + 0x10000);
                     93:        } else {
                     94:                return iplrom1->Peek8(addr);
                     95:        }
                     96: }
                     97: 
                     98: 
                     99: //
1.1       root      100: // IPLROM(1)
                    101: //
                    102: 
                    103: IPLROM1Device::IPLROM1Device()
1.1.1.6 ! root      104:        : inherited("IPLROM(1)")
1.1       root      105: {
1.1.1.6 ! root      106:        ClearAlias();
        !           107:        AddAlias("IPLROM1");
        !           108: 
1.1       root      109:        devaddr = 0xfe0000;
                    110:        devlen  = 0x020000;
                    111:        mask = devlen - 1;
                    112: }
                    113: 
                    114: IPLROM1Device::~IPLROM1Device()
                    115: {
                    116: }
                    117: 
                    118: bool
                    119: IPLROM1Device::Init()
                    120: {
                    121:        std::string name;
                    122: 
                    123:        if (gMainApp.benchmark_mode != 0) {
                    124:                name = string_format("BENCH%02d.ROM", gMainApp.benchmark_mode);
                    125:        } else {
                    126:                name = "IPLROM30.DAT";
                    127:        }
                    128: 
                    129:        if (LoadROM(name.c_str(), 128 * 1024) == false) {
                    130:                return false;
                    131:        }
                    132:        return true;
                    133: }
                    134: 
                    135: 
                    136: //
                    137: // IPLROM(2)
                    138: //
                    139: 
                    140: IPLROM2Device::IPLROM2Device()
1.1.1.6 ! root      141:        : inherited("IPLROM(2)")
1.1       root      142: {
1.1.1.6 ! root      143:        ClearAlias();
        !           144:        AddAlias("IPLROM2");
        !           145: 
1.1       root      146:        devaddr = 0xfc0000;
                    147:        devlen  = 0x020000;
                    148:        mask = devlen - 1;
                    149: }
                    150: 
                    151: IPLROM2Device::~IPLROM2Device()
                    152: {
                    153: }
                    154: 
                    155: bool
                    156: IPLROM2Device::Init()
                    157: {
                    158:        if (gMainApp.benchmark_mode != 0) {
                    159:                return true;
                    160:        }
                    161: 
                    162:        if (LoadROM("ROM30.DAT", 128 * 1024) == false) {
                    163:                return false;
                    164:        }
                    165:        return true;
                    166: }
                    167: 
                    168: 
                    169: //
                    170: // CGROM
                    171: //
                    172: 
                    173: CGROMDevice::CGROMDevice()
1.1.1.6 ! root      174:        : inherited("CGROM")
1.1       root      175: {
                    176:        devaddr = 0xf00000;
                    177:        devlen  = 768 * 1024;
                    178:        mask = 1024 * 1024 - 1;
                    179: }
                    180: 
                    181: CGROMDevice::~CGROMDevice()
                    182: {
                    183: }
                    184: 
                    185: bool
                    186: CGROMDevice::Init()
                    187: {
                    188: #if 0
                    189:        mem = builtin_cgrom;
                    190: #else
                    191:        if (LoadROM("CGROM30.DAT", 768 * 1024) == false) {
                    192:                return false;
                    193:        }
                    194: #endif
                    195:        return true;
                    196: }

unix.superglobalmegacorp.com

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