[VM][FMTOWNS][SPRITE] Fix around memory accessing.

diff --git a/source/src/vm/fmtowns/sprite.cpp b/source/src/vm/fmtowns/sprite.cpp
index 8d6752c..0d27aee 100644 (file)
--- a/source/src/vm/fmtowns/sprite.cpp
+++ b/source/src/vm/fmtowns/sprite.cpp
@@ -760,38 +760,120 @@ uint32_t TOWNS_SPRITE::read_io8(uint32_t addr)
 
 uint32_t TOWNS_SPRITE::read_memory_mapped_io8(uint32_t addr)
 {
-       __LIKELY_IF((addr >= 0x81000000) && (addr < 0x81020000)) {
-               return pattern_ram[addr & 0x1ffff];
-       }/* else if((addr >= 0xc8000) && (addr < 0xc9000)) {
-               return pattern_ram[addr - 0xc8000];
-       } else if((addr >= 0xca000) && (addr < 0xcb000)) {
-               return pattern_ram[addr - 0xc8000];
-       }*/
-       else if((addr >= 0xc8000) && (addr < 0xcb000)) { // OK? From TSUGARU
-               return pattern_ram[addr - 0xc8000];
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
+               addr = addr - 0x000c8000; // Trick :-)
        }
-       return 0x00;
+       return pattern_ram[addr & 0x1ffff];
 }
 
+uint32_t TOWNS_SPRITE::read_memory_mapped_io16(uint32_t addr)
+{
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
+               addr = addr - 0x000c8000; // Trick :-)
+       }
+       pair16_t n;
+       addr = addr & 0x1ffff;
+       __UNLIKELY_IF(addr == 0x1ffff) {
+               n.b.h = 0xff;
+               n.b.l = pattern_ram[0x1ffff];
+       } else {
+               n.read_2bytes_le_from(&(pattern_ram[addr]));
+       }
+       return n.w;
+}
+
+uint32_t TOWNS_SPRITE::read_memory_mapped_io32(uint32_t addr)
+{
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
+               addr = addr - 0x000c8000; // Trick :-)
+       }
+       pair32_t d;
+       addr = addr & 0x1ffff;
+       __UNLIKELY_IF(addr > 0x1fffc) {
+               d.d = 0xffffffff;
+               switch(addr) {
+               case 0x1ffff:
+                       d.b.l = pattern_ram[0x1ffff];
+                       break;
+               case 0x1fffe:
+                       d.b.h = pattern_ram[0x1ffff];
+                       d.b.l = pattern_ram[0x1fffe];
+                       break;
+               case 0x1fffd:
+                       d.b.h2 = pattern_ram[0x1ffff];
+                       d.b.h  = pattern_ram[0x1fffe];
+                       d.b.l  = pattern_ram[0x1fffd];
+                       break;
+               default:
+                       break;
+               }
+       } else {
+               d.read_4bytes_le_from(&(pattern_ram[addr]));
+       }
+       return d.d;
+}
 
 void TOWNS_SPRITE::write_memory_mapped_io8(uint32_t addr, uint32_t data)
 {
-       __LIKELY_IF((addr >= 0x81000000) && (addr < 0x81020000)) {
-               pattern_ram[addr & 0x1ffff] = data;
-       } /*else if((addr >= 0xc8000) && (addr < 0xc9000)) {
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
                tvram_enabled = true;
                tvram_enabled_bak = true;
-               pattern_ram[addr - 0xc8000] = data;
-       } else if((addr >= 0xca000) && (addr < 0xcb000)) {
+               addr = addr - 0x000c8000; // Trick :-)
+       }
+       addr = addr & 0x1ffff;
+       pattern_ram[addr] = data;
+       return;
+}
+
+void TOWNS_SPRITE::write_memory_mapped_io16(uint32_t addr, uint32_t data)
+{
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
                tvram_enabled = true;
                tvram_enabled_bak = true;
-               pattern_ram[addr - 0xc8000] = data;
-       }*/
-        else if((addr >= 0xc8000) && (addr < 0xcb000)) { // OK? From TSUGARU
+               addr = addr - 0x000c8000; // Trick :-)
+       }
+       addr = addr & 0x1ffff;
+       pair16_t n;
+       n.w = data;
+       __UNLIKELY_IF(addr == 0x1ffff) {
+               pattern_ram[0x1ffff] = n.b.l;
+       } else {
+               n.write_2bytes_le_to(&(pattern_ram[addr]));
+       }
+       return;
+}
+
+void TOWNS_SPRITE::write_memory_mapped_io32(uint32_t addr, uint32_t data)
+{
+       __UNLIKELY_IF((addr >= 0x000c8000) && (addr < 0x000cb000))  { // OK?
                tvram_enabled = true;
                tvram_enabled_bak = true;
-               pattern_ram[addr - 0xc8000] = data;
-        }
+               addr = addr - 0x000c8000; // Trick :-)
+       }
+       addr = addr & 0x1ffff;
+       pair32_t d;
+       d.d = data;
+       __UNLIKELY_IF(addr > 0x1fffc) {
+               d.d = 0xffffffff;
+               switch(addr) {
+               case 0x1ffff:
+                       pattern_ram[0x1ffff] = d.b.l;
+                       break;
+               case 0x1fffe:
+                       pattern_ram[0x1ffff] = d.b.h;
+                       pattern_ram[0x1fffe] = d.b.l;
+                       break;
+               case 0x1fffd:
+                       pattern_ram[0x1ffff] = d.b.h2;
+                       pattern_ram[0x1fffe] = d.b.h;
+                       pattern_ram[0x1fffd] = d.b.l;
+                       break;
+               default:
+                       break;
+               }
+       } else {
+               d.write_4bytes_le_to(&(pattern_ram[addr]));
+       }
        return;
 }
 

diff --git a/source/src/vm/fmtowns/sprite.h b/source/src/vm/fmtowns/sprite.h
index f2cbc88..90a267e 100644 (file)
--- a/source/src/vm/fmtowns/sprite.h
+++ b/source/src/vm/fmtowns/sprite.h
@@ -75,19 +75,46 @@ public:
        }
        ~TOWNS_SPRITE() {}
 
-       void __FASTCALL write_io8(uint32_t addr, uint32_t data);
-       uint32_t __FASTCALL read_io8(uint32_t addr);
+       void reset() override;
+       void initialize() override;
 
-       void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data);
-       uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr);
-       uint32_t __FASTCALL read_via_debugger_data8(uint32_t addr)
+       void event_pre_frame() override;
+       void event_vline(int v, int clk) override;
+       void __FASTCALL event_callback(int id, int err) override;
+
+       void __FASTCALL write_io8(uint32_t addr, uint32_t data) override;
+       uint32_t __FASTCALL read_io8(uint32_t addr) override;
+       uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr) override;
+       uint32_t __FASTCALL read_memory_mapped_io16(uint32_t addr) override;
+       uint32_t __FASTCALL read_memory_mapped_io32(uint32_t addr) override;
+
+       void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data) override;
+       void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data) override;
+       void __FASTCALL write_memory_mapped_io32(uint32_t addr, uint32_t data) override;
+
+       void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask) override;
+       uint32_t __FASTCALL read_signal(int id) override;
+
+       bool is_debugger_available() override
+       {
+               return true;
+       }
+       void *get_debugger() override
+       {
+               return d_debugger;
+       }
+       uint64_t get_debug_data_addr_space() override
+       {
+               return 0x20000;
+       }
+       uint32_t __FASTCALL read_debug_data8(uint32_t addr) override
        {
                if(addr >= 0x20000) {
                        return 0x00;
                }
                return pattern_ram[addr];
        }
-       void __FASTCALL write_via_debugger_data8(uint32_t addr, uint32_t data)
+       void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data) override
        {
                if(addr >= 0x20000) {
                        return;
@@ -101,40 +128,13 @@ public:
                }
                pattern_ram[addr] = (uint8_t)data;
        }
-       bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len);
-       bool write_debug_reg(const _TCHAR *reg, uint32_t data);
-       uint32_t __FASTCALL read_debug_data8(uint32_t addr)
-       {
-               return read_via_debugger_data8(addr);
-       }
-       void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data)
-       {
-               write_via_debugger_data8(addr, data);
-       }
-
-       bool is_debugger_available()
-       {
-               return true;
-       }
-       void *get_debugger()
-       {
-               return d_debugger;
-       }
-       uint64_t get_debug_data_addr_space()
-       {
-               return 0x20000;
-       }
-
-       void reset();
-       void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask);
-       uint32_t __FASTCALL read_signal(int id);
-       void initialize();
-       void event_pre_frame();
-       void event_vline(int v, int clk);
-       void __FASTCALL event_callback(int id, int err);
-
-       bool process_state(FILEIO* state_fio, bool loading);
+       bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len) override;
+       bool write_debug_reg(const _TCHAR *reg, uint32_t data) override;
 
+       bool process_state(FILEIO* state_fio, bool loading) override;
+       /*
+         Unique functions
+       */
        void set_context_vram(TOWNS_VRAM *p)
        {
                d_vram = p;

diff --git a/source/src/vm/fmtowns/towns_memory.cpp b/source/src/vm/fmtowns/towns_memory.cpp
index f1ca969..a978499 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.cpp
+++ b/source/src/vm/fmtowns/towns_memory.cpp
@@ -76,7 +76,7 @@ void TOWNS_MEMORY::initialize()
        set_region_device_rw(0x80000000, 0x8007ffff, d_vram, NOT_NEED_TO_OFFSET);
        set_region_device_rw(0x80100000, 0x8017ffff, d_vram, NOT_NEED_TO_OFFSET);
 
-       set_region_device_rw(0x81000000, 0x8101ffff, d_sprite, NOT_NEED_TO_OFFSET);
+       set_region_device_rw(0x81000000, 0x8101ffff, d_sprite, 0);
        set_region_device_rw(0xc0000000, 0xc0ffffff, d_iccard[0], 0);
        set_region_device_rw(0xc1000000, 0xc1ffffff, d_iccard[1], 0);
 //     set_wait_rw(0x00000000, 0xffffffff,  vram_wait_val);
@@ -958,8 +958,8 @@ uint32_t TOWNS_MEMORY::read_dma_data8w(uint32_t addr, int* wait)
        uint32_t offset = addr & memory_map_mask();
        uint8_t val;
        int waitval;
-       //return read_8bit_data(dma_read_map, mapptr, addr, offset, true, wait);
-       val = read_8bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
+       val = read_8bit_data(dma_read_map, mapptr, addr, offset, true, &waitval);
+       //val = read_8bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.
        }
@@ -975,8 +975,8 @@ uint32_t TOWNS_MEMORY::read_dma_data16w(uint32_t addr, int* wait)
        __UNLIKELY_IF(check_device_boundary(dma_read_map, mapptr, offset, 2)) {
                val = read_beyond_boundary_data16(dma_read_map, addr, offset, mapptr, true, &waitval);
        } else {
-               val = read_16bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
-       //val =  read_16bit_data(dma_read_map, mapptr, addr, offset, true, &waitval);
+               val = read_16bit_data(dma_read_map, mapptr, addr, offset, true, &waitval);
+               //val = read_16bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
        }
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.
@@ -994,8 +994,8 @@ uint32_t TOWNS_MEMORY::read_dma_data32w(uint32_t addr, int* wait)
        __UNLIKELY_IF(check_device_boundary(dma_read_map, mapptr, offset, 4)) {
                val =  read_beyond_boundary_data32(dma_read_map, addr, offset, mapptr, true, &waitval);
        } else {
-       //return read_32bit_data(dma_read_map, mapptr, addr, offset, true, wait);
-               val = read_32bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
+               val = read_32bit_data(dma_read_map, mapptr, addr, offset, true, &waitval);
+               //val = read_32bit_data(dma_read_map, mapptr, addr, offset, false, &waitval);
        }
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.
@@ -1040,8 +1040,8 @@ void TOWNS_MEMORY::write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
        uint32_t mapptr = (uint32_t)(((uint64_t)addr) >> memory_map_shift());
        uint32_t offset = addr & memory_map_mask();
        int waitval;
-       //write_8bit_data(dma_write_map, mapptr, addr, offset, true, data, wait);
-       write_8bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
+       write_8bit_data(dma_write_map, mapptr, addr, offset, true, data, &waitval);
+       //write_8bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.
        }
@@ -1055,8 +1055,8 @@ void TOWNS_MEMORY::write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
        __UNLIKELY_IF(check_device_boundary(dma_write_map, mapptr, offset, 2)) {
                write_beyond_boundary_data16(dma_write_map, addr, offset, mapptr, true, data, &waitval);
        } else {
-               //write_16bit_data(dma_write_map, mapptr, addr, offset, true, data, wait);
-               write_16bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
+               write_16bit_data(dma_write_map, mapptr, addr, offset, true, data, &waitval);
+               //write_16bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
        }
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.
@@ -1072,8 +1072,8 @@ void TOWNS_MEMORY::write_dma_data32w(uint32_t addr, uint32_t data, int* wait)
        __UNLIKELY_IF(check_device_boundary(dma_write_map, mapptr, offset, 4)) {
                write_beyond_boundary_data32(dma_write_map, addr, offset, mapptr, true, data, &waitval);
        } else {
-               //write_32bit_data(dma_write_map, mapptr, addr, offset, true, data, &waitval);
-               write_32bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
+               write_32bit_data(dma_write_map, mapptr, addr, offset, true, data, &waitval);
+               //write_32bit_data(dma_write_map, mapptr, addr, offset, false, data, &waitval);
        }
        __LIKELY_IF(wait != NULL) {
                *wait = 0; // Discard wait value for DMA.