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

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.