[VM][FMTOWNS][MEMORY] Revert to use primitive_[read|write]. Fix CDROM's some issues...

diff --git a/source/src/vm/fmtowns/towns_memory.cpp b/source/src/vm/fmtowns/towns_memory.cpp
index 199ff87..b0dd9f0 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.cpp
+++ b/source/src/vm/fmtowns/towns_memory.cpp
@@ -803,88 +803,125 @@ void TOWNS_MEMORY::write_memory_mapped_io8(uint32_t addr, uint32_t data)
 
 void TOWNS_MEMORY::write_data8(uint32_t addr, uint32_t data)
 {
-       write_primitive_byte(addr, data);
+//     write_primitive_byte(addr, data);
+       MEMORY::write_data8(addr, data);
 }
 
 void TOWNS_MEMORY::write_data16(uint32_t addr, uint32_t data)
 {
-       write_primitive_word(addr, data);
+       MEMORY::write_data16(addr, data);
+//     write_primitive_word(addr, data);
 }
 
 void TOWNS_MEMORY::write_data32(uint32_t addr, uint32_t data)
 {
-       write_primitive_dword(addr, data);
+       MEMORY::write_data32(addr, data);
+//     write_primitive_dword(addr, data);
 }
 
 uint32_t TOWNS_MEMORY::read_data8(uint32_t addr)
 {
-       return read_primitive_byte(addr);
+       return MEMORY::read_data8(addr);
+//     return read_primitive_byte(addr);
 }
 
 uint32_t TOWNS_MEMORY::read_data16(uint32_t addr)
 {
-       return read_primitive_word(addr);
+       return MEMORY::read_data16(addr);
+//     return read_primitive_word(addr);
 }
 
 uint32_t TOWNS_MEMORY::read_data32(uint32_t addr)
 {
-       return read_primitive_dword(addr);
+       return MEMORY::read_data32(addr);
+//     return read_primitive_dword(addr);
 }
 
 void TOWNS_MEMORY::write_data8w(uint32_t addr, uint32_t data, int* wait)
 {
-       int bank = (addr & addr_mask) >> addr_shift;
-       if(wait != NULL) {
-               *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
-       }
-       write_primitive_byte(addr, data);
+//     int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+//     }
+//     write_primitive_byte(addr, data);
+//     int dummy;
+       MEMORY::write_data8w(addr, data, wait);
+//     if(wait != NULL) {
+//             *wait = wr_table[bank].wait;
+//     }
 }
 
 void TOWNS_MEMORY::write_data16w(uint32_t addr, uint32_t data, int* wait)
 {
        int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+//     }
+//     write_primitive_word(addr, data);
+       int dummy;
+       MEMORY::write_data16w(addr, data, &dummy);
        if(wait != NULL) {
-               *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+               *wait = wr_table[bank].wait;
        }
-       write_primitive_word(addr, data);
 }
 
 void TOWNS_MEMORY::write_data32w(uint32_t addr, uint32_t data, int* wait)
 {
        int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+//     }
+//     write_primitive_dword(addr, data);
+       int dummy;
+       MEMORY::write_data32w(addr, data, &dummy);
        if(wait != NULL) {
-               *wait = wr_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+               *wait = wr_table[bank].wait;
        }
-       write_primitive_dword(addr, data);
 }
 
 uint32_t TOWNS_MEMORY::read_data8w(uint32_t addr, int* wait)
 {
-       int bank = (addr & addr_mask) >> addr_shift;
-       if(wait != NULL) {
-               *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
-       }
-       return read_primitive_byte(addr);
+//     int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+//     }
+//     return read_primitive_byte(addr);
+       return MEMORY::read_data8w(addr, wait);
 }
 
 uint32_t TOWNS_MEMORY::read_data16w(uint32_t addr, int* wait)
 {
        int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+///    }
+//     return read_primitive_word(addr);
+       int dummy;
+       uint32_t val = MEMORY::read_data16w(addr, &dummy);
+       // Note: WAIT valus may be same as 1 bytes r/w.
        if(wait != NULL) {
-               *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+               *wait = wr_table[bank].wait;
        }
-       return read_primitive_word(addr);
+       return val;
 }
 
 uint32_t TOWNS_MEMORY::read_data32w(uint32_t addr, int* wait)
 {
        int bank = (addr & addr_mask) >> addr_shift;
+//     if(wait != NULL) {
+//             *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+//     }
+//     return read_primitive_dword(addr);
+       // Note: WAIT valus may be same as 1 bytes r/w.
+       int dummy;
+       uint32_t val = MEMORY::read_data32w(addr, &dummy);
        if(wait != NULL) {
-               *wait = rd_table[bank].wait; // OK? AT BOUNDARY 20200906 K.O
+               *wait = wr_table[bank].wait;
        }
-       return read_primitive_dword(addr);
+       return val;
+       
 }
-
+#if 0
 void TOWNS_MEMORY::write_dma_data8(uint32_t addr, uint32_t data)
 {
        write_primitive_byte(addr, data);
@@ -969,6 +1006,91 @@ uint32_t TOWNS_MEMORY::read_dma_data32w(uint32_t addr, int* wait)
        }
        return read_primitive_dword(addr);
 }
+#else
+uint32_t TOWNS_MEMORY::read_dma_data8(uint32_t addr)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(rd_table[bank].device != NULL) {
+               return rd_table[bank].device->read_memory_mapped_io8(addr);
+       } else {
+               return rd_table[bank].memory[addr & bank_mask];
+       }
+}
+
+uint32_t TOWNS_MEMORY::read_dma_data16(uint32_t addr)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(rd_table[bank].device != NULL) {
+               return rd_table[bank].device->read_memory_mapped_io16(addr);
+       } else {
+               pair32_t n;
+               n.d = 0;
+               n.b.l = rd_table[bank].memory[(addr & bank_mask) + 0];
+               n.b.h = rd_table[bank].memory[(addr & bank_mask) + 1];
+               return n.d;
+       }
+}
+
+uint32_t TOWNS_MEMORY::read_dma_data32(uint32_t addr)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(rd_table[bank].device != NULL) {
+               return rd_table[bank].device->read_memory_mapped_io32(addr);
+       } else {
+               pair32_t n;
+               n.d = 0;
+               n.b.l  = rd_table[bank].memory[(addr & bank_mask) + 0];
+               n.b.h  = rd_table[bank].memory[(addr & bank_mask) + 1];
+               n.b.h2 = rd_table[bank].memory[(addr & bank_mask) + 2];
+               n.b.h3 = rd_table[bank].memory[(addr & bank_mask) + 3];
+               return n.d;
+       }
+}
+
+void TOWNS_MEMORY::write_dma_data8(uint32_t addr, uint32_t data)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(wr_table[bank].device != NULL) {
+               wr_table[bank].device->write_memory_mapped_io8(addr, data);
+       } else {
+               wr_table[bank].memory[addr & bank_mask] = data;
+       }
+}
+
+void TOWNS_MEMORY::write_dma_data16(uint32_t addr, uint32_t data)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(wr_table[bank].device != NULL) {
+               wr_table[bank].device->write_memory_mapped_io16(addr, data);
+       } else {
+               pair32_t n;
+               n.d = data;
+               wr_table[bank].memory[(addr & bank_mask) + 0] = n.b.l;
+               wr_table[bank].memory[(addr & bank_mask) + 1] = n.b.h;
+       }
+}
+
+void TOWNS_MEMORY::write_dma_data32(uint32_t addr, uint32_t data)
+{
+       int bank = (addr & addr_mask) >> addr_shift;
+       
+       if(wr_table[bank].device != NULL) {
+               wr_table[bank].device->write_memory_mapped_io32(addr, data);
+       } else {
+               pair32_t n;
+               n.d = data;
+               wr_table[bank].memory[(addr & bank_mask) + 0] = n.b.l;
+               wr_table[bank].memory[(addr & bank_mask) + 1] = n.b.h;
+               wr_table[bank].memory[(addr & bank_mask) + 2] = n.b.h2;
+               wr_table[bank].memory[(addr & bank_mask) + 3] = n.b.h3;
+       }
+}
+#endif
 
 void TOWNS_MEMORY::write_signal(int ch, uint32_t data, uint32_t mask)
 {

diff --git a/source/src/vm/fmtowns/towns_memory.h b/source/src/vm/fmtowns/towns_memory.h
index 45d289b..7bf8335 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.h
+++ b/source/src/vm/fmtowns/towns_memory.h
@@ -370,12 +370,12 @@ public:
        void __FASTCALL write_data16w(uint32_t addr, uint32_t data, int* wait);
        void __FASTCALL write_data32w(uint32_t addr, uint32_t data, int* wait);
 
-       uint32_t __FASTCALL read_dma_data8w(uint32_t addr, int* wait);
-       uint32_t __FASTCALL read_dma_data16w(uint32_t addr, int* wait);
-       uint32_t __FASTCALL read_dma_data32w(uint32_t addr, int* wait);
-       void __FASTCALL write_dma_data8w(uint32_t addr, uint32_t data, int* wait);
-       void __FASTCALL write_dma_data16w(uint32_t addr, uint32_t data, int* wait);
-       void __FASTCALL write_dma_data32w(uint32_t addr, uint32_t data, int* wait);
+//     uint32_t __FASTCALL read_dma_data8w(uint32_t addr, int* wait);
+//     uint32_t __FASTCALL read_dma_data16w(uint32_t addr, int* wait);
+//     uint32_t __FASTCALL read_dma_data32w(uint32_t addr, int* wait);
+//     void __FASTCALL write_dma_data8w(uint32_t addr, uint32_t data, int* wait);
+//     void __FASTCALL write_dma_data16w(uint32_t addr, uint32_t data, int* wait);
+//     void __FASTCALL write_dma_data32w(uint32_t addr, uint32_t data, int* wait);
        
        uint32_t __FASTCALL read_dma_data8(uint32_t addr);
        uint32_t __FASTCALL read_dma_data16(uint32_t addr);