source/src/vm/x07/x07.cpp

   1 /*
   2         CANON X-07 Emulator 'eX-07'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2007.12.26 -
   6
   7         [ virtual machine ]
   8 */
   9
  10 #include "x07.h"
  11 #include "../../emu.h"
  12 #include "../device.h"
  13 #include "../event.h"
  14
  15 #include "../beep.h"
  16 #include "../memory.h"
  17 #include "../z80.h"
  18
  19 #ifdef USE_DEBUGGER
  20 #include "../debugger.h"
  21 #endif
  22
  23 #include "io.h"
  24
  25 // ----------------------------------------------------------------------------
  26 // initialize
  27 // ----------------------------------------------------------------------------
  28
  29 VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
  30 {
  31         // create devices
  32         first_device = last_device = NULL;
  33         dummy = new DEVICE(this, emu);  // must be 1st device
  34         event = new EVENT(this, emu);   // must be 2nd device
  35         dummy->set_device_name(_T("1st Dummy"));
  36
  37         beep = new BEEP(this, emu);
  38         memory = new MEMORY(this, emu);
  39         cpu = new Z80(this, emu);
  40
  41         io = new IO(this, emu);
  42         // set contexts
  43         event->set_context_cpu(cpu);
  44         event->set_context_sound(beep);
  45
  46         io->set_context_beep(beep);
  47         io->set_context_cpu(cpu);
  48         io->set_context_mem(memory, ram);
  49
  50         // memory bus
  51         memset(ram, 0, sizeof(ram));
  52         memset(app, 0xff, sizeof(app));
  53         memset(tv, 0xff, sizeof(tv));
  54         memset(bas, 0xff, sizeof(bas));
  55
  56         memory->read_bios(_T("APP.ROM"), app, sizeof(app));
  57         memory->read_bios(_T("TV.ROM"), tv, sizeof(tv));
  58         memory->read_bios(_T("BASIC.ROM"), bas, sizeof(bas));
  59
  60         memory->set_memory_rw(0x0000, 0x5fff, ram);
  61         memory->set_memory_r(0x6000, 0x7fff, app);
  62         memory->set_memory_rw(0x8000, 0x97ff, vram);
  63         memory->set_memory_r(0xa000, 0xafff, tv);
  64         memory->set_memory_r(0xb000, 0xffff, bas);
  65
  66         // cpu bus
  67         cpu->set_context_mem(memory);
  68         cpu->set_context_io(io);
  69         cpu->set_context_intr(io);
  70 #ifdef USE_DEBUGGER
  71         cpu->set_context_debugger(new DEBUGGER(this, emu));
  72 #endif
  73
  74         // initialize all devices
  75 #if defined(__GIT_REPO_VERSION)
  76         strncpy(_git_revision, __GIT_REPO_VERSION, sizeof(_git_revision) - 1);
  77 #endif
  78         for(DEVICE* device = first_device; device; device = device->next_device) {
  79                 device->initialize();
  80         }
  81         decl_state();
  82 }
  83
  84 VM::~VM()
  85 {
  86         // delete all devices
  87         for(DEVICE* device = first_device; device;) {
  88                 DEVICE *next_device = device->next_device;
  89                 device->release();
  90                 delete device;
  91                 device = next_device;
  92         }
  93 }
  94
  95 DEVICE* VM::get_device(int id)
  96 {
  97         for(DEVICE* device = first_device; device; device = device->next_device) {
  98                 if(device->this_device_id == id) {
  99                         return device;
 100                 }
 101         }
 102         return NULL;
 103 }
 104
 105 // ----------------------------------------------------------------------------
 106 // drive virtual machine
 107 // ----------------------------------------------------------------------------
 108
 109 void VM::reset()
 110 {
 111         // reset all devices
 112         for(DEVICE* device = first_device; device; device = device->next_device) {
 113                 device->reset();
 114         }
 115 }
 116
 117 void VM::run()
 118 {
 119         event->drive();
 120 }
 121
 122 // ----------------------------------------------------------------------------
 123 // debugger
 124 // ----------------------------------------------------------------------------
 125
 126 #ifdef USE_DEBUGGER
 127 DEVICE *VM::get_cpu(int index)
 128 {
 129         if(index == 0) {
 130                 return cpu;
 131         }
 132         return NULL;
 133 }
 134 #endif
 135
 136 // ----------------------------------------------------------------------------
 137 // draw screen
 138 // ----------------------------------------------------------------------------
 139
 140 void VM::draw_screen()
 141 {
 142         io->draw_screen();
 143 }
 144
 145 // ----------------------------------------------------------------------------
 146 // soud manager
 147 // ----------------------------------------------------------------------------
 148
 149 void VM::initialize_sound(int rate, int samples)
 150 {
 151         // init sound manager
 152         event->initialize_sound(rate, samples);
 153
 154         // init sound gen
 155         beep->initialize_sound(rate, 1000, 8000);
 156 }
 157
 158 uint16_t* VM::create_sound(int* extra_frames)
 159 {
 160         return event->create_sound(extra_frames);
 161 }
 162
 163 int VM::get_sound_buffer_ptr()
 164 {
 165         return event->get_sound_buffer_ptr();
 166 }
 167
 168 #ifdef USE_SOUND_VOLUME
 169 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 170 {
 171         if(ch == 0) {
 172                 beep->set_volume(0, decibel_l, decibel_r);
 173         }
 174 }
 175 #endif
 176
 177 // ----------------------------------------------------------------------------
 178 // notify key
 179 // ----------------------------------------------------------------------------
 180
 181 void VM::key_down(int code, bool repeat)
 182 {
 183         io->key_down(code);
 184 }
 185
 186 void VM::key_up(int code)
 187 {
 188         io->key_up(code);
 189 }
 190
 191 bool VM::get_caps_locked()
 192 {
 193         return io->get_caps_locked();
 194 }
 195
 196 bool VM::get_kana_locked()
 197 {
 198         return io->get_kana_locked();
 199 }
 200
 201 // ----------------------------------------------------------------------------
 202 // user interface
 203 // ----------------------------------------------------------------------------
 204
 205 void VM::play_tape(int drv, const _TCHAR* file_path)
 206 {
 207         io->play_tape(file_path);
 208 }
 209
 210 void VM::rec_tape(int drv, const _TCHAR* file_path)
 211 {
 212         io->rec_tape(file_path);
 213 }
 214
 215 void VM::close_tape(int drv)
 216 {
 217         io->close_tape();
 218 }
 219
 220 bool VM::is_tape_inserted(int drv)
 221 {
 222         return io->is_tape_inserted();
 223 }
 224
 225 bool VM::is_frame_skippable()
 226 {
 227         return event->is_frame_skippable();
 228 }
 229
 230 void VM::update_config()
 231 {
 232         for(DEVICE* device = first_device; device; device = device->next_device) {
 233                 device->update_config();
 234         }
 235 }
 236
 237 #define STATE_VERSION   2
 238
 239 #include "../../statesub.h"
 240 #include "../../qt/gui/csp_logger.h"
 241 extern CSP_Logger DLL_PREFIX_I *csp_logger;
 242
 243 void VM::decl_state(void)
 244 {
 245
 246         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::X07_HEAD")), csp_logger);
 247         DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
 248         DECL_STATE_ENTRY_1D_ARRAY(vram, sizeof(vram));
 249         for(DEVICE* device = first_device; device; device = device->next_device) {
 250                 device->decl_state();
 251         }
 252 }
 253
 254 void VM::save_state(FILEIO* state_fio)
 255 {
 256         //state_fio->FputUint32(STATE_VERSION);
 257
 258         if(state_entry != NULL) {
 259                 state_entry->save_state(state_fio);
 260         }
 261         for(DEVICE* device = first_device; device; device = device->next_device) {
 262                 device->save_state(state_fio);
 263         }
 264         //state_fio->Fwrite(ram, sizeof(ram), 1);
 265         //state_fio->Fwrite(vram, sizeof(vram), 1);
 266 }
 267
 268 bool VM::load_state(FILEIO* state_fio)
 269 {
 270         //if(state_fio->FgetUint32() != STATE_VERSION) {
 271         //      return false;
 272         //}
 273         bool mb = false;
 274         if(state_entry != NULL) {
 275                 mb = state_entry->load_state(state_fio);
 276         }
 277         if(!mb) {
 278                 emu->out_debug_log("INFO: HEADER DATA ERROR");
 279                 return false;
 280         }
 281         for(DEVICE* device = first_device; device; device = device->next_device) {
 282                 if(!device->load_state(state_fio)) {
 283                         return false;
 284                 }
 285         }
 286         //state_fio->Fread(ram, sizeof(ram), 1);
 287         //state_fio->Fread(vram, sizeof(vram), 1);
 288         return true;
 289 }
 290
 291 bool VM::process_state(FILEIO* state_fio, bool loading)
 292 {
 293         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 294                 return false;
 295         }
 296         for(DEVICE* device = first_device; device; device = device->next_device) {
 297                 const char *name = typeid(*device).name() + 6; // skip "class "
 298                 int len = strlen(name);
 299
 300                 if(!state_fio->StateCheckInt32(len)) {
 301                         return false;
 302                 }
 303                 if(!state_fio->StateCheckBuffer(name, len, 1)) {
 304                         return false;
 305                 }
 306                 if(!device->process_state(state_fio, loading)) {
 307                         return false;
 308                 }
 309         }
 310         state_fio->StateBuffer(ram, sizeof(ram), 1);
 311         state_fio->StateBuffer(vram, sizeof(vram), 1);
 312         return true;
 313 }