Return to romimg_x68k.cpp CVS log

Up to [Isaki's NoNo m68k/m88k emulator] / nono / vm

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

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()
        !            28: {
        !            29:        devname = "IPLROM(0)";
        !            30:        mask = 0x10000 - 1;
        !            31: }
        !            32: 
        !            33: IPLROM0Device::~IPLROM0Device()
        !            34: {
        !            35: }
        !            36: 
        !            37: bool
        !            38: IPLROM0Device::Init()
        !            39: {
        !            40:        iplrom1 = gIPLROM1.get();
        !            41:        return true;
        !            42: }
        !            43: 
        !            44: void
        !            45: IPLROM0Device::ResetHard()
        !            46: {
        !            47:        gVM->SwitchBootPage(this, true);
        !            48: }
        !            49: 
        !            50: uint64
        !            51: IPLROM0Device::Read8(uint32 addr)
        !            52: {
        !            53:        if (addr < 0x10000) {
        !            54:                return iplrom1->Read8(addr + 0x10000);
        !            55:        } else {
        !            56:                gVM->SwitchBootPage(this, false);
        !            57:                return iplrom1->Read8(addr);
        !            58:        }
        !            59: }
        !            60: 
        !            61: uint64
        !            62: IPLROM0Device::Read16(uint32 addr)
        !            63: {
        !            64:        if (addr < 0x10000) {
        !            65:                return iplrom1->Read16(addr + 0x10000);
        !            66:        } else {
        !            67:                gVM->SwitchBootPage(this, false);
        !            68:                return iplrom1->Read16(addr);
        !            69:        }
        !            70: }
        !            71: 
        !            72: uint64
        !            73: IPLROM0Device::Read32(uint32 addr)
        !            74: {
        !            75:        if (addr < 0x10000) {
        !            76:                return iplrom1->Read32(addr + 0x10000);
        !            77:        } else {
        !            78:                gVM->SwitchBootPage(this, false);
        !            79:                return iplrom1->Read32(addr);
        !            80:        }
        !            81: }
        !            82: 
        !            83: // Write は RAM 領域へも ROM 領域へも発生しないはずなので基底のを使う。
        !            84: 
        !            85: uint64
        !            86: IPLROM0Device::Peek8(uint32 addr)
        !            87: {
        !            88:        if (addr < 0x10000) {
        !            89:                return iplrom1->Peek8(addr + 0x10000);
        !            90:        } else {
        !            91:                return iplrom1->Peek8(addr);
        !            92:        }
        !            93: }
        !            94: 
        !            95: 
        !            96: //
1.1       root       97: // IPLROM(1)
                     98: //
                     99: 
                    100: IPLROM1Device::IPLROM1Device()
                    101: {
                    102:        devname = "IPLROM(1)";
                    103:        devaddr = 0xfe0000;
                    104:        devlen  = 0x020000;
                    105:        mask = devlen - 1;
                    106: }
                    107: 
                    108: IPLROM1Device::~IPLROM1Device()
                    109: {
                    110: }
                    111: 
                    112: bool
                    113: IPLROM1Device::Init()
                    114: {
                    115:        std::string name;
                    116: 
                    117:        if (gMainApp.benchmark_mode != 0) {
                    118:                name = string_format("BENCH%02d.ROM", gMainApp.benchmark_mode);
                    119:        } else {
                    120:                name = "IPLROM30.DAT";
                    121:        }
                    122: 
                    123:        if (LoadROM(name.c_str(), 128 * 1024) == false) {
                    124:                return false;
                    125:        }
                    126:        return true;
                    127: }
                    128: 
                    129: 
                    130: //
                    131: // IPLROM(2)
                    132: //
                    133: 
                    134: IPLROM2Device::IPLROM2Device()
                    135: {
                    136:        devname = "IPLROM(2)";
                    137:        devaddr = 0xfc0000;
                    138:        devlen  = 0x020000;
                    139:        mask = devlen - 1;
                    140: }
                    141: 
                    142: IPLROM2Device::~IPLROM2Device()
                    143: {
                    144: }
                    145: 
                    146: bool
                    147: IPLROM2Device::Init()
                    148: {
                    149:        if (gMainApp.benchmark_mode != 0) {
                    150:                return true;
                    151:        }
                    152: 
                    153:        if (LoadROM("ROM30.DAT", 128 * 1024) == false) {
                    154:                return false;
                    155:        }
                    156:        return true;
                    157: }
                    158: 
                    159: 
                    160: //
                    161: // CGROM
                    162: //
                    163: 
                    164: CGROMDevice::CGROMDevice()
                    165: {
                    166:        devname = "CGROM";
                    167:        devaddr = 0xf00000;
                    168:        devlen  = 768 * 1024;
                    169:        mask = 1024 * 1024 - 1;
                    170: }
                    171: 
                    172: CGROMDevice::~CGROMDevice()
                    173: {
                    174: }
                    175: 
                    176: bool
                    177: CGROMDevice::Init()
                    178: {
                    179: #if 0
                    180:        mem = builtin_cgrom;
                    181: #else
                    182:        if (LoadROM("CGROM30.DAT", 768 * 1024) == false) {
                    183:                return false;
                    184:        }
                    185: #endif
                    186:        return true;
                    187: }

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