From: K.Ohta Date: Sun, 21 Jun 2020 17:28:26 +0000 (+0900) Subject: [VM][FMTONWS][DICTIONARY][CMOS] Available to use dictionary ROM. X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=9537b3b05c4c3701792d65246a479ae3c376ffba;p=csp-qt%2Fcommon_source_project-fm7.git [VM][FMTONWS][DICTIONARY][CMOS] Available to use dictionary ROM. --- diff --git a/source/src/vm/fmtowns/fmtowns.cpp b/source/src/vm/fmtowns/fmtowns.cpp index 2c18600f3..72922f92d 100644 --- a/source/src/vm/fmtowns/fmtowns.cpp +++ b/source/src/vm/fmtowns/fmtowns.cpp @@ -294,7 +294,6 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu) event->set_context_sound(head_up_sound); #ifdef USE_DEBUGGER - cdrom->set_context_debugger(new DEBUGGER(this, emu)); pit0->set_context_debugger(new DEBUGGER(this, emu)); pit1->set_context_debugger(new DEBUGGER(this, emu)); #endif @@ -366,7 +365,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu) memory->set_context_serial_rom(serialrom); memory->set_context_sprite(sprite); memory->set_context_pcm(rf5c68); - + adpcm->set_context_opn2(opn2); adpcm->set_context_rf5c68(rf5c68); adpcm->set_context_adc(adc); @@ -492,7 +491,7 @@ VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu) io->set_iomap_single_rw(0x0458, vram); // VRAM ACCESS CONTROLLER (ADDRESS) io->set_iomap_range_rw (0x045a, 0x045f, vram); // VRAM ACCESS CONTROLLER (DATA) - io->set_iomap_single_rw(0x0480, sysrom); // MEMORY REGISTER + io->set_iomap_single_rw(0x0480, memory); // MEMORY REGISTER io->set_iomap_single_rw(0x0484, dictionary); // Dictionary //io->set_iomap_alias_r(0x48a, memory_card, 0); // diff --git a/source/src/vm/fmtowns/fontroms.cpp b/source/src/vm/fmtowns/fontroms.cpp index d33d474bf..60880e7ca 100644 --- a/source/src/vm/fmtowns/fontroms.cpp +++ b/source/src/vm/fmtowns/fontroms.cpp @@ -41,9 +41,9 @@ uint32_t FONT_ROMS::read_memory_mapped_io8(uint32_t addr) { if((addr >= 0xc2100000) && (addr < 0xc2140000)) { return (uint32_t)(font_kanji16[addr & 0x3ffff]); - } /*else if((addr >= 0x000ca000) && (addr < 0x000ca800)) { + } else if((addr >= 0x000ca000) && (addr < 0x000ca800)) { return (uint32_t)(font_kanji16[0x3d000 + (addr & 0x7ff)]); - } */else if((addr >= 0x000cb000) && (addr < 0x000cc000)) { + } else if((addr >= 0x000cb000) && (addr < 0x000cc000)) { return (uint32_t)(font_kanji16[0x3d800 + (addr & 0xfff)]); } return 0xff; diff --git a/source/src/vm/fmtowns/towns_dictionary.cpp b/source/src/vm/fmtowns/towns_dictionary.cpp index acfc487bb..775cf78aa 100644 --- a/source/src/vm/fmtowns/towns_dictionary.cpp +++ b/source/src/vm/fmtowns/towns_dictionary.cpp @@ -25,7 +25,6 @@ void DICTIONARY::initialize() { memset(dict_rom, 0xff, sizeof(dict_rom)); memset(dict_ram, 0x00, sizeof(dict_ram)); -// memset(ram_d0, 0x00, sizeof(ram_d0)); FILEIO* fio = new FILEIO(); if(fio->Fopen(create_local_path(_T("FMT_DIC.ROM")), FILEIO_READ_BINARY)) { // DICTIONARIES @@ -81,10 +80,11 @@ uint32_t DICTIONARY::read_memory_mapped_io8(uint32_t addr) } else if(addr < 0xda000) { return dict_ram[addr & 0x1fff]; } else { + return 0x00; } - } else if((addr >= 0xc20800000) && (addr < 0xc2100000)) { + } else if((addr >= 0xc2080000) && (addr < 0xc2100000)) { n_data = dict_rom[addr & 0x7ffff]; - } else if((addr >= 0xc21400000) && (addr < 0xc2142000)) { + } else if((addr >= 0xc2140000) && (addr < 0xc2142000)) { n_data = dict_ram[addr & 0x1fff]; } return n_data; @@ -102,9 +102,9 @@ void DICTIONARY::write_memory_mapped_io8(uint32_t addr, uint32_t data) } // ToDo: address >= 0xda000 return; - } else if((addr >= 0xc20800000) && (addr < 0xc2100000)) { + } else if((addr >= 0xc2080000) && (addr < 0xc2100000)) { return; - } else if((addr >= 0xc21400000) && (addr < 0xc2142000)) { + } else if((addr >= 0xc2140000) && (addr < 0xc2142000)) { cmos_dirty = true; dict_ram[addr & 0x1fff] = data; return; @@ -158,11 +158,8 @@ void DICTIONARY::write_io8(uint32_t addr, uint32_t data) if(addr == 0x0484) { dict_bank = data & 0x0f; } else if((addr >= 0x3000) && (addr < 0x4000)) { - if((addr & 0x0001) == 0) { // OK? -// uint32_t naddr = (addr >> 1) & 0x7ff; - cmos_dirty = true; - dict_ram[addr & 0xfff] = (uint8_t)data; - } + cmos_dirty = true; + dict_ram[((addr - 0x3000) >> 1) & 0x7ff] = (uint8_t)data; } } @@ -172,12 +169,7 @@ uint32_t DICTIONARY::read_io8(uint32_t addr) if(addr == 0x0484) { data = dict_bank & 0x0f; } else if((addr >= 0x3000) && (addr < 0x4000)) { - if((addr & 0x0001) == 0) { // OK? -// uint32_t naddr = (addr >> 1) & 0x7ff; - data = dict_ram[addr & 0x0fff]; - } else { - data = 0xff; - } + data = dict_ram[((addr - 0x3000) >> 1) & 0x07ff]; } else { data = 0xff; } @@ -202,6 +194,38 @@ uint32_t DICTIONARY::read_signal(int ch) } return 0x00; } + +uint32_t DICTIONARY::read_debug_data8(uint32_t addr) +{ + // May read ram only + return dict_ram[addr & 0x1fff]; +} + +void DICTIONARY::write_debug_data8(uint32_t addr, uint32_t data) +{ + // May read ram only + dict_ram[addr & 0x1fff] = data; +} + +bool DICTIONARY::write_debug_reg(const _TCHAR *reg, uint32_t data) +{ + if(reg == NULL) return false; + if(strcasecmp(reg, _T("bank")) == 0) { + dict_bank = data & 0x0f; + return true; + } + return false; +} + +bool DICTIONARY::get_debug_regs_info(_TCHAR *buffer, size_t buffer_len) +{ + if(buffer == NULL) return false; + if(buffer_len <= 1) return false; + my_stprintf_s(buffer, buffer_len - 1, + _T("BANK=%02X WROTE=%s\n"), + dict_bank, (cmos_dirty) ? _T("Yes") : _T("No ")); + return true; +} #define STATE_VERSION 1 @@ -215,7 +239,6 @@ bool DICTIONARY::process_state(FILEIO* state_fio, bool loading) } state_fio->StateValue(dict_bank); state_fio->StateArray(dict_ram, sizeof(dict_ram), 1); -// state_fio->StateArray(ram_d0, sizeof(ram_d0), 1); if(loading) { cmos_dirty = true; diff --git a/source/src/vm/fmtowns/towns_dictionary.h b/source/src/vm/fmtowns/towns_dictionary.h index 47747e54d..5dcbc743b 100644 --- a/source/src/vm/fmtowns/towns_dictionary.h +++ b/source/src/vm/fmtowns/towns_dictionary.h @@ -30,7 +30,6 @@ class DICTIONARY : public DEVICE protected: uint8_t dict_rom[0x80000]; // 512KB uint8_t dict_ram[0x2000]; // 2 + 6KB -// uint8_t ram_d0[0x8000]; // 32KB uint8_t dict_bank; bool cmos_dirty; @@ -62,6 +61,21 @@ public: uint32_t __FASTCALL read_signal(int ch); bool process_state(FILEIO* state_fio, bool loading); + + bool is_debugger_available() + { + return true; + } + uint64_t get_debug_data_addr_space() + { + return 0x2000; + } + uint32_t __FASTCALL read_debug_data8(uint32_t addr); + void __FASTCALL write_debug_data8(uint32_t addr, uint32_t data); + + bool write_debug_reg(const _TCHAR *reg, uint32_t data); + bool get_debug_regs_info(_TCHAR *buffer, size_t buffer_len); + }; } diff --git a/source/src/vm/fmtowns/towns_memory.cpp b/source/src/vm/fmtowns/towns_memory.cpp index 0b40076a4..3fb60c3da 100644 --- a/source/src/vm/fmtowns/towns_memory.cpp +++ b/source/src/vm/fmtowns/towns_memory.cpp @@ -31,26 +31,34 @@ void TOWNS_MEMORY::config_page00() { if(dma_is_vram) { set_memory_rw (0x00000000, 0x000bffff, ram_page0); -// set_memory_mapped_io_r (0x000b0000, 0x000bffff, d_msdos); // OK? <- for compatible ROM. - set_memory_rw (0x000c0000, 0x000cffff, ram_pagec); + set_memory_rw (0x000cc000, 0x000cffff, &(ram_pagec[0xc000])); + // OK? From TSUGARU set_memory_mapped_io_rw(0x000c0000, 0x000c7fff, d_planevram); - set_memory_mapped_io_rw(0x000c8000, 0x000c8fff, d_sprite); + set_memory_mapped_io_rw(0x000c8000, 0x000cbfff, d_sprite); set_memory_mapped_io_rw(0x000ca000, 0x000cafff, d_sprite); if(ankcg_enabled) { -// set_memory_mapped_io_r(0x000ca000, 0x000ca7ff, d_font); + set_memory_mapped_io_r(0x000ca000, 0x000ca7ff, d_font); + set_memory_r (0x000ca800, 0x000cafff, rd_dummy); set_memory_mapped_io_r(0x000cb000, 0x000cbfff, d_font); } +// set_memory_mapped_io_rw(0x000c0000, 0x000cbfff, this); // BANKED set_memory_mapped_io_rw(0x000cfc00, 0x000cffff, this); // MMIO - set_memory_rw (0x000d0000, 0x000d7fff, ram_paged); - 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_rw (0x000da000, 0x000effff, ram_pagee); + } + if((select_d0_rom) && (select_d0_dict)) { + set_memory_mapped_io_rw(0x000d0000, 0x000dffff, d_dictionary); + } else { + set_memory_rw (0x000d0000, 0x000dffff, ram_paged); + } + set_memory_rw (0x000e0000, 0x000effff, ram_pagee); set_memory_rw (0x000f0000, 0x000f7fff, ram_pagef); - set_memory_mapped_io_rw(0x000f8000, 0x000fffff, d_sysrom); + if(select_d0_rom) { + set_memory_mapped_io_rw(0x000f8000, 0x000fffff, d_sysrom); + } else { + set_memory_rw (0x000f8000, 0x000fffff, &(ram_pagef[0x8000])); + } } void TOWNS_MEMORY::initialize() @@ -104,14 +112,19 @@ void TOWNS_MEMORY::initialize() memset(ram_pagee, 0x00, sizeof(ram_pagee)); memset(ram_pagef, 0x00, sizeof(ram_pagef)); + select_d0_dict = false; + select_d0_rom = true; + dma_is_vram = true; config_page00(); set_memory_mapped_io_rw(0x80000000, 0x8007ffff, d_vram); set_memory_mapped_io_rw(0x80100000, 0x8017ffff, d_vram); set_memory_mapped_io_rw(0x81000000, 0x8101ffff, d_sprite); + // set_memory_mapped_io_rw(0xc0000000, 0xc0ffffff, d_iccard[0]); // set_memory_mapped_io_rw(0xc1000000, 0xc1ffffff, d_iccard[1]); + set_memory_mapped_io_r (0xc2000000, 0xc207ffff, d_msdos); set_memory_mapped_io_r (0xc2080000, 0xc20fffff, d_dictionary); set_memory_mapped_io_r (0xc2100000, 0xc213ffff, d_font); @@ -119,7 +132,7 @@ void TOWNS_MEMORY::initialize() if(d_font_20pix != NULL) { set_memory_mapped_io_r (0xc2180000, 0xc21fffff, d_font_20pix); } - set_memory_mapped_io_rw(0xc2200000, 0xc220ffff, d_pcm); + set_memory_mapped_io_rw(0xc2200000, 0xc2200fff, d_pcm); set_memory_mapped_io_r (0xfffc0000, 0xffffffff, d_sysrom); set_wait_values(); // Another devices are blank @@ -224,6 +237,8 @@ void TOWNS_MEMORY::reset() nmi_vector_protect = false; ankcg_enabled = false; nmi_mask = false; + select_d0_dict = false; + select_d0_rom = true; config_page00(); // cpu_clock_val = 16000 * 1000; set_wait_values(); @@ -318,6 +333,10 @@ uint32_t TOWNS_MEMORY::read_io8(uint32_t addr) // val = (dma_is_vram) ? 0x7f : 0xff; val = (dma_is_vram) ? 0x00 : 0x80; break; + case 0x0480: + val = (select_d0_dict) ? 0x01 : 0x00; + val |= ((select_d0_rom) ? 0x00 : 0x02); + break; case 0x05c0: // val = (extra_nmi_mask) ? 0xf7 : 0xff; val = (extra_nmi_mask) ? 0x00 : 0x08; @@ -550,6 +569,11 @@ void TOWNS_MEMORY::write_io8(uint32_t addr, uint32_t data) dma_is_vram = ((data & 0x80) == 0); config_page00(); break; + case 0x0480: + select_d0_dict = ((data & 0x01) != 0) ? true : false; + select_d0_rom = ((data & 0x02) == 0) ? true : false; + config_page00(); + break; case 0x05c0: extra_nmi_mask = ((data & 0x08) == 0); break; @@ -641,10 +665,73 @@ void TOWNS_MEMORY::write_io8(uint32_t addr, uint32_t data) } return; } +/* +// At page 000C0000h - 000CFFFFh : Maybe return real memory for word/dword access. +uint32_t TOWNS_MEMORY::read_memory_mapped_io16(uint32_t addr) +{ + if((addr >= 0xc0000) && (addr <= 0xcffff)) { + pair32_t n; + n.d = 0; + n.b.l = ram_pagec[(addr & 0xffff) + 0]; + n.b.h = ram_pagec[(addr & 0xffff) + 1]; + return n.d; + } + return 0xffff; +} +uint32_t TOWNS_MEMORY::read_memory_mapped_io32(uint32_t addr) +{ + if((addr >= 0xc0000) && (addr <= 0xcffff)) { + pair32_t n; + n.d = 0; + n.b.l = ram_pagec[(addr & 0xffff) + 0]; + n.b.h = ram_pagec[(addr & 0xffff) + 1]; + n.b.h2 = ram_pagec[(addr & 0xffff) + 2]; + n.b.h3 = ram_pagec[(addr & 0xffff) + 3]; + return n.d; + } + return 0xffffffff; +} +*/ uint32_t TOWNS_MEMORY::read_memory_mapped_io8(uint32_t addr) { uint32_t val = 0xff; + if((addr >= 0xc0000) && (addr <= 0xc7fff)) { + if(d_planevram != NULL) { + return d_planevram->read_memory_mapped_io8(addr); + } + return 0xff; + } else if((addr >= 0xc8000) && (addr <= 0xc9fff)) { + if(d_sprite != NULL) { + d_sprite->read_memory_mapped_io8(addr); + } else { + return 0xff; + } + } else if((addr >= 0xca000) && (addr <= 0xcbfff)) { + if(ankcg_enabled) { + if((addr >= 0xca000) && (addr <= 0xca7ff)) { + if(d_font != NULL) { + d_font->read_memory_mapped_io8(addr); + } else { + return 0xff; + } + } else if((addr >= 0xcb000) && (addr <= 0xcbfff)) { + if(d_font != NULL) { + d_font->read_memory_mapped_io8(addr); + } else { + return 0xff; + } + } else if((addr >= 0xca800) && (addr <= 0xcafff)) { + return 0xff; + } + } + if(d_sprite != NULL) { + d_sprite->read_memory_mapped_io8(addr); + } else { + return 0xff; + } + } + if((addr < 0xcfc00) || (addr >= 0xd0000)) return 0xff; switch(addr) { case 0xcff88: @@ -659,6 +746,9 @@ uint32_t TOWNS_MEMORY::read_memory_mapped_io8(uint32_t addr) val = read_io8(addr & 0xffff); break; default: + if((addr < 0xcff80) || (addr > 0xcffbb)) { + return ram_pagec[addr & 0xffff]; + } if(d_planevram != NULL) { val = d_planevram->read_io8(addr & 0xffff); } @@ -666,9 +756,48 @@ uint32_t TOWNS_MEMORY::read_memory_mapped_io8(uint32_t addr) } return (uint32_t)val; } +/* +void TOWNS_MEMORY::write_memory_mapped_io16(uint32_t addr, uint32_t data) +{ + if((addr >= 0xc0000) && (addr <= 0xcffff)) { + pair16_t n; + n.w = data; + ram_pagec[(addr & 0xffff) + 0] = n.b.l; + ram_pagec[(addr & 0xffff) + 1] = n.b.h; + } +} + +void TOWNS_MEMORY::write_memory_mapped_io32(uint32_t addr, uint32_t data) +{ + if((addr >= 0xc0000) && (addr <= 0xcffff)) { + pair32_t n; + n.d = data; + ram_pagec[(addr & 0xffff) + 0] = n.b.l; + ram_pagec[(addr & 0xffff) + 1] = n.b.h; + ram_pagec[(addr & 0xffff) + 2] = n.b.h2; + ram_pagec[(addr & 0xffff) + 3] = n.b.h3; + } +} +*/ void TOWNS_MEMORY::write_memory_mapped_io8(uint32_t addr, uint32_t data) { + if((addr >= 0xc0000) && (addr <= 0xc7fff)) { + if(d_planevram != NULL) { + d_planevram->write_memory_mapped_io8(addr, data); + } + return; + } else if((addr >= 0xc8000) && (addr <= 0xc9fff)) { + if(d_sprite != NULL) { + d_sprite->write_memory_mapped_io8(addr, data); + } + return; + } else if((addr >= 0xca000) && (addr <= 0xcbfff)) { + if(d_sprite != NULL) { + d_sprite->write_memory_mapped_io8(addr, data); + } + return; + } if((addr < 0xcfc00) || (addr >= 0xd0000)) return; switch(addr) { case 0xcff94: @@ -679,6 +808,10 @@ void TOWNS_MEMORY::write_memory_mapped_io8(uint32_t addr, uint32_t data) write_io8(addr & 0xffff, data); break; default: + if((addr < 0xcff80) || (addr > 0xcffbb)) { + ram_pagec[addr & 0xffff] = data; + return; + } if(d_planevram != NULL) { d_planevram->write_io8(addr & 0xffff, data); } @@ -686,6 +819,91 @@ void TOWNS_MEMORY::write_memory_mapped_io8(uint32_t addr, uint32_t data) } return; } + +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; + } +} + void TOWNS_MEMORY::write_signal(int ch, uint32_t data, uint32_t mask) { if(ch == SIG_MEMORY_EXTNMI) { @@ -760,7 +978,7 @@ void TOWNS_MEMORY::set_intr_line(bool line, bool pending, uint32_t bit) // ToDo: DMA -#define STATE_VERSION 4 +#define STATE_VERSION 5 bool TOWNS_MEMORY::process_state(FILEIO* state_fio, bool loading) { @@ -794,6 +1012,16 @@ bool TOWNS_MEMORY::process_state(FILEIO* state_fio, bool loading) state_fio->StateArray(ram_paged, sizeof(ram_paged), 1); state_fio->StateArray(ram_pagee, sizeof(ram_pagee), 1); state_fio->StateArray(ram_pagef, sizeof(ram_pagef), 1); + + state_fio->StateValue(select_d0_rom); + state_fio->StateValue(select_d0_dict); + state_fio->StateValue(ankcg_enabled); + + state_fio->StateValue(vram_wait_val); + state_fio->StateValue(mem_wait_val); + state_fio->StateValue(vram_size); + state_fio->StateValue(cpu_clock_val); + if(loading) { uint32_t length_tmp = state_fio->FgetUint32_LE(); if(extra_ram != NULL) { @@ -814,6 +1042,7 @@ bool TOWNS_MEMORY::process_state(FILEIO* state_fio, bool loading) set_memory_rw(0x00100000, (extram_size + 0x00100000) - 1, extra_ram); } set_wait_values(); + config_page00(); } else { // At saving if(extra_ram == NULL) { @@ -823,12 +1052,6 @@ bool TOWNS_MEMORY::process_state(FILEIO* state_fio, bool loading) state_fio->Fwrite(extra_ram, extram_size, 1); } } - state_fio->StateValue(ankcg_enabled); - - state_fio->StateValue(vram_wait_val); - state_fio->StateValue(mem_wait_val); - state_fio->StateValue(vram_size); - state_fio->StateValue(cpu_clock_val); // ToDo: Do save ROMs? return true; diff --git a/source/src/vm/fmtowns/towns_memory.h b/source/src/vm/fmtowns/towns_memory.h index 73e06848e..a80855394 100644 --- a/source/src/vm/fmtowns/towns_memory.h +++ b/source/src/vm/fmtowns/towns_memory.h @@ -83,7 +83,9 @@ protected: bool bankc0_vram; bool ankcg_enabled; - + bool select_d0_rom; + bool select_d0_dict; + uint16_t machine_id; uint8_t cpu_id; bool is_compatible; @@ -92,9 +94,9 @@ protected: // RAM uint8_t ram_page0[0xc0000]; // 0x00000000 - 0x000bffff : RAM uint8_t ram_pagec[0x10000]; // 0x000c0000 - 0x000cffff : URA? RAM - uint8_t ram_paged[0x0a000]; // 0x000d0000 - 0x000d9fff : RAM - uint8_t ram_pagee[0x16000]; // 0x000da000 - 0x000effff : RAM - uint8_t ram_pagef[0x08000]; // 0x000f0000 - 0x000f7fff : RAM + uint8_t ram_paged[0x10000]; // 0x000d0000 - 0x000dffff : RAM + uint8_t ram_pagee[0x10000]; // 0x000e0000 - 0x000effff : RAM + uint8_t ram_pagef[0x10000]; // 0x000f0000 - 0x000f8fff : RAM uint8_t *extra_ram; // 0x00100000 - (0x3fffffff) : Size is defined by extram_size; uint32_t extram_size; @@ -191,11 +193,21 @@ public: uint32_t __FASTCALL read_data32w(uint32_t addr, int* wait); void __FASTCALL write_data16w(uint32_t addr, uint32_t data, int* wait); void __FASTCALL write_data32w(uint32_t addr, uint32_t data, int* wait); - virtual void __FASTCALL write_memory_mapped_io8(uint32_t addr, uint32_t data); +// virtual void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data); +// virtual void __FASTCALL write_memory_mapped_io32(uint32_t addr, uint32_t data); virtual uint32_t __FASTCALL read_memory_mapped_io8(uint32_t addr); - +// virtual uint32_t __FASTCALL read_memory_mapped_io16(uint32_t addr); +// virtual uint32_t __FASTCALL read_memory_mapped_io32(uint32_t addr); + + uint32_t __FASTCALL read_dma_data8(uint32_t addr); + uint32_t __FASTCALL read_dma_data16(uint32_t addr); + uint32_t __FASTCALL read_dma_data32(uint32_t addr); + void __FASTCALL write_dma_data8(uint32_t addr, uint32_t data); + void __FASTCALL write_dma_data16(uint32_t addr, uint32_t data); + void __FASTCALL write_dma_data32(uint32_t addr, uint32_t data); + void __FASTCALL write_signal(int id, uint32_t data, uint32_t mask); uint32_t __FASTCALL read_signal(int ch); diff --git a/source/src/vm/fmtowns/towns_sysrom.cpp b/source/src/vm/fmtowns/towns_sysrom.cpp index c66616997..ec5c718d9 100644 --- a/source/src/vm/fmtowns/towns_sysrom.cpp +++ b/source/src/vm/fmtowns/towns_sysrom.cpp @@ -14,13 +14,13 @@ #include "./towns_common.h" #include "./towns_sysrom.h" +#include "./towns_dictionary.h" #include "../../fileio.h" namespace FMTOWNS { void SYSROM::initialize() { memset(rom, 0xff, sizeof(rom)); - memset(ram, 0x00, sizeof(ram)); FILEIO* fio = new FILEIO(); if(fio->Fopen(create_local_path(_T("FMT_SYS.ROM")), FILEIO_READ_BINARY)) { // DICTIONARIES @@ -33,52 +33,14 @@ void SYSROM::initialize() void SYSROM::reset() { - select_f8_rom = true; - select_f8_dictram = false; -} - -void SYSROM::write_io8(uint32_t addr, uint32_t data) -{ - switch(addr) { - case 0x0480: - select_f8_rom = ((data & 0x02) == 0); - select_f8_dictram = ((data & 0x01) != 0); -// out_debug_log(_T("F8 ROM %s, F8 DICTRAM %s"), (select_f8_rom) ? _T("ON") : _T("OFF") -// ,(select_f8_dictram) ? _T("ON") : _T("OFF")); - break; - } -} - -uint32_t SYSROM::read_io8(uint32_t addr) -{ - switch(addr) { - case 0x0480: - return (0x00 | ((select_f8_dictram) ? 0x01 : 0x00) | ((select_f8_rom) ? 0x00 : 0x02)); - break; - } - return 0xff; } uint32_t SYSROM::read_memory_mapped_io8(uint32_t addr) { uint8_t n_data = 0xff; - if(addr < 0xfffc0000) { // Banked (from MSDOS/i86 compatible mode) + if(addr < 0xfffc0000) { // Banked (from MSDOS/i86 compatible mode) if((addr >= 0x000f8000) && (addr < 0x00100000)) { - if(select_f8_rom) { // BOOT ROM - n_data = rom[(addr & 0x7fff) + 0x38000]; - } else { // RAM - if((select_f8_dictram) && (addr < 0x000fa000)) { - // OK? - if(d_dict != NULL) { - n_data = d_dict->read_memory_mapped_io8(0xc21400000 + (addr & 0x1fff)); - return n_data; - } - } else { - n_data = ram[addr & 0x7fff]; - } - } - } else if((addr >= 0x000f0000) && (addr < 0x000f8000)) { -// n_data = ram[addr & 0x7fff]; + n_data = rom[(addr & 0x7fff) + 0x38000]; } } else { n_data = rom[addr & 0x3ffff]; @@ -111,29 +73,6 @@ uint32_t SYSROM::read_memory_mapped_io32(uint32_t addr) void SYSROM::write_memory_mapped_io8(uint32_t addr, uint32_t data) { - if(addr < 0xfffc0000) { - if((addr >= 0x000f8000) && (addr < 0x00100000)) { - // page 000F8xxxx : enable to write at all condition. - if(select_f8_rom) { - ram[addr & 0x7fff] = data; - return; - } else - { - // RAM - if((select_f8_dictram) && (addr < 0x000fa000)) { // OK? - if(d_dict != NULL) { - d_dict->write_memory_mapped_io8(0xc21400000 + (addr & 0x1fff), data); - return; - } - } else { - ram[addr & 0x7fff] = data; - } - } - } else if((addr >= 0x000f0000) && (addr < 0x000f8000)) { - //ram[addr & 0x7fff] = data; - } - return; - } // ADDR >= 0xfffc0000 return; } @@ -158,45 +97,5 @@ void SYSROM::write_memory_mapped_io32(uint32_t addr, uint32_t data) write_memory_mapped_io8(addr + 3, nd.b.h3); } -void SYSROM::write_signal(int ch, uint32_t data, uint32_t mask) -{ - switch(ch) { - case SIG_FMTOWNS_SYSROMSEL: - select_f8_rom = ((data & mask) == 0); - break; - case SIG_FMTOWNS_F8_DICTRAM: - select_f8_dictram = ((data & mask) != 0); - break; - } -} - -uint32_t SYSROM::read_signal(int ch) -{ - switch(ch) { - case SIG_FMTOWNS_SYSROMSEL: - return ((select_f8_rom) ? 0xffffffff : 0x00000000); - break; - case SIG_FMTOWNS_F8_DICTRAM: - return ((select_f8_dictram) ? 0xffffffff : 0x00000000); - break; - } - return 0x00; -} -#define STATE_VERSION 1 - -bool SYSROM::process_state(FILEIO* state_fio, bool loading) -{ - if(!state_fio->StateCheckUint32(STATE_VERSION)) { - return false; - } - if(!state_fio->StateCheckInt32(this_device_id)) { - return false; - } - state_fio->StateValue(select_f8_rom); - state_fio->StateValue(select_f8_dictram); - - state_fio->StateArray(ram, sizeof(ram), 1); - return true; -} } diff --git a/source/src/vm/fmtowns/towns_sysrom.h b/source/src/vm/fmtowns/towns_sysrom.h index fd97a1625..5885977c6 100644 --- a/source/src/vm/fmtowns/towns_sysrom.h +++ b/source/src/vm/fmtowns/towns_sysrom.h @@ -6,7 +6,10 @@ [ SYSTEM rom & RAM area 0x000f8000 - 0x000fffff] * MEMORY : - * 0x000f8000 - 0x000fffff : RAM / DICTIONARY (BANKED) + * 0x000d0000 - 0x000d7fff : RAM / DICTIONARY (BANKED) + * 0x000d8000 - 0x000d9fff : RAM / CMOS + * 0x000da000 - 0x000dffff : RAM / RESERVED + * 0x000f8000 - 0x000fffff : RAM / SYSTEM * 0xfffc0000 - 0xffffffff : SYSTEM ROM * I/O : * 0x0480 : F8 BANK @@ -25,18 +28,12 @@ class DICTIONARY; class SYSROM : public DEVICE { protected: - DEVICE *d_dict; - uint8_t rom[0x40000]; // 256KB - uint8_t ram[0x8000]; // 32KB - bool select_f8_rom; - bool select_f8_dictram; public: SYSROM(VM* parent_vm, EMU* parent_emu) : DEVICE(parent_vm, parent_emu) { - d_dict = NULL; - set_device_name("FM-Towns SYSTEM ROM and RAM 0x000f8000 - 0x00fffff"); + set_device_name("FM-Towns SYSTEM ROM"); } ~SYSROM() {} void initialize(); @@ -49,19 +46,6 @@ public: void __FASTCALL write_memory_mapped_io16(uint32_t addr, uint32_t data); void __FASTCALL write_memory_mapped_io32(uint32_t addr, uint32_t data); - void __FASTCALL write_io8(uint32_t addr, uint32_t data); - uint32_t __FASTCALL read_io8(uint32_t addr); - - void __FASTCALL write_signal(int ch, uint32_t data, uint32_t mask); - uint32_t __FASTCALL read_signal(int ch); - - bool process_state(FILEIO* state_fio, bool loading); - - // Unique functions - void set_context_dictionary(DEVICE *dev) - { - d_dict = dev; - } }; }