Return to romimg.cpp CVS log

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

Annotation of nono/vm/romimg.cpp, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2018 [email protected]
        !             4: //
        !             5: 
        !             6: #include <fcntl.h>
        !             7: #include <unistd.h>
        !             8: #include <sys/mman.h>
        !             9: #include <sys/stat.h>
        !            10: #include "romimg.h"
        !            11: #include "mainapp.h"
        !            12: 
        !            13: //
        !            14: // ROM 共通部
        !            15: //
        !            16: // ROM はビッグエンディアンのままメモリに置かれるので、
        !            17: // 必要ならアクセス時に都度変換すること。
        !            18: //
        !            19: 
        !            20: ROMDevice::ROMDevice()
        !            21: {
        !            22:        logname = "rom";
        !            23: 
        !            24:        mask = 0xffffffff;
        !            25:        fd = -1;
        !            26: }
        !            27: 
        !            28: ROMDevice::~ROMDevice()
        !            29: {
        !            30:        if (file) {
        !            31:                munmap(file, filesize);
        !            32:                file = NULL;
        !            33:        }
        !            34:        if (fd != 0) {
        !            35:                close(fd);
        !            36:                fd = -1;
        !            37:        }
        !            38: }
        !            39: 
        !            40: // name の ROM を探してロードする。
        !            41: // name はパスを含まないファイル名のみ。パスはこちらで探す。
        !            42: // mem は file をさす。
        !            43: // 失敗した場合はエラーメッセージを表示して false を返す。
        !            44: bool
        !            45: ROMDevice::LoadROM(const char *name, int size)
        !            46: {
        !            47:        struct stat st;
        !            48: 
        !            49:        filename = gMainApp.SearchFile(name);
        !            50:        if (filename.empty()) {
        !            51:                warnx("%s not found", name);
        !            52:                return false;
        !            53:        }
        !            54: 
        !            55:        // オープン
        !            56:        fd = open(filename.c_str(), O_RDONLY);
        !            57:        if (fd == -1) {
        !            58:                warn("ROM \"%s\" open failed", filename.c_str());
        !            59:                return false;
        !            60:        }
        !            61: 
        !            62:        // ファイルサイズをチェック。
        !            63:        // ファイルが短くても mmap はしれっと成功してしまうようだ。
        !            64:        if (fstat(fd, &st) == -1) {
        !            65:                warn("ROM \"%s\" fstat failed", filename.c_str());
        !            66:                close(fd);
        !            67:                return false;
        !            68:        }
        !            69:        if (st.st_size < size) {
        !            70:                warnx("ROM \"%s\" is too short (filesize is expected %d but %d)",
        !            71:                        filename.c_str(), size, (int)st.st_size);
        !            72:                close(fd);
        !            73:                return false;
        !            74:        }
        !            75:        if (st.st_size > size) {
        !            76:                // 大きすぎるほうはワーニングだけでいいか
        !            77:                warnx("ROM \"%s\" is too large (ignore %d bytes)",
        !            78:                        filename.c_str(), (int)st.st_size - size);
        !            79:        }
        !            80: 
        !            81:        // mmap
        !            82:        // ファイルには書き戻さないけど、オンメモリでハックを入れることが
        !            83:        // できるように MAP_PRIVATE を指定する。
        !            84:        filesize = size;
        !            85:        file = (uint8 *)mmap(NULL, filesize, PROT_READ | PROT_WRITE,
        !            86:                MAP_PRIVATE, fd, 0);
        !            87:        if (file == MAP_FAILED) {
        !            88:                warn("ROM \"%s\" mmap failed", filename.c_str());
        !            89:                close(fd);
        !            90:                return false;
        !            91:        }
        !            92: 
        !            93:        mem = file;
        !            94:        return true;
        !            95: }
        !            96: 
        !            97: uint64
        !            98: ROMDevice::Read8(uint32 addr)
        !            99: {
        !           100:        return mem[addr & mask];
        !           101: }
        !           102: 
        !           103: uint64
        !           104: ROMDevice::Read16(uint32 addr)
        !           105: {
        !           106:        uint16 data;
        !           107:        data = *(uint16 *)&mem[addr & mask];
        !           108:        return be16toh(data);
        !           109: }
        !           110: 
        !           111: uint64
        !           112: ROMDevice::Read32(uint32 addr)
        !           113: {
        !           114:        uint32 data;
        !           115:        data = *(uint32 *)&mem[addr & mask];
        !           116:        return be32toh(data);
        !           117: }
        !           118: 
        !           119: uint64
        !           120: ROMDevice::Write8(uint32 addr, uint32 data)
        !           121: {
        !           122:        return (uint64)-1;
        !           123: }
        !           124: 
        !           125: uint64
        !           126: ROMDevice::Write16(uint32 addr, uint32 data)
        !           127: {
        !           128:        return (uint64)-1;
        !           129: }
        !           130: 
        !           131: uint64
        !           132: ROMDevice::Write32(uint32 addr, uint32 data)
        !           133: {
        !           134:        return (uint64)-1;
        !           135: }
        !           136: 
        !           137: uint64
        !           138: ROMDevice::Peek8(uint32 addr)
        !           139: {
        !           140:        return mem[addr & mask];
        !           141: }

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