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

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

unix.superglobalmegacorp.com

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