source/src/vm/fmtowns/dictionary.cpp

   1 /*
   2         FUJITSU FM Towns Emulator 'eFMTowns'
   3
   4         Author : Kyuma.Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2019.01.09-
   6
   7         [ dictionary rom/ram & cmos & RAM area 0x000d0000 - 0x000dffff]
   8         * MEMORY :
   9         *   0x000d0000 - 0x000d7fff : DICTIONARY ROM (BANKED)
  10         *   0x000d8000 - 0x000d9fff : DICTIONARY RAM / GAIJI RAM
  11         *   0x000da000 - 0x000dffff : RESERVED
  12         *   0xc2080000 - 0xc20fffff : DICTIONARY ROM (NOT BANKED)
  13         *   0xc2140000 - 0xc2141fff : DICTIONARY RAM
  14         * I/O :
  15         *   0x0484                         : DICTIONARY BANK (for 0xd0000 - 0xd7ffff)
  16         *   0x3000 - 0x3ffe (even address) : DICTIONARY RAM
  17 */
  18
  19 #include "./towns_common.h"
  20 #include "./dictionary.h"
  21 #include "../../fileio.h"
  22
  23 namespace FMTOWNS {
  24 void DICTIONARY::initialize()
  25 {
  26         memset(dict_rom, 0xff, sizeof(dict_rom));
  27         memset(dict_ram, 0x00, sizeof(dict_ram));
  28
  29         FILEIO* fio = new FILEIO();
  30         if(fio->Fopen(create_local_path(_T("FMT_DIC.ROM")), FILEIO_READ_BINARY)) { // DICTIONARIES
  31                 fio->Fread(dict_rom, sizeof(dict_rom), 1);
  32                 fio->Fclose();
  33         }
  34
  35         cmos_dirty = true;
  36         if(fio->Fopen(create_local_path(_T("FMT_CMOS.BIN")), FILEIO_READ_BINARY)) {
  37                 if(fio->Fread(dict_ram, sizeof(dict_ram), 1) == 1) {
  38                         cmos_dirty = false;
  39                 }
  40                 fio->Fclose();
  41         }
  42         delete fio;
  43
  44 }
  45
  46 void DICTIONARY::release()
  47 {
  48         if(cmos_dirty) {
  49                 FILEIO* fio = new FILEIO();
  50                 if(fio->Fopen(create_local_path(_T("FMT_CMOS.BIN")), FILEIO_WRITE_BINARY)) {
  51                         fio->Fwrite(dict_ram, sizeof(dict_ram), 1);
  52                         fio->Fclose();
  53                 }
  54                 delete fio;
  55         }
  56 }
  57
  58 void DICTIONARY::reset()
  59 {
  60         dict_bank = 0;
  61         // Write CMOD every resetting. 20200511 K.O
  62         if(cmos_dirty) {
  63                 FILEIO* fio = new FILEIO();
  64                 if(fio->Fopen(create_local_path(_T("FMT_CMOS.BIN")), FILEIO_WRITE_BINARY)) {
  65                         fio->Fwrite(dict_ram, sizeof(dict_ram), 1);
  66                         fio->Fclose();
  67                 }
  68                 delete fio;
  69                 cmos_dirty = false;
  70         }
  71 }
  72
  73 uint32_t DICTIONARY::read_memory_mapped_io8w(uint32_t addr, int *wait)
  74 {
  75         uint8_t n_data = 0x00;
  76         // 0xd0000 - 0xdffff : primary  is VRAM, secondary is DICTIONARY.
  77         if((addr < 0x000da000) && (addr >= 0x000d0000)) {
  78                 *wait = 6; // temporally.
  79                 if(addr < 0xd8000) {
  80                         return dict_rom[(((uint32_t)dict_bank) << 15) | (addr & 0x7fff)];
  81                 } else {
  82                         return dict_ram[addr & 0x1fff];
  83                 }
  84         } else if((addr >= 0xc2080000) && (addr < 0xc2100000)) {
  85                 n_data = dict_rom[addr & 0x7ffff];
  86         } else if((addr >= 0xc2140000) && (addr < 0xc2142000)) {
  87                 n_data = dict_ram[addr & 0x1fff];
  88         }
  89         return n_data;
  90 }
  91
  92 void DICTIONARY::write_memory_mapped_io8w(uint32_t addr, uint32_t data, int *wait)
  93 {
  94         if((addr < 0x000da000) && (addr >= 0x000d8000)) {
  95                 *wait = 6; // Temporally.
  96                 cmos_dirty = true;
  97                 dict_ram[addr & 0x1fff] = data;
  98                 return;
  99         } else if((addr >= 0xc2140000) && (addr < 0xc2142000)) {
 100                 *wait = 6; // Temporally.
 101                 cmos_dirty = true;
 102                 dict_ram[addr & 0x1fff] = data;
 103                 return;
 104         }
 105 }
 106
 107
 108
 109 void DICTIONARY::write_io8w(uint32_t addr, uint32_t data, int *wait)
 110 {
 111         *wait = 6; // Temporally.
 112         if(addr == 0x0484) {
 113                 dict_bank = data & 0x0f;
 114         } else if((addr >= 0x3000) && (addr < 0x4000)) {
 115                 cmos_dirty = true;
 116                 dict_ram[((addr - 0x3000) >> 1) & 0x7ff] = (uint8_t)data;
 117         }
 118 }
 119
 120 uint32_t DICTIONARY::read_io8w(uint32_t addr, int *wait)
 121 {
 122         *wait = 6; // Temporally.
 123         uint32_t data = 0xff;
 124         if(addr == 0x0484) {
 125                 data = dict_bank & 0x0f;
 126         } else if((addr >= 0x3000) && (addr < 0x4000)) {
 127                 data = dict_ram[((addr - 0x3000) >> 1) & 0x07ff];
 128         }
 129         return data;
 130 }
 131
 132 void DICTIONARY::write_signal(int ch, uint32_t data, uint32_t mask)
 133 {
 134         switch(ch) {
 135         case SIG_FMTOWNS_DICT_BANK:
 136                 dict_bank = (uint8_t)(data & 0x0f);
 137                 break;
 138         }
 139 }
 140
 141 uint32_t DICTIONARY::read_signal(int ch)
 142 {
 143         switch(ch) {
 144         case SIG_FMTOWNS_DICT_BANK:
 145                 return (uint32_t)(dict_bank & 0x0f);
 146                 break;
 147         }
 148         return 0x00;
 149 }
 150
 151 uint32_t DICTIONARY::read_debug_data8(uint32_t addr)
 152 {
 153         // May read ram only
 154         return dict_ram[addr & 0x1fff];
 155 }
 156
 157 void DICTIONARY::write_debug_data8(uint32_t addr, uint32_t data)
 158 {
 159         // May read ram only
 160         dict_ram[addr & 0x1fff] = data;
 161 }
 162
 163 bool DICTIONARY::write_debug_reg(const _TCHAR *reg, uint32_t data)
 164 {
 165         if(reg == NULL) return false;
 166         if(strcasecmp(reg, _T("bank")) == 0) {
 167                 dict_bank = data & 0x0f;
 168                 return true;
 169         }
 170         return false;
 171 }
 172
 173 bool DICTIONARY::get_debug_regs_info(_TCHAR *buffer, size_t buffer_len)
 174 {
 175         if(buffer == NULL) return false;
 176         if(buffer_len <= 1) return false;
 177         my_stprintf_s(buffer, buffer_len - 1,
 178                                   _T("BANK=%02X WROTE=%s\n"),
 179                                   dict_bank, (cmos_dirty) ? _T("Yes") : _T("No "));
 180         return true;
 181 }
 182
 183 #define STATE_VERSION   1
 184
 185 bool DICTIONARY::process_state(FILEIO* state_fio, bool loading)
 186 {
 187         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 188                 return false;
 189         }
 190         if(!state_fio->StateCheckInt32(this_device_id)) {
 191                 return false;
 192         }
 193         state_fio->StateValue(dict_bank);
 194         state_fio->StateArray(dict_ram, sizeof(dict_ram), 1);
 195
 196         if(loading) {
 197                 cmos_dirty = true;
 198         }/* else {
 199                 FILEIO* fio = new FILEIO();
 200                 if(fio->Fopen(create_local_path(_T("FMT_CMOS.BIN")), FILEIO_WRITE_BINARY)) {
 201                         fio->Fwrite(dict_ram, sizeof(dict_ram), 1);
 202                         fio->Fclose();
 203                 }
 204                 delete fio;
 205                 cmos_dirty = false;
 206         } */
 207         return true;
 208 }
 209 }