{
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
} 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;
}
// 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;
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;
}
}
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;
}
}
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
}
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;
{
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()
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);
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
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();
// 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;
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;
}
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:
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);
}
}
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:
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);
}
}
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) {
// ToDo: DMA
-#define STATE_VERSION 4
+#define STATE_VERSION 5
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) {
set_memory_rw(0x00100000, (extram_size + 0x00100000) - 1, extra_ram);
}
set_wait_values();
+ config_page00();
} else {
// At saving
if(extra_ram == NULL) {
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;
#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
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];
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;
}
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;
-}
}
OSDN Git Service
