source/src/vm/pc6001/pc6001.cpp

   1 /*
   2         NEC PC-6001 Emulator 'yaPC-6001'
   3         NEC PC-6001mkII Emulator 'yaPC-6201'
   4         NEC PC-6001mkIISR Emulator 'yaPC-6401'
   5         NEC PC-6601 Emulator 'yaPC-6601'
   6         NEC PC-6601SR Emulator 'yaPC-6801'
   7
   8         Author : tanam
   9         Date   : 2013.07.15-
  10
  11         [ virtual machine ]
  12 */
  13
  14 #include "pc6001.h"
  15 #include "../../emu.h"
  16 #include "../device.h"
  17 #include "../event.h"
  18
  19 #include "../disk.h"
  20 #include "../i8255.h"
  21 #include "../io.h"
  22 #ifdef _PC6001
  23 #include "../mc6847.h"
  24 #include "display.h"
  25 #else
  26 #include "../upd7752.h"
  27 #endif
  28 #include "../noise.h"
  29 #include "../pc6031.h"
  30 #include "../pc80s31k.h"
  31 #include "../prnfile.h"
  32 #include "../upd765a.h"
  33 #if defined(_PC6001MK2SR) || defined(_PC6601SR)
  34 #include "../ym2203.h"
  35 #else
  36 #include "../ay_3_891x.h"
  37 #endif
  38 #include "../z80.h"
  39
  40 #include "../datarec.h"
  41 #include "../mcs48.h"
  42
  43 #ifdef USE_DEBUGGER
  44 #include "../debugger.h"
  45 #endif
  46
  47 #if defined(_PC6601) || defined(_PC6601SR)
  48 #include "floppy.h"
  49 #endif
  50 #include "joystick.h"
  51 #include "memory.h"
  52 #include "psub.h"
  53 #include "sub.h"
  54 #include "timer.h"
  55
  56 // ----------------------------------------------------------------------------
  57 // initialize
  58 // ----------------------------------------------------------------------------
  59
  60 VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
  61 {
  62         support_pc80s31k = FILEIO::IsFileExisting(create_local_path(_T("DISK.ROM")));
  63 #ifdef _PC6601SR
  64         support_sub_cpu = false;
  65 #else
  66         support_sub_cpu = FILEIO::IsFileExisting(create_local_path(_T(SUB_CPU_ROM_FILE_NAME)));
  67 #endif
  68
  69         // create devices
  70         first_device = last_device = NULL;
  71         dummy = new DEVICE(this, emu);  // must be 1st device
  72         event = new EVENT(this, emu);   // must be 2nd device
  73
  74         pio_sub = new I8255(this, emu);
  75         io = new IO(this, emu);
  76         noise_seek = new NOISE(this, emu);
  77         noise_head_down = new NOISE(this, emu);
  78         noise_head_up = new NOISE(this, emu);
  79 #if defined(_PC6001MK2SR) || defined(_PC6601SR)
  80         psg = new YM2203(this, emu);
  81 #else
  82         psg = new AY_3_891X(this, emu);
  83 #endif
  84         cpu = new Z80(this, emu);
  85
  86         if(config.printer_type == 0) {
  87                 printer = new PRNFILE(this, emu);
  88         } else {
  89                 printer = dummy;
  90         }
  91
  92 #if defined(_PC6601) || defined(_PC6601SR)
  93         floppy = new FLOPPY(this, emu);
  94         floppy->set_context_noise_seek(noise_seek);
  95 //      floppy->set_context_noise_head_down(noise_head_down);
  96 //      floppy->set_context_noise_head_up(noise_head_up);
  97 #endif
  98         joystick = new JOYSTICK(this, emu);
  99         memory = new MEMORY(this, emu);
 100         timer = new TIMER(this, emu);
 101
 102         // set contexts
 103         event->set_context_cpu(cpu);
 104         event->set_context_sound(psg);
 105         event->set_context_sound(noise_seek);
 106         event->set_context_sound(noise_head_down);
 107         event->set_context_sound(noise_head_up);
 108
 109         pio_sub->set_context_port_b(printer, SIG_PRINTER_DATA, 0xff, 0);
 110         pio_sub->set_context_port_c(printer, SIG_PRINTER_STROBE, 0x01, 0);
 111         pio_sub->set_context_port_c(memory, SIG_MEMORY_PIO_PORT_C, 0x06, 0);    // CRTKILL,CGSWN
 112
 113 #ifdef _PC6001
 114         display = new DISPLAY(this, emu);
 115         vdp = new MC6847(this, emu);
 116         display->set_context_vdp(vdp);
 117         display->set_vram_ptr(memory->get_vram());
 118         display->set_context_timer(timer);
 119         vdp->load_font_image(create_local_path(_T("CGROM60.60")));
 120         vdp->set_context_cpu(cpu);
 121         pio_sub->set_context_port_c(vdp, SIG_MC6847_ENABLE, 0x02, 0);   // CRTKILL
 122 #else
 123         voice = new UPD7752(this, emu);
 124         event->set_context_sound(voice);
 125         memory->set_context_timer(timer);
 126 #endif
 127         memory->set_context_cpu(cpu);
 128         joystick->set_context_psg(psg);
 129
 130         timer->set_context_cpu(cpu);
 131 #ifndef _PC6001
 132         timer->set_context_memory(memory);
 133 #endif
 134         if(support_sub_cpu) {
 135                 cpu_sub = new MCS48(this, emu);
 136                 cpu_sub->set_device_name(_T("MCS48 MCU (Sub)"));
 137                 sub = new SUB(this, emu);
 138                 drec = new DATAREC(this, emu);
 139                 drec->set_device_name(_T("Data Recorder (Sub)"));
 140                 drec->set_context_noise_play(new NOISE(this, emu));
 141                 drec->set_context_noise_stop(new NOISE(this, emu));
 142                 drec->set_context_noise_fast(new NOISE(this, emu));
 143                 event->set_context_cpu(cpu_sub, 8000000);
 144                 event->set_context_sound(drec);
 145                 event->set_context_sound(drec->get_context_noise_play());
 146                 event->set_context_sound(drec->get_context_noise_stop());
 147                 event->set_context_sound(drec->get_context_noise_fast());
 148                 cpu_sub->set_context_mem(new MCS48MEM(this, emu));
 149                 cpu_sub->set_context_io(sub);
 150 #ifdef USE_DEBUGGER
 151                 cpu_sub->set_context_debugger(new DEBUGGER(this, emu));
 152 #endif
 153                 sub->set_context_pio(pio_sub);
 154                 sub->set_context_drec(drec);
 155                 sub->set_context_timer(timer);
 156                 pio_sub->set_context_port_c(cpu_sub, SIG_CPU_IRQ, 0x80, 0);
 157                 drec->set_context_ear(sub, SIG_SUB_DATAREC, 1);
 158                 timer->set_context_sub(sub);
 159         } else {
 160                 psub = new PSUB(this, emu);
 161                 psub->set_context_pio(pio_sub);
 162                 psub->set_context_timer(timer);
 163                 timer->set_context_sub(psub);
 164                 cpu_sub = NULL;
 165         }
 166         if(support_pc80s31k) {
 167                 pio_fdd = new I8255(this, emu);
 168                 pio_fdd->set_device_name(_T("8255 PIO (FDD I/F)"));
 169                 pio_pc80s31k = new I8255(this, emu);
 170                 pio_pc80s31k->set_device_name(_T("8255 PIO (320KB FDD)"));
 171                 pc80s31k = new PC80S31K(this, emu);
 172                 pc80s31k->set_device_name(_T("PC-80S31K (320KB FDD)"));
 173                 fdc_pc80s31k = new UPD765A(this, emu);
 174                 fdc_pc80s31k->set_device_name(_T("uPD765A FDC (320KB FDD)"));
 175                 cpu_pc80s31k = new Z80(this, emu);
 176                 cpu_pc80s31k->set_device_name(_T("Z80 CPU (320KB FDD)"));
 177
 178                 event->set_context_cpu(cpu_pc80s31k, 4000000);
 179
 180                 pc80s31k->set_context_cpu(cpu_pc80s31k);
 181                 pc80s31k->set_context_fdc(fdc_pc80s31k);
 182                 pc80s31k->set_context_pio(pio_pc80s31k);
 183                 pio_fdd->set_context_port_a(pio_pc80s31k, SIG_I8255_PORT_B, 0xff, 0);
 184                 pio_fdd->set_context_port_b(pio_pc80s31k, SIG_I8255_PORT_A, 0xff, 0);
 185                 pio_fdd->set_context_port_c(pio_pc80s31k, SIG_I8255_PORT_C, 0x0f, 4);
 186                 pio_fdd->set_context_port_c(pio_pc80s31k, SIG_I8255_PORT_C, 0xf0, -4);
 187                 pio_fdd->clear_ports_by_cmdreg = true;
 188                 pio_pc80s31k->set_context_port_a(pio_fdd, SIG_I8255_PORT_B, 0xff, 0);
 189                 pio_pc80s31k->set_context_port_b(pio_fdd, SIG_I8255_PORT_A, 0xff, 0);
 190                 pio_pc80s31k->set_context_port_c(pio_fdd, SIG_I8255_PORT_C, 0x0f, 4);
 191                 pio_pc80s31k->set_context_port_c(pio_fdd, SIG_I8255_PORT_C, 0xf0, -4);
 192                 pio_pc80s31k->clear_ports_by_cmdreg = true;
 193                 fdc_pc80s31k->set_context_irq(cpu_pc80s31k, SIG_CPU_IRQ, 1);
 194                 fdc_pc80s31k->set_context_noise_seek(noise_seek);
 195                 fdc_pc80s31k->set_context_noise_head_down(noise_head_down);
 196                 fdc_pc80s31k->set_context_noise_head_up(noise_head_up);
 197                 cpu_pc80s31k->set_context_mem(pc80s31k);
 198                 cpu_pc80s31k->set_context_io(pc80s31k);
 199                 cpu_pc80s31k->set_context_intr(pc80s31k);
 200 #ifdef USE_DEBUGGER
 201                 cpu_pc80s31k->set_context_debugger(new DEBUGGER(this, emu));
 202 #endif
 203 #if defined(_PC6601) || defined(_PC6601SR)
 204                 floppy->set_context_ext(pio_fdd);
 205 #endif
 206         } else {
 207                 pc6031 = new PC6031(this, emu);
 208                 pc6031->set_context_noise_seek(noise_seek);
 209 //              pc6031->set_context_noise_head_down(noise_head_down);
 210 //              pc6031->set_context_noise_head_up(noise_head_up);
 211 #if defined(_PC6601) || defined(_PC6601SR)
 212                 floppy->set_context_ext(pc6031);
 213 #endif
 214                 cpu_pc80s31k = NULL;
 215         }
 216
 217         // cpu bus
 218         cpu->set_context_mem(memory);
 219         cpu->set_context_io(io);
 220         cpu->set_context_intr(timer);
 221 #ifdef USE_DEBUGGER
 222         cpu->set_context_debugger(new DEBUGGER(this, emu));
 223 #endif
 224
 225         // i/o bus
 226         if(support_sub_cpu) {
 227                 io->set_iomap_range_rw(0x90, 0x93, sub);
 228         } else {
 229                 io->set_iomap_range_rw(0x90, 0x93, psub);
 230         }
 231         io->set_iomap_alias_w(0xa0, psg, 0);                    // PSG ch
 232         io->set_iomap_alias_w(0xa1, psg, 1);                    // PSG data
 233         io->set_iomap_alias_r(0xa2, psg, 1);                    // PSG data
 234 #if defined(_PC6601SR) || defined(_PC6001MK2SR)
 235         io->set_iomap_alias_r(0xa3, psg, 0);                    // FM status
 236         io->set_iomap_range_rw(0x40, 0x6f, memory);             // VRAM addr
 237 #endif
 238 #ifdef _PC6001
 239         io->set_iomap_single_w(0xb0, display);                  // VRAM addr
 240         io->set_iomap_single_w(0x00, memory);                   // MEMORY MAP
 241 #else
 242         io->set_iomap_single_w(0xb0, memory);                   // VRAM addr
 243         io->set_iomap_range_rw(0xc0, 0xcf, memory);             // VRAM addr
 244         io->set_iomap_range_rw(0xe0, 0xe3, voice);              // VOICE
 245 #if defined(_PC6601) || defined(_PC6601SR)
 246         io->set_iomap_range_rw(0xb8, 0xbf, timer);              // IRQ
 247         io->set_iomap_range_rw(0xfa, 0xfb, timer);              // IRQ
 248 #endif
 249         io->set_iomap_range_rw(0xf3, 0xf7, timer);              // IRQ/Timer
 250 #endif
 251
 252 #if defined(_PC6601) || defined(_PC6601SR)
 253         io->set_iomap_range_rw(0xb1, 0xb3, floppy);             // DISK DRIVE
 254         io->set_iomap_range_rw(0xb5, 0xb7, floppy);             // DISK DRIVE (Mirror)
 255         io->set_iomap_range_rw(0xd0, 0xde, floppy);             // DISK DRIVE
 256 #else
 257         io->set_iovalue_single_r(0xb1, 0x01);
 258 #if defined(_PC6601SR)
 259         io->set_iovalue_single_r(0xb2, 0x02);
 260 #elif defined(_PC6001MK2SR)
 261         io->set_iovalue_single_r(0xb2, 0x00);
 262 #endif
 263
 264         if(support_pc80s31k) {
 265                 io->set_iomap_range_rw(0xd0, 0xd2, pio_fdd);
 266                 io->set_iomap_single_w(0xd3, pio_fdd);
 267         } else {
 268                 io->set_iomap_range_rw(0xd0, 0xd3, pc6031);
 269         }
 270 #endif
 271         io->set_iomap_range_rw(0xf0, 0xf2, memory);             // MEMORY MAP
 272
 273         // initialize all devices
 274         for(DEVICE* device = first_device; device; device = device->next_device) {
 275                 device->initialize();
 276         }
 277
 278         if(support_sub_cpu) {
 279                 // load rom images after cpustate is allocated
 280 #ifdef _PC6601SR
 281 #else
 282                 cpu_sub->load_rom_image(create_local_path(_T(SUB_CPU_ROM_FILE_NAME)));
 283 #endif
 284         }
 285         int drive_num = 0;
 286 #if defined(_PC6601) || defined(_PC6601SR)
 287         floppy->get_disk_handler(0)->drive_num = drive_num++;
 288         floppy->get_disk_handler(1)->drive_num = drive_num++;
 289 #endif
 290         if(support_pc80s31k) {
 291                 fdc_pc80s31k->get_disk_handler(0)->drive_num = drive_num++;
 292                 fdc_pc80s31k->get_disk_handler(1)->drive_num = drive_num++;
 293         } else {
 294                 pc6031->get_disk_handler(0)->drive_num = drive_num++;
 295                 pc6031->get_disk_handler(1)->drive_num = drive_num++;
 296         }
 297         decl_state();
 298 }
 299
 300 VM::~VM()
 301 {
 302         // delete all devices
 303         for(DEVICE* device = first_device; device;) {
 304                 DEVICE *next_device = device->next_device;
 305                 device->release();
 306                 delete device;
 307                 device = next_device;
 308         }
 309 }
 310
 311 DEVICE* VM::get_device(int id)
 312 {
 313         for(DEVICE* device = first_device; device; device = device->next_device) {
 314                 if(device->this_device_id == id) {
 315                         return device;
 316                 }
 317         }
 318         return NULL;
 319 }
 320
 321 // ----------------------------------------------------------------------------
 322 // drive virtual machine
 323 // ----------------------------------------------------------------------------
 324 void VM::reset()
 325 {
 326         // reset all devices
 327         for(DEVICE* device = first_device; device; device = device->next_device) {
 328                 device->reset();
 329         }
 330         if(support_pc80s31k) {
 331                 pio_fdd->write_signal(SIG_I8255_PORT_C, 0, 0xff);
 332                 pio_pc80s31k->write_signal(SIG_I8255_PORT_C, 0, 0xff);
 333         }
 334 }
 335
 336 void VM::run()
 337 {
 338         event->drive();
 339 }
 340
 341 // ----------------------------------------------------------------------------
 342 // debugger
 343 // ----------------------------------------------------------------------------
 344
 345 #ifdef USE_DEBUGGER
 346 DEVICE *VM::get_cpu(int index)
 347 {
 348         if(index == 0) {
 349                 return cpu;
 350         } else if(index == 1) {
 351                 return cpu_sub;
 352         } else if(index == 2) {
 353                 return cpu_pc80s31k;
 354         }
 355         return NULL;
 356 }
 357 #endif
 358
 359 // ----------------------------------------------------------------------------
 360 // draw screen
 361 // ----------------------------------------------------------------------------
 362
 363 void VM::draw_screen()
 364 {
 365 #ifdef _PC6001
 366         display->draw_screen();
 367 #else
 368         memory->draw_screen();
 369 #endif
 370 }
 371 // ----------------------------------------------------------------------------
 372 // soud manager
 373 // ----------------------------------------------------------------------------
 374
 375 void VM::initialize_sound(int rate, int samples)
 376 {
 377         // init sound manager
 378         event->initialize_sound(rate, samples);
 379
 380         // init sound gen
 381         psg->initialize_sound(rate, 4000000, samples, 0, 0);
 382 #ifndef _PC6001
 383         voice->initialize_sound(rate);
 384 #endif
 385 }
 386
 387 uint16_t* VM::create_sound(int* extra_frames)
 388 {
 389         return event->create_sound(extra_frames);
 390 }
 391
 392 int VM::get_sound_buffer_ptr()
 393 {
 394         return event->get_sound_buffer_ptr();
 395 }
 396
 397 #ifdef USE_SOUND_VOLUME
 398 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 399 {
 400         if(ch-- == 0) {
 401                 psg->set_volume(1, decibel_l, decibel_r);
 402 #if !defined(_PC6001)
 403         } else if(ch-- == 0) {
 404                 voice->set_volume(0, decibel_l, decibel_r);
 405 #endif
 406         } else if(ch-- == 0) {
 407                 if(support_sub_cpu) {
 408                         drec->set_volume(0, decibel_l, decibel_r);
 409                 }
 410         } else if(ch-- == 0) {
 411                 noise_seek->set_volume(0, decibel_l, decibel_r);
 412                 noise_head_down->set_volume(0, decibel_l, decibel_r);
 413                 noise_head_up->set_volume(0, decibel_l, decibel_r);
 414         } else if(ch-- == 0) {
 415                 if(support_sub_cpu) {
 416                         drec->get_context_noise_play()->set_volume(0, decibel_l, decibel_r);
 417                         drec->get_context_noise_stop()->set_volume(0, decibel_l, decibel_r);
 418                         drec->get_context_noise_fast()->set_volume(0, decibel_l, decibel_r);
 419                 }
 420         }
 421 }
 422 #endif
 423
 424 // ----------------------------------------------------------------------------
 425 // notify key
 426 // ----------------------------------------------------------------------------
 427
 428 void VM::key_down(int code, bool repeat)
 429 {
 430         if(!support_sub_cpu) {
 431                 psub->key_down(code);
 432         }
 433 }
 434
 435 void VM::key_up(int code)
 436 {
 437         if(!support_sub_cpu) {
 438                 psub->key_up(code);
 439         }
 440 }
 441
 442 // ----------------------------------------------------------------------------
 443 // user interface
 444 // ----------------------------------------------------------------------------
 445
 446 void VM::open_cart(int drv, const _TCHAR* file_path)
 447 {
 448         if(drv == 0) {
 449                 memory->open_cart(file_path);
 450                 reset();
 451         }
 452 }
 453
 454 void VM::close_cart(int drv)
 455 {
 456         if(drv == 0) {
 457                 memory->close_cart();
 458                 reset();
 459         }
 460 }
 461
 462 bool VM::is_cart_inserted(int drv)
 463 {
 464         if(drv == 0) {
 465                 return memory->is_cart_inserted();
 466         } else {
 467                 return false;
 468         }
 469 }
 470
 471 void VM::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
 472 {
 473 #if defined(_PC6601) || defined(_PC6601SR)
 474         if(drv < 2) {
 475                 floppy->open_disk(drv, file_path, bank);
 476                 return;
 477         } else {
 478                 drv -= 2;
 479         }
 480 #endif
 481         if(support_pc80s31k) {
 482                 fdc_pc80s31k->open_disk(drv, file_path, bank);
 483         } else {
 484                 pc6031->open_disk(drv, file_path, bank);
 485         }
 486 }
 487
 488 void VM::close_floppy_disk(int drv)
 489 {
 490 #if defined(_PC6601) || defined(_PC6601SR)
 491         if(drv < 2) {
 492                 floppy->close_disk(drv);
 493                 return;
 494         } else {
 495                 drv -= 2;
 496         }
 497 #endif
 498         if(support_pc80s31k) {
 499                 fdc_pc80s31k->close_disk(drv);
 500         } else {
 501                 pc6031->close_disk(drv);
 502         }
 503 }
 504
 505 bool VM::is_floppy_disk_inserted(int drv)
 506 {
 507 #if defined(_PC6601) || defined(_PC6601SR)
 508         if(drv < 2) {
 509                 return floppy->is_disk_inserted(drv);
 510         } else {
 511                 drv -= 2;
 512         }
 513 #endif
 514         if(support_pc80s31k) {
 515                 return fdc_pc80s31k->is_disk_inserted(drv);
 516         } else {
 517                 return pc6031->is_disk_inserted(drv);
 518         }
 519 }
 520
 521 void VM::is_floppy_disk_protected(int drv, bool value)
 522 {
 523 #if defined(_PC6601) || defined(_PC6601SR)
 524         if(drv < 2) {
 525                 floppy->is_disk_protected(drv, value);
 526                 return;
 527         } else {
 528                 drv -= 2;
 529         }
 530 #endif
 531         if(support_pc80s31k) {
 532                 fdc_pc80s31k->is_disk_protected(drv, value);
 533         } else {
 534                 pc6031->is_disk_protected(drv, value);
 535         }
 536 }
 537
 538 bool VM::is_floppy_disk_protected(int drv)
 539 {
 540 #if defined(_PC6601) || defined(_PC6601SR)
 541         if(drv < 2) {
 542                 return floppy->is_disk_protected(drv);
 543         } else {
 544                 drv -= 2;
 545         }
 546 #endif
 547         if(support_pc80s31k) {
 548                 return fdc_pc80s31k->is_disk_protected(drv);
 549         } else {
 550                 return pc6031->is_disk_protected(drv);
 551         }
 552 }
 553
 554 uint32_t VM::is_floppy_disk_accessed()
 555 {
 556         uint32_t status = 0; /// fdc->read_signal(0);
 557         if(support_pc80s31k) {
 558                 status |= fdc_pc80s31k->read_signal(0);
 559         } else {
 560                 status |= pc6031->read_signal(0);
 561         }
 562 #if defined(_PC6601) || defined(_PC6601SR)
 563         status <<= 2;
 564         status |= floppy->read_signal(0);
 565 #endif
 566         return status;
 567 }
 568
 569 void VM::play_tape(int drv, const _TCHAR* file_path)
 570 {
 571         if(support_sub_cpu) {
 572                 // support both p6/p6t and wav
 573                 drec->play_tape(file_path);
 574 //              drec->set_remote(true);
 575         } else {
 576                 // support only p6/p6t
 577                 psub->play_tape(file_path);
 578         }
 579 }
 580
 581 void VM::rec_tape(int drv, const _TCHAR* file_path)
 582 {
 583         if(support_sub_cpu) {
 584                 // support both p6/p6t and wav
 585                 sub->rec_tape(file_path);       // temporary
 586 //              drec->rec_tape(file_path);
 587 //              drec->set_remote(true);
 588         } else {
 589                 // support both p6/p6t and wav
 590                 psub->rec_tape(file_path);
 591         }
 592 }
 593
 594 void VM::close_tape(int drv)
 595 {
 596         if(support_sub_cpu) {
 597                 if(sub->is_tape_inserted()) {
 598                         sub->close_tape();      // temporary
 599                 } else {
 600                         emu->lock_vm();
 601                         drec->close_tape();
 602                         emu->unlock_vm();
 603 //                      drec->set_remote(false);
 604                 }
 605         } else {
 606                 psub->close_tape();
 607         }
 608 }
 609
 610 bool VM::is_tape_inserted(int drv)
 611 {
 612         if(support_sub_cpu) {
 613                 return drec->is_tape_inserted() || sub->is_tape_inserted();
 614         } else {
 615                 return psub->is_tape_inserted();
 616         }
 617 }
 618
 619 bool VM::is_tape_playing(int drv)
 620 {
 621         if(support_sub_cpu) {
 622                 return drec->is_tape_playing();
 623         } else {
 624                 return false;
 625         }
 626 }
 627
 628 bool VM::is_tape_recording(int drv)
 629 {
 630         if(support_sub_cpu) {
 631                 return drec->is_tape_recording();
 632         } else {
 633                 return false;
 634         }
 635 }
 636
 637 int VM::get_tape_position(int drv)
 638 {
 639         if(support_sub_cpu) {
 640                 return drec->get_tape_position();
 641         } else {
 642                 return 0;
 643         }
 644 }
 645
 646 const _TCHAR* VM::get_tape_message(int drv)
 647 {
 648         if(support_sub_cpu) {
 649                 return drec->get_message();
 650         } else {
 651                 return NULL;
 652         }
 653 }
 654
 655 void VM::push_play(int drv)
 656 {
 657         if(support_sub_cpu) {
 658                 drec->set_ff_rew(0);
 659                 drec->set_remote(true);
 660         }
 661 }
 662
 663 void VM::push_stop(int drv)
 664 {
 665         if(support_sub_cpu) {
 666                 drec->set_remote(false);
 667         }
 668 }
 669
 670 void VM::push_fast_forward(int drv)
 671 {
 672         if(support_sub_cpu) {
 673                 drec->set_ff_rew(1);
 674                 drec->set_remote(true);
 675         }
 676 }
 677
 678 void VM::push_fast_rewind(int drv)
 679 {
 680         if(support_sub_cpu) {
 681                 drec->set_ff_rew(-1);
 682                 drec->set_remote(true);
 683         }
 684 }
 685
 686 bool VM::is_frame_skippable()
 687 {
 688         return event->is_frame_skippable();
 689 }
 690
 691 void VM::update_config()
 692 {
 693         for(DEVICE* device = first_device; device; device = device->next_device) {
 694                 device->update_config();
 695         }
 696 }
 697
 698 #define STATE_VERSION   6
 699
 700 #include "../../statesub.h"
 701 #include "../../qt/gui/csp_logger.h"
 702 extern CSP_Logger DLL_PREFIX_I *csp_logger;
 703
 704 void VM::decl_state(void)
 705 {
 706 #if defined(_PC6001)
 707         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6001_HEAD")), csp_logger);
 708 #elif defined(_PC6001MK2)
 709         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6001_MK2_HEAD")), csp_logger);
 710 #elif defined(_PC6001MK2SR)
 711         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6001_MK2_SR_HEAD")), csp_logger);
 712 #elif defined(_PC6601)
 713         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6601_HEAD")), csp_logger);
 714 #elif defined(_PC601SR)
 715         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6601_SR_HEAD")), csp_logger);
 716 #else
 717         state_entry = new csp_state_utils(STATE_VERSION, 0, (_TCHAR *)(_T("CSP::PC_6001_SERIES_HEAD")), csp_logger);
 718 #endif
 719         DECL_STATE_ENTRY_INT32(sr_mode);
 720         for(DEVICE* device = first_device; device; device = device->next_device) {
 721                 device->decl_state();
 722         }
 723 }
 724
 725 void VM::save_state(FILEIO* state_fio)
 726 {
 727         //state_fio->FputUint32(STATE_VERSION);
 728
 729         if(state_entry != NULL) {
 730                 state_entry->save_state(state_fio);
 731         }
 732         for(DEVICE* device = first_device; device; device = device->next_device) {
 733                 device->save_state(state_fio);
 734         }
 735         //state_fio->FputInt32(sr_mode);
 736 }
 737
 738 bool VM::load_state(FILEIO* state_fio)
 739 {
 740         //if(state_fio->FgetUint32() != STATE_VERSION) {
 741         //      return false;
 742         //}
 743         bool mb = false;
 744         if(state_entry != NULL) {
 745                 mb = state_entry->load_state(state_fio);
 746         }
 747         if(!mb) {
 748                 emu->out_debug_log("INFO: HEADER DATA ERROR");
 749                 return false;
 750         }
 751         for(DEVICE* device = first_device; device; device = device->next_device) {
 752                 if(!device->load_state(state_fio)) {
 753                         return false;
 754                 }
 755         }
 756         //sr_mode = state_fio->FgetInt32();
 757         return true;
 758 }
 759