Return to sram.cpp CVS log

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

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

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2017 [email protected]
                      4: //
                      5: 
                      6: #include "configfile.h"
                      7: #include "sram.h"
                      8: #include <sys/fcntl.h>
                      9: #include <sys/mman.h>
                     10: 
                     11: //
                     12: // SRAM
                     13: //
                     14: // SRAM はビッグエンディアンのままメモリに置かれるので、
                     15: // 必要ならアクセス時に都度変換すること。
                     16: //
                     17: 
                     18: SRAMDevice *gSRAM;
                     19: 
                     20: SRAMDevice::SRAMDevice()
                     21: {
                     22:        logname = "sram";
                     23:        devname = "SRAM";
                     24:        devaddr = baseaddr;
                     25:        devlen  = 0x10000;      // 通常実際は16KBだが64KB分占有しておく
                     26: 
                     27:        fd = -1;
                     28: }
                     29: 
                     30: SRAMDevice::~SRAMDevice()
                     31: {
                     32:        if (mem) {
                     33:                munmap(mem, memlen);
                     34:                mem = NULL;
                     35:                memlen = 0;
                     36:        }
                     37:        if (fd >= 0) {
                     38:                close(fd);
                     39:                fd = -1;
                     40:        }
                     41: }
                     42: 
                     43: bool
                     44: SRAMDevice::Init()
                     45: {
                     46:        filename = gConfig->GetConfigDir() + "SRAM030.DAT";
                     47: 
                     48:        fd = open(filename.c_str(), O_RDWR);
                     49:        if (fd == -1) {
                     50:                warn("%s: cannot open %s", devname, filename.c_str());
                     51:                return false;
                     52:        }
                     53: 
                     54:        memlen = 16 * 1024;
                     55:        mem = (uint8 *)mmap(NULL, memlen, PROT_READ | PROT_WRITE,
                     56:                MAP_SHARED, fd, 0);
                     57:        if (mem == MAP_FAILED) {
                     58:                warn("%s: cannot mmap %s", devname, filename.c_str());
                     59:                close(fd);
                     60:                return false;
                     61:        }
                     62: 
                     63:        return true;
                     64: }
                     65: 
                     66: uint64
                     67: SRAMDevice::Read8(uint32 addr)
                     68: {
                     69:        return mem[addr - baseaddr];
                     70: }
                     71: 
                     72: uint64
                     73: SRAMDevice::Read16(uint32 addr)
                     74: {
                     75:        return be16toh(*(uint16 *)&mem[addr - baseaddr]);
                     76: }
                     77: 
                     78: uint64
                     79: SRAMDevice::Write8(uint32 addr, uint32 data)
                     80: {
                     81:        if (writeable) {
                     82:                if (addr - baseaddr < 0x100) {
                     83:                        putlog(1, "更新 $%06x <- $%02x", addr, data);
                     84:                }
                     85:                mem[addr - baseaddr] = data;
                     86:        } else {
                     87:                putlog(1, "書き込み禁止 $%06x <- $%02x", addr, data);
                     88:        }
                     89:        return 0;
                     90: }
                     91: 
                     92: uint64
                     93: SRAMDevice::Write16(uint32 addr, uint32 data)
                     94: {
                     95:        if (writeable) {
                     96:                if (addr - baseaddr < 0x100) {
                     97:                        putlog(1, "更新 $%06x <- $%04x", addr, data);
                     98:                }
                     99:                *(uint16 *)&mem[addr - baseaddr] = htobe16(data);
                    100:        } else {
                    101:                putlog(1, "書き込み禁止 $%06x <- $%04x", addr, data);
                    102:        }
                    103:        return 0;
                    104: }
                    105: 
                    106: uint64
                    107: SRAMDevice::Peek8(uint32 addr)
                    108: {
                    109:        return mem[addr - baseaddr];
                    110: }
                    111: 
                    112: void
                    113: SRAMDevice::write_enable(bool value)
                    114: {
                    115:        if (writeable == false && value == true) {
                    116:                putlog(1, "書き込み許可");
                    117:        } else if (writeable == true && value == false) {
                    118:                putlog(1, "書き込み禁止");
                    119:        }
                    120: 
                    121:        writeable = value;
                    122: }

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