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

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: 
                     36: if ((addr & 1))PANIC("unaligned access $%08x", addr);
                     37:        if (addr < ram_size) {
                     38:                data = *(uint16 *)&ram[HLW(addr)];
                     39:        } else {
                     40:                IODevice *dev = ::devtable[addr >> 24];
                     41:                data = dev->Read16(addr);
                     42:        }
                     43:        return data;
                     44: }
                     45: 
                     46: uint64
1.1.1.2   root       47: vm_phys_read_32(uint32 addr)
1.1       root       48: {
                     49:        uint64 data;
                     50: 
                     51: if ((addr & 3))PANIC("unaligned access $%08x", addr);
                     52: 
                     53:        if (addr < ram_size) {
                     54:                data = *(uint32 *)&ram[addr];
                     55:        } else {
                     56:                IODevice *dev = ::devtable[addr >> 24];
                     57:                data = dev->Read32(addr);
                     58:        }
                     59:        return data;
                     60: }
                     61: 
                     62: uint64
1.1.1.2   root       63: vm_phys_write_8(uint32 addr, uint32 data)
1.1       root       64: {
                     65:        if (addr < ram_size) {
                     66:                ram[HLB(addr)] = data;
                     67:                return 0;
                     68:        } else {
                     69:                IODevice *dev = ::devtable[addr >> 24];
                     70:                return dev->Write8(addr, data);
                     71:        }
                     72: }
                     73: 
                     74: uint64
1.1.1.2   root       75: vm_phys_write_16(uint32 addr, uint32 data)
1.1       root       76: {
                     77: if ((addr & 1))PANIC("unaligned access $%08x", addr);
                     78:        if (addr < ram_size) {
                     79:                *(uint16 *)&ram[HLW(addr)] = data;
                     80:                return 0;
                     81:        } else {
                     82:                IODevice *dev = ::devtable[addr >> 24];
                     83:                return dev->Write16(addr, data);
                     84:        }
                     85: }
                     86: 
                     87: uint64
1.1.1.2   root       88: vm_phys_write_32(uint32 addr, uint32 data)
1.1       root       89: {
                     90: if ((addr & 3))PANIC("unaligned access $%08x", addr);
                     91:        if (addr < ram_size) {
                     92:                *(uint32 *)&ram[addr] = data;
                     93:                return 0;
                     94:        } else {
                     95:                IODevice *dev = ::devtable[addr >> 24];
                     96:                return dev->Write32(addr, data);
                     97:        }
                     98: }
                     99: 
                    100: uint64
1.1.1.2   root      101: vm_phys_peek_8(uint32 addr)
1.1       root      102: {
                    103:        uint64 data;
                    104: 
                    105:        if (addr < ram_size) {
                    106:                data = ram[HLB(addr)];
                    107:        } else {
                    108:                IODevice *dev = ::devtable[addr >> 24];
                    109:                data = dev->Peek8(addr);
                    110:        }
                    111:        return data;
                    112: }

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