source/src/vm/pc98ha/memory.cpp

   1 /*
   2         NEC PC-98LT Emulator 'ePC-98LT'
   3         NEC PC-98HA Emulator 'eHANDY98'
   4
   5         Author : Takeda.Toshiya
   6         Date   : 2008.06.10 -
   7
   8         [ memory ]
   9 */
  10
  11 #include "./memory.h"
  12
  13 #define SET_BANK(s, e, w, r) { \
  14         int sb = (s) >> 14, eb = (e) >> 14; \
  15         for(int i = sb; i <= eb; i++) { \
  16                 if((w) == wdmy) { \
  17                         wbank[i] = wdmy; \
  18                 } else { \
  19                         wbank[i] = (w) + 0x4000 * (i - sb); \
  20                 } \
  21                 if((r) == rdmy) { \
  22                         rbank[i] = rdmy + 0x4000 * (i & 3); \
  23                 } else { \
  24                         rbank[i] = (r) + 0x4000 * (i - sb); \
  25                 } \
  26         } \
  27 }
  28
  29 void PC98LT_MEMORY::initialize()
  30 {
  31         // init memory
  32         memset(ram, 0, sizeof(ram));
  33         memset(vram, 0, sizeof(vram));
  34         memset(ipl, 0xff, sizeof(ipl));
  35         memset(learn, 0xff, sizeof(learn));
  36         memset(dic, 0xff, sizeof(dic));
  37         memset(kanji, 0xff, sizeof(kanji));
  38         memset(romdrv, 0xff, sizeof(romdrv));
  39 #ifdef _PC98HA
  40         memset(ramdrv, 0, sizeof(ramdrv));
  41         for(int i = 0; i < sizeof(memcard); i++) {
  42                 memcard[i] = ((i & 1) ? (i >> 8) : i) & 0xff;
  43         }
  44 #endif
  45         for(int i = 0; i < sizeof(rdmy); i++) {
  46                 rdmy[i] = ((i & 1) ? (i >> 8) : i) & 0xff;
  47         }
  48
  49         // load rom/ram images
  50         FILEIO* fio = new FILEIO();
  51         if(fio->Fopen(create_local_path(_T("IPL.ROM")), FILEIO_READ_BINARY)) {
  52                 fio->Fread(ipl, sizeof(ipl), 1);
  53                 fio->Fclose();
  54         }
  55         if(fio->Fopen(create_local_path(_T("BACKUP.BIN")), FILEIO_READ_BINARY)) {
  56                 fio->Fread(learn, sizeof(learn), 1);
  57                 fio->Fclose();
  58         }
  59         if(fio->Fopen(create_local_path(_T("DICT.ROM")), FILEIO_READ_BINARY)) {
  60                 fio->Fread(dic, sizeof(dic), 1);
  61                 fio->Fclose();
  62         }
  63         if(fio->Fopen(create_local_path(_T("KANJI.ROM")), FILEIO_READ_BINARY)) {
  64                 fio->Fread(kanji, sizeof(kanji), 1);
  65                 fio->Fclose();
  66         }
  67         if(fio->Fopen(create_local_path(_T("ROMDRV.ROM")), FILEIO_READ_BINARY)) {
  68                 fio->Fread(romdrv, sizeof(romdrv), 1);
  69                 fio->Fclose();
  70         }
  71 #ifdef _PC98HA
  72         if(fio->Fopen(create_local_path(_T("RAMDRV.BIN")), FILEIO_READ_BINARY)) {
  73                 fio->Fread(ramdrv, sizeof(ramdrv), 1);
  74                 fio->Fclose();
  75         }
  76         if(fio->Fopen(create_local_path(_T("MEMCARD.BIN")), FILEIO_READ_BINARY)) {
  77                 fio->Fread(memcard, sizeof(memcard), 1);
  78                 fio->Fclose();
  79         }
  80 #endif
  81         delete fio;
  82
  83         learn_crc32 = get_crc32(learn, sizeof(learn));
  84 #ifdef _PC98HA
  85         ramdrv_crc32 = get_crc32(ramdrv, sizeof(ramdrv));
  86         memcard_crc32 = get_crc32(memcard, sizeof(memcard));
  87 #endif
  88 }
  89
  90 void PC98LT_MEMORY::release()
  91 {
  92         // save ram images
  93         FILEIO* fio = new FILEIO();
  94         if(learn_crc32 != get_crc32(learn, sizeof(learn))) {
  95                 if(fio->Fopen(create_local_path(_T("BACKUP.BIN")), FILEIO_WRITE_BINARY)) {
  96                         fio->Fwrite(learn, sizeof(learn), 1);
  97                         fio->Fclose();
  98                 }
  99         }
 100 #ifdef _PC98HA
 101         if(ramdrv_crc32 != get_crc32(ramdrv, sizeof(ramdrv))) {
 102                 if(fio->Fopen(create_local_path(_T("RAMDRV.BIN")), FILEIO_WRITE_BINARY)) {
 103                         fio->Fwrite(ramdrv, sizeof(ramdrv), 1);
 104                         fio->Fclose();
 105                 }
 106         }
 107         if(memcard_crc32 != get_crc32(memcard, sizeof(memcard))) {
 108                 if(fio->Fopen(create_local_path(_T("MEMCARD.BIN")), FILEIO_WRITE_BINARY)) {
 109                         fio->Fwrite(memcard, sizeof(memcard), 1);
 110                         fio->Fclose();
 111                 }
 112         }
 113 #endif
 114         delete fio;
 115 }
 116
 117 void PC98LT_MEMORY::reset()
 118 {
 119         // set memory bank
 120         learn_bank = dic_bank = kanji_bank = romdrv_bank = 0;
 121 #ifdef _PC98HA
 122         ramdrv_bank = 0;
 123         ramdrv_sel = 0x81;
 124         ems_bank[0] = 0; ems_bank[1] = 1; ems_bank[2] = 2; ems_bank[3] = 3;
 125 #endif
 126         update_bank();
 127 }
 128
 129 void PC98LT_MEMORY::write_data8(uint32_t addr, uint32_t data)
 130 {
 131         addr &= 0xfffff;
 132         wbank[addr >> 14][addr & 0x3fff] = data;
 133 #ifdef _PC98HA
 134         // patch for pcmcia
 135         if(ram[0x59e] == 0x3e) {
 136                 ram[0x59e] &= ~0x20;
 137         }
 138 #endif
 139 }
 140
 141 uint32_t PC98LT_MEMORY::read_data8(uint32_t addr)
 142 {
 143         addr &= 0xfffff;
 144         return rbank[addr >> 14][addr & 0x3fff];
 145 }
 146
 147 void PC98LT_MEMORY::write_io8(uint32_t addr, uint32_t data)
 148 {
 149         switch(addr & 0xffff) {
 150 #ifdef _PC98HA
 151         case 0x8e1:
 152                 ems_bank[0] = data & 0x7f;
 153                 update_bank();
 154                 break;
 155         case 0x8e3:
 156                 ems_bank[1] = data & 0x7f;
 157                 update_bank();
 158                 break;
 159         case 0x8e5:
 160                 ems_bank[2] = data & 0x7f;
 161                 update_bank();
 162                 break;
 163         case 0x8e7:
 164                 ems_bank[3] = data & 0x7f;
 165                 update_bank();
 166                 break;
 167         case 0x0c10:
 168                 learn_bank = data & 0x0f;
 169                 update_bank();
 170                 break;
 171         case 0x0e8e:
 172                 ramdrv_bank = data & 0x7f;
 173                 update_bank();
 174                 break;
 175         case 0x1e8e:
 176                 ramdrv_sel = data;
 177                 update_bank();
 178                 break;
 179         case 0x4c10:
 180                 dic_bank = data & 0x3f;
 181                 update_bank();
 182                 break;
 183         case 0xcc10:
 184                 romdrv_bank = data & 0x0f;
 185                 update_bank();
 186                 break;
 187 #else
 188         case 0x0c10:
 189                 learn_bank = data & 3;
 190                 update_bank();
 191                 break;
 192         case 0x4c10:
 193                 dic_bank = data & 0x1f;
 194                 update_bank();
 195                 break;
 196         case 0xcc10:
 197                 romdrv_bank = data & 7;
 198                 update_bank();
 199                 break;
 200 #endif
 201         case 0x8c10:
 202                 kanji_bank = data & 0x0f;
 203                 update_bank();
 204                 break;
 205         }
 206 }
 207
 208 uint32_t PC98LT_MEMORY::read_io8(uint32_t addr)
 209 {
 210         switch(addr & 0xffff) {
 211         case 0x0c10:
 212                 return learn_bank | 0x40;
 213         case 0x4c10:
 214                 return dic_bank | 0x40;
 215         case 0x8c10:
 216                 return kanji_bank | 0x40;
 217         case 0xcc10:
 218                 return romdrv_bank | 0x40;
 219         }
 220         return 0xff;
 221 }
 222
 223 void PC98LT_MEMORY::update_bank()
 224 {
 225         SET_BANK(0x00000, 0xfffff, wdmy, rdmy);
 226
 227         SET_BANK(0x00000, 0x9ffff, ram, ram);
 228         SET_BANK(0xa8000, 0xaffff, vram, vram);
 229 #ifdef _PC98HA
 230         SET_BANK(0xc0000, 0xc3fff, ems + 0x4000 * ems_bank[0], ems + 0x4000 * ems_bank[0]);
 231         SET_BANK(0xc4000, 0xc7fff, ems + 0x4000 * ems_bank[1], ems + 0x4000 * ems_bank[1]);
 232         SET_BANK(0xc8000, 0xcbfff, ems + 0x4000 * ems_bank[2], ems + 0x4000 * ems_bank[2]);
 233         SET_BANK(0xcc000, 0xcffff, ems + 0x4000 * ems_bank[3], ems + 0x4000 * ems_bank[3]);
 234 #endif
 235         SET_BANK(0xd0000, 0xd3fff, learn + 0x4000 * learn_bank, learn + 0x4000 * learn_bank);
 236         if(dic_bank < 48) {
 237                 SET_BANK(0xd4000, 0xd7fff, wdmy, dic + 0x4000 * dic_bank);
 238         }
 239         SET_BANK(0xd8000, 0xdbfff, wdmy, kanji + 0x4000 * kanji_bank);
 240 #ifdef _PC98HA
 241         if(ramdrv_sel == 0x80) {
 242                 // ???
 243         } else if(ramdrv_sel == 0x81 && ramdrv_bank < 88) {
 244                 SET_BANK(0xdc000, 0xdffff, ramdrv + 0x4000 * ramdrv_bank, ramdrv + 0x4000 * ramdrv_bank);
 245         } else if(ramdrv_sel == 0x82) {
 246                 // memory card
 247                 SET_BANK(0xdc000, 0xdffff, memcard + 0x4000 * ramdrv_bank, memcard + 0x4000 * ramdrv_bank);
 248         }
 249 #endif
 250         if(romdrv_bank < 16) {
 251                 SET_BANK(0xe0000, 0xeffff, wdmy, romdrv + 0x10000 * romdrv_bank);
 252         }
 253         SET_BANK(0xf0000, 0xfffff, wdmy, ipl);
 254 }
 255
 256 void PC98LT_MEMORY::draw_screen()
 257 {
 258         // draw to real screen
 259         scrntype_t cd = RGB_COLOR(48, 56, 16);
 260         scrntype_t cb = RGB_COLOR(160, 168, 160);
 261         int ptr = 0;
 262
 263         for(int y = 0; y < 400; y++) {
 264                 scrntype_t* dest = emu->get_screen_buffer(y);
 265                 for(int x = 0; x < 640; x += 8) {
 266                         uint8_t pat = vram[ptr++];
 267                         dest[x + 0] = (pat & 0x80) ? cd : cb;
 268                         dest[x + 1] = (pat & 0x40) ? cd : cb;
 269                         dest[x + 2] = (pat & 0x20) ? cd : cb;
 270                         dest[x + 3] = (pat & 0x10) ? cd : cb;
 271                         dest[x + 4] = (pat & 0x08) ? cd : cb;
 272                         dest[x + 5] = (pat & 0x04) ? cd : cb;
 273                         dest[x + 6] = (pat & 0x02) ? cd : cb;
 274                         dest[x + 7] = (pat & 0x01) ? cd : cb;
 275                 }
 276         }
 277 }
 278
 279 #define STATE_VERSION   1
 280
 281 bool PC98LT_MEMORY::process_state(FILEIO* state_fio, bool loading)
 282 {
 283         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 284                 return false;
 285         }
 286         if(!state_fio->StateCheckInt32(this_device_id)) {
 287                 return false;
 288         }
 289         state_fio->StateBuffer(ram, sizeof(ram), 1);
 290         state_fio->StateBuffer(vram, sizeof(vram), 1);
 291         state_fio->StateBuffer(learn, sizeof(learn), 1);
 292 #ifdef _PC98HA
 293         state_fio->StateBuffer(ramdrv, sizeof(ramdrv), 1);
 294         state_fio->StateBuffer(ems, sizeof(ems), 1);
 295         state_fio->StateBuffer(memcard, sizeof(memcard), 1);
 296 #endif
 297         state_fio->StateUint32(learn_crc32);
 298 #ifdef _PC98HA
 299         state_fio->StateUint32(ramdrv_crc32);
 300         state_fio->StateUint32(memcard_crc32);
 301 #endif
 302         state_fio->StateUint8(learn_bank);
 303         state_fio->StateUint8(dic_bank);
 304         state_fio->StateUint8(kanji_bank);
 305         state_fio->StateUint8(romdrv_bank);
 306 #ifdef _PC98HA
 307         state_fio->StateUint8(ramdrv_bank);
 308         state_fio->StateUint8(ramdrv_sel);
 309         state_fio->StateBuffer(ems_bank, sizeof(ems_bank), 1);
 310 #endif
 311
 312         // post process
 313         if(loading) {
 314                 update_bank();
 315         }
 316         return true;
 317 }