[VM][FMTOWNS][TOWNS_MEMORY] Now working memory check of Syetem ROM.

diff --git a/source/src/qt/machines/fmtowns/MainWindow.cpp b/source/src/qt/machines/fmtowns/MainWindow.cpp
index 1253281..fb2e740 100644 (file)
--- a/source/src/qt/machines/fmtowns/MainWindow.cpp
+++ b/source/src/qt/machines/fmtowns/MainWindow.cpp
@@ -24,10 +24,33 @@ void META_MainWindow::retranslateUi(void)
 {
        Ui_MainWindowBase::retranslateUi();
        retranslateControlMenu("", false);
+# if defined(USE_MOUSE_TYPE)
+       menuMouseType->setTitle(QApplication::translate("Machine", "Mouse", 0));
+       menuMouseType->setToolTipsVisible(true);
+       actionMouseType[0]->setText(QApplication::translate("Machine", "none", 0));
+       actionMouseType[0]->setToolTip(QApplication::translate("Machine", "Not connect mouse.", 0));
+       actionMouseType[1]->setText(QApplication::translate("Machine", "PAD port1", 0));
+       actionMouseType[1]->setToolTip(QApplication::translate("Machine", "Connect mouse to PAD port #1.", 0));
+       actionMouseType[2]->setText(QApplication::translate("Machine", "PAD port2", 0));
+       actionMouseType[2]->setToolTip(QApplication::translate("Machine", "Connect mouse to PAD port #2.", 0));
+# endif        
+#if defined(USE_JOYSTICK_TYPE)
+       actionJoystickType[0]->setText(QApplication::translate("Machine", "2 buttons", 0));
+       actionJoystickType[0]->setToolTip(QApplication::translate("Machine", "Connect 2 buttons Towns PAD to PORTs.", 0));
+       actionJoystickType[1]->setText(QApplication::translate("Machine", "6 buttons", 0));
+       actionJoystickType[1]->setToolTip(QApplication::translate("Machine", "Connect 6 buttons Towns PAD to PORTs.", 0));
+       menuJoystickType->setTitle(QApplication::translate("Machine", "Towns PAD", 0));
+#endif
 //     menu_BINs[0]->setTitle(QApplication::translate("MenuBABBAGE", "RAM", 0));
        //menuMachine->setVisible(false);
        // Set Labels
        
+#ifdef USE_DEBUGGER
+       actionDebugger[0]->setVisible(true);
+       actionDebugger[1]->setVisible(false);
+       actionDebugger[2]->setVisible(false);
+       actionDebugger[3]->setVisible(false);
+#endif
 } // retranslateUi
 
 void META_MainWindow::setupUI_Emu(void)

diff --git a/source/src/vm/fmtowns/CMakeLists.txt b/source/src/vm/fmtowns/CMakeLists.txt
index 439a0e8..a8bf2a3 100644 (file)
--- a/source/src/vm/fmtowns/CMakeLists.txt
+++ b/source/src/vm/fmtowns/CMakeLists.txt
@@ -16,6 +16,8 @@ set(VM_FMTOWNS_DEV_SRCS
        towns_dmac.cpp
        
        fontroms.cpp
+       joystick.cpp
+
        msdosrom.cpp
        serialrom.cpp
        towns_dictionary.cpp

diff --git a/source/src/vm/fmtowns/fmtowns.cpp b/source/src/vm/fmtowns/fmtowns.cpp
index c45b78e..0fc2cc9 100644 (file)
--- a/source/src/vm/fmtowns/fmtowns.cpp
+++ b/source/src/vm/fmtowns/fmtowns.cpp
@@ -57,6 +57,7 @@
 #include "./cdc.h"
 #include "./floppy.h"
 #include "./fontroms.h"
+#include "./joystick.h"
 #include "./keyboard.h"
 #include "./msdosrom.h"
 #include "./scsi.h"
@@ -71,6 +72,7 @@ using FMTOWNS::CDC;
 using FMTOWNS::DICTIONARY;
 using FMTOWNS::FLOPPY;
 using FMTOWNS::FONT_ROMS;
+using FMTOWNS::JOYSTICK;
 using FMTOWNS::KEYBOARD;
 using FMTOWNS::MSDOSROM;
 using FMTOWNS::SCSI;
@@ -189,6 +191,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
 
        floppy = new FLOPPY(this, emu);
        keyboard = new KEYBOARD(this, emu);
+       joystick = new JOYSTICK(this, emu);
        scsi = new SCSI(this, emu);
        timer = new TIMER(this, emu);
        
@@ -325,6 +328,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        //e_volume[1]->set_context_ch2(mic, MB87878_VOLUME_LEFT | MB87878_VOLUME_RIGHT);
        //e_volume[1]->set_context_ch3(modem, MB87878_VOLUME_LEFT | MB87878_VOLUME_RIGHT);
        
+       memory->set_context_cpu(cpu);
        memory->set_context_dmac(dma);
        memory->set_context_vram(vram);
        memory->set_context_system_rom(sysrom);
@@ -336,7 +340,6 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        memory->set_context_sprite(sprite);
        memory->set_machine_id(machine_id);
        memory->set_cpu_id(cpu_id);
-       memory->set_context_cpu(cpu);
        
        cdrom->scsi_id = 0;
        cdrom->set_context_interface(cdc_scsi);
@@ -371,6 +374,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        cpu->set_context_intr(pic);
        cpu->set_context_dma(dma);
        cpu->set_context_bios(NULL);
+       cpu->set_context_extreset(memory, SIG_FMTOWNS_NOTIFY_RESET, 0xffffffff);
 #ifdef USE_DEBUGGER
        cpu->set_context_debugger(new DEBUGGER(this, emu));
 #endif
@@ -476,10 +480,10 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        
        io->set_iomap_range_rw(0x04c0, 0x04cf, cdc); // CDROM
        // PAD, Sound
-#if 0
-       io->set_iomap_single_r(0x04d0, pad); // Pad1
-       io->set_iomap_single_r(0x04d2, pad); // Pad 2
-       io->set_iomap_single_w(0x04d6, pad); // Pad out
+#if 1
+       io->set_iomap_single_r(0x04d0, joystick); // Pad1
+       io->set_iomap_single_r(0x04d2, joystick); // Pad 2
+       io->set_iomap_single_w(0x04d6, joystick); // Pad out
 #endif 
        io->set_iomap_single_rw(0x04d5, adpcm); // mute 
        // OPN2(YM2612)
@@ -508,7 +512,6 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        io->set_iomap_single_rw(0x0600, keyboard);
        io->set_iomap_single_rw(0x0602, keyboard);
        io->set_iomap_single_rw(0x0604, keyboard);
-       io->set_iomap_single_r (0x0606, keyboard); // BufFul (After Towns2)
 
        //io->set_iomap_single_rw(0x0800, printer);
        //io->set_iomap_single_rw(0x0802, printer);
@@ -572,7 +575,6 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
 #endif
        // ToDo : Use config framework
        memory->set_extra_ram_size(6);
-
        for(DEVICE* device = first_device; device; device = device->next_device) {
                device->initialize();
        }
@@ -583,6 +585,7 @@ VM::~VM()
        // delete all devices
        for(DEVICE* device = first_device; device;) {
                DEVICE *next_device = device->next_device;
+//             printf("DEVID=%d\n", device->this_device_id);
                device->release();
                delete device;
                device = next_device;
@@ -629,10 +632,6 @@ void VM::reset()
        for(DEVICE* device = first_device; device; device = device->next_device) {
                device->reset();
        }
-       // temporary fix...
-       for(DEVICE* device = first_device; device; device = device->next_device) {
-               device->reset();
-       }
 }
 
 void VM::run()

diff --git a/source/src/vm/fmtowns/fmtowns.h b/source/src/vm/fmtowns/fmtowns.h
index d64c0a1..719a40b 100644 (file)
--- a/source/src/vm/fmtowns/fmtowns.h
+++ b/source/src/vm/fmtowns/fmtowns.h
@@ -15,6 +15,8 @@
 #undef TYPE_TOWNS2_UX
 #undef TYPE_TOWNS2_CX
 
+
+
 #if defined(_FMTOWNS_1)
 #define DEVICE_NAME            "FUJITSU FM-Towns Model 1"
 #define CONFIG_NAME            "fmtowns_1"
@@ -128,6 +130,13 @@
 
 #endif
 
+#if defined(WITH_386SX)
+#define MEMORY_ADDR_MAX 0x001000000 /* 16MB */
+#else
+#define MEMORY_ADDR_MAX 0x100000000 /* 4GiB */
+#endif
+#define MEMORY_BANK_SIZE 1024
+
 // device informations for virtual machine
 #define FRAMES_PER_SEC         55.4 // OK?
 #define LINES_PER_FRAME        784  // OK?
@@ -169,6 +178,12 @@
 #define USE_CRT_FILTER
 #define USE_SOUND_FILES                1
 #define USE_SOUND_FILES_FDD
+#define USE_JOYSTICK
+#define USE_JOY_BUTTON_CAPTIONS
+#define USE_JOYSTICK_TYPE      2
+#define JOYSTICK_TYPE_DEFAULT  0
+#define USE_MOUSE
+#define USE_MOUSE_TYPE      3
 
 #if defined(USE_SOUND_FILES)
 #define USE_SOUND_VOLUME       5
@@ -192,6 +207,18 @@ static const _TCHAR *sound_device_caption[] = {
 #endif
 };
 #endif
+#ifdef USE_JOY_BUTTON_CAPTIONS
+static const _TCHAR *joy_button_captions[] = {
+       _T("Up"),
+       _T("Down"),
+       _T("Left"),
+       _T("Right"),
+       _T("Button #1"),
+       _T("Button #2"),
+       _T("RUN"),
+       _T("SELECT"),
+};
+#endif
 
 class EMU;
 class DEVICE;
@@ -223,6 +250,7 @@ namespace FMTOWNS {
        class ADPCM;
        class CDC;
        class FLOPPY;
+       class JOYSTICK;
        class KEYBOARD;
        class SERIAL_ROM;
        class SCSI;
@@ -276,6 +304,7 @@ protected:
        FMTOWNS::ADPCM*          adpcm;
        FMTOWNS::TOWNS_CRTC*     crtc;
        FMTOWNS::FLOPPY*         floppy;
+       FMTOWNS::JOYSTICK*       joystick;
        FMTOWNS::KEYBOARD*       keyboard;
        FMTOWNS::TIMER*          timer;
        FMTOWNS::TOWNS_VRAM*     vram;

diff --git a/source/src/vm/fmtowns/towns_memory.cpp b/source/src/vm/fmtowns/towns_memory.cpp
index cc462d2..81e3d58 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.cpp
+++ b/source/src/vm/fmtowns/towns_memory.cpp
@@ -21,11 +21,14 @@
 
 namespace FMTOWNS {
 
+#define ADDR_MASK (addr_max - 1)
+#define BANK_MASK (bank_size - 1)
+       
 void TOWNS_MEMORY::config_page00()
 {
-       set_memory_rw          (0x00000000, 0x000bffff, ram_page0);
        if(dma_is_vram) {
-               set_memory_mapped_io_r (0x000b0000, 0x000bffff, d_msdos); // OK? <- for compatible ROM.
+               set_memory_rw          (0x00000000, 0x000bffff, ram_page0);
+//             set_memory_mapped_io_r (0x000b0000, 0x000bffff, d_msdos); // OK? <- for compatible ROM.
                set_memory_mapped_io_rw(0x000c0000, 0x000c7fff, d_vram);
                set_memory_mapped_io_rw(0x000c8000, 0x000cafff, d_sprite);
                set_memory_mapped_io_rw(0x000cb000, 0x000cbfff, d_font);
@@ -34,6 +37,7 @@ void TOWNS_MEMORY::config_page00()
 //             set_memory_mapped_io_rw(0x000d0000, 0x000d9fff, d_dictionary); // CMOS
                set_memory_mapped_io_rw(0x000d8000, 0x000d9fff, d_dictionary); // CMOS
        } else {
+               set_memory_rw          (0x00000000, 0x000bffff, ram_page0);
                set_memory_rw          (0x000c0000, 0x000cffff, ram_pagec);
                set_memory_rw          (0x000d0000, 0x000d9fff, ram_paged);
                set_memory_mapped_io_rw(0x000c8000, 0x000cafff, d_sprite);
@@ -47,7 +51,7 @@ void TOWNS_MEMORY::config_page00()
 void TOWNS_MEMORY::initialize()
 {
        if(initialized) return;
-       initialized = true;
+       DEVICE::initialize();
        
        extra_nmi_mask = true;
        extra_nmi_val = false;
@@ -56,20 +60,43 @@ void TOWNS_MEMORY::initialize()
        mem_wait_val = 3;
 
        // Initialize R/W table
-       memset(rd_dummy, 0xff, sizeof(rd_dummy));
-       memset(wr_dummy, 0x00, sizeof(wr_dummy));
-       memset(rd_table, 0x00, sizeof(rd_table));
-       memset(wr_table, 0x00, sizeof(wr_table));
-       for(int i = 0; i < (0x100000000 >> TOWNS_BANK_SHIFT); i++) {
-               rd_table[i].dev = NULL;
-               rd_table[i].memory = rd_dummy;
-               rd_table[i].wait = 6;
+       _MEMORY_DISABLE_DMA_MMIO = osd->check_feature(_T("MEMORY_DISABLE_DMA_MMIO"));
+       if(!(addr_max_was_set) && osd->check_feature(_T("MEMORY_ADDR_MAX"))) {
+               addr_max = osd->get_feature_uint64_value(_T("MEMORY_ADDR_MAX"));
        }
-       for(int i = 0; i < (0x100000000 >> TOWNS_BANK_SHIFT); i++) {
-               wr_table[i].dev = NULL;
-               wr_table[i].memory = rd_dummy;
-               wr_table[i].wait = 6;
+       if(!(bank_size_was_set) && osd->check_feature(_T("MEMORY_BANK_SIZE"))) {
+               bank_size = osd->get_feature_uint64_value(_T("MEMORY_BANK_SIZE"));
+       }
+       // allocate tables here to support multiple instances with different address range
+       if(rd_table == NULL) {
+               int64_t bank_num = addr_max / bank_size;
+               bank_mask = BANK_MASK;
+               addr_mask = ADDR_MASK;
+               
+               rd_dummy = (uint8_t *)malloc(bank_size);
+               wr_dummy = (uint8_t *)malloc(bank_size);
+               
+               rd_table = (bank_t *)calloc(bank_num, sizeof(bank_t));
+               wr_table = (bank_t *)calloc(bank_num, sizeof(bank_t));
+               
+               for(int i = 0; i < bank_num; i++) {
+                       rd_table[i].dev = NULL;
+                       rd_table[i].memory = rd_dummy;
+                       rd_table[i].wait = 0;
+                       
+                       wr_table[i].dev = NULL;
+                       wr_table[i].memory = wr_dummy;
+                       rd_table[i].wait = 0;
+               }
+               for(int i = 0;; i++) {
+                       if(bank_size == (uint64_t)(1 << i)) {
+                               addr_shift = i;
+                               break;
+                       }
+               }
+               memset(rd_dummy, 0xff, bank_size);
        }
+       initialized = true;
        
        extram_size = extram_size & 0x3ff00000;
        set_extra_ram_size(extram_size >> 20); // Check extra ram size.
@@ -251,10 +278,10 @@ void TOWNS_MEMORY::copy_table_w(uint32_t to, uint32_t start, uint32_t end)
 {
        TOWNS_MEMORY::initialize();
 
-       uint32_t start_bank = start >> addr_shift;
-       uint32_t end_bank = end >> addr_shift;
-       uint32_t to_bank = to >> addr_shift;
-       int blocks = (int)((0xffffffff / bank_size) + 1);
+       uint64_t start_bank = start >> addr_shift;
+       uint64_t end_bank = end >> addr_shift;
+       uint64_t to_bank = to >> addr_shift;
+       uint64_t blocks = addr_max / bank_size;
        
        for(uint32_t i = start_bank; i <= end_bank; i++) {
                if(to_bank >= blocks) break;
@@ -269,10 +296,10 @@ void TOWNS_MEMORY::copy_table_r(uint32_t to, uint32_t start, uint32_t end)
 {
        TOWNS_MEMORY::initialize();
 
-       uint32_t start_bank = start >> addr_shift;
-       uint32_t end_bank = end >> addr_shift;
-       uint32_t to_bank = to >> addr_shift;
-       int blocks = (int)((0xffffffff / bank_size) + 1);
+       uint64_t start_bank = start >> addr_shift;
+       uint64_t end_bank = end >> addr_shift;
+       uint64_t to_bank = to >> addr_shift;
+       uint64_t blocks = addr_max / bank_size;
 
        for(uint32_t i = start_bank; i <= end_bank; i++) {
                if(to_bank >= blocks) break;
@@ -324,7 +351,7 @@ void TOWNS_MEMORY::set_wait_rw(uint32_t start, uint32_t end, int wait)
 // 20191202 K.Ohta
 uint32_t TOWNS_MEMORY::read_data8w(uint32_t addr, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = rd_table[bank].wait;
        }
@@ -332,14 +359,14 @@ uint32_t TOWNS_MEMORY::read_data8w(uint32_t addr, int *wait)
 //             return rd_table[bank].dev->read_data8w(addr, wait);
                return rd_table[bank].dev->read_memory_mapped_io8(addr);
        } else if(rd_table[bank].memory != NULL) {
-               return rd_table[bank].memory[addr & (TOWNS_BANK_SIZE - 1)];
+               return rd_table[bank].memory[addr & bank_mask];
        }
        return 0xff;
 }
 
 uint32_t TOWNS_MEMORY::read_data16w(uint32_t addr, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = rd_table[bank].wait;
        }
@@ -349,8 +376,8 @@ uint32_t TOWNS_MEMORY::read_data16w(uint32_t addr, int *wait)
        } else if(rd_table[bank].memory != NULL) {
                // Internal memories may access with 32bit width.
                pair32_t nd;
-               nd.b.l = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 0];
-               nd.b.h = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 1];
+               nd.b.l = rd_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 0];
+               nd.b.h = rd_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 1];
                return nd.w.l;
        }
        return 0xffff;
@@ -358,7 +385,7 @@ uint32_t TOWNS_MEMORY::read_data16w(uint32_t addr, int *wait)
 
 uint32_t TOWNS_MEMORY::read_data32w(uint32_t addr, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = rd_table[bank].wait;
        }
@@ -368,10 +395,10 @@ uint32_t TOWNS_MEMORY::read_data32w(uint32_t addr, int *wait)
        } else if(rd_table[bank].memory != NULL) {
                // Internal memories may access with 32bit width.
                pair32_t nd;
-               nd.b.l  = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 0];
-               nd.b.h  = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 1];
-               nd.b.h2 = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 2];
-               nd.b.h3 = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 3];
+               nd.b.l  = rd_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 0];
+               nd.b.h  = rd_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 1];
+               nd.b.h2 = rd_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 2];
+               nd.b.h3 = rd_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 3];
                return nd.d;
        }
        return 0xffffffff;
@@ -379,7 +406,7 @@ uint32_t TOWNS_MEMORY::read_data32w(uint32_t addr, int *wait)
 
 void TOWNS_MEMORY::write_data8w(uint32_t addr, uint32_t data, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = wr_table[bank].wait;
        }
@@ -387,13 +414,13 @@ void TOWNS_MEMORY::write_data8w(uint32_t addr, uint32_t data, int *wait)
                wr_table[bank].dev->write_memory_mapped_io8(addr, data);
        } else if(wr_table[bank].memory != NULL) {
                // Internal memories may access with 32bit width.
-               wr_table[bank].memory[addr & (TOWNS_BANK_SIZE - 1)] = data;
+               wr_table[bank].memory[addr & bank_mask] = data;
        }
 }
 
 void TOWNS_MEMORY::write_data16w(uint32_t addr, uint32_t data, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = wr_table[bank].wait;
        }
@@ -404,14 +431,14 @@ void TOWNS_MEMORY::write_data16w(uint32_t addr, uint32_t data, int *wait)
                // Internal memories may access with 32bit width.
                pair32_t nd;
                nd.d = data; 
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 0] = nd.b.l;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 1] = nd.b.h;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 0] = nd.b.l;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 1] = nd.b.h;
        }
 }
 
 void TOWNS_MEMORY::write_data32w(uint32_t addr, uint32_t data, int *wait)
 {
-       uint32_t bank = addr >> TOWNS_BANK_SHIFT;
+       uint32_t bank = addr >> addr_shift;
        if(wait != NULL) {
                *wait = wr_table[bank].wait;
        }
@@ -422,16 +449,16 @@ void TOWNS_MEMORY::write_data32w(uint32_t addr, uint32_t data, int *wait)
                // Internal memories may access with 32bit width.
                pair32_t nd;
                nd.d = data; 
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 0] = nd.b.l;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 1] = nd.b.h;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 2] = nd.b.h2;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 4)) + 3] = nd.b.h3;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 0] = nd.b.l;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 1] = nd.b.h;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 2] = nd.b.h2;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffc) + 3] = nd.b.h3;
        }
 }
 
 uint32_t TOWNS_MEMORY::read_dma_data8w(uint32_t addr, int* wait)
 {
-       int bank = (addr & (TOWNS_BANK_SIZE - 1)) >> addr_shift;
+       int bank = addr >> addr_shift;
        if(rd_table[bank].dev != NULL) { 
                if(wait != NULL) {
                        *wait = rd_table[bank].wait;
@@ -442,14 +469,14 @@ uint32_t TOWNS_MEMORY::read_dma_data8w(uint32_t addr, int* wait)
                if(wait != NULL) {
                        *wait = mem_wait_val;
                }
-               return rd_table[bank].memory[addr & (TOWNS_BANK_SIZE - 1)];
+               return rd_table[bank].memory[addr & bank_mask];
        }
        return 0xff;
 }
 
 uint32_t TOWNS_MEMORY::read_dma_data16w(uint32_t addr, int* wait)
 {
-       int bank = (addr & (TOWNS_BANK_SIZE - 2)) >> addr_shift;
+       int bank = addr >> addr_shift;
        if(rd_table[bank].dev != NULL) { 
                if(wait != NULL) {
                        *wait = rd_table[bank].wait;
@@ -460,8 +487,8 @@ uint32_t TOWNS_MEMORY::read_dma_data16w(uint32_t addr, int* wait)
                        *wait = mem_wait_val;
                }
                pair16_t nd;
-               nd.b.l = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 0];
-               nd.b.h = rd_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 1];
+               nd.b.l = rd_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 0];
+               nd.b.h = rd_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 1];
                return nd.w;
        }
        return 0xffff;
@@ -470,7 +497,7 @@ uint32_t TOWNS_MEMORY::read_dma_data16w(uint32_t addr, int* wait)
 
 void TOWNS_MEMORY::write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
 {
-       int bank = (addr & (TOWNS_BANK_SIZE - 1)) >> addr_shift;
+       int bank = addr >> addr_shift;
        if(wr_table[bank].dev != NULL) { 
                if(wait != NULL) {
                        *wait = wr_table[bank].wait;
@@ -481,14 +508,14 @@ void TOWNS_MEMORY::write_dma_data8w(uint32_t addr, uint32_t data, int* wait)
                if(wait != NULL) {
                        *wait = mem_wait_val;
                }
-               wr_table[bank].memory[addr & (TOWNS_BANK_SIZE - 1)] = data;
+               wr_table[bank].memory[addr & bank_mask] = data;
        }
        return;
 }
 
 void TOWNS_MEMORY::write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
 {
-       int bank = (addr & (TOWNS_BANK_SIZE - 2)) >> addr_shift;
+       int bank = addr  >> addr_shift;
        if(wr_table[bank].dev != NULL) { 
                if(wait != NULL) {
                        *wait = wr_table[bank].wait;
@@ -501,8 +528,8 @@ void TOWNS_MEMORY::write_dma_data16w(uint32_t addr, uint32_t data, int* wait)
                }
                pair32_t nd;
                nd.d = data;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 0] = nd.b.l;
-               wr_table[bank].memory[(addr & (TOWNS_BANK_SIZE - 2)) + 1] = nd.b.h;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 0] = nd.b.l;
+               wr_table[bank].memory[(addr & bank_mask & 0xfffffffe) + 1] = nd.b.h;
        }
        return;
 }
@@ -532,6 +559,11 @@ void TOWNS_MEMORY::write_dma_data16(uint32_t addr, uint32_t data)
 
 void TOWNS_MEMORY::release()
 {
+       if(rd_table != NULL) free(rd_table);
+       if(rd_dummy != NULL) free(rd_dummy);
+       if(wr_table != NULL) free(wr_table);
+       if(wr_dummy != NULL) free(wr_dummy);
+       
        if(extra_ram != NULL) {
                free(extra_ram);
                extra_ram = NULL;
@@ -597,13 +629,10 @@ void TOWNS_MEMORY::write_data32(uint32_t addr, uint32_t data)
 
 uint32_t TOWNS_MEMORY::read_io8(uint32_t addr)
 {
-       uint32_t val = 0xff;
+       uint32_t val = 0x00;  // MAY NOT FILL to "1" for unused bit 20200129 K.O
        switch(addr & 0xffff) {
        case 0x0020: // Software reset ETC.
                // reset cause register
-#if 0
-               val = 0x00;
-#else
                if(d_cpu != NULL) {
                        val = ((software_reset) ? 1 : 0) | ((d_cpu->get_shutdown_flag() != 0) ? 2 : 0);
                }
@@ -611,19 +640,16 @@ uint32_t TOWNS_MEMORY::read_io8(uint32_t addr)
                if(d_cpu != NULL) {
                        d_cpu->set_shutdown_flag(0);
                }
-#endif
-               val =  val | 0x7c;
+//             val =  val | 0x7c; // MAY NOT FILL to "1" for unused bit 20200129 K.O
                break;
        case 0x0022:
                // Power register
-               val = 0xff;
 //             if(d_dmac != NULL) {
 //                     val = d_dmac->read_signal(SIG_TOWNS_DMAC_ADDR_REG);
 //             }
                break;
        case 0x0024:
                // Power register
-               val = 0xff;
                if(d_dmac != NULL) {
                        val = d_dmac->read_signal(SIG_TOWNS_DMAC_WRAP_REG);
                }
@@ -645,16 +671,20 @@ uint32_t TOWNS_MEMORY::read_io8(uint32_t addr)
                }
                break;
        case 0x0400: // Resolution:
-               val = 0xfe;
+//             val = 0xfe;
+               val = 0x00;
                break;
        case 0x0404: // System Status Reg.
-               val = (dma_is_vram) ? 0x7f : 0xff;
+//             val = (dma_is_vram) ? 0x7f : 0xff;
+               val = (dma_is_vram) ? 0x00 : 0x80;
                break;
        case 0x05c0:
-               val = (extra_nmi_mask) ? 0xf7 : 0xff;
+//             val = (extra_nmi_mask) ? 0xf7 : 0xff;
+               val = (extra_nmi_mask) ? 0x00 : 0x08;
                break;
        case 0x05c2:
-               val = (extra_nmi_val) ? 0xff : 0xf7;
+//             val = (extra_nmi_val) ? 0xff : 0xf7;
+               val = (extra_nmi_val) ? 0x08 : 0x00;
                break;
        case 0x05e8:
                // After Towns1F/2F/1H/2H
@@ -681,7 +711,7 @@ uint32_t TOWNS_MEMORY::read_io8(uint32_t addr)
                                val = ((extram_size >> 20) & 0x7f);
                                break;
                        default:
-                               val = 0xff; // ???
+                               val = 0x00; // ???
                                break;
                        }
                }
@@ -744,7 +774,18 @@ void TOWNS_MEMORY::write_io8(uint32_t addr, uint32_t data)
                        }
                }
                if(d_cpu != NULL) {
-//                     switch(data & 0x08) {
+#if 1
+                       
+                       switch(data & 0x08) {
+                       case 0x00:      // 32bit
+                               d_cpu->set_address_mask(0xffffffff);
+                               break;
+                       default:        // 20bit
+                               d_cpu->set_address_mask(0x000fffff);
+                               break;
+                       }
+                       
+#else
                        switch(data & 0x30) { // From eFMR50
                        case 0x00:      // 20bit
                                d_cpu->set_address_mask(0x000fffff);
@@ -756,6 +797,7 @@ void TOWNS_MEMORY::write_io8(uint32_t addr, uint32_t data)
                                d_cpu->set_address_mask(0xffffffff);
                                break;
                        }
+#endif
                        if(d_dmac != NULL) {
                                uint32_t maskval = d_cpu->get_address_mask();
                                d_dmac->write_signal(SIG_TOWNS_DMAC_ADDR_MASK, maskval, 0xff);
@@ -778,7 +820,6 @@ void TOWNS_MEMORY::write_io8(uint32_t addr, uint32_t data)
                if(d_dmac != NULL) {
                        d_dmac->write_signal(SIG_TOWNS_DMAC_WRAP_REG, data, 0xff);
                }
-               // Power register
                break;
        case 0x0032:
                {
@@ -961,6 +1002,10 @@ void TOWNS_MEMORY::write_signal(int ch, uint32_t data, uint32_t mask)
                if(d_cpu != NULL) {
                        d_cpu->write_signal(SIG_I386_A20, data, mask);
                }
+       } else if(ch == SIG_FMTOWNS_NOTIFY_RESET) {
+               out_debug_log("RESET FROM CPU!!!\n");
+//             d_cpu->set_address_mask(0x000fffff);
+               d_cpu->set_address_mask(0xffffffff);
        } else if(ch == SIG_FMTOWNS_RAM_WAIT) {
                mem_wait_val = (int)data;
                set_wait_values();

diff --git a/source/src/vm/fmtowns/towns_memory.h b/source/src/vm/fmtowns/towns_memory.h
index d2a2a16..7c26b2c 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.h
+++ b/source/src/vm/fmtowns/towns_memory.h
@@ -14,7 +14,7 @@
 #include "../../emu.h"
 #include "device.h"
 #include "../../common.h"
-#include "../memory.h"
+//#include "../memory.h"
 #include "./towns_common.h"
 
 #define SIG_FMTOWNS_MACHINE_ID 1
@@ -79,15 +79,15 @@ protected:
                int wait;
        } bank_t;
        
-       bank_t rd_table[0x100000000 >> TOWNS_BANK_SHIFT];
-       bank_t wr_table[0x100000000 >> TOWNS_BANK_SHIFT];
-       uint32_t bank_size;
-       uint32_t addr_mask;
+       bank_t *rd_table;
+       bank_t *wr_table;
        int addr_shift;
-       bool initialized;
+       uint8_t *rd_dummy;
+       uint8_t *wr_dummy;
        
-       uint8_t rd_dummy[TOWNS_BANK_SIZE];
-       uint8_t wr_dummy[TOWNS_BANK_SIZE];
+       bool _MEMORY_DISABLE_DMA_MMIO;
+       bool bank_size_was_set;
+       bool addr_max_was_set;
        
        DEVICE* d_vram;
        DEVICE* d_sprite;       // 0x81000000 - 0x8101ffff ?
@@ -137,6 +137,8 @@ protected:
 #endif
        // misc
        uint32_t vram_size; // Normally 512KB.
+       bool initialized;
+
 
        uint8_t* read_bank_adrs_cx[0x100000]; // Per 4KB.
        uint8_t* write_bank_adrs_cx[0x100000]; // Per 4KB.
@@ -150,9 +152,18 @@ protected:
 public:
        TOWNS_MEMORY(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu) {
                set_device_name(_T("FMTOWNS_MEMORY"));
-               bank_size = TOWNS_BANK_SIZE; // 1024
-               addr_mask = bank_size - 1;
-               addr_shift = TOWNS_BANK_SHIFT;
+               addr_max = 0x100000000; // 4GiB
+               bank_size = 1024; // 1024
+               addr_shift = 10;
+               addr_mask = 0;
+               bank_mask = 0;
+               bank_size_was_set = false;
+               addr_max_was_set = false;
+               
+               rd_table = wr_table = NULL;
+               rd_dummy = wr_dummy = NULL;
+
+               _MEMORY_DISABLE_DMA_MMIO = false;
                
                extram_size = 0x00200000; // Basically 2MB
                
@@ -167,7 +178,7 @@ public:
                d_dictionary = NULL;
                d_msdos = NULL;
                initialized = false;
-               
+
                initialize_output_signals(&outputs_ram_wait);
                initialize_output_signals(&outputs_rom_wait);
                // Note: machine id must set before initialize() from set_context_machine_id() by VM::VM().
@@ -352,6 +363,36 @@ public:
        {
                cpu_id = val & 0x07;
        }
+
+       // Unique functions.
+       void set_addr_max(int64_t size)
+       {
+               // Allow to modify before initialize() or set_foo_r|w|rw()..
+               if(rd_table == NULL) {
+                       addr_max_was_set = true;
+                       addr_max = size;
+               }
+       }
+       void set_bank_size(int64_t size)
+       {
+               if(rd_table == NULL) {
+                       bank_size_was_set = true;
+                       bank_size = size;
+               }
+       }
+       uint64_t get_addr_max()
+       {
+               return addr_max;
+       }
+       uint64_t get_bank_size()
+       {
+               return bank_size;
+       }
+       uint64_t addr_max;
+       uint64_t bank_size;
+
+       uint64_t addr_mask;
+       uint64_t bank_mask;
 };
 
 }