source/src/vm/multi8/memory.cpp

   1 /*
   2         MITSUBISHI Electric MULTI8 Emulator 'EmuLTI8'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.09.15 -
   6
   7         [ memory ]
   8 */
   9
  10 #include "memory.h"
  11 #include "../i8255.h"
  12
  13 #define SET_BANK(s, e, w, r) { \
  14         int sb = (s) >> 12, eb = (e) >> 12; \
  15         for(int i = sb; i <= eb; i++) { \
  16                 if((w) == wdmy) { \
  17                         wbank[i] = wdmy; \
  18                 } else { \
  19                         wbank[i] = (w) + 0x1000 * (i - sb); \
  20                 } \
  21                 if((r) == rdmy) { \
  22                         rbank[i] = rdmy; \
  23                 } else { \
  24                         rbank[i] = (r) + 0x1000 * (i - sb); \
  25                 } \
  26         } \
  27 }
  28
  29 void MEMORY::initialize()
  30 {
  31         // init memory
  32         memset(rom, 0xff, sizeof(rom));
  33         memset(fdc, 0xff, sizeof(fdc));
  34         memset(ram0, 0, sizeof(ram0));
  35         memset(ram1, 0, sizeof(ram1));
  36         memset(vram, 0, sizeof(vram));
  37         memset(rdmy, 0xff, sizeof(rdmy));
  38
  39         // load ipl
  40         FILEIO* fio = new FILEIO();
  41         if(fio->Fopen(create_local_path(_T("BASIC.ROM")), FILEIO_READ_BINARY)) {
  42                 fio->Fread(rom, sizeof(rom), 1);
  43                 fio->Fclose();
  44         }
  45         if(fio->Fopen(create_local_path(_T("FDC.ROM")), FILEIO_READ_BINARY)) {
  46                 fio->Fread(fdc, sizeof(fdc), 1);
  47                 fio->Fclose();
  48
  49                 // 8255 Port A, bit1 = 0 (fdc rom exists)
  50                 d_pio->write_signal(SIG_I8255_PORT_A, 0, 2);
  51         } else {
  52                 // 8255 Port A, bit1 = 1 (fdc rom does not exist)
  53                 d_pio->write_signal(SIG_I8255_PORT_A, 2, 2);
  54         }
  55         delete fio;
  56 }
  57
  58 void MEMORY::reset()
  59 {
  60         map1 = 0xf;
  61         map2 = 0;
  62         update_map();
  63 }
  64
  65 void MEMORY::write_data8(uint32_t addr, uint32_t data)
  66 {
  67         addr &= 0xffff;
  68         if((addr & 0xc000) == 0x8000 && (map1 & 0x10)) {
  69                 uint32_t ptr = addr & 0x3fff;
  70                 // select vram
  71                 if(!(map1 & 1)) {
  72                         vram[0x0000 | ptr] = data;
  73                 }
  74                 if(!(map1 & 2)) {
  75                         vram[0x4000 | ptr] = data;
  76                 }
  77                 if(!(map1 & 4)) {
  78                         vram[0x8000 | ptr] = data;
  79                 }
  80                 if(!(map1 & 8)) {
  81                         vram[0xc000 | ptr] = data;
  82                 }
  83                 return;
  84         }
  85         wbank[addr >> 12][addr & 0xfff] = data;
  86 }
  87
  88 uint32_t MEMORY::read_data8(uint32_t addr)
  89 {
  90         addr &= 0xffff;
  91         if((addr & 0xc000) == 0x8000 && (map1 & 0x10)) {
  92                 uint32_t ptr = addr & 0x3fff;
  93                 // select vram
  94                 uint32_t val = 0xff;
  95                 if(!(map1 & 1)) {
  96                         val &= vram[0x0000 | ptr];
  97                 }
  98                 if(!(map1 & 2)) {
  99                         val &= vram[0x4000 | ptr];
 100                 }
 101                 if(!(map1 & 4)) {
 102                         val &= vram[0x8000 | ptr];
 103                 }
 104                 if(!(map1 & 8)) {
 105                         val &= vram[0xc000 | ptr];
 106                 }
 107                 return val;
 108         }
 109         return rbank[addr >> 12][addr & 0xfff];
 110 }
 111
 112 void MEMORY::write_io8(uint32_t addr, uint32_t data)
 113 {
 114         map2 = data;
 115         update_map();
 116 }
 117
 118 void MEMORY::write_signal(int id, uint32_t data, uint32_t mask)
 119 {
 120         if(id == SIG_MEMORY_I8255_C) {
 121                 map1 = data & mask;
 122                 update_map();
 123         }
 124 }
 125
 126 void MEMORY::update_map()
 127 {
 128         if(map1 & 0x20) {
 129                 SET_BANK(0x0000, 0x7fff, ram0, ram0);
 130                 SET_BANK(0x8000, 0xffff, ram1, ram1);
 131         } else {
 132                 SET_BANK(0x0000, 0x7fff, wdmy, rom);
 133                 if(map2 & 1) {
 134                         SET_BANK(0x6000, 0x6fff, wdmy, fdc);
 135                 }
 136                 SET_BANK(0x8000, 0xffff, ram1, ram1);
 137         }
 138 }
 139
 140 #define STATE_VERSION   1
 141
 142 #include "../../statesub.h"
 143
 144 void MEMORY::decl_state()
 145 {
 146         enter_decl_state(STATE_VERSION);
 147
 148         DECL_STATE_ENTRY_1D_ARRAY(ram0, sizeof(ram0));
 149         DECL_STATE_ENTRY_1D_ARRAY(ram1, sizeof(ram1));
 150         DECL_STATE_ENTRY_1D_ARRAY(vram, sizeof(vram));
 151         DECL_STATE_ENTRY_UINT8(map1);
 152         DECL_STATE_ENTRY_UINT8(map2);
 153
 154         leave_decl_state();
 155 }
 156
 157 void MEMORY::save_state(FILEIO* state_fio)
 158 {
 159         if(state_entry != NULL) {
 160                 state_entry->save_state(state_fio);
 161         }
 162 //      state_fio->FputUint32(STATE_VERSION);
 163 //      state_fio->FputInt32(this_device_id);
 164
 165 //      state_fio->Fwrite(ram0, sizeof(ram0), 1);
 166 //      state_fio->Fwrite(ram1, sizeof(ram1), 1);
 167 //      state_fio->Fwrite(vram, sizeof(vram), 1);
 168 //      state_fio->FputUint8(map1);
 169 //      state_fio->FputUint8(map2);
 170 }
 171
 172 bool MEMORY::load_state(FILEIO* state_fio)
 173 {
 174         bool mb = false;
 175         if(state_entry != NULL) {
 176                 mb = state_entry->load_state(state_fio);
 177         }
 178         if(!mb) {
 179                 return false;
 180         }
 181 //      if(state_fio->FgetUint32() != STATE_VERSION) {
 182 //              return false;
 183 //      }
 184 //      if(state_fio->FgetInt32() != this_device_id) {
 185 //              return false;
 186 //      }
 187 //      state_fio->Fread(ram0, sizeof(ram0), 1);
 188 //      state_fio->Fread(ram1, sizeof(ram1), 1);
 189 //      state_fio->Fread(vram, sizeof(vram), 1);
 190 //      map1 = state_fio->FgetUint8();
 191 //      map2 = state_fio->FgetUint8();
 192
 193         // post process
 194         update_map();
 195         return true;
 196 }
 197
 198 bool MEMORY::process_state(FILEIO* state_fio, bool loading)
 199 {
 200         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 201                 return false;
 202         }
 203         if(!state_fio->StateCheckInt32(this_device_id)) {
 204                 return false;
 205         }
 206         state_fio->StateBuffer(ram0, sizeof(ram0), 1);
 207         state_fio->StateBuffer(ram1, sizeof(ram1), 1);
 208         state_fio->StateBuffer(vram, sizeof(vram), 1);
 209         state_fio->StateUint8(map1);
 210         state_fio->StateUint8(map2);
 211
 212         // post process
 213         if(loading) {
 214                 update_map();
 215         }
 216         return true;
 217 }