[VM][FMTOWNS] Some devices are enabled to compile.

[BUILD][CMAKE][FMTOWNS] Add skelton.
[UI][Qt][FMTOWNS] Add *DUMMY* UI.Resources also still be dummy.

diff --git a/source/build-cmake/cmake/config_fmtowns.cmake b/source/build-cmake/cmake/config_fmtowns.cmake
new file mode 100644 (file)
index 0000000..6c1dc73
--- /dev/null
+++ b/source/build-cmake/cmake/config_fmtowns.cmake
@@ -0,0 +1,88 @@
+# Build Common Sourcecode Project, Qt.
+# (C) 2014 K.Ohta <whatisthis.sowhat@gmail.com>
+# This is part of XM7/SDL, but license is apache 2.2,
+# this part was written only me.
+
+cmake_minimum_required (VERSION 2.8)
+cmake_policy(SET CMP0011 NEW)
+
+set(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../cmake")
+
+set(VM_NAME fmtowns)
+set(USE_FMGEN ON)
+set(WITH_JOYSTICK ON)
+set(WITH_MOUSE ON)
+set(VMFILES
+  event.cpp
+  io.cpp
+  
+  scsi_host.cpp
+  scsi_dev.cpp
+  scsi_hdd.cpp
+  scsi_cdrom.cpp
+)
+set(VMFILES_LIB
+   noise.cpp
+   pcm1bit.cpp
+   i8251.cpp
+   i8253.cpp
+   i8259.cpp
+   msm58321.cpp
+   upd71071.cpp
+   
+   mb8877.cpp
+   ym2151.cpp
+   
+   disk.cpp
+   prnfile.cpp
+   harddisk.cpp
+)
+
+set(FLAG_USE_I386 ON)
+
+set(BUILD_FMTOWNS_2 OFF CACHE BOOL "Build for FM-Towns Model 2")
+set(BUILD_FMTOWNS_2H OFF CACHE BOOL "Build for FM-Towns 2H")
+set(BUILD_FMTOWNS_20H OFF CACHE BOOL "Build for FM-Towns 20H")
+set(BUILD_FMTOWNS2_UX40 OFF CACHE BOOL "Build for FM-Towns2 UX40")
+set(BUILD_FMTOWNS2_CX100 OFF CACHE BOOL "Build for FM-Towns2 CX100")
+
+set(BUILD_SHARED_LIBS OFF)
+set(USE_OPENMP ON CACHE BOOL "Build using OpenMP")
+set(USE_OPENGL ON CACHE BOOL "Build using OpenGL")
+set(WITH_DEBUGGER ON CACHE BOOL "Build with debugger.")
+
+include(detect_target_cpu)
+#include(windows-mingw-cross)
+# set entry
+set(CMAKE_SYSTEM_PROCESSOR ${ARCHITECTURE} CACHE STRING "Set processor to build.")
+
+if(BUILD_FMTOWNS_2)
+  set(EXEC_TARGET emufmtowns_2)
+  add_definitions(-D_FMTOWNS_2)
+  ## ToDo
+  set(RESOURCE ${CMAKE_SOURCE_DIR}/../../src/qt/common/qrc/x1.qrc)
+elseif(BUILD_FMTOWNS_2H)
+  set(EXEC_TARGET emufmtowns2H)
+  add_definitions(-D_FMTOWNS_2H)
+  ## ToDo
+  set(RESOURCE ${CMAKE_SOURCE_DIR}/../../src/qt/common/qrc/x1.qrc)
+elseif(BUILD_FMTOWNS_20H)
+  set(EXEC_TARGET emufmtowns40H)
+  add_definitions(-D_FMTOWNS_40H)
+  ## ToDo
+  set(RESOURCE ${CMAKE_SOURCE_DIR}/../../src/qt/common/qrc/x1.qrc)
+elseif(BUILD_FMTOWNS2_UX40)
+  set(EXEC_TARGET emufmtownsUX40)
+  add_definitions(-D_FMTOWNS2_UX40)
+  ## ToDo
+  set(RESOURCE ${CMAKE_SOURCE_DIR}/../../src/qt/common/qrc/x1.qrc)
+elseif(BUILD_FMTOWNS2_CX100)
+  set(EXEC_TARGET emufmtownsCX100)
+  add_definitions(-D_FMTOWNS2_CX100)
+  ## ToDo
+  set(RESOURCE ${CMAKE_SOURCE_DIR}/../../src/qt/common/qrc/x1.qrc)
+endif()
+
+include(config_commonsource)
+   
+

diff --git a/source/build-cmake/fmtowns_2h/CMakeLists.txt b/source/build-cmake/fmtowns_2h/CMakeLists.txt
new file mode 100644 (file)
index 0000000..d66662e
--- /dev/null
+++ b/source/build-cmake/fmtowns_2h/CMakeLists.txt
@@ -0,0 +1,17 @@
+# Build Common Sourcecode Project, Agar.
+# (C) 2014 K.Ohta <whatisthis.sowhat@gmail.com>
+# This is part of , but license is apache 2.2,
+# this part was written only me.
+
+cmake_minimum_required (VERSION 2.8)
+cmake_policy(SET CMP0011 NEW)
+
+
+project (emufmtowns_2h)
+set(CMAKE_MODULE_PATH "${emufmtowns_2h_SOURCE_DIR}/../cmake")
+
+set(BUILD_FMTOWNS_2H ON CACHE BOOL "Build for FM-Towns 2H")
+
+include(config_fmtowns)
+#include(config_commonsource)
+

diff --git a/source/src/qt/machines/fmtowns/CMakeLists.txt b/source/src/qt/machines/fmtowns/CMakeLists.txt
new file mode 100644 (file)
index 0000000..7f636a1
--- /dev/null
+++ b/source/src/qt/machines/fmtowns/CMakeLists.txt
@@ -0,0 +1,19 @@
+message("* qt/fmtowns")
+
+set(s_qt_fmtowns_headers
+         menuclasses.h
+)
+
+if(USE_QT_5)
+  QT5_WRAP_CPP(s_qt_fmtowns_headers_MOC ${s_qt_fmtowns_headers})
+#  QT5_ADD_RESOURCES(s_qt_fmtowns_headers_RCC ${RESOURCE})
+else()
+  QT4_WRAP_CPP(s_qt_fmtowns_headers_MOC ${s_qt_fmtowns_headers})
+endif()
+
+add_library(qt_fmtowns
+         MainWindow.cpp
+         ${s_qt_fmtowns_headers_MOC}
+)
+
+

diff --git a/source/src/qt/machines/fmtowns/MainWindow.cpp b/source/src/qt/machines/fmtowns/MainWindow.cpp
new file mode 100644 (file)
index 0000000..323bd5c
--- /dev/null
+++ b/source/src/qt/machines/fmtowns/MainWindow.cpp
@@ -0,0 +1,52 @@
+/*
+ * Common Source code Project:
+ * Ui->Qt->MainWindow for Babbage2nd .
+ * (C) 2015 K.Ohta <whatisthis.sowhat _at_ gmail.com>
+ *   License : GPLv2
+ *   History :
+ * Jan 14, 2015 : Initial, many of constructors were moved to qt/gui/menu_main.cpp.
+ */
+#include <QApplication>
+#include <QtCore/QVariant>
+#include <QtGui>
+#include "menuclasses.h"
+#include "commonclasses.h"
+
+#include "emu.h"
+#include "qt_main.h"
+#include "../../vm/fmtowns/fmtowns.h"
+#include "menu_binary.h"
+
+//QT_BEGIN_NAMESPACE
+
+
+void META_MainWindow::retranslateUi(void)
+{
+       Ui_MainWindowBase::retranslateUi();
+       retranslateControlMenu("", false);
+       menu_BINs[0]->setTitle(QApplication::translate("MenuBABBAGE", "RAM", 0));
+       //menuMachine->setVisible(false);
+       // Set Labels
+       
+} // retranslateUi
+
+void META_MainWindow::setupUI_Emu(void)
+{
+}
+
+
+META_MainWindow::META_MainWindow(USING_FLAGS *p, CSP_Logger *logger, QWidget *parent) : Ui_MainWindow(p, logger, parent)
+{
+       setupUI_Emu();
+       retranslateUi();
+}
+
+
+META_MainWindow::~META_MainWindow()
+{
+}
+
+//QT_END_NAMESPACE
+
+
+

diff --git a/source/src/qt/machines/fmtowns/menuclasses.h b/source/src/qt/machines/fmtowns/menuclasses.h
new file mode 100644 (file)
index 0000000..ee35813
--- /dev/null
+++ b/source/src/qt/machines/fmtowns/menuclasses.h
@@ -0,0 +1,26 @@
+
+#ifndef _CSP_QT_MENUCLASSES_H
+#define _CSP_QT_MENUCLASSES_H
+
+#include "mainwidget.h"
+// This extends class CSP_MainWindow as Ui_MainWindow.
+// You may use this as 
+QT_BEGIN_NAMESPACE
+
+class Ui_MainWindow;
+class USING_FLAGS;
+class CSP_Logger;
+//  wrote of Specific menu.
+class META_MainWindow : public Ui_MainWindow {
+       Q_OBJECT
+protected:
+       void setupUI_Emu(void);
+       void retranslateUi(void);
+public:
+       META_MainWindow(USING_FLAGS *p, CSP_Logger *logger, QWidget *parent = 0);
+       ~META_MainWindow();
+};
+
+QT_END_NAMESPACE
+
+#endif // END

diff --git a/source/src/vm/fmtowns/CMakeLists.txt b/source/src/vm/fmtowns/CMakeLists.txt
index e5cf513..d933970 100644 (file)
--- a/source/src/vm/fmtowns/CMakeLists.txt
+++ b/source/src/vm/fmtowns/CMakeLists.txt
@@ -14,8 +14,8 @@ add_library(vm_fmtowns
        timer.cpp
 
        serialrom.cpp
-       sysrom.cpp
-       dictionary.cpp
+       towns_sysrom.cpp
+       towns_dictionary.cpp
        msdosrom.cpp
        
        fontroms.cpp

diff --git a/source/src/vm/fmtowns/ad7820kr.cpp b/source/src/vm/fmtowns/ad7820kr.cpp
index 68c3fe9..c7a276f 100644 (file)
--- a/source/src/vm/fmtowns/ad7820kr.cpp
+++ b/source/src/vm/fmtowns/ad7820kr.cpp
@@ -75,7 +75,7 @@ void AD7820KR::event_callback(int event_id, int err)
                                increment_sound_in_passed_data(this_bank, passed_usec);
                                int gotsize = get_sound_in_data(this_bank, buffer, 1, this_sample_rate, 1);
                                if(gotsize > 0) {
-                                       int32_t _n = tmpbuf[gotsize - 1];
+                                       int32_t _n = buffer[gotsize - 1];
                                        if(_n >= 16383) { // OVERFLOW
                                                overflow = true;
                                                _n = 16383;
@@ -180,6 +180,7 @@ bool AD7820KR::process_state(FILEIO* state_fio, bool loading)
        state_fio->StateValue(adc_data);
        state_fio->StateValue(adc_msb);
        state_fio->StateValue(prev_clock);
+       state_fio->StateValue(cs_enabled);
        state_fio->StateValue(wr_rd_mode);
        state_fio->StateValue(req_convert);
        state_fio->StateValue(this_sample_rate);

diff --git a/source/src/vm/fmtowns/ad7820kr.h b/source/src/vm/fmtowns/ad7820kr.h
index 6d55aef..d31224a 100644 (file)
--- a/source/src/vm/fmtowns/ad7820kr.h
+++ b/source/src/vm/fmtowns/ad7820kr.h
@@ -33,14 +33,16 @@ class AD7820KR : public DEVICE {
        uint8_t adc_data;
        uint8_t adc_msb;
        uint32_t prev_clock;
-
+       
+       bool cs_enabled;
        bool req_convert;
        bool wr_rd_mode;
+       
        int this_bank;
        int this_sample_rate;
        int event_sample;
-
-       void srart_sample(double usec);
+       
+       void start_sample(double usec);
 public:
        AD7820KR(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
        {
@@ -53,7 +55,10 @@ public:
                req_convert = false;
                adc_data = 0x00;
                adc_msb = 0x00;
+               cs_enabled = false;
                prev_clock = 0;
+               set_device_name(_T("A/D Converter AD7820KR"));
+       
        }
        ~AD7820KR()
        {
@@ -81,15 +86,15 @@ public:
        }
        void set_context_ready(DEVICE* device, int id, uint32_t mask)
        {
-               register_output_signal(&output_ready, device, id, mask);
+               register_output_signal(&outputs_ready, device, id, mask);
        }
        void set_context_interrupt(DEVICE* device, int id, uint32_t mask)
        {
-               register_output_signal(&output_intr, device, id, mask);
+               register_output_signal(&outputs_intr, device, id, mask);
        }
        void set_context_overflow(DEVICE* device, int id, uint32_t mask)
        {
-               register_output_signal(&output_overflow, device, id, mask);
+               register_output_signal(&outputs_overflow, device, id, mask);
        }
 };
 

diff --git a/source/src/vm/fmtowns/adpcm.cpp b/source/src/vm/fmtowns/adpcm.cpp
index 54c23ef..e35699e 100644 (file)
--- a/source/src/vm/fmtowns/adpcm.cpp
+++ b/source/src/vm/fmtowns/adpcm.cpp
@@ -10,6 +10,7 @@
 #include "./adpcm.h"
 #include "rf5c68.h"
 #include "ad7820kr.h"
+#include "../i8259.h"
 
 namespace FMTOWNS {
 
@@ -20,13 +21,10 @@ void ADPCM::initialize()
 {
        adc_fifo = new FIFO(64); // OK?
        for(int i = 0; i < 8; i++) {
-               dac_int_mask[i] = true; // true = enable intrrupt.
+               dac_intr_mask[i] = true; // true = enable intrrupt.
                dac_intr[i] = false;
        }
        intr_opx = false;
-       event_adc_clock = -1;
-       initialize_adc_clock(-1);
-       event_adpcm_clock = -1;
 }
 
 void ADPCM::release()
@@ -39,6 +37,10 @@ void ADPCM::reset()
 {
        // Is clear FIFO?
        adc_fifo->clear();
+       write_signals(&outputs_intr, 0x00000000);
+       write_signals(&outputs_led_control, 0x00000000);
+       write_signals(&outputs_allmute, 0xffffffff); // OK?
+       
        initialize_adc_clock(-1);
        if(event_adpcm_clock >= 0) {
                cancel_event(this, event_adpcm_clock);
@@ -64,9 +66,11 @@ void ADPCM::event_callback(int id, int err)
 {
        switch(id) {
        case EVENT_ADC_CLOCK:
-               d_adc->write_signal(SIG_AD7820_WR_CONVERSION_MODE, 0, 0xffffffff); // READ MODE
-               d_adc->write_signal(SIG_AD7820_CS, 0xffffffff, 0xffffffff);
-               d_adc->read_data8(SIG_AD7820_DATA_REG); // Dummy read, start to  sample.
+               if(!(adc_fifo->full())) {
+                       d_adc->write_signal(SIG_AD7820_WR_CONVERSION_MODE, 0, 0xffffffff); // READ MODE
+                       d_adc->write_signal(SIG_AD7820_CS, 0xffffffff, 0xffffffff);
+                       d_adc->read_data8(SIG_AD7820_DATA_REG); // Dummy read, start to  sample.
+               }
                break;
        case EVENT_ADPCM_CLOCK:
                d_rf5c68->write_signal(SIG_RF5C68_DAC_PERIOD, 1, 1);
@@ -77,22 +81,24 @@ void ADPCM::event_callback(int id, int err)
 uint32_t ADPCM::read_io8(uint32_t addr)
 {
        /*
+         0x04d5 : OPN2/ADPCM MUTE
          0x04e7 - 0x04e8 : ADC
+         0x04e9 - 0x04ec : DAC CONTROL
          0x04f0 - 0x04f8 : DAC
        */
        uint8_t val = 0xff;
-       switch(addr & 0x1f) {
-       case 0x07: // ADC data register
+       switch(addr & 0xff) {
+       case 0xe7: // ADC data register
                if(!(adc_fifo->empty())) {
                        val = (uint8_t)(adc_fifo->read() & 0xff);
                } else {
                        val = 0x00;
                }
                break;
-       case 0x08: // ADC flags
+       case 0xe8: // ADC flags
                val = (!(adc_fifo->empty())) ? 0x01 : 0x00;
                break;
-       case 0x09: // Int13 reason
+       case 0xe9: // Int13 reason
                {
                        bool intr_pcm = false;
                        for(int i = 0; i < 8; i++) {
@@ -104,13 +110,13 @@ uint32_t ADPCM::read_io8(uint32_t addr)
                        val = 0xf6 | ((intr_pcm) ? 0x08 : 0x00) | ((intr_opx) ? 0x01 : 0x00);
                }
                break;
-       case 0x0a: // PCM Interrupt mask
+       case 0xea: // PCM Interrupt mask
                val = 0x00;
                for(int i = 0; i < 8; i++) {
-                       val = val | ((dac_int_mask[i]) ? (0x01 << i) : 0);
+                       val = val | ((dac_intr_mask[i]) ? (0x01 << i) : 0);
                }
                break;
-       case 0x0b: // PCM Interrupt status
+       case 0xeb: // PCM Interrupt status
                {
                        bool _s = false;
                        val = 0x00;
@@ -129,7 +135,7 @@ uint32_t ADPCM::read_io8(uint32_t addr)
                }
                break;
        default:
-               if((addr & 0x1f) >= 0x10) val = d_rf5c68->read_io8(addr & 0x0f); // AROUND DAC
+               if((addr & 0xff) >= 0xf0) val = d_rf5c68->read_io8(addr & 0x0f); // AROUND DAC
                break;
        }
        return val;
@@ -137,21 +143,45 @@ uint32_t ADPCM::read_io8(uint32_t addr)
 
 void ADPCM::write_io8(uint32_t addr, uint32_t data)
 {
-       uint32_t naddr = addr & 0x1f;
-       if(naddr == 0x08) {
+       /*
+         0x04d5 : OPN2/ADPCM MUTE
+         0x04e7 - 0x04e8 : ADC
+         0x04e9 - 0x04ec : DAC CONTROL
+         0x04f0 - 0x04f8 : DAC
+       */
+       uint32_t naddr = addr & 0xff;
+       switch(naddr) {
+       case 0xd5:
+               opn2_mute = ((data & 0x02) == 0) ? true : false;
+               adpcm_mute =  ((data & 0x01) == 0) ? true : false;
+               //d_opn2->write_signal(SIG_YM2612_MUTE, (opn2_mute) ? 0xffffffff : 0x00000000, 0xffffffff);
+               d_rf5c68->write_signal(SIG_RF5C68_MUTE, (adpcm_mute) ? 0xffffffff : 0x00000000, 0xffffffff);
+               break;
+       case 0xe8:
                adc_fifo->clear();
-       } else if(naddr == 0x0a) {
-               uint32_t mask = 0x01;
-               for(int i = 0; i < 8; i++) {
-                       if((data & mask) != 0) {
-                               dac_int_mask[i] = true;
-                       } else {
-                               dac_int_mask[i] = false;
+               break;
+       case 0xea:
+               {
+                       uint32_t mask = 0x01;
+                       for(int i = 0; i < 8; i++) {
+                               if((data & mask) != 0) {
+                                       dac_intr_mask[i] = true;
+                               } else {
+                                       dac_intr_mask[i] = false;
+                               }
+                               mask <<= 1;
                        }
-                       mask <<= 1;
                }
-       } else if(naddr >= 0x10) {
-               d_rf5c68->write_io8(naddr & 0x0f, data);
+               break;
+       case 0xec:
+               write_signals(&outputs_led_control, ((data & 0x80) == 0) ? 0xffffffff : 0x00000000);
+               write_signals(&outputs_allmute, ((data & 0x40) == 0) ? 0xffffffff : 0x00000000);
+               break;
+       default:
+               if(naddr >= 0xf0) {
+                       d_rf5c68->write_io8(naddr & 0x0f, data);
+               }
+               break;
        }
 }
 
@@ -177,9 +207,9 @@ void ADPCM::write_signal(int ch, uint32_t data, uint32_t mask)
                bool n_onoff = (((data & mask) & 0x00000008) != 0) ? true : false;
                bool n_allset =(((data & mask) & 0x80000000) != 0) ? true : false;
                if(!(n_allset)) {
-                       n_onoff = n_onoff & dac_int_mask[n_ch];
+                       n_onoff = n_onoff & dac_intr_mask[n_ch];
                        if(n_onoff != dac_intr[n_ch]) { // SET/RESET INT13                              
-                               write_signals(&output_intr, (n_onoff) ? 0xffffffff : 0x00000000);
+                               write_signals(&outputs_intr, (n_onoff) ? 0xffffffff : 0x00000000);
                        }
                        dac_intr[n_ch] = n_onoff;
                } else {
@@ -188,16 +218,16 @@ void ADPCM::write_signal(int ch, uint32_t data, uint32_t mask)
                        bool _s = false;
                        for(int i = 0; i < 8; i++) { // SET/RESET INT13                         
                                n_backup = dac_intr[i];
-                               dac_intr[i] = n_onoff & dac_int_mask[i];
+                               dac_intr[i] = n_onoff & dac_intr_mask[i];
                                if(n_backup != dac_intr[i]) _s = true;
                        }
                        if(_s) {
-                               write_signals(&output_intr, (n_onoff) ? 0xffffffff : 0x00000000);
+                               write_signals(&outputs_intr, (n_onoff) ? 0xffffffff : 0x00000000);
                        }
                }
        } else if(ch == SIG_ADPCM_OPX_INTR) { // SET/RESET INT13
                intr_opx = ((data & mask) != 0); 
-               write_signals(&output_intr, (intr_opx) ? 0xffffffff : 0x00000000);
+               write_signals(&outputs_intr, (intr_opx) ? 0xffffffff : 0x00000000);
        } else if(ch == SIG_ADPCM_ADC_INTR) { // Push data to FIFO from ADC.
                if((data & mask) != 0) {
                        uint32_t n_data = d_adc->read_signal(SIG_AD7820_DATA_REG);
@@ -222,9 +252,15 @@ bool ADPCM::process_state(FILEIO* state_fio, bool loading)
        if(!(adc_fifo->process_state((void *)state_fio, loading))) {
                return false;
        }
+       state_fio->StateValue(opn2_mute);
+       state_fio->StateValue(adpcm_mute);
+       
        state_fio->StateValue(intr_opx);
        state_fio->StateArray(dac_intr,     sizeof(dac_intr), 1);
-       state_fio->StateArray(dac_int_mask, sizeof(dac_int_mask), 1);
+       state_fio->StateArray(dac_intr_mask, sizeof(dac_intr_mask), 1);
+
+       state_fio->StateValue(event_adc_clock);
+       state_fio->StateValue(event_adpcm_clock);
        return true;
 }
        

diff --git a/source/src/vm/fmtowns/adpcm.h b/source/src/vm/fmtowns/adpcm.h
index f206bb5..c7a285d 100644 (file)
--- a/source/src/vm/fmtowns/adpcm.h
+++ b/source/src/vm/fmtowns/adpcm.h
@@ -9,43 +9,71 @@
 #pragma once
 /*
   I/O:
+  0x04d5          : OPN2/ADPCM MUTE
   0x04e7 - 0x04e8 : ADC
-  0x04f0 - 0x04f8 : DAC
+  0x04e9 - 0x04ec : ADPCM CONTROL 
+  0x04e8 - 0x04f8 : DAC
+
   MEMORY:
   0xc2200000-c2200fff: banked ADPCM RAM.
 */
 
 #include "../device.h"
-#include "../../fifo.h"
 
 #define        SIG_ADPCM_WRITE_INTERRUPT  1
 #define SIG_ADPCM_OPX_INTR         2
-#define SIG_ADPCM_PUSH_FIFO        3
+#define SIG_ADPCM_ADC_INTR         3
 
+class FIFO;
 namespace FMTOWNS {
 
 class ADPCM : public DEVICE {
 
 protected:
        DEVICE* d_rf5c68;
+       DEVICE* d_opn2;
+       DEVICE* d_pic;
+       DEVICE* d_adc;
        
-       outputs_t output_intr;
+       outputs_t outputs_intr;
+       outputs_t outputs_led_control;
+       outputs_t outputs_allmute;
 
        FIFO* adc_fifo;
        bool intr_opx;
        bool dac_intr[8];
-       bool dac_int_mask[8];
+       bool dac_intr_mask[8];
+
+       bool opn2_mute;
+       bool adpcm_mute;
 
+       int event_adc_clock;
+       int event_adpcm_clock;
+       void initialize_adc_clock(int freq);
 public:
        ADPCM(VM_TEMPLATE* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
        {
-               adc_fifo = new FIFO(256); // OK?
-               initialize_output_signals(output_intr);
+               adc_fifo = NULL;
+               initialize_output_signals(&outputs_intr);
+               initialize_output_signals(&outputs_led_control);
+               initialize_output_signals(&outputs_allmute);
+               for(int i = 0; i < 8; i++) {
+                       dac_intr[i] = false;
+                       dac_intr_mask[i] = true;
+               }
+               intr_opx = false;
+               adpcm_mute = false;
+               opn2_mute = false;
+               event_adc_clock = -1;
+               event_adpcm_clock = -1;
                set_device_name(_T("FM-Towns ADPCM"));
        }
        ~ADPCM() {}
 
        void initialize();
+       void release();
+       void reset();
+       void event_callback(int id, int err);
        
        uint32_t read_io8(uint32_t addr);
        void     write_io8(uint32_t addr, uint32_t data);
@@ -53,16 +81,37 @@ public:
        void     write_data8(uint32_t addr, uint32_t data);
 
        void write_signal(int ch, uint32_t data, uint32_t mask);
+       uint32_t read_signal(int ch);
 
        bool process_state(FILEIO* state_fio, bool loading);
 
+       void set_context_pic(DEVICE* dev)
+       {
+               d_pic = dev;
+       }
+       void set_context_adc(DEVICE* dev)
+       {
+               d_adc = dev;
+       }
        void set_context_rf5c68(DEVICE* dev)
        {
                d_rf5c68 = dev;
        }
+       void set_context_opn2(DEVICE* dev)
+       {
+               d_opn2 = dev;
+       }
        void set_context_intr_line(DEVICE* dev, int id, uint32_t mask)
        {
-               register_output_signal(&output_intr, dev, id, mask);
+               register_output_signal(&outputs_intr, dev, id, mask);
+       }
+       void set_context_led(DEVICE* dev, int id, uint32_t mask)
+       {
+               register_output_signal(&outputs_led_control, dev, id, mask);
+       }
+       void set_context_all_mute(DEVICE* dev, int id, uint32_t mask)
+       {
+               register_output_signal(&outputs_allmute, dev, id, mask);
        }
 
 };

diff --git a/source/src/vm/fmtowns/fmtowns.cpp b/source/src/vm/fmtowns/fmtowns.cpp
index 79da6af..25d63df 100644 (file)
--- a/source/src/vm/fmtowns/fmtowns.cpp
+++ b/source/src/vm/fmtowns/fmtowns.cpp
@@ -35,9 +35,9 @@
 //YM-2612 "OPN2"
 //#include "../ym2612.h"
 //RF5C68 PCM
-#include "rp5c68.h"
+#include "rf5c68.h"
 //AD7820 ADC
-#include "ad7820.h"
+#include "ad7820kr.h"
 // 80387?
 
 #ifdef USE_DEBUGGER
@@ -421,7 +421,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        // PAD, Sound
        io->set_iomap_alias_r(0x4d0, pad, 0); // Pad1
        io->set_iomap_alias_r(0x4d2, pad, 1); // Pad 2
-       io->set_iomap_alias_rw(0x4d5, sound, 0); // mute 
+       io->set_iomap_single_rw(0x4d5, adpcm, 0); // mute 
        io->set_iomap_alias_w(0x4d6, pad, 3); // Pad out
        
        // OPN2(YM2612)
@@ -436,7 +436,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
        io->set_iomap_alias_rw(0x4e3, e_volume[1], 1);
 
        // ADPCM
-       io->set_iomap_single_w(0x4e7, 0x4ff, adpcm); // 
+       io->set_iomap_range_w(0x4e7, 0x4ff, adpcm); // 
 
        io->set_iomap_single_rw(0x5c0, memory); // NMI MASK
        io->set_iomap_single_r(0x5c2, memory);  // NMI STATUS

diff --git a/source/src/vm/fmtowns/fmtowns.h b/source/src/vm/fmtowns/fmtowns.h
index 51746b6..e385bdf 100644 (file)
--- a/source/src/vm/fmtowns/fmtowns.h
+++ b/source/src/vm/fmtowns/fmtowns.h
@@ -7,8 +7,6 @@
 */
 #pragma once
 
-#ifndef _FMTOWNS_H_
-#define _FMTOWNS_H_
 
 #undef WITH_386SX
 #undef WITH_486
@@ -17,33 +15,44 @@
 #undef TYPE_TOWNS2_UX
 #undef TYPE_TOWNS2_CX
 
-#if defined(_FMTOWNS2F)
+#if defined(_FMTOWNS_1)
+#define DEVICE_NAME            "FUJITSU FM-Towns Model 1"
+#define CONFIG_NAME            "fmtowns_1"
+#define MAX_DRIVE       1
+#define _HAS_HDD        1
+
+#elif defined(_FMTOWNS_2)
+#define DEVICE_NAME            "FUJITSU FM-Towns Model 2"
+#define CONFIG_NAME            "fmtowns_2"
+#define MAX_DRIVE       2
+#define _HAS_HDD        1
+#elif defined(_FMTOWNS_2F)
 #define DEVICE_NAME            "FUJITSU FM-Towns 2F"
 #define CONFIG_NAME            "fmtowns_2f"
 #define MAX_DRIVE       2
-#define _HAS_HDD        1
+#undef  _HAS_HDD
 
-#elif defined(_FMTOWNS2H)
+#elif defined(_FMTOWNS_2H)
 #define DEVICE_NAME            "FUJITSU FM-Towns 2H"
 #define CONFIG_NAME            "fmtowns_2h"
 #define MAX_DRIVE       2
-#define _HAS_HDD        1
+#define _HAS_HDD        2
 
-#elif defined(_FMTOWNS20F)
+#elif defined(_FMTOWNS_20F)
 #define DEVICE_NAME            "FUJITSU FM-Towns 20F"
 #define CONFIG_NAME            "fmtowns_20f"
 #define MAX_DRIVE       2
 #undef  _HAS_HDD
 #define TYPE_TOWNS_X0   1
 
-#elif defined(_FMTOWNS40H)
+#elif defined(_FMTOWNS_40H)
 #define DEVICE_NAME            "FUJITSU FM-Towns 40H"
 #define CONFIG_NAME            "fmtowns_20h"
 #define MAX_DRIVE       2
-#define _HAS_HDD        1
+#define _HAS_HDD        2
 #define TYPE_TOWNS_X0   1
 
-#elif defined(_FMTOWNS2UX20)
+#elif defined(_FMTOWNS2_UX20)
 #define DEVICE_NAME            "FUJITSU FM-Towns II UX20"
 #define CONFIG_NAME            "fmtowns2_ux20"
 #define MAX_DRIVE       2
@@ -51,7 +60,7 @@
 #define WITH_386SX      1
 #define TYPE_TOWNS2_UX  1
 
-#elif defined(_FMTOWNS2UX40)
+#elif defined(_FMTOWNS2_UX40)
 #define DEVICE_NAME            "FUJITSU FM-Towns II UX40"
 #define CONFIG_NAME            "fmtowns2_ux20"
 #define MAX_DRIVE       2
@@ -59,20 +68,26 @@
 #define WITH_386SX      1
 #define TYPE_TOWNS2_UX  1
 
-#elif defined(_FMTOWNS2CX20)
+#elif defined(_FMTOWNS2_CX20)
 #define DEVICE_NAME            "FUJITSU FM-Towns II CX20"
 #define CONFIG_NAME            "fmtowns2_cx20"
 #define MAX_DRIVE       2
 #undef _HAS_HDD
 #define TYPE_TOWNS2_CX  1
 
-#elif defined(_FMTOWNS2CX40)
+#elif defined(_FMTOWNS2_CX40)
 #define DEVICE_NAME            "FUJITSU FM-Towns II CX40"
-#define CONFIG_NAME            "fmtowns2_cx20"
+#define CONFIG_NAME            "fmtowns2_cx40"
 #define MAX_DRIVE       2
-#define _HAS_HDD        1
+#define _HAS_HDD        4
 #define TYPE_TOWNS2_CX  1
 
+#elif defined(_FMTOWNS2_CX100)
+#define DEVICE_NAME            "FUJITSU FM-Towns II CX40"
+#define CONFIG_NAME            "fmtowns2_cx100"
+#define MAX_DRIVE       2
+#define _HAS_HDD        4
+#define TYPE_TOWNS2_CX  1
 #endif
 
 // device informations for virtual machine
@@ -90,6 +105,7 @@
 #define SCREEN_HEIGHT          400
 #define WINDOW_HEIGHT_ASPECT   480
 #endif
+
 #if defined(_HAS_HDD)
 #define MAX_SCSI               8
 #endif
@@ -113,11 +129,13 @@
 #define USE_CRT_FILTER
 #define USE_SOUND_FILES                1
 #define USE_SOUND_FILES_FDD
+
 #if defined(USE_SOUND_FILES)
 #define USE_SOUND_VOLUME       5
 #else
 #define USE_SOUND_VOLUME       6
 #endif
+
 #define USE_DEBUGGER
 #define USE_STATE
 #define USE_CPU_I386
@@ -149,13 +167,19 @@ class RF5C68;      // DAC
 class YM2612;      // OPNB
 class MB87078;     // VOLUME
 class AD7820KR;    // A/D Converter.
+class PCM1BIT;
 
 class MB8877;      // FDC
 class MSM58321;    // RTC
 class RF5C68;      // ADPCM
 class UPD71071;    // DMAC
 
-namespace TOWNS {
+class SCSI_HOST;
+class SCSI_DEV;
+class SCSI_HDD;
+class SCSI_CDROM;
+
+namespace FMTOWNS {
        class ADPCM;
        class CDC;
        class FLOPPY;
@@ -215,7 +239,7 @@ protected:
        FMTOWNS::SYSROM*         sysrom;
        FMTOWNS::MSDOSROM*       msdosrom;
        FMTOWNS::FONT_ROMS*      fontrom;
-if defined(HAS_20PIX_FONTS)
+#if defined(HAS_20PIX_FONTS)
        FMTOWNS::FONT_ROM_20PIX* fontrom_20pix;
 #endif
        FMTOWNS::SERIAL_ROM*     serialrom;
@@ -288,4 +312,3 @@ public:
        //DEVICE* last_device;
 };
 
-#endif

diff --git a/source/src/vm/fmtowns/msdosrom.cpp b/source/src/vm/fmtowns/msdosrom.cpp
index bc2b5f5..a41d7b4 100644 (file)
--- a/source/src/vm/fmtowns/msdosrom.cpp
+++ b/source/src/vm/fmtowns/msdosrom.cpp
@@ -7,7 +7,6 @@
        [MSDOS ROM]
 */
 
-#include "./towns_common.h"
 #include "./msdosrom.h"
 
 namespace FMTOWNS {

diff --git a/source/src/vm/fmtowns/rf5c68.cpp b/source/src/vm/fmtowns/rf5c68.cpp
index 13bd4fe..2c6a998 100644 (file)
--- a/source/src/vm/fmtowns/rf5c68.cpp
+++ b/source/src/vm/fmtowns/rf5c68.cpp
@@ -40,6 +40,7 @@ void RF5C68::initialize()
 
 void RF5C68::reset()
 {
+       is_mute = true; // OK?
        for(int i = 0; i < 8; i++) {
                dac_addr_st[i].d = 0x00;
                dac_env[i] = 0x0000000;
@@ -71,6 +72,56 @@ void RF5C68::reset()
 
 uint32_t RF5C68::read_signal(int ch)
 {
+       if(ch >= SIG_RF5C68_REG_ADDR_ST) {
+               if(ch >= 0x100) return 0x00;
+               int major_num = ch & 0xf8;
+               int local_ch = ch & 0x07;
+               switch(major_num) {
+               case SIG_RF5C68_REG_ADDR_ST:
+                       return dac_addr_st[local_ch].d;
+                       break;
+               case SIG_RF5C68_REG_ADDR:
+                       return dac_addr[local_ch];
+                       break;
+               case SIG_RF5C68_REG_ENV:
+                       return dac_env[local_ch];
+                       break;
+               case SIG_RF5C68_REG_LPAN:
+                       return dac_lpan[local_ch];
+                       break;
+               case SIG_RF5C68_REG_RPAN:
+                       return dac_rpan[local_ch];
+                       break;
+               case SIG_RF5C68_REG_LS:
+                       return dac_ls[local_ch].d;
+                       break;
+               case SIG_RF5C68_REG_FD:
+                       return dac_fd[local_ch].d;
+                       break;
+               case SIG_RF5C68_FORCE_LOAD:
+                       return ((dac_force_load[local_ch]) ? 0xffffffff : 0x00000000);
+                       break;
+               default:
+                       break;
+               }
+       } else {
+               switch(ch) {
+               case SIG_RF5C68_MUTE:
+                       return ((is_mute) ? 0xffffffff : 0x00000000);
+                       break;
+               case SIG_RF5C68_REG_ON:
+                       return ((dac_on) ? 0xffffffff : 0x00000000);
+                       break;
+               case SIG_RF5C68_REG_BANK:
+                       return dac_bank;
+                       break;
+               case SIG_RF5C68_REG_CH:
+                       return dac_ch;
+                       break;
+               default:
+                       break;
+               }
+       }
        return 0x00;
 }
 
@@ -106,12 +157,11 @@ void RF5C68::write_signal(int ch, uint32_t data, uint32_t mask)
                                                        // Skip
                                                        dac_force_load[ch] = true;
                                                        // Q: Is clear data reg?
-                                                       dac_data[ch] = 0;
                                                        dac_tmpval_l[ch] = 0;
                                                        dac_tmpval_r[ch] = 0;
                                                } else { // Normal OP
-                                                       uint32_t sign = tmpval[ch].d & 0x80;
-                                                       uint32_t val = tmpval[ch].d & 0x7f;
+                                                       uint32_t sign = tmpval.d & 0x80;
+                                                       uint32_t val = tmpval.d & 0x7f;
                                                        uint32_t lval, rval;
                                                        val = val * dac_env[ch];
                                                        lval = val * dac_lpan[ch];
@@ -126,12 +176,12 @@ void RF5C68::write_signal(int ch, uint32_t data, uint32_t mask)
                                                        // Limiter
                                                        if(dac_tmpval_l[ch] >= (127 << 6)) {
                                                                dac_tmpval_l[ch] = 127 << 6;
-                                                       } else if(dacval_tmpval_l[ch] < -(127 << 6)) {
+                                                       } else if(dac_tmpval_l[ch] < -(127 << 6)) {
                                                                dac_tmpval_l[ch] = -(127 << 6);
                                                        } 
                                                        if(dac_tmpval_r[ch] >= (127 << 6)) {
                                                                dac_tmpval_r[ch] = 127 << 6;
-                                                       } else if(dacval_tmpval_r[ch] < -(127 << 6)) {
+                                                       } else if(dac_tmpval_r[ch] < -(127 << 6)) {
                                                                dac_tmpval_r[ch] = -(127 << 6);
                                                        }
                                                }
@@ -149,6 +199,9 @@ void RF5C68::write_signal(int ch, uint32_t data, uint32_t mask)
        case SIG_RF5C68_SET_ALL_INTR:
                write_signals(&interrupt_boundary, 0x80000008);
                break;
+       case SIG_RF5C68_MUTE:
+               is_mute = ((data & mask) != 0) ? true : false;
+               break;
        default:
                break;
        }
@@ -180,7 +233,7 @@ void RF5C68::write_io8(uint32_t addr, uint32_t data)
        case 0x06: // ST
                dac_addr_st[dac_ch].d = 0;
                dac_addr_st[dac_ch].b.h = data & 0xff;
-               break
+               break;
        case 0x07: // Control
                dac_on = ((data & 0x80) != 0) ? true : false;
                if((data & 0x40) != 0) { // CB2-0
@@ -270,6 +323,7 @@ void RF5C68::mix(int32_t* buffer, int cnt)
        if(sample_length < cnt) cnt = sample_length;
        if(sample_length < sample_count) sample_count = sample_length;
        if(cnt <= 0) return;
+       if(is_mute) return;
        
        if(sample_buffer != NULL) {
                for(int i = 0; i < (cnt << 1); i += 2) {
@@ -302,10 +356,12 @@ void RF5C68::initialize_sound(int sample_rate, int samples)
                }
                if(event_dac_sample != -1) {
                        cancel_event(this, event_dac_sample);
-                       event_sample = -1;
+                       event_dac_sample = -1;
+               }
+               if(mix_rate > 0) {
+                       sample_tick_us = 1.0e6 / ((double)mix_rate);
+                       register_event(this, EVENT_DAC_SAMPLE, sample_tick_us, true, &event_dac_sample);
                }
-               sample_tick_us = 1.0e6 / ((double)mix_rate);
-               register_event(this, EVENT_DAC_SAMPLE, sample_tick_us, true, &event_dac_sample);
        } else {
                if(sample_buffer != NULL) {
                        free(sample_buffer);
@@ -335,7 +391,8 @@ bool RF5C68::process_state(FILEIO* state_fio, bool loading)
        state_fio->StateValue(dac_on);
        state_fio->StateValue(dac_bank);
        state_fio->StateValue(dac_ch);
-       state_fio->StateArray(dac_on);
+       state_fio->StateValue(dac_on);
+       state_fio->StateValue(is_mute);
        state_fio->StateArray(dac_onoff, sizeof(dac_onoff), 1);
        state_fio->StateArray(dac_addr_st, sizeof(dac_addr_st), 1);     
        state_fio->StateArray(dac_addr, sizeof(dac_addr), 1);
@@ -349,25 +406,21 @@ bool RF5C68::process_state(FILEIO* state_fio, bool loading)
        state_fio->StateArray(dac_tmpval_r, sizeof(dac_tmpval_r), 1);
        
        state_fio->StateArray(wave_memory, sizeof(wave_memory), 1);
-
-       // ToDo: OLD_mix_rate != mix_rate.
-       state_fio->StateValue(mix_rate);
-       // ToDo: OLD_sample_length != sample_length.
-       state_fio->StateValue(sample_length);
        state_fio->StateValue(event_dac_sample);
+
        // Post Process
        if(loading) {
-               if((sample_buffer != NULL) && (sample_length > 0)) {
-                       memset(sample_buffer, 0x00, sample_length * sizeof(int32_t) * 2);
-               } else {
-                       sample_length = 0;
+               if(event_dac_sample != -1) {
+                       cancel_event(this, event_dac_sample);
+                       event_dac_sample = -1;
                }
-               sample_count = 0;
                if(mix_rate > 0) {
                        sample_tick_us = 1.0e6 / ((double)mix_rate);
+                       register_event(this, EVENT_DAC_SAMPLE, sample_tick_us, true, &event_dac_sample);
                } else {
                        sample_tick_us = 0;
                }
+               sample_count = 0;
        }
        return true;
 }

diff --git a/source/src/vm/fmtowns/rf5c68.h b/source/src/vm/fmtowns/rf5c68.h
index 7321110..4986553 100644 (file)
--- a/source/src/vm/fmtowns/rf5c68.h
+++ b/source/src/vm/fmtowns/rf5c68.h
@@ -14,8 +14,21 @@
 #include "../device.h"
 #include "../../common.h"
 
-#define SIG_RF5C68_DAC_PERIOD     0x10
-#define SIG_RF5C68_CLEAR_INTR     0x11
+#define SIG_RF5C68_DAC_PERIOD     0x01
+#define SIG_RF5C68_CLEAR_INTR     0x02
+#define SIG_RF5C68_MUTE           0x03
+#define SIG_RF5C68_REG_ON         0x04
+#define SIG_RF5C68_REG_BANK       0x05
+#define SIG_RF5C68_REG_CH         0x06
+#define SIG_RF5C68_SET_ALL_INTR   0x07
+#define SIG_RF5C68_REG_ADDR_ST    0x20
+#define SIG_RF5C68_REG_ADDR       0x30
+#define SIG_RF5C68_REG_ENV        0x38
+#define SIG_RF5C68_REG_LPAN       0x40
+#define SIG_RF5C68_REG_RPAN       0x48
+#define SIG_RF5C68_REG_LS         0x50
+#define SIG_RF5C68_REG_FD         0x58
+#define SIG_RF5C68_FORCE_LOAD     0x60
 
 class RF5C68 : public DEVICE {
 protected:
@@ -27,6 +40,8 @@ protected:
        bool dac_on;
        uint8_t dac_bank;
        uint8_t dac_ch;
+       bool is_mute;
+       
        bool dac_onoff[8];
        pair32_t dac_addr_st[8];
        uint32_t dac_addr[8];
@@ -59,8 +74,9 @@ public:
                sample_length = 0;
                sample_count = 0;
                mix_rate = 0;
-               event_sample = -1;
+               event_dac_sample = -1;
                sample_tick_us = 0.0;
+               is_mute = true;
                initialize_output_signals(&interrupt_boundary);
                set_device_name(_T("ADPCM RF5C68"));
        }

diff --git a/source/src/vm/fmtowns/serialrom.cpp b/source/src/vm/fmtowns/serialrom.cpp
index 05fdf08..c327bed 100644 (file)
--- a/source/src/vm/fmtowns/serialrom.cpp
+++ b/source/src/vm/fmtowns/serialrom.cpp
@@ -23,13 +23,13 @@ void SERIAL_ROM::initialize()
        rom_addr = 0;
        
        memset(rom, 0xff, sizeof(rom));
-       FILEIO *fio = new FULEIO();
+       FILEIO *fio = new FILEIO();
        if(fio->Fopen(create_local_path(_T("MYTOWNS.ROM")), FILEIO_READ_BINARY)) { // FONT
                fio->Fread(rom, sizeof(rom), 1);
-               fio->Fcolose();
+               fio->Fclose();
        } else if(fio->Fopen(create_local_path(_T("SERIAL.ROM")), FILEIO_READ_BINARY)) { // FONT
                fio->Fread(rom, sizeof(rom), 1);
-               fio->Fcolose();
+               fio->Fclose();
        } else {
                // Header
                const _TCHAR *id = _T("FUJITSU");
@@ -96,7 +96,7 @@ void SERIAL_ROM::reset()
 void SERIAL_ROM::write_signal(int ch, uint32_t data, uint32_t mask)
 {
        switch(ch) {
-       case SIG_SERIAL_ROM_CLK:
+       case SIG_SERIALROM_CLK:
                {
                        bool oldclk = clk;
                        bool newclk = clk;
@@ -112,10 +112,10 @@ void SERIAL_ROM::write_signal(int ch, uint32_t data, uint32_t mask)
                        }
                }
                break;
-       case SIG_SERIAL_ROM_CS:
+       case SIG_SERIALROM_CS:
                cs = ((data & mask) == 0);
                break;
-       case SIG_SERIAL_ROM_RESET:
+       case SIG_SERIALROM_RESET:
                reset_reg = ((data & mask) != 0);
                if((cs) && (clk)) {
                        switch(reset_state) {

diff --git a/source/src/vm/fmtowns/towns_crtc.h b/source/src/vm/fmtowns/towns_crtc.h
index f1733bc..3dd0b71 100644 (file)
--- a/source/src/vm/fmtowns/towns_crtc.h
+++ b/source/src/vm/fmtowns/towns_crtc.h
@@ -141,6 +141,7 @@ private:
        // output signals
        outputs_t outputs_int_vsync;  // Connect to int 11.
        uint16_t regs[32];      // I/O 0442H, 0443H
+       bool regs_written[32];
        uint8_t ch;         // I/O 0440H
        bool timing_changed[2];
        bool address_changed[2];
@@ -290,7 +291,7 @@ public:
        // unique function
        void set_context_vsync(DEVICE* device, int id, uint32_t mask)
        {
-               register_output_signal(&outputs_vsync, device, id, mask);
+               register_output_signal(&outputs_int_vsync, device, id, mask);
        }
        uint16_t* get_regs_ptr()
        {

diff --git a/source/src/vm/fmtowns/towns_dictionary.cpp b/source/src/vm/fmtowns/towns_dictionary.cpp
index f3947c9..a6bbf36 100644 (file)
--- a/source/src/vm/fmtowns/towns_dictionary.cpp
+++ b/source/src/vm/fmtowns/towns_dictionary.cpp
@@ -7,16 +7,13 @@
        [ dictionary rom/ram & cmos & RAM area 0x000d0000 - 0x000effff]
 */
 
-#include "./towns_common.h"
-#include "./towns_dictrom.h"
+#include "./towns_dictionary.h"
 #include "./towns_sysrom.h"
 #include "../../fileio.h"
 
 namespace FMTOWNS {
 void DICTIONARY::initialize()
 {
-       cmos_dirty = false;
-       
        memset(dict_rom, 0xff, sizeof(dict_rom));
        memset(dict_ram, 0x00, sizeof(dict_ram));
        memset(ram_0d0, 0x00, sizeof(ram_0d0));
@@ -35,9 +32,6 @@ void DICTIONARY::initialize()
                cmos_dirty = true;
        }
        delete fio;
-
-       dict_bank = 0;
-       bankd0_dict = false;
 }
 
 void DICTIONARY::release()
@@ -103,8 +97,8 @@ uint32_t DICTIONARY::read_data16(uint32_t addr)
 {
        pair16_t n;
        addr = addr & 0xfffffffe;
-       n.l = (uint8_t)read_data8(addr + 0);
-       n.h = (uint8_t)read_data8(addr + 1);
+       n.b.l = (uint8_t)read_data8(addr + 0);
+       n.b.h = (uint8_t)read_data8(addr + 1);
        return (uint32_t)(n.u16);
 }
 
@@ -112,11 +106,11 @@ uint32_t DICTIONARY::read_data32(uint32_t addr)
 {
        pair32_t n;
        addr = addr & 0xfffffffc;
-       n.l  = (uint8_t)read_data8(addr + 0);
-       n.h  = (uint8_t)read_data8(addr + 1);
-       n.h2 = (uint8_t)read_data8(addr + 2);
-       n.h3 = (uint8_t)read_data8(addr + 3);
-       return n.u32;
+       n.b.l  = (uint8_t)read_data8(addr + 0);
+       n.b.h  = (uint8_t)read_data8(addr + 1);
+       n.b.h2 = (uint8_t)read_data8(addr + 2);
+       n.b.h3 = (uint8_t)read_data8(addr + 3);
+       return n.d;
 }
 
 void DICTIONARY::write_data16(uint32_t addr, uint32_t data)
@@ -124,19 +118,19 @@ void DICTIONARY::write_data16(uint32_t addr, uint32_t data)
        pair16_t n;
        addr = addr & 0xfffffffe;
        n.u16 = (uint16_t)data;
-       write_data8(addr + 0, n.l);
-       write_data8(addr + 1, n.h);
+       write_data8(addr + 0, n.b.l);
+       write_data8(addr + 1, n.b.h);
 }
 
 void DICTIONARY::write_data32(uint32_t addr, uint32_t data)
 {
        pair32_t n;
        addr = addr & 0xfffffffc;
-       n.u32 = data;
-       write_data8(addr + 0, n.l);
-       write_data8(addr + 1, n.h);
-       write_data8(addr + 2, n.h2);
-       write_data8(addr + 3, n.h3);
+       n.d = data;
+       write_data8(addr + 0, n.b.l);
+       write_data8(addr + 1, n.b.h);
+       write_data8(addr + 2, n.b.h2);
+       write_data8(addr + 3, n.b.h3);
 }
 
 
@@ -144,7 +138,7 @@ void DICTIONARY::write_io8(uint32_t addr, uint32_t data)
 {
        if(addr == 0x0480) {
                bankd0_dict = ((data & 0x01) != 0);
-               d_sysrom->write_signal(SIG_FMTONWS_SYSROMSEL, data, 0x02);
+               d_sysrom->write_signal(SIG_FMTOWNS_SYSROMSEL, data, 0x02);
        } else if(addr == 0x0484) {
                dict_bank = data & 0x0f;
        } else if((addr >= 0x3000) && (addr < 0x4000)) {
@@ -160,7 +154,7 @@ uint32_t DICTIONARY::read_io8(uint32_t addr)
 {
        uint32_t data;
        if(addr == 0x0480) {
-               data = ((bank0_dict) ? 0x01 : 0x00) | ((d_sysrom->read_signal(SIG_FMTOWNS_SYSROMSEL) == 0) ? 0x02 : 0x00);
+               data = ((bankd0_dict) ? 0x01 : 0x00) | ((d_sysrom->read_signal(SIG_FMTOWNS_SYSROMSEL) == 0) ? 0x02 : 0x00);
        } else if(addr == 0x0484) {
                data = dict_bank & 0x0f;
        } else if((addr >= 0x3000) && (addr < 0x4000)) {

diff --git a/source/src/vm/fmtowns/towns_dictionary.h b/source/src/vm/fmtowns/towns_dictionary.h
index 4c97025..cb58b3f 100644 (file)
--- a/source/src/vm/fmtowns/towns_dictionary.h
+++ b/source/src/vm/fmtowns/towns_dictionary.h
@@ -34,6 +34,10 @@ protected:
 public:
        DICTIONARY(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu)
        {
+               bankd0_dict = false;
+               dict_bank = 0x00;
+               cmos_dirty = false;
+               d_sysrom = NULL;
                set_device_name("FM-Towns Dictionary ROM/RAM 0x000d0000 - 0x000effff with CMOS RAM");
        }
        ~DICTIONARY() {}
@@ -50,7 +54,7 @@ public:
        void write_data32(uint32_t addr, uint32_t data);
 
        void write_io8(uint32_t addr, uint32_t data);
-       void read_io8(uint32_t addr, uint32_t data);
+       uint32_t read_io8(uint32_t addr);
 
        void write_signal(int ch, uint32_t data, uint32_t mask);
        uint32_t read_signal(int ch);

diff --git a/source/src/vm/fmtowns/towns_memory.cpp b/source/src/vm/fmtowns/towns_memory.cpp
index e55756f..576c531 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.cpp
+++ b/source/src/vm/fmtowns/towns_memory.cpp
@@ -9,6 +9,7 @@
 
 #include "../../fileio.h"
 #include "./towns_memory.h"
+#include "./towns_vram.h"
 #include "../i386.h"
 
 namespace FMTOWNS {

diff --git a/source/src/vm/fmtowns/towns_memory.h b/source/src/vm/fmtowns/towns_memory.h
index 5c39610..caa1b28 100644 (file)
--- a/source/src/vm/fmtowns/towns_memory.h
+++ b/source/src/vm/fmtowns/towns_memory.h
@@ -64,7 +64,7 @@ namespace FMTOWNS {
        class TOWNS_VRAM;
        class TOWNS_SPRITE;
        class TOWNS_ROM_CARD;
-       class TOWNS_PCM;
+       class ADPCM;
 }
        
 namespace FMTOWNS {
@@ -76,8 +76,8 @@ protected:
        TOWNS_VRAM* d_vram;
        TOWNS_SPRITE* d_sprite;       // 0x81000000 - 0x8101ffff ?
        TOWNS_ROM_CARD* d_romcard[2]; // 0xc0000000 - 0xc0ffffff / 0xc1000000 - 0xc1ffffff
-       TOWNS_PCM* d_pcm;             // 0xc2200000 - 0xc2200fff 
-       BEEP* d_beep;
+       FMTOWNS::ADPCM* d_pcm;             // 0xc2200000 - 0xc2200fff 
+       DEVICE* d_beep;
 
        DEVICE* d_dictionary;
        DEVICE* d_sysrom;
@@ -235,15 +235,15 @@ public:
        {
                d_beep = device;
        }
-       void set_context_sprite(DEVICE* device)
+       void set_context_sprite(TOWNS_SPRITE* device)
        {
                d_sprite = device;
        }
-       void set_context_romcard(DEVICE* device, int num)
+       void set_context_romcard(TOWNS_ROM_CARD* device, int num)
        {
                d_romcard[num & 1] = device;
        }
-       void set_context_pcm(DEVICE* device)
+       void set_context_pcm(FMTOWNS::ADPCM* device)
        {
                d_pcm = device;
        }

diff --git a/source/src/vm/fmtowns/towns_sysrom.cpp b/source/src/vm/fmtowns/towns_sysrom.cpp
index ba9ac3e..1af10fc 100644 (file)
--- a/source/src/vm/fmtowns/towns_sysrom.cpp
+++ b/source/src/vm/fmtowns/towns_sysrom.cpp
@@ -7,15 +7,12 @@
        [ system rom & RAM area 0x000f0000 - 0x000fffff]
 */
 
-#include "./towns_common.h"
 #include "./towns_sysrom.h"
 #include "../../fileio.h"
 
 namespace FMTOWNS {
 void SYSROM::initialize()
 {
-       cmos_dirty = false;
-       
        memset(rom, 0xff, sizeof(rom));
        memset(ram, 0x00, sizeof(ram));
        

diff --git a/source/src/vm/fmtowns/towns_vram.h b/source/src/vm/fmtowns/towns_vram.h
index 2ab231a..00ebe01 100644 (file)
--- a/source/src/vm/fmtowns/towns_vram.h
+++ b/source/src/vm/fmtowns/towns_vram.h
@@ -14,6 +14,8 @@
 #include "../vm.h"
 #include "../emu.h"
 #include "device.h"
+#include "../../common.h"
+
 #if defined(_USE_QT)
 #include <QMutex>
 #endif