source/src/vm/msx/msx.cpp

   1 /*
   2         ASCII MSX1 Emulator 'yaMSX1'
   3         ASCII MSX2 Emulator 'yaMSX2'
   4         Pioneer PX-7 Emulator 'ePX-7'
   5
   6         Author : tanam
   7         Date   : 2013.06.29-
   8
   9         modified by Takeda.Toshiya
  10         modified by umaiboux
  11
  12         [ virtual machine ]
  13 */
  14
  15 #include "msx.h"
  16 #include "../../emu.h"
  17 #include "../device.h"
  18 #include "../event.h"
  19
  20 #include "../datarec.h"
  21 #include "../i8255.h"
  22 #include "../io.h"
  23 #if defined(_PX7)
  24 #include "../ld700.h"
  25 #endif
  26 #include "../noise.h"
  27 #include "../not.h"
  28 //#include "../ym2203.h"
  29 #include "../ay_3_891x.h"
  30 #include "../pcm1bit.h"
  31 #if defined(_MSX2)
  32 #include "../rp5c01.h"
  33 #include "../v99x8.h"
  34 #else
  35 #include "../tms9918a.h"
  36 #endif
  37 #include "../z80.h"
  38
  39 #ifdef USE_DEBUGGER
  40 #include "../debugger.h"
  41 #endif
  42
  43 #include "joystick.h"
  44 #include "keyboard.h"
  45 #include "memory.h"
  46 #if defined(_MSX2)
  47 #include "rtcif.h"
  48 #endif
  49
  50 // ----------------------------------------------------------------------------
  51 // initialize
  52 // ----------------------------------------------------------------------------
  53
  54 VM::VM(EMU* parent_emu) : emu(parent_emu)
  55 {
  56         // create devices
  57         first_device = last_device = NULL;
  58         dummy = new DEVICE(this, emu);  // must be 1st device
  59         event = new EVENT(this, emu);   // must be 2nd device
  60         dummy->set_device_name(_T("1st Dummy"));
  61         event->set_device_name(_T("EVENT"));
  62
  63         drec = new DATAREC(this, emu);
  64         drec->set_context_noise_play(new NOISE(this, emu));
  65         drec->set_context_noise_stop(new NOISE(this, emu));
  66         drec->set_context_noise_fast(new NOISE(this, emu));
  67         pio = new I8255(this, emu);
  68         io = new IO(this, emu);
  69 #if defined(_PX7)
  70         ldp = new LD700(this, emu);
  71 #endif
  72         not_remote = new NOT(this, emu);
  73 //      psg = new YM2203(this, emu);
  74         psg = new AY_3_891X(this, emu);
  75         pcm = new PCM1BIT(this, emu);
  76         not_remote->set_device_name(_T("NOT Gate (REMOTE)"));
  77
  78 #if defined(_MSX2)
  79         rtc = new RP5C01(this, emu);
  80         vdp = new V99X8(this, emu);
  81 #else
  82         vdp = new TMS9918A(this, emu);
  83 #endif
  84         cpu = new Z80(this, emu);
  85         joystick = new JOYSTICK(this, emu);
  86         keyboard = new KEYBOARD(this, emu);
  87         memory = new MEMORY(this, emu);
  88 #if defined(_MSX2)
  89         rtcif = new RTCIF(this, emu);
  90 #endif
  91         slot0 = new SLOT0(this, emu);   // #0: main memory
  92         slot1 = new SLOT1(this, emu);   // #1: rom-cartridge or msx-dos
  93         slot2 = new SLOT2(this, emu);   // #2: fdd-cartridge or p-basic
  94         slot3 = new SLOT3(this, emu);   // #3: rom-cartridge or ram-cartridge
  95
  96         slot0->set_device_name(_T("SLOT#0 MAIN MEMORY"));
  97         slot1->set_device_name(_T("SLOT#1 ROM CARTRIDGE"));
  98         slot2->set_device_name(_T("SLOT#2 FDD CARTRIDGE"));
  99         slot3->set_device_name(_T("SLOT#3 ROM CARTRIDGE"));
 100
 101         // set contexts
 102         event->set_context_cpu(cpu);
 103         event->set_context_sound(psg);
 104         event->set_context_sound(pcm);
 105         event->set_context_sound(drec);
 106 #if defined(_PX7)
 107         event->set_context_sound(ldp);
 108 #endif
 109         event->set_context_sound(drec->get_context_noise_play());
 110         event->set_context_sound(drec->get_context_noise_stop());
 111         event->set_context_sound(drec->get_context_noise_fast());
 112
 113         drec->set_context_ear(psg, SIG_AY_3_891X_PORT_A, 0x80);
 114         pio->set_context_port_a(memory, SIG_MEMORY_SEL, 0xff, 0);
 115         pio->set_context_port_c(keyboard, SIG_KEYBOARD_COLUMN, 0x0f, 0);
 116         pio->set_context_port_c(not_remote, SIG_NOT_INPUT, 0x10, 0);
 117         not_remote->set_context_out(drec, SIG_DATAREC_REMOTE, 1);
 118         pio->set_context_port_c(drec, SIG_DATAREC_MIC, 0x20, 0);
 119         pio->set_context_port_c(pcm, SIG_PCM1BIT_SIGNAL, 0x80, 0);
 120         psg->set_context_port_b(joystick, SIG_JOYSTICK_SEL, 0x40, 0);
 121         vdp->set_context_irq(cpu, SIG_CPU_IRQ, 1);
 122
 123 #if defined(_PX7)
 124         pio->set_context_port_c(slot2, SIG_SLOT2_MUTE, 0x10, 0);
 125         ldp->set_context_exv(slot2, SIG_SLOT2_EXV, 1);
 126         ldp->set_context_ack(slot2, SIG_SLOT2_ACK, 1);
 127         ldp->set_context_sound(psg, SIG_AY_3_891X_PORT_A, 0x80);
 128 #endif
 129         joystick->set_context_psg(psg);
 130 //      keyboard->set_context_cpu(cpu);
 131         keyboard->set_context_pio(pio);
 132         memory->set_context_slot(0, slot0);
 133         memory->set_context_slot(1, slot1);
 134         memory->set_context_slot(2, slot2);
 135         memory->set_context_slot(3, slot3);
 136 #if defined(_MSX2)
 137         rtcif->set_context_rtc(rtc);
 138 #endif
 139 #if defined(_PX7)
 140         slot2->set_context_cpu(cpu);
 141         slot2->set_context_ldp(ldp);
 142         slot2->set_context_vdp(vdp);
 143 #endif
 144
 145         // cpu bus
 146         cpu->set_context_mem(memory);
 147         cpu->set_context_io(io);
 148         cpu->set_context_intr(dummy);
 149 #if !defined(_PX7)
 150         cpu->set_context_bios(memory);
 151 #endif
 152 #ifdef USE_DEBUGGER
 153         cpu->set_context_debugger(new DEBUGGER(this, emu));
 154 #endif
 155
 156         // i/o bus
 157 #ifdef _MSX2
 158         io->set_iomap_range_rw(0xb4, 0xb5, rtcif);
 159         io->set_iomap_range_rw(0x98, 0x9b, vdp);
 160 #else
 161         io->set_iomap_range_rw(0x98, 0x99, vdp);
 162 #endif
 163         io->set_iomap_range_rw(0xa8, 0xab, pio);
 164         io->set_iomap_alias_w(0xa0, psg, 0);    // PSG ch
 165         io->set_iomap_alias_w(0xa1, psg, 1);    // PSG data
 166         io->set_iomap_alias_r(0xa2, psg, 1);    // PSG data
 167         io->set_iomap_range_rw(0xfc, 0xff, memory);
 168
 169         // initialize all devices
 170         for(DEVICE* device = first_device; device; device = device->next_device) {
 171                 device->initialize();
 172         }
 173 }
 174
 175 VM::~VM()
 176 {
 177         // delete all devices
 178         for(DEVICE* device = first_device; device;) {
 179                 DEVICE *next_device = device->next_device;
 180                 device->release();
 181                 delete device;
 182                 device = next_device;
 183         }
 184 }
 185
 186 DEVICE* VM::get_device(int id)
 187 {
 188         for(DEVICE* device = first_device; device; device = device->next_device) {
 189                 if(device->this_device_id == id) {
 190                         return device;
 191                 }
 192         }
 193         return NULL;
 194 }
 195
 196 // ----------------------------------------------------------------------------
 197 // drive virtual machine
 198 // ----------------------------------------------------------------------------
 199
 200 void VM::reset()
 201 {
 202         // reset all devices
 203         for(DEVICE* device = first_device; device; device = device->next_device) {
 204                 device->reset();
 205         }
 206 }
 207
 208 void VM::run()
 209 {
 210         event->drive();
 211 }
 212
 213 // ----------------------------------------------------------------------------
 214 // debugger
 215 // ----------------------------------------------------------------------------
 216
 217 #ifdef USE_DEBUGGER
 218 DEVICE *VM::get_cpu(int index)
 219 {
 220         if(index == 0) {
 221                 return cpu;
 222         }
 223         return NULL;
 224 }
 225 #endif
 226
 227 // ----------------------------------------------------------------------------
 228 // draw screen
 229 // ----------------------------------------------------------------------------
 230
 231 void VM::draw_screen()
 232 {
 233         vdp->draw_screen();
 234 }
 235
 236 // ----------------------------------------------------------------------------
 237 // soud manager
 238 // ----------------------------------------------------------------------------
 239
 240 void VM::initialize_sound(int rate, int samples)
 241 {
 242         // init sound manager
 243         event->initialize_sound(rate, samples);
 244
 245         // init sound gen
 246         psg->initialize_sound(rate, 3579545, samples, 0, 0);
 247         pcm->initialize_sound(rate, 8000);
 248 #if defined(_PX7)
 249         ldp->initialize_sound(rate, samples);
 250 #endif
 251 }
 252
 253 uint16_t* VM::create_sound(int* extra_frames)
 254 {
 255         return event->create_sound(extra_frames);
 256 }
 257
 258 int VM::get_sound_buffer_ptr()
 259 {
 260         return event->get_sound_buffer_ptr();
 261 }
 262
 263 #if defined(_PX7)
 264 void VM::movie_sound_callback(uint8_t *buffer, long size)
 265 {
 266         ldp->movie_sound_callback(buffer, size);
 267 }
 268 #endif
 269
 270 #ifdef USE_SOUND_VOLUME
 271 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 272 {
 273         if(ch-- == 0) {
 274                 psg->set_volume(1, decibel_l, decibel_r);
 275         } else if(ch-- == 0) {
 276                 pcm->set_volume(0, decibel_l, decibel_r);
 277         } else if(ch-- == 0) {
 278                 drec->set_volume(0, decibel_l, decibel_r);
 279 #if defined(_PX7)
 280         } else if(ch-- == 0) {
 281                 ldp->set_volume(0, decibel_l, decibel_r);
 282 #endif
 283         } else if(ch-- == 0) {
 284                 drec->get_context_noise_play()->set_volume(0, decibel_l, decibel_r);
 285                 drec->get_context_noise_stop()->set_volume(0, decibel_l, decibel_r);
 286                 drec->get_context_noise_fast()->set_volume(0, decibel_l, decibel_r);
 287         }
 288 }
 289 #endif
 290
 291 // ----------------------------------------------------------------------------
 292 // user interface
 293 // ----------------------------------------------------------------------------
 294
 295 void VM::open_cart(int drv, const _TCHAR* file_path)
 296 {
 297         if(drv == 0) {
 298                 slot1->open_cart(file_path);
 299         } else {
 300                 slot3->open_cart(file_path);
 301         }
 302         reset();
 303 }
 304
 305 void VM::close_cart(int drv)
 306 {
 307         if(drv == 0) {
 308                 slot1->close_cart();
 309         } else {
 310                 slot3->close_cart();
 311         }
 312         reset();
 313 }
 314
 315 bool VM::is_cart_inserted(int drv)
 316 {
 317         if(drv == 0) {
 318                 return slot1->is_cart_inserted();
 319         } else {
 320                 return slot3->is_cart_inserted();
 321         }
 322 }
 323
 324 void VM::play_tape(int drv, const _TCHAR* file_path)
 325 {
 326         drec->play_tape(file_path);
 327 //      drec->set_remote(true);
 328 }
 329
 330 void VM::rec_tape(int drv, const _TCHAR* file_path)
 331 {
 332         drec->rec_tape(file_path);
 333 //      drec->set_remote(true);
 334 }
 335
 336 void VM::close_tape(int drv)
 337 {
 338         emu->lock_vm();
 339         drec->close_tape();
 340         emu->unlock_vm();
 341 //      drec->set_remote(false);
 342 }
 343
 344 bool VM::is_tape_inserted(int drv)
 345 {
 346         return drec->is_tape_inserted();
 347 }
 348
 349 bool VM::is_tape_playing(int drv)
 350 {
 351         return drec->is_tape_playing();
 352 }
 353
 354 bool VM::is_tape_recording(int drv)
 355 {
 356         return drec->is_tape_recording();
 357 }
 358
 359 int VM::get_tape_position(int drv)
 360 {
 361         return drec->get_tape_position();
 362 }
 363
 364 const _TCHAR* VM::get_tape_message(int drv)
 365 {
 366         return drec->get_message();
 367 }
 368
 369 void VM::push_play(int drv)
 370 {
 371         drec->set_ff_rew(0);
 372         drec->set_remote(true);
 373 }
 374
 375 void VM::push_stop(int drv)
 376 {
 377         drec->set_remote(false);
 378 }
 379
 380 void VM::push_fast_forward(int drv)
 381 {
 382         drec->set_ff_rew(1);
 383         drec->set_remote(true);
 384 }
 385
 386 void VM::push_fast_rewind(int drv)
 387 {
 388         drec->set_ff_rew(-1);
 389         drec->set_remote(true);
 390 }
 391
 392 void VM::load_binary(int drv, const _TCHAR* file_path)
 393 {
 394         if(drv == 0) {
 395                 pac2->open_rampac2(file_path);
 396         }
 397 }
 398
 399 #if defined(_PX7)
 400 void VM::open_laser_disc(int drv, const _TCHAR* file_path)
 401 {
 402         ldp->open_disc(file_path);
 403 }
 404
 405 void VM::close_laser_disc(int drv)
 406 {
 407         ldp->close_disc();
 408 }
 409
 410 bool VM::is_laser_disc_inserted(int drv)
 411 {
 412         return ldp->is_disc_inserted();
 413 }
 414
 415 uint32_t VM::is_laser_disc_accessed()
 416 {
 417         return lpd->read_signal(0);
 418 }
 419 #else
 420 void VM::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
 421 {
 422         memory->open_disk(drv, file_path, bank);
 423 }
 424
 425 void VM::close_floppy_disk(int drv)
 426 {
 427         memory->close_disk(drv);
 428 }
 429
 430 bool VM::is_floppy_disk_inserted(int drv)
 431 {
 432         return memory->is_disk_inserted(drv);
 433 }
 434
 435 void VM::is_floppy_disk_protected(int drv, bool value)
 436 {
 437         memory->is_disk_protected(drv, value);
 438 }
 439
 440 bool VM::is_floppy_disk_protected(int drv)
 441 {
 442         return memory->is_disk_protected(drv);
 443 }
 444
 445 uint32_t VM::is_floppy_disk_accessed()
 446 {
 447         return memory->read_signal(0);
 448 }
 449 #endif
 450
 451 bool VM::is_frame_skippable()
 452 {
 453         return event->is_frame_skippable();
 454 }
 455
 456 void VM::update_config()
 457 {
 458         for(DEVICE* device = first_device; device; device = device->next_device) {
 459                 device->update_config();
 460         }
 461 }
 462
 463 #define STATE_VERSION   4
 464
 465 void VM::save_state(FILEIO* state_fio)
 466 {
 467         state_fio->FputUint32(STATE_VERSION);
 468
 469         for(DEVICE* device = first_device; device; device = device->next_device) {
 470                 device->save_state(state_fio);
 471         }
 472 }
 473
 474 bool VM::load_state(FILEIO* state_fio)
 475 {
 476         if(state_fio->FgetUint32() != STATE_VERSION) {
 477                 return false;
 478         }
 479         for(DEVICE* device = first_device; device; device = device->next_device) {
 480                 if(!device->load_state(state_fio)) {
 481                         return false;
 482                 }
 483         }
 484         return true;
 485 }
 486