Return to zram.cpp CVS log

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

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

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2018 [email protected]
        !             4: //
        !             5: 
        !             6: #include "zram.h"
        !             7: 
        !             8: //
        !             9: // 3ポート共有 RAM
        !            10: //
        !            11: // ZRAM はロングワード単位でホストバイトオーダ配置なので、
        !            12: // バイトアクセス、ワードアクセス時は HLB(), HLW() マクロ使用のこと。
        !            13: //
        !            14: 
        !            15: ZRAMDevice *gZRAM;
        !            16: 
        !            17: ZRAMDevice::ZRAMDevice()
        !            18: {
        !            19:        logname = "zram";
        !            20:        devname = "ZRAM";
        !            21:        devaddr = 0x71000000;
        !            22:        devlen = 128 * 1024;
        !            23: 
        !            24:        ram = new uint8[devlen];
        !            25: }
        !            26: 
        !            27: ZRAMDevice::~ZRAMDevice()
        !            28: {
        !            29: }
        !            30: 
        !            31: // たぶん 128KB で折り返しイメージが見えるはず。要確認。
        !            32: 
        !            33: uint64
        !            34: ZRAMDevice::Read8(uint32 addr)
        !            35: {
        !            36:        std::unique_lock<std::mutex> lock(mtx);
        !            37: 
        !            38:        uint32 an = addr % devlen;
        !            39:        uint32 data = ram[HLB(an)];
        !            40:        return data;
        !            41: }
        !            42: 
        !            43: uint64
        !            44: ZRAMDevice::Read16(uint32 addr)
        !            45: {
        !            46:        std::unique_lock<std::mutex> lock(mtx);
        !            47: 
        !            48:        uint32 an = addr % devlen;
        !            49:        uint32 data = *(uint16 *)&ram[HLW(an)];
        !            50:        return data;
        !            51: }
        !            52: 
        !            53: uint64
        !            54: ZRAMDevice::Read32(uint32 addr)
        !            55: {
        !            56:        std::unique_lock<std::mutex> lock(mtx);
        !            57: 
        !            58:        uint32 an = addr % devlen;
        !            59:        uint32 data = *(uint32 *)&ram[an];
        !            60:        return data;
        !            61: }
        !            62: 
        !            63: uint64
        !            64: ZRAMDevice::Write8(uint32 addr, uint32 data)
        !            65: {
        !            66:        std::unique_lock<std::mutex> lock(mtx);
        !            67: 
        !            68:        uint32 an = addr % devlen;
        !            69:        ram[HLB(an)] = data;
        !            70:        return 0;
        !            71: }
        !            72: 
        !            73: uint64
        !            74: ZRAMDevice::Write16(uint32 addr, uint32 data)
        !            75: {
        !            76:        std::unique_lock<std::mutex> lock(mtx);
        !            77: 
        !            78:        uint32 an = addr % devlen;
        !            79:        *(uint16 *)&ram[HLW(an)] = data;
        !            80:        return 0;
        !            81: }
        !            82: 
        !            83: uint64
        !            84: ZRAMDevice::Write32(uint32 addr, uint32 data)
        !            85: {
        !            86:        std::unique_lock<std::mutex> lock(mtx);
        !            87: 
        !            88:        uint32 an = addr % devlen;
        !            89:        *(uint32 *)&ram[an] = data;
        !            90:        return 0;
        !            91: }
        !            92: 
        !            93: uint64
        !            94: ZRAMDevice::Peek8(uint32 addr)
        !            95: {
        !            96:        std::unique_lock<std::mutex> lock(mtx);
        !            97: 
        !            98:        uint32 an = addr % devlen;
        !            99:        return ram[HLB(an)];
        !           100: }

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