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

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

unix.superglobalmegacorp.com

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