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.3

1.1       root        1: //
                      2: // nono
1.1.1.2   root        3: // Copyright (C) 2020 nono project
                      4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
                      7: #pragma once
                      8: 
                      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:
1.1.1.3 ! root      109:        IODevice *dev {};
        !           110:        uint32 addr {};
1.1       root      111: };

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