Annotation of nono/vm/bt454.cpp, revision 1.1.1.1

1.1       root        1: //
                      2: // nono
                      3: // Copyright (C) 2018 [email protected]
                      4: //
                      5: 
                      6: #include "bt454.h"
                      7: #include "bitmap.h"
                      8: 
                      9: // XXX 仕様書には $c100_0000 と書いてあるが、PROM も NetBSD カーネルも
                     10: // $c110_0000 にアクセスしているので、とりあえず $c110_0000 にしておく
                     11: // というか $10_0000 で折り返して見せることにしておく。
                     12: // 実機調査すること。
                     13: 
                     14: // 下位ニブルのパターンは不明。とりあえず
                     15: #define LOW_NIBBLE     (0x0f)
                     16: 
                     17: BT454Device *gBT454;
                     18: 
                     19: BT454Device::BT454Device()
                     20: {
                     21:        logname = "bt454";
                     22:        devname = "BT454";
                     23:        devaddr = 0xc1000000;
                     24: }
                     25: 
                     26: BT454Device::~BT454Device()
                     27: {
                     28: }
                     29: 
                     30: bool
                     31: BT454Device::Init()
                     32: {
                     33:        nplane = gBitmap->GetPlaneCount();
                     34:        return true;
                     35: }
                     36: 
                     37: void
                     38: BT454Device::ResetHard()
                     39: {
                     40:        reg.addr = 0;
                     41: }
                     42: 
                     43: /* static */ const char
                     44: BT454Device::rgbstr[3] = { 'R', 'G', 'B' };
                     45: 
                     46: uint64
                     47: BT454Device::Read8(uint32 addr)
                     48: {
                     49:        uint32 an = (addr - devaddr) & 0x000fffff;
                     50:        uint32 data;
                     51: 
                     52:        switch (an) {
                     53:         case 0:        // アドレスレジスタ
                     54:                // 今の(今からアクセスする)パレット番号
                     55:                data = reg.addr / 3;
                     56:                data = (data << 4) | LOW_NIBBLE;
                     57:                putlog(2, "アドレスレジスタ -> $%02x", data);
                     58:                break;
                     59: 
                     60:         case 1:        // カラーマップレジスタ
                     61:                // reg.color[] は上位4ビットが有効なのでそのまま読み出せる。
                     62:                data = reg.color[reg.addr];
                     63:                data |= LOW_NIBBLE;
                     64:                putlog(2, "カラーマップ $%x(%c) -> $%02x",
                     65:                        reg.addr / 3, rgbstr[reg.addr % 3], data);
                     66:                // アクセスするたびにインクリメントする。
                     67:                reg.addr++;
                     68:                if (reg.addr >= countof(reg.color)) {
                     69:                        reg.addr = 0;
                     70:                }
                     71:                break;
                     72: 
                     73:         default:
                     74:                putlog(0, "未実装バイト読み込み $%08x", addr);
                     75:                data = 0xff;
                     76:                break;
                     77:        }
                     78: 
                     79:        return data;
                     80: }
                     81: 
                     82: uint64
                     83: BT454Device::Read16(uint32 addr)
                     84: {
                     85:        putlog(0, "未実装ワード読み込み $%08x", addr);
                     86:        return 0xffff;
                     87: }
                     88: 
                     89: uint64
                     90: BT454Device::Read32(uint32 addr)
                     91: {
                     92:        putlog(0, "未実装ロング読み込み $%08x", addr);
                     93:        return 0xffffffff;
                     94: }
                     95: 
                     96: uint64
                     97: BT454Device::Write8(uint32 addr, uint32 data)
                     98: {
                     99:        uint32 an = (addr - devaddr) & 0x000fffff;
                    100: 
                    101:        // 書き込みデータのうち有効なのは上位ニブルだけ
                    102: 
                    103:        switch (an) {
                    104:         case 0:        // アドレスレジスタ
                    105:                // 今からアクセスするパレット番号
                    106:                // data はパレット番号だが reg.addr は配列のインデックスなので 3倍。
                    107:                putlog(2, "アドレスレジスタ <- $%02x", data);
                    108:                reg.addr = (data >> 4) * 3;
                    109:                break;
                    110: 
                    111:         case 1:        // カラーマップレジスタ
                    112:                // reg.color[] は上位4ビットが有効なのでそのまま書き込む。
                    113:                // 下位4ビットはどうするか。
                    114:                reg.color[reg.addr] = (data & 0xf0);
                    115:                if (loglevel == 1) {
                    116:                        // ログレベル1なら RGB が書き込まれた時点で表示。
                    117:                        // 大体はこれくらいの表示で構わないはず。
                    118:                        if (reg.addr % 3 == 2) {
                    119:                                putlog("カラーマップ $%x = (%x,%x,%x)",
                    120:                                        reg.addr / 3,
                    121:                                        reg.color[reg.addr - 2] >> 4,
                    122:                                        reg.color[reg.addr - 1] >> 4,
                    123:                                        reg.color[reg.addr    ] >> 4);
                    124:                        }
                    125:                } else if (loglevel >= 2) {
                    126:                        putlog("カラーマップ $%x(%c) <- $%02x",
                    127:                                reg.addr / 3, rgbstr[reg.addr % 3], data);
                    128:                }
                    129:                // ホストカラーを計算。
                    130:                MakeHostColor(reg.addr);
                    131: 
                    132:                // ホストカラー計算後にインクリメントする。
                    133:                reg.addr++;
                    134:                if (reg.addr >= countof(reg.color)) {
                    135:                        reg.addr = 0;
                    136:                }
                    137:                break;
                    138: 
                    139:         default:
                    140:                putlog(0, "未実装バイト書き込み $%08x <- %02x", addr, data);
                    141:                break;
                    142:        }
                    143:        return 0;
                    144: }
                    145: 
                    146: uint64
                    147: BT454Device::Write16(uint32 addr, uint32 data)
                    148: {
                    149:        putlog(0, "未実装ワード書き込み $%08x <- %04x", addr, data);
                    150:        return 0;
                    151: }
                    152: 
                    153: uint64
                    154: BT454Device::Write32(uint32 addr, uint32 data)
                    155: {
                    156:        putlog(0, "未実装ロング書き込み $%08x <- %08x", addr, data);
                    157:        return 0;
                    158: }
                    159: 
                    160: uint64
                    161: BT454Device::Peek8(uint32 addr)
                    162: {
                    163:        uint32 an = (addr - devaddr) & 0x000fffff;
                    164: 
                    165:        switch (an) {
                    166:         case 0:        // アドレスレジスタ
                    167:                // XXX 下位ニブルは?
                    168:                return ((reg.addr / 3) << 4) | LOW_NIBBLE;
                    169: 
                    170:         case 1:        // カラーマップレジスタ
                    171:                // 今読み出そうとしたら読み出せるやつ
                    172:                return reg.color[reg.addr] | LOW_NIBBLE;
                    173: 
                    174:         default:
                    175:                return 0xff;
                    176:        }
                    177: }
                    178: 
                    179: // addr 番目のレジスタ値からホストパレットを作成。
                    180: void
                    181: BT454Device::MakeHostColor(int addr)
                    182: {
                    183:        int col = addr / 3;
                    184:        int idx = addr % 3;
                    185: 
                    186:        if (nplane == 1) {
                    187:                // 1bpp なら R,G,B のうち G の値だけを使用
                    188:                if (idx == 1) {
                    189:                        reg.hostcolor[col * 4 + 0] = reg.color[col * 3 + 1];
                    190:                        reg.hostcolor[col * 4 + 1] = reg.color[col * 3 + 1];
                    191:                        reg.hostcolor[col * 4 + 2] = reg.color[col * 3 + 1];
                    192:                }
                    193:        } else {
                    194:                // 4bpp なら代入するだけ
                    195:                reg.hostcolor[col * 4 + idx] = reg.color[col * 3 + idx];
                    196:        }
                    197: }

unix.superglobalmegacorp.com

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