Return to iodevstream.h CVS log

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

Annotation of nono/vm/iodevstream.h, revision 1.1

1.1     ! root        1: //
        !             2: // nono
        !             3: // Copyright (C) 2019 [email protected]
        !             4: //
        !             5: 
        !             6: #pragma once
        !             7: 
        !             8: #include "header.h"
        !             9: #include "device.h"
        !            10: 
        !            11: // IODevice クラスへの Read/Write をストリームっぽく扱う。
        !            12: // Read/Write とも受け渡しはホストバイトオーダの値で行い、
        !            13: // デバイスへのアクセスはビッグエンディアンで行う。
        !            14: // アクセス中にバスエラーが起きることは考慮していない。
        !            15: class IODeviceStream
        !            16: {
        !            17:  public:
        !            18:        // コンストラクタ
        !            19:        IODeviceStream(IODevice *d) {
        !            20:                dev = d;
        !            21:        }
        !            22:        IODeviceStream(IODevice *d, uint32 a) {
        !            23:                dev = d;
        !            24:                addr = a;
        !            25:        }
        !            26:        // デストラクタ不要
        !            27: 
        !            28:        // アドレスを設定する
        !            29:        void SetAddr(uint32 a) {
        !            30:                addr = a;
        !            31:        }
        !            32:        // アドレスを取得する
        !            33:        uint32 GetAddr() const {
        !            34:                return addr;
        !            35:        }
        !            36: 
        !            37:        // 1バイト読み込んでポインタを進める
        !            38:        uint64 Read8() {
        !            39:                uint64 data = dev->Read8(addr);
        !            40:                addr += 1;
        !            41:                return data;
        !            42:        }
        !            43: 
        !            44:        // 2バイト読み込んでポインタを進める。addr はアラインしなくてよい
        !            45:        uint64 Read16() {
        !            46:                uint64 data;
        !            47:                data  = Read8() << 8;
        !            48:                data |= Read8();
        !            49:                return data;
        !            50:        }
        !            51: 
        !            52:        // 4バイト読み込んでポインタを進める。addr はアラインしなくてよい
        !            53:        // データはホストエンディアンで返される。
        !            54:        uint64 Read32() {
        !            55:                uint64 data;
        !            56:                data  = Read16(addr) << 16;
        !            57:                data |= Read16(addr);
        !            58:                return data;
        !            59:        }
        !            60: 
        !            61:        // 1バイト書き込んでポインタを進める
        !            62:        void Write8(uint32 data)
        !            63:        {
        !            64:                dev->Write8(addr, data);
        !            65:                addr += 1;
        !            66:        }
        !            67: 
        !            68:        // 2バイト書き込んでポインタを進める。addr はアラインしてなくてよい
        !            69:        void Write16(uint32 data)
        !            70:        {
        !            71:                Write8(data >> 8);
        !            72:                Write8(data & 0xff);
        !            73:        }
        !            74: 
        !            75:        // 4バイト書き込んでポインタを進める。addr はアラインしてなくてよい
        !            76:        void Write32(uint32 data)
        !            77:        {
        !            78:                Write16(data >> 16);
        !            79:                Write16(data & 0xffff);
        !            80:        }
        !            81: 
        !            82:        // アドレスも指定する版。ポインタは同様に進める
        !            83:        uint64 Read8(uint32 a) {
        !            84:                SetAddr(a);
        !            85:                return Read8();
        !            86:        }
        !            87:        uint64 Read16(uint32 a) {
        !            88:                SetAddr(a);
        !            89:                return Read16();
        !            90:        }
        !            91:        uint64 Read32(uint32 a) {
        !            92:                SetAddr(a);
        !            93:                return Read32();
        !            94:        }
        !            95:        void Write8(uint32 a, uint32 data) {
        !            96:                SetAddr(a);
        !            97:                Write8(data);
        !            98:        }
        !            99:        void Write16(uint32 a, uint32 data) {
        !           100:                SetAddr(a);
        !           101:                Write16(data);
        !           102:        }
        !           103:        void Write32(uint32 a, uint32 data) {
        !           104:                SetAddr(a);
        !           105:                Write32(data);
        !           106:        }
        !           107: 
        !           108:  private:
        !           109:        IODevice *dev;
        !           110:        uint32 addr;
        !           111: };

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