source/src/vm/m5/m5.cpp

   1 /*
   2         SORD m5 Emulator 'Emu5'
   3
   4         Author : Takeda.Toshiya
   5         Date   : 2006.08.18 -
   6
   7         [ virtual machine ]
   8 */
   9
  10 #include "m5.h"
  11 #include "../../emu.h"
  12 #include "../device.h"
  13 #include "../event.h"
  14
  15 #include "../datarec.h"
  16 #include "../io.h"
  17 #include "../memory.h"
  18 #include "../noise.h"
  19 #include "../sn76489an.h"
  20 #include "../tms9918a.h"
  21 #include "../z80.h"
  22 #include "../z80ctc.h"
  23
  24 #ifdef USE_DEBUGGER
  25 #include "../debugger.h"
  26 #endif
  27
  28 #include "cmt.h"
  29 #include "keyboard.h"
  30
  31 // ----------------------------------------------------------------------------
  32 // initialize
  33 // ----------------------------------------------------------------------------
  34
  35 VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
  36 {
  37         // create devices
  38         first_device = last_device = NULL;
  39         dummy = new DEVICE(this, emu);  // must be 1st device
  40         event = new EVENT(this, emu);   // must be 2nd device
  41         dummy->set_device_name(_T("1st Dummy"));
  42
  43         drec = new DATAREC(this, emu);
  44         drec->set_context_noise_play(new NOISE(this, emu));
  45         drec->set_context_noise_stop(new NOISE(this, emu));
  46         drec->set_context_noise_fast(new NOISE(this, emu));
  47         io = new IO(this, emu);
  48         memory = new MEMORY(this, emu);
  49         psg = new SN76489AN(this, emu);
  50         vdp = new TMS9918A(this, emu);
  51         cpu = new Z80(this, emu);
  52         ctc = new Z80CTC(this, emu);
  53
  54         cmt = new CMT(this, emu);
  55         key = new KEYBOARD(this, emu);
  56         // set contexts
  57         event->set_context_cpu(cpu);
  58         event->set_context_sound(psg);
  59         event->set_context_sound(drec);
  60         event->set_context_sound(drec->get_context_noise_play());
  61         event->set_context_sound(drec->get_context_noise_stop());
  62         event->set_context_sound(drec->get_context_noise_fast());
  63
  64         drec->set_context_ear(cmt, SIG_CMT_IN, 1);
  65         drec->set_context_end(cmt, SIG_CMT_EOT, 1);
  66         vdp->set_context_irq(ctc, SIG_Z80CTC_TRIG_3, 1);
  67         cmt->set_context_drec(drec);
  68
  69         // cpu bus
  70         cpu->set_context_mem(memory);
  71         cpu->set_context_io(io);
  72         cpu->set_context_intr(ctc);
  73 #ifdef USE_DEBUGGER
  74         cpu->set_context_debugger(new DEBUGGER(this, emu));
  75 #endif
  76
  77         // z80 family daisy chain
  78         ctc->set_context_intr(cpu, 0);
  79
  80         // memory bus
  81         memset(ram, 0, sizeof(ram));
  82         memset(ext, 0, sizeof(ext));
  83         memset(ipl, 0xff, sizeof(ipl));
  84         memset(cart, 0xff, sizeof(cart));
  85
  86         memory->read_bios(_T("IPL.ROM"), ipl, sizeof(ipl));
  87
  88         memory->set_memory_r(0x0000, 0x1fff, ipl);
  89         memory->set_memory_r(0x2000, 0x6fff, cart);
  90         memory->set_memory_rw(0x7000, 0x7fff, ram);
  91         memory->set_memory_rw(0x8000, 0xffff, ext);
  92
  93         // i/o bus
  94         io->set_iomap_range_rw(0x00, 0x03, ctc);
  95         io->set_iomap_range_rw(0x10, 0x11, vdp);
  96         io->set_iomap_single_w(0x20, psg);
  97         io->set_iomap_range_r(0x30, 0x37, key);
  98         io->set_iomap_single_w(0x40, cmt);
  99         io->set_iomap_single_rw(0x50, cmt);
 100
 101         // FD5 floppy drive uint
 102         subcpu = NULL;
 103 #ifdef USE_DEBUGGER
 104 //      subcpu->set_context_debugger(new DEBUGGER(this, emu));
 105 #endif
 106
 107         // initialize all devices
 108         for(DEVICE* device = first_device; device; device = device->next_device) {
 109                 device->initialize();
 110         }
 111         decl_state();
 112         inserted = false;
 113 }
 114
 115 VM::~VM()
 116 {
 117         // delete all devices
 118         for(DEVICE* device = first_device; device;) {
 119                 DEVICE *next_device = device->next_device;
 120                 device->release();
 121                 delete device;
 122                 device = next_device;
 123         }
 124 }
 125
 126 DEVICE* VM::get_device(int id)
 127 {
 128         for(DEVICE* device = first_device; device; device = device->next_device) {
 129                 if(device->this_device_id == id) {
 130                         return device;
 131                 }
 132         }
 133         return NULL;
 134 }
 135
 136 // ----------------------------------------------------------------------------
 137 // drive virtual machine
 138 // ----------------------------------------------------------------------------
 139
 140 void VM::reset()
 141 {
 142         // reset all devices
 143         for(DEVICE* device = first_device; device; device = device->next_device) {
 144                 device->reset();
 145         }
 146 }
 147
 148 void VM::run()
 149 {
 150         event->drive();
 151 }
 152
 153 // ----------------------------------------------------------------------------
 154 // debugger
 155 // ----------------------------------------------------------------------------
 156
 157 #ifdef USE_DEBUGGER
 158 DEVICE *VM::get_cpu(int index)
 159 {
 160         if(index == 0) {
 161                 return cpu;
 162         } else if(index == 1) {
 163                 return subcpu;
 164         }
 165         return NULL;
 166 }
 167 #endif
 168
 169 // ----------------------------------------------------------------------------
 170 // draw screen
 171 // ----------------------------------------------------------------------------
 172
 173 void VM::draw_screen()
 174 {
 175         vdp->draw_screen();
 176 }
 177
 178 // ----------------------------------------------------------------------------
 179 // soud manager
 180 // ----------------------------------------------------------------------------
 181
 182 void VM::initialize_sound(int rate, int samples)
 183 {
 184         // init sound manager
 185         event->initialize_sound(rate, samples);
 186
 187         // init sound gen
 188         psg->initialize_sound(rate, 3579545, 8000);
 189 }
 190
 191 uint16_t* VM::create_sound(int* extra_frames)
 192 {
 193         return event->create_sound(extra_frames);
 194 }
 195
 196 int VM::get_sound_buffer_ptr()
 197 {
 198         return event->get_sound_buffer_ptr();
 199 }
 200
 201 #ifdef USE_SOUND_VOLUME
 202 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 203 {
 204         if(ch == 0) {
 205                 psg->set_volume(0, decibel_l, decibel_r);
 206         } else if(ch == 1) {
 207                 drec->set_volume(0, decibel_l, decibel_r);
 208         } else if(ch == 2) {
 209                 drec->get_context_noise_play()->set_volume(0, decibel_l, decibel_r);
 210                 drec->get_context_noise_stop()->set_volume(0, decibel_l, decibel_r);
 211                 drec->get_context_noise_fast()->set_volume(0, decibel_l, decibel_r);
 212         }
 213 }
 214 #endif
 215
 216 // ----------------------------------------------------------------------------
 217 // user interface
 218 // ----------------------------------------------------------------------------
 219
 220 void VM::open_cart(int drv, const _TCHAR* file_path)
 221 {
 222         if(drv == 0) {
 223                 memset(cart, 0xff, sizeof(cart));
 224                 inserted = memory->read_image(file_path, cart, sizeof(cart));
 225                 reset();
 226         }
 227 }
 228
 229 void VM::close_cart(int drv)
 230 {
 231         if(drv == 0) {
 232                 memset(cart, 0xff, sizeof(cart));
 233                 inserted = false;
 234                 reset();
 235         }
 236 }
 237
 238 bool VM::is_cart_inserted(int drv)
 239 {
 240         if(drv == 0) {
 241                 return inserted;
 242         } else {
 243                 return false;
 244         }
 245 }
 246
 247 void VM::play_tape(int drv, const _TCHAR* file_path)
 248 {
 249         drec->play_tape(file_path);
 250 //      drec->set_remote(true);
 251 }
 252
 253 void VM::rec_tape(int drv, const _TCHAR* file_path)
 254 {
 255         drec->rec_tape(file_path);
 256 //      drec->set_remote(true);
 257 }
 258
 259 void VM::close_tape(int drv)
 260 {
 261         emu->lock_vm();
 262         drec->close_tape();
 263         emu->unlock_vm();
 264 //      drec->set_remote(false);
 265 }
 266
 267 bool VM::is_tape_inserted(int drv)
 268 {
 269         return drec->is_tape_inserted();
 270 }
 271
 272 bool VM::is_tape_playing(int drv)
 273 {
 274         return drec->is_tape_playing();
 275 }
 276
 277 bool VM::is_tape_recording(int drv)
 278 {
 279         return drec->is_tape_recording();
 280 }
 281
 282 int VM::get_tape_position(int drv)
 283 {
 284         return drec->get_tape_position();
 285 }
 286
 287 const _TCHAR* VM::get_tape_message(int drv)
 288 {
 289         return drec->get_message();
 290 }
 291
 292 void VM::push_play(int drv)
 293 {
 294         drec->set_ff_rew(0);
 295         drec->set_remote(true);
 296 }
 297
 298 void VM::push_stop(int drv)
 299 {
 300         drec->set_remote(false);
 301 }
 302
 303 void VM::push_fast_forward(int drv)
 304 {
 305         drec->set_ff_rew(1);
 306         drec->set_remote(true);
 307 }
 308
 309 void VM::push_fast_rewind(int drv)
 310 {
 311         drec->set_ff_rew(-1);
 312         drec->set_remote(true);
 313 }
 314
 315 bool VM::is_frame_skippable()
 316 {
 317         return event->is_frame_skippable();
 318 }
 319
 320 void VM::update_config()
 321 {
 322         for(DEVICE* device = first_device; device; device = device->next_device) {
 323                 device->update_config();
 324         }
 325 }
 326
 327 #define STATE_VERSION   3
 328
 329 #include "../../statesub.h"
 330 #include "../../qt/gui/csp_logger.h"
 331 extern CSP_Logger DLL_PREFIX_I *csp_logger;
 332
 333 void VM::decl_state(void)
 334 {
 335         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::M5_HEAD")), csp_logger);
 336         DECL_STATE_ENTRY_1D_ARRAY(ram, sizeof(ram));
 337         DECL_STATE_ENTRY_1D_ARRAY(ext, sizeof(ext));
 338         DECL_STATE_ENTRY_BOOL(inserted);
 339
 340         for(DEVICE* device = first_device; device; device = device->next_device) {
 341                 device->decl_state();
 342         }
 343 }
 344
 345 void VM::save_state(FILEIO* state_fio)
 346 {
 347         //state_fio->FputUint32(STATE_VERSION);
 348
 349         if(state_entry != NULL) {
 350                 state_entry->save_state(state_fio);
 351         }
 352         for(DEVICE* device = first_device; device; device = device->next_device) {
 353                 device->save_state(state_fio);
 354         }
 355         //state_fio->Fwrite(ram, sizeof(ram), 1);
 356         //state_fio->Fwrite(ext, sizeof(ext), 1);
 357         //state_fio->FputBool(inserted);
 358 }
 359
 360 bool VM::load_state(FILEIO* state_fio)
 361 {
 362         //if(state_fio->FgetUint32() != STATE_VERSION) {
 363         //      return false;
 364         //}
 365         bool mb = false;
 366         if(state_entry != NULL) {
 367                 mb = state_entry->load_state(state_fio);
 368         }
 369         if(!mb) {
 370                 emu->out_debug_log("INFO: HEADER DATA ERROR");
 371                 return false;
 372         }
 373         for(DEVICE* device = first_device; device; device = device->next_device) {
 374                 if(!device->load_state(state_fio)) {
 375                         return false;
 376                 }
 377         }
 378         //state_fio->Fread(ram, sizeof(ram), 1);
 379         //state_fio->Fread(ext, sizeof(ext), 1);
 380         //inserted = state_fio->FgetBool();
 381         return true;
 382 }
 383