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