Return to bus.cpp CVS log

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

Annotation of nono/vm/bus.cpp, revision 1.1.1.4

1.1       root        1: //
                      2: // nono
1.1.1.3   root        3: // Copyright (C) 2020 nono project
                      4: // Licensed under nono-license.txt
1.1       root        5: //
                      6: 
                      7: #include "bus.h"
                      8: #include "ram.h"
                      9: 
                     10: IODevice *devtable[256];
                     11: 
                     12: //
                     13: // 物理バスアクセス?
                     14: // addr はそれぞれアラインされていること
                     15: //
                     16: 
                     17: uint64
1.1.1.2   root       18: vm_phys_read_8(uint32 addr)
1.1       root       19: {
                     20:        uint64 data;
                     21: 
                     22:        if (addr < ram_size) {
                     23:                data = ram[HLB(addr)];
                     24:        } else {
                     25:                IODevice *dev = ::devtable[addr >> 24];
                     26:                data = dev->Read8(addr);
                     27:        }
                     28:        return data;
                     29: }
                     30: 
                     31: uint64
1.1.1.2   root       32: vm_phys_read_16(uint32 addr)
1.1       root       33: {
                     34:        uint64 data;
                     35: 
1.1.1.4 ! root       36:        if (__predict_false(addr & 1))
        !            37:                PANIC("unaligned access $%08x", addr);
        !            38: 
1.1       root       39:        if (addr < ram_size) {
                     40:                data = *(uint16 *)&ram[HLW(addr)];
                     41:        } else {
                     42:                IODevice *dev = ::devtable[addr >> 24];
                     43:                data = dev->Read16(addr);
                     44:        }
                     45:        return data;
                     46: }
                     47: 
                     48: uint64
1.1.1.2   root       49: vm_phys_read_32(uint32 addr)
1.1       root       50: {
                     51:        uint64 data;
                     52: 
1.1.1.4 ! root       53:        if (__predict_false(addr & 3))
        !            54:                PANIC("unaligned access $%08x", addr);
1.1       root       55: 
                     56:        if (addr < ram_size) {
                     57:                data = *(uint32 *)&ram[addr];
                     58:        } else {
                     59:                IODevice *dev = ::devtable[addr >> 24];
                     60:                data = dev->Read32(addr);
                     61:        }
                     62:        return data;
                     63: }
                     64: 
                     65: uint64
1.1.1.2   root       66: vm_phys_write_8(uint32 addr, uint32 data)
1.1       root       67: {
                     68:        if (addr < ram_size) {
                     69:                ram[HLB(addr)] = data;
                     70:                return 0;
                     71:        } else {
                     72:                IODevice *dev = ::devtable[addr >> 24];
                     73:                return dev->Write8(addr, data);
                     74:        }
                     75: }
                     76: 
                     77: uint64
1.1.1.2   root       78: vm_phys_write_16(uint32 addr, uint32 data)
1.1       root       79: {
1.1.1.4 ! root       80:        if (__predict_false(addr & 1))
        !            81:                PANIC("unaligned access $%08x", addr);
        !            82: 
1.1       root       83:        if (addr < ram_size) {
                     84:                *(uint16 *)&ram[HLW(addr)] = data;
                     85:                return 0;
                     86:        } else {
                     87:                IODevice *dev = ::devtable[addr >> 24];
                     88:                return dev->Write16(addr, data);
                     89:        }
                     90: }
                     91: 
                     92: uint64
1.1.1.2   root       93: vm_phys_write_32(uint32 addr, uint32 data)
1.1       root       94: {
1.1.1.4 ! root       95:        if (__predict_false(addr & 3))
        !            96:                PANIC("unaligned access $%08x", addr);
        !            97: 
1.1       root       98:        if (addr < ram_size) {
                     99:                *(uint32 *)&ram[addr] = data;
                    100:                return 0;
                    101:        } else {
                    102:                IODevice *dev = ::devtable[addr >> 24];
                    103:                return dev->Write32(addr, data);
                    104:        }
                    105: }
                    106: 
                    107: uint64
1.1.1.2   root      108: vm_phys_peek_8(uint32 addr)
1.1       root      109: {
                    110:        uint64 data;
                    111: 
                    112:        if (addr < ram_size) {
                    113:                data = ram[HLB(addr)];
                    114:        } else {
                    115:                IODevice *dev = ::devtable[addr >> 24];
                    116:                data = dev->Peek8(addr);
                    117:        }
                    118:        return data;
                    119: }

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