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

1.1       root        1: //
                      2: // nono
1.1.1.4   root        3: // Copyright (C) 2020 nono project
                      4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
                      7: #include "sram.h"
1.1.1.4   root        8: #include "mainapp.h"
1.1       root        9: 
                     10: //
                     11: // SRAM
                     12: //
                     13: // SRAM はビッグエンディアンのままメモリに置かれるので、
                     14: // 必要ならアクセス時に都度変換すること。
                     15: //
                     16: 
1.1.1.3   root       17: std::unique_ptr<SRAMDevice> gSRAM;
1.1       root       18: 
                     19: SRAMDevice::SRAMDevice()
                     20: {
                     21:        logname = "sram";
                     22:        devname = "SRAM";
                     23:        devaddr = baseaddr;
1.1.1.4   root       24:        devlen  = 0x4000;
1.1       root       25: }
                     26: 
                     27: SRAMDevice::~SRAMDevice()
                     28: {
                     29: }
                     30: 
                     31: bool
                     32: SRAMDevice::Init()
                     33: {
1.1.1.3   root       34:        filename = gMainApp.GetVMDir() + "SRAM030.DAT";
1.1.1.4   root       35:        file.SetFilename(filename);
                     36:        file.SetDispname(string_format("SRAM \"%s\"", filename.c_str()));
                     37:        mem = file.OpenCreate(16 * 1024);
                     38:        if (mem == NULL) {
1.1       root       39:                return false;
                     40:        }
                     41: 
                     42:        return true;
                     43: }
                     44: 
1.1.1.3   root       45: // アドレスデコーダ
                     46: inline uint64
                     47: SRAMDevice::Decoder(uint32 addr) const
                     48: {
1.1.1.4   root       49:        uint32 offset = addr - baseaddr;
                     50:        assertmsg(offset < file.GetMemSize(),
                     51:                "offset=%x memlen=%x", offset, (int)file.GetMemSize());
                     52:        return offset;
1.1.1.3   root       53: }
                     54: 
1.1       root       55: uint64
                     56: SRAMDevice::Read8(uint32 addr)
                     57: {
1.1.1.3   root       58:        uint32 offset = Decoder(addr);
1.1.1.4   root       59:        uint32 data;
                     60: 
                     61:        // ホストファイル起動モードなら起動アドレスとして Pluto-X を見せる。
                     62:        if (gMainApp.host_file) {
                     63:                data = PeekHostBoot(offset);
                     64:                if ((int32)data >= 0) {
                     65:                        if ((offset & 1) == 0) {
                     66:                                data = data >> 8;
                     67:                        } else {
                     68:                                data = data & 0xff;
                     69:                        }
                     70:                        return data;
                     71:                }
                     72:        }
                     73: 
                     74:        data = mem[offset];
                     75:        return data;
1.1       root       76: }
                     77: 
                     78: uint64
                     79: SRAMDevice::Read16(uint32 addr)
                     80: {
1.1.1.3   root       81:        uint32 offset = Decoder(addr);
1.1.1.4   root       82:        uint32 data;
                     83: 
                     84:        // ホストファイル起動モードなら起動アドレスとして Pluto-X を見せる。
                     85:        if (gMainApp.host_file) {
                     86:                data = PeekHostBoot(offset);
                     87:                if ((int32)data >= 0) {
                     88:                        return data;
                     89:                }
                     90:        }
                     91: 
                     92:        data = be16toh(*(uint16 *)&mem[offset]);
                     93:        return data;
1.1       root       94: }
                     95: 
                     96: uint64
                     97: SRAMDevice::Write8(uint32 addr, uint32 data)
                     98: {
1.1.1.3   root       99:        uint32 offset = Decoder(addr);
                    100: 
1.1       root      101:        if (writeable) {
1.1.1.3   root      102:                if (offset < 0x100) {
1.1       root      103:                        putlog(1, "更新 $%06x <- $%02x", addr, data);
                    104:                }
1.1.1.3   root      105:                mem[offset] = data;
1.1       root      106:        } else {
                    107:                putlog(1, "書き込み禁止 $%06x <- $%02x", addr, data);
                    108:        }
                    109:        return 0;
                    110: }
                    111: 
                    112: uint64
                    113: SRAMDevice::Write16(uint32 addr, uint32 data)
                    114: {
1.1.1.3   root      115:        uint32 offset = Decoder(addr);
                    116: 
1.1       root      117:        if (writeable) {
1.1.1.3   root      118:                if (offset < 0x100) {
1.1       root      119:                        putlog(1, "更新 $%06x <- $%04x", addr, data);
                    120:                }
1.1.1.3   root      121:                *(uint16 *)&mem[offset] = htobe16(data);
1.1       root      122:        } else {
                    123:                putlog(1, "書き込み禁止 $%06x <- $%04x", addr, data);
                    124:        }
                    125:        return 0;
                    126: }
                    127: 
                    128: uint64
                    129: SRAMDevice::Peek8(uint32 addr)
                    130: {
1.1.1.3   root      131:        uint32 offset = Decoder(addr);
1.1.1.4   root      132: 
                    133:        // ホストファイル起動モードなら起動アドレスとして Pluto-X を見せる。
                    134:        if (gMainApp.host_file) {
                    135:                uint32 data = PeekHostBoot(offset);
                    136:                if ((int32)data >= 0) {
                    137:                        if ((offset & 1) == 0) {
                    138:                                data = data >> 8;
                    139:                        } else {
                    140:                                data = data & 0xff;
                    141:                        }
                    142:                        return data;
                    143:                }
                    144:        }
                    145: 
1.1.1.3   root      146:        return mem[offset];
1.1       root      147: }
                    148: 
                    149: void
                    150: SRAMDevice::write_enable(bool value)
                    151: {
                    152:        if (writeable == false && value == true) {
                    153:                putlog(1, "書き込み許可");
                    154:        } else if (writeable == true && value == false) {
                    155:                putlog(1, "書き込み禁止");
                    156:        }
                    157: 
                    158:        writeable = value;
                    159: }
1.1.1.4   root      160: 
                    161: // ホストファイル起動用の読み出し値を返す。
                    162: // offset はワード境界であること。戻り値はホストバイトオーダのワード値。
                    163: // 本来の SRAM の値を読み出してよいところについては (uint32)-1 を返す。
                    164: //
                    165: // mem[] は SRAM.DAT を直接 mmap(2) しており書き換えておくことは出来ないため、
                    166: // ホストファイル起動モードなら読み出し時に動的に値を返す。
                    167: uint32
                    168: SRAMDevice::PeekHostBoot(uint32 offset) const
                    169: {
                    170:        switch (offset) {
                    171:         case 0x0c:                     // ROM 起動アドレス(H)
                    172:                return (plutoaddr >> 16);
                    173:         case 0x0e:                     // ROM 起動アドレス(L)
                    174:                return (plutoaddr & 0xffff);
                    175:         case 0x18:                     // 起動デバイスを ROM にする
                    176:                return 0xa000;
                    177:         default:
                    178:                break;
                    179:        }
                    180:        return (uint32)-1;
                    181: }

unix.superglobalmegacorp.com

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