source/src/vm/x1/x1.cpp

   1 /*
   2         SHARP X1 Emulator 'eX1'
   3         SHARP X1twin Emulator 'eX1twin'
   4         SHARP X1turbo Emulator 'eX1turbo'
   5         SHARP X1turboZ Emulator 'eX1turboZ'
   6
   7         Author : Takeda.Toshiya
   8         Date   : 2009.03.11-
   9
  10         [ virtual machine ]
  11 */
  12
  13 #include "x1.h"
  14 #include "../../emu.h"
  15 #include "../device.h"
  16 #include "../event.h"
  17
  18 #include "../datarec.h"
  19 #include "../disk.h"
  20 #include "../harddisk.h"
  21 #include "../hd46505.h"
  22 #include "../i8255.h"
  23 #include "../io.h"
  24 #include "../mb8877.h"
  25 #include "../mz1p17.h"
  26 #include "../noise.h"
  27 //#include "../pcpr201.h"
  28 #include "../prnfile.h"
  29 #include "../scsi_hdd.h"
  30 #include "../scsi_host.h"
  31 #include "../ym2151.h"
  32 //#include "../ym2203.h"
  33 #include "../ay_3_891x.h"
  34 #include "../z80.h"
  35 #include "../z80ctc.h"
  36 #include "../z80sio.h"
  37 #ifdef _X1TURBO_FEATURE
  38 #include "../z80dma.h"
  39 #endif
  40
  41 #ifdef USE_DEBUGGER
  42 #include "../debugger.h"
  43 #endif
  44
  45 #include "display.h"
  46 #include "emm.h"
  47 #include "floppy.h"
  48 #include "iobus.h"
  49 #include "joystick.h"
  50 #include "memory.h"
  51 #include "mouse.h"
  52 #include "psub.h"
  53 #include "sasi.h"
  54
  55 #include "../mcs48.h"
  56 #include "../upd1990a.h"
  57 #include "sub.h"
  58 #include "keyboard.h"
  59
  60 #ifdef _X1TWIN
  61 #include "../huc6280.h"
  62 #include "../pcengine/pce.h"
  63 #endif
  64 #if defined(Q_OS_WIN)
  65 DLL_PREFIX_I struct cur_time_s cur_time;
  66 #endif
  67
  68 // ----------------------------------------------------------------------------
  69 // initialize
  70 // ----------------------------------------------------------------------------
  71
  72 VM::VM(EMU* parent_emu) : VM_TEMPLATE(parent_emu)
  73 {
  74         pseudo_sub_cpu = !(FILEIO::IsFileExisting(create_local_path(SUB_ROM_FILE_NAME)) && FILEIO::IsFileExisting(create_local_path(KBD_ROM_FILE_NAME)));
  75
  76         sound_type = config.sound_type;
  77
  78         // create devices
  79         first_device = last_device = NULL;
  80         dummy = new DEVICE(this, emu);  // must be 1st device
  81         event = new EVENT(this, emu);   // must be 2nd device
  82         dummy->set_device_name(_T("1st Dummy"));
  83
  84         drec = new DATAREC(this, emu);
  85         drec->set_context_noise_play(new NOISE(this, emu));
  86         drec->set_context_noise_stop(new NOISE(this, emu));
  87         drec->set_context_noise_fast(new NOISE(this, emu));
  88         crtc = new HD46505(this, emu);
  89         pio = new I8255(this, emu);
  90         io = new IO(this, emu);
  91         fdc = new MB8877(this, emu);
  92         fdc->set_context_noise_seek(new NOISE(this, emu));
  93         fdc->set_context_noise_head_down(new NOISE(this, emu));
  94         fdc->set_context_noise_head_up(new NOISE(this, emu));
  95         sasi_host = new SCSI_HOST(this, emu);
  96         for (int i = 0; i < array_length(sasi_hdd); i++) {
  97                 sasi_hdd[i] = new SASI_HDD(this, emu);
  98                 sasi_hdd[i]->set_device_name(_T("SASI Hard Disk Drive #%d"), i + 1);
  99                 sasi_hdd[i]->scsi_id = i;
 100                 sasi_hdd[i]->bytes_per_sec = 32 * 1024; // 32KB/s
 101                 sasi_hdd[i]->set_context_interface(sasi_host);
 102                 sasi_host->set_context_target(sasi_hdd[i]);
 103         }
 104         for(int drv = 0; drv < USE_HARD_DISK; drv++) {
 105                 sasi_hdd[drv >> 1]->set_disk_handler(drv & 1, new HARDDISK(emu));
 106         }
 107 //      psg = new YM2203(this, emu);
 108         psg = new AY_3_891X(this, emu);
 109         cpu = new Z80(this, emu);
 110         ctc = new Z80CTC(this, emu);
 111         sio = new Z80SIO(this, emu);
 112         if(sound_type >= 1) {
 113                 opm1 = new YM2151(this, emu);
 114                 opm1->set_device_name(_T("YM2151 OPM (CZ-8BS1 #1)"));
 115                 ctc1 = new Z80CTC(this, emu);
 116                 ctc1->set_device_name(_T("Z80 CTC (CZ-8BS1 #1)"));
 117         }
 118         if(sound_type == 2) {
 119                 opm2 = new YM2151(this, emu);
 120                 opm2->set_device_name(_T("YM2151 OPM (CZ-8BS1 #2)"));
 121                 ctc2 = new Z80CTC(this, emu);
 122                 ctc2->set_device_name(_T("Z80 CTC (CZ-8BS1 #2)"));
 123         }
 124         if(config.printer_type == 0) {
 125                 printer = new PRNFILE(this, emu);
 126         } else if(config.printer_type == 1) {
 127                 printer = new MZ1P17(this, emu);
 128 //      } else if(config.printer_type == 2) {
 129 //              printer = new PCPR201(this, emu);
 130         } else {
 131                 printer = dummy;
 132         }
 133 #ifdef _X1TURBO_FEATURE
 134         dma = new Z80DMA(this, emu);
 135 #endif
 136
 137         display = new DISPLAY(this, emu);
 138         emm = new EMM(this, emu);
 139         floppy = new FLOPPY(this, emu);
 140         iobus = new IOBUS(this, emu);
 141         joy = new JOYSTICK(this, emu);
 142         memory = new MEMORY(this, emu);
 143         mouse = new MOUSE(this, emu);
 144         sasi = new SASI(this, emu);
 145
 146         if(pseudo_sub_cpu) {
 147                 psub = new PSUB(this, emu);
 148                 cpu_sub = NULL;
 149                 cpu_kbd = NULL;
 150         } else {
 151                 // sub cpu
 152                 cpu_sub = new MCS48(this, emu);
 153                 cpu_sub->set_device_name(_T("MCS48 MCU (Sub)"));
 154                 pio_sub = new I8255(this, emu);
 155                 pio_sub->set_device_name(_T("i8255 PIO (Sub)"));
 156                 rtc_sub = new UPD1990A(this, emu);
 157                 rtc_sub->set_device_name(_T("uPD1990A RTC (Sub)"));
 158                 sub = new SUB(this, emu);
 159
 160                 // keyboard
 161                 cpu_kbd = new MCS48(this, emu);
 162                 cpu_kbd->set_device_name(_T("MCS48 MCU (Keyboard)"));
 163                 kbd = new KEYBOARD(this, emu);
 164         }
 165
 166         // set contexts
 167         event->set_context_cpu(cpu);
 168         if(!pseudo_sub_cpu) {
 169                 event->set_context_cpu(cpu_sub, 6000000);
 170                 event->set_context_cpu(cpu_kbd, 6000000);
 171         }
 172         if(sound_type >= 1) {
 173                 event->set_context_sound(opm1);
 174         }
 175         if(sound_type == 2) {
 176                 event->set_context_sound(opm2);
 177         }
 178         event->set_context_sound(psg);
 179         event->set_context_sound(drec);
 180         event->set_context_sound(fdc->get_context_noise_seek());
 181         event->set_context_sound(fdc->get_context_noise_head_down());
 182         event->set_context_sound(fdc->get_context_noise_head_up());
 183         event->set_context_sound(drec->get_context_noise_play());
 184         event->set_context_sound(drec->get_context_noise_stop());
 185         event->set_context_sound(drec->get_context_noise_fast());
 186
 187         drec->set_context_ear(pio, SIG_I8255_PORT_B, 0x02);
 188         crtc->set_context_vblank(display, SIG_DISPLAY_VBLANK, 1);
 189         crtc->set_context_disp(display, SIG_DISPLAY_DISP, 1);
 190         crtc->set_context_vblank(pio, SIG_I8255_PORT_B, 0x80);
 191         crtc->set_context_vsync(pio, SIG_I8255_PORT_B, 0x04);
 192         pio->set_context_port_a(printer, SIG_PRINTER_DATA, 0xff, 0);
 193         pio->set_context_port_c(drec, SIG_DATAREC_MIC, 0x01, 0);
 194         pio->set_context_port_c(display, SIG_DISPLAY_COLUMN40, 0x40, 0);
 195         pio->set_context_port_c(iobus, SIG_IOBUS_MODE, 0x60, 0);
 196         pio->set_context_port_c(printer, SIG_PRINTER_STROBE, 0x80, 0);
 197 #ifdef _X1TURBO_FEATURE
 198         fdc->set_context_drq(dma, SIG_Z80DMA_READY, 1);
 199 #endif
 200         sasi_host->set_context_irq(sasi, SIG_SASI_IRQ, 1);
 201         sasi_host->set_context_drq(sasi, SIG_SASI_DRQ, 1);
 202         ctc->set_context_zc0(ctc, SIG_Z80CTC_TRIG_3, 1);
 203         ctc->set_context_zc1(sio, SIG_Z80SIO_TX_CLK_CH0, 1);
 204         ctc->set_context_zc1(sio, SIG_Z80SIO_RX_CLK_CH0, 1);
 205         ctc->set_context_zc2(sio, SIG_Z80SIO_TX_CLK_CH1, 1);
 206         ctc->set_context_zc2(sio, SIG_Z80SIO_RX_CLK_CH1, 1);
 207         ctc->set_constant_clock(1, CPU_CLOCKS >> 1);
 208         ctc->set_constant_clock(2, CPU_CLOCKS >> 1);
 209         sio->set_context_rts(1, mouse, SIG_MOUSE_RTS, 1);
 210 //      sio->set_tx_clock(0, 9600 * 16);        // 9600 baud for RS-232C
 211 //      sio->set_rx_clock(0, 9600 * 16);        // clock is from Z-80CTC ch1 (2MHz/13)
 212 //      sio->set_tx_clock(1, 4800 * 16);        // 4800 baud for mouse
 213 //      sio->set_rx_clock(1, 4800 * 16);        // clock is from Z-80CTC ch2 (2MHz/26)
 214
 215         if(sound_type >= 1) {
 216                 ctc1->set_context_zc0(ctc1, SIG_Z80CTC_TRIG_3, 1);
 217 //              ctc1->set_constant_clock(1, CPU_CLOCKS >> 1);
 218 //              ctc1->set_constant_clock(2, CPU_CLOCKS >> 1);
 219         }
 220         if(sound_type == 2) {
 221                 ctc2->set_context_zc0(ctc2, SIG_Z80CTC_TRIG_3, 1);
 222 //              ctc2->set_constant_clock(1, CPU_CLOCKS >> 1);
 223 //              ctc2->set_constant_clock(2, CPU_CLOCKS >> 1);
 224         }
 225         if(config.printer_type == 0) {
 226                 PRNFILE *prnfile = (PRNFILE *)printer;
 227                 prnfile->set_context_busy(pio, SIG_I8255_PORT_B, 0x08);
 228         } else if(config.printer_type == 1) {
 229                 MZ1P17 *mz1p17 = (MZ1P17 *)printer;
 230                 mz1p17->mode = MZ1P17_MODE_X1;
 231                 mz1p17->set_context_busy(pio, SIG_I8255_PORT_B, 0x08);
 232 //      } else if(config.printer_type == 2) {
 233 //              PCPR201 *pcpr201 = (PCPR201 *)printer;
 234 //              pcpr201->set_context_busy(pio, SIG_I8255_PORT_B, 0x08);
 235         }
 236 #ifdef _X1TURBO_FEATURE
 237         dma->set_context_memory(memory);
 238         dma->set_context_io(iobus);
 239 #endif
 240
 241 #ifdef _X1TURBO_FEATURE
 242         display->set_context_cpu(cpu);
 243 #endif
 244         display->set_context_crtc(crtc);
 245         display->set_vram_ptr(iobus->get_vram());
 246         display->set_regs_ptr(crtc->get_regs());
 247         floppy->set_context_fdc(fdc);
 248         iobus->set_context_cpu(cpu);
 249         iobus->set_context_display(display);
 250         iobus->set_context_io(io);
 251         joy->set_context_psg(psg);
 252 #ifdef _X1TURBO_FEATURE
 253         memory->set_context_pio(pio);
 254 #endif
 255         mouse->set_context_sio(sio);
 256         sasi->set_context_host(sasi_host);
 257 #ifdef _X1TURBO_FEATURE
 258         sasi->set_context_dma(dma);
 259 #endif
 260
 261         if(pseudo_sub_cpu) {
 262                 drec->set_context_remote(psub, SIG_PSUB_TAPE_REMOTE, 1);
 263                 drec->set_context_end(psub, SIG_PSUB_TAPE_END, 1);
 264                 psub->set_context_pio(pio);
 265                 psub->set_context_drec(drec);
 266         } else {
 267                 // sub cpu
 268                 cpu_sub->set_context_mem(new MCS48MEM(this, emu));
 269                 cpu_sub->set_context_io(sub);
 270 #ifdef USE_DEBUGGER
 271                 cpu_sub->set_context_debugger(new DEBUGGER(this, emu));
 272 #endif
 273                 drec->set_context_end(sub, SIG_SUB_TAPE_END, 1);
 274                 drec->set_context_apss(sub, SIG_SUB_TAPE_APSS, 1);
 275                 pio_sub->set_context_port_c(sub, SIG_SUB_PIO_PORT_C, 0x80, 0);
 276                 // pc1:break -> pb0 of 8255(main)
 277                 pio_sub->set_context_port_c(pio, SIG_I8255_PORT_B, 0x02, -1);
 278                 // pc5:ibf -> pb6 of 8255(main)
 279                 pio_sub->set_context_port_c(pio, SIG_I8255_PORT_B, 0x20, 1);
 280                 // pc7:obf -> pb5 of 8255(main)
 281                 pio_sub->set_context_port_c(pio, SIG_I8255_PORT_B, 0x80, -2);
 282                 // pc7:obf -> pb7 of 8255(sub)
 283                 pio_sub->set_context_port_c(pio_sub, SIG_I8255_PORT_B, 0x80, 0);
 284
 285                 sub->set_context_pio(pio_sub);
 286                 sub->set_context_rtc(rtc_sub);
 287                 sub->set_context_drec(drec);
 288
 289                 // keyboard
 290                 cpu_kbd->set_context_mem(new MCS48MEM(this, emu));
 291                 cpu_kbd->set_context_io(kbd);
 292 #ifdef USE_DEBUGGER
 293                 cpu_kbd->set_context_debugger(new DEBUGGER(this, emu));
 294 #endif
 295                 kbd->set_context_cpu(cpu_sub);
 296         }
 297
 298         // cpu bus
 299         cpu->set_context_mem(memory);
 300         cpu->set_context_io(iobus);
 301 #if defined(_X1TURBO_FEATURE) && defined(SINGLE_MODE_DMA)
 302         cpu->set_context_dma(dma);
 303 #endif
 304 #ifdef USE_DEBUGGER
 305         cpu->set_context_debugger(new DEBUGGER(this, emu));
 306 #endif
 307
 308         // z80 family daisy chain
 309         DEVICE* parent_dev = NULL;
 310         int level = 0;
 311
 312         #define Z80_DAISY_CHAIN(dev) { \
 313                 if(parent_dev == NULL) { \
 314                         cpu->set_context_intr(dev); \
 315                 } else { \
 316                         parent_dev->set_context_child(dev); \
 317                 } \
 318                 dev->set_context_intr(cpu, level++); \
 319                 parent_dev = dev; \
 320         }
 321 #ifndef _X1TURBO_FEATURE
 322         Z80_DAISY_CHAIN(sio);   // CZ-8BM2
 323         Z80_DAISY_CHAIN(ctc);
 324 #endif
 325         if(sound_type >= 1) {
 326                 Z80_DAISY_CHAIN(ctc1);
 327         }
 328         if(sound_type == 2) {
 329                 Z80_DAISY_CHAIN(ctc2);
 330         }
 331 #ifdef _X1TURBO_FEATURE
 332         Z80_DAISY_CHAIN(sio);
 333         Z80_DAISY_CHAIN(dma);
 334         Z80_DAISY_CHAIN(ctc);
 335 #endif
 336         if(pseudo_sub_cpu) {
 337                 Z80_DAISY_CHAIN(psub);
 338         } else {
 339                 Z80_DAISY_CHAIN(sub);
 340         }
 341
 342         // i/o bus
 343         if(sound_type >= 1) {
 344                 io->set_iomap_single_w(0x700, opm1);
 345                 io->set_iovalue_single_r(0x700, 0x00);
 346                 io->set_iomap_single_rw(0x701, opm1);
 347 #ifdef _X1TURBOZ
 348                 io->set_flipflop_single_rw(0x704, 0x00);
 349 #else
 350                 io->set_iomap_range_rw(0x704, 0x707, ctc1);
 351 #endif
 352         }
 353         if(sound_type == 2) {
 354                 io->set_iomap_single_w(0x708, opm2);
 355                 io->set_iovalue_single_r(0x708, 0x00);
 356                 io->set_iomap_single_rw(0x709, opm2);
 357                 io->set_iomap_range_rw(0x70c, 0x70f, ctc2);
 358         }
 359 #ifdef _X1TURBO_FEATURE
 360         io->set_iomap_single_rw(0xb00, memory);
 361 #endif
 362         io->set_iomap_range_rw(0xd00, 0xd03, emm);
 363         io->set_iomap_range_r(0xe80, 0xe81, display);
 364         io->set_iomap_range_w(0xe80, 0xe82, display);
 365         io->set_iomap_range_rw(0xfd0, 0xfd3, sasi);
 366         io->set_iomap_range_rw(0xff8, 0xffb, fdc);
 367         io->set_iomap_single_w(0xffc, floppy);
 368 #ifdef _X1TURBO_FEATURE
 369         io->set_iomap_range_r(0xffc, 0xfff, floppy);
 370 #endif
 371         io->set_iomap_range_rw(0x1000, 0x17ff, display);
 372         for(int i = 0x1800; i <= 0x18ff; i += 0x10) {
 373                 io->set_iomap_range_rw(i, i + 1, crtc);
 374         }
 375         if(pseudo_sub_cpu) {
 376                 io->set_iomap_range_rw(0x1900, 0x19ff, psub);
 377         } else {
 378                 io->set_iomap_range_rw(0x1900, 0x19ff, sub);
 379         }
 380         for(int i = 0x1a00; i <= 0x1aff; i += 4) {
 381                 io->set_iomap_range_rw(i, i + 3, pio);
 382         }
 383         for(int i = 0x1b00; i <= 0x1bff; i++) {
 384                 io->set_iomap_alias_rw(i, psg, 1);
 385         }
 386         for(int i = 0x1c00; i <= 0x1cff; i++) {
 387                 io->set_iomap_alias_w(i, psg, 0);
 388         }
 389         io->set_iomap_range_r(0x1e00, 0x1eff, memory);
 390         io->set_iomap_range_w(0x1d00, 0x1eff, memory);
 391 #ifdef _X1TURBO_FEATURE
 392         io->set_iomap_range_rw(0x1f80, 0x1f8f, dma);
 393         io->set_iomap_range_rw(0x1f90, 0x1f93, sio);
 394         io->set_iomap_range_rw(0x1fa0, 0x1fa3, ctc);
 395 #ifdef _X1TURBOZ
 396         io->set_iomap_single_rw(0x1fb0, display);
 397         io->set_iomap_range_rw(0x1fb9, 0x1fc5, display);
 398         io->set_iomap_single_rw(0x1fd0, display);
 399         io->set_iomap_single_rw(0x1fe0, display);
 400 #else
 401         io->set_iomap_single_w(0x1fd0, display);
 402         io->set_iomap_single_w(0x1fe0, display);
 403 #endif
 404         // 0x1ff0: dipswitch
 405 //      io->set_iovalue_single_r(0x1ff0, 0x00);
 406         update_dipswitch();
 407 #else
 408         io->set_iomap_range_rw(0x1f98, 0x1f9b, sio);    // CZ-8BM2
 409         io->set_iomap_range_rw(0x1fa8, 0x1fab, ctc);
 410 #endif
 411         io->set_iomap_range_rw(0x2000, 0x3fff, display);        // tvram
 412
 413 #ifdef _X1TWIN
 414         // init PC Engine
 415         pceevent = new EVENT(this, emu);
 416         pceevent->set_frames_per_sec(PCE_FRAMES_PER_SEC);
 417         pceevent->set_lines_per_frame(PCE_LINES_PER_FRAME);
 418         pceevent->set_device_name(_T("EVENT (PC-ENGINE)"));
 419         pcecpu = new HUC6280(this, emu);
 420         pcecpu->set_device_name(_T("HuC6820 CPU (PC-ENGINE)"));
 421         pcecpu->set_context_event_manager(pceevent);
 422         pce = new PCE(this, emu);
 423         pce->set_device_name(_T("SUB SYSTEM (PC-ENGINE)"));
 424         pce->set_context_event_manager(pceevent);
 425
 426         pceevent->set_context_cpu(pcecpu, PCE_CPU_CLOCKS);
 427         pceevent->set_context_sound(pce);
 428
 429         pcecpu->set_context_mem(pce);
 430         pcecpu->set_context_io(pce);
 431 #ifdef USE_DEBUGGER
 432         pcecpu->set_context_debugger(new DEBUGGER(this, emu));
 433 #endif
 434         pce->set_context_cpu(pcecpu);
 435 #endif
 436
 437         // initialize all devices
 438 #if defined(__GIT_REPO_VERSION)
 439         strncpy(_git_revision, __GIT_REPO_VERSION, sizeof(_git_revision) - 1);
 440 #endif
 441         for(DEVICE* device = first_device; device; device = device->next_device) {
 442                 device->initialize();
 443         }
 444         if(!pseudo_sub_cpu) {
 445                 // load rom images after cpustate is allocated
 446                 cpu_sub->load_rom_image(create_local_path(SUB_ROM_FILE_NAME));
 447                 cpu_kbd->load_rom_image(create_local_path(KBD_ROM_FILE_NAME));
 448
 449                 // patch to set the current year
 450                 uint8_t *rom = cpu_sub->get_rom_ptr();
 451                 sub->rom_crc32 = get_crc32(rom, 0x800); // 2KB
 452                 if(rom[0x23] == 0xb9 && rom[0x24] == 0x35 && rom[0x25] == 0xb1) {
 453                         //dll_cur_time_t cur_time;
 454                         cur_time_t cur_time;
 455                         get_host_time(&cur_time);
 456                         rom[0x26] = TO_BCD(cur_time.year);
 457                 }
 458         }
 459         for(int drv = 0; drv < MAX_DRIVE; drv++) {
 460 //#ifdef _X1TURBO_FEATURE
 461 //              if(config.drive_type == 2) {
 462 //                      fdc->set_drive_type(drv, DRIVE_TYPE_2HD);
 463 //              } else
 464 ///#ndif
 465                 fdc->set_drive_type(drv, DRIVE_TYPE_2D);
 466 //              fdc->set_drive_rpm(drv, 300);
 467 //              fdc->set_drive_mfm(drv, true);
 468         }
 469         for(int drv = 0; drv < USE_HARD_DISK; drv++) {
 470                 if(!(config.last_hard_disk_path[drv][0] != _T('\0') && FILEIO::IsFileExisting(config.last_hard_disk_path[drv]))) {
 471                         create_local_path(config.last_hard_disk_path[drv], _MAX_PATH, _T("SASI%d.DAT"), drv);
 472                 }
 473         }
 474 }
 475
 476 VM::~VM()
 477 {
 478         // delete all devices
 479         for(DEVICE* device = first_device; device;) {
 480                 DEVICE *next_device = device->next_device;
 481                 device->release();
 482                 delete device;
 483                 device = next_device;
 484         }
 485 }
 486
 487 DEVICE* VM::get_device(int id)
 488 {
 489         for(DEVICE* device = first_device; device; device = device->next_device) {
 490                 if(device->this_device_id == id) {
 491                         return device;
 492                 }
 493         }
 494         return NULL;
 495 }
 496
 497 // ----------------------------------------------------------------------------
 498 // drive virtual machine
 499 // ----------------------------------------------------------------------------
 500
 501 void VM::reset()
 502 {
 503         // reset all devices
 504         for(DEVICE* device = first_device; device; device = device->next_device) {
 505                 device->reset();
 506         }
 507         pio->write_signal(SIG_I8255_PORT_B, 0x00, 0x08);        // busy = low
 508         psg->set_reg(0x2e, 0);  // set prescaler
 509 }
 510
 511 void VM::special_reset()
 512 {
 513         // nmi reset
 514         cpu->write_signal(SIG_CPU_NMI, 1, 1);
 515 }
 516
 517 void VM::run()
 518 {
 519         event->drive();
 520 #ifdef _X1TWIN
 521         if(pce->is_cart_inserted()) {
 522                 pceevent->drive();
 523         }
 524 #endif
 525 }
 526
 527 double VM::get_frame_rate()
 528 {
 529 #ifdef _X1TWIN
 530         if(pce->is_cart_inserted()) {
 531                 return pceevent->get_frame_rate();
 532         }
 533 #endif
 534         return event->get_frame_rate();
 535 }
 536
 537 // ----------------------------------------------------------------------------
 538 // debugger
 539 // ----------------------------------------------------------------------------
 540
 541 #ifdef USE_DEBUGGER
 542 DEVICE *VM::get_cpu(int index)
 543 {
 544         if(index == 0) {
 545                 return cpu;
 546         } else if(index == 1) {
 547                 return cpu_sub;
 548         } else if(index == 2) {
 549                 return cpu_kbd;
 550 #ifdef _X1TWIN
 551         } else if(index == 3 && pce->is_cart_inserted()) {
 552                 return pcecpu;
 553 #endif
 554         }
 555         return NULL;
 556 }
 557 #endif
 558
 559 // ----------------------------------------------------------------------------
 560 // draw screen
 561 // ----------------------------------------------------------------------------
 562
 563 void VM::draw_screen()
 564 {
 565         display->draw_screen();
 566 #ifdef _X1TWIN
 567         if(pce->is_cart_inserted()) {
 568                 pce->draw_screen();
 569         }
 570 #endif
 571 }
 572
 573 // ----------------------------------------------------------------------------
 574 // soud manager
 575 // ----------------------------------------------------------------------------
 576
 577 void VM::initialize_sound(int rate, int samples)
 578 {
 579         // init sound manager
 580         event->initialize_sound(rate, samples);
 581 #ifdef _X1TWIN
 582         pceevent->initialize_sound(rate, samples);
 583 #endif
 584
 585         // init sound gen
 586         if(sound_type >= 1) {
 587                 opm1->initialize_sound(rate, 4000000, samples, 0);
 588         }
 589         if(sound_type == 2) {
 590                 opm2->initialize_sound(rate, 4000000, samples, 0);
 591         }
 592         psg->initialize_sound(rate, 2000000, samples, 0, 0);
 593 #ifdef _X1TWIN
 594         pce->initialize_sound(rate);
 595 #endif
 596 }
 597
 598 uint16_t* VM::create_sound(int* extra_frames)
 599 {
 600 #ifdef _X1TWIN
 601         if(pce->is_cart_inserted()) {
 602                 uint16_t* buffer = pceevent->create_sound(extra_frames);
 603                 for(int i = 0; i < *extra_frames; i++) {
 604                         event->drive();
 605                 }
 606                 return buffer;
 607         }
 608 #endif
 609         return event->create_sound(extra_frames);
 610 }
 611
 612 int VM::get_sound_buffer_ptr()
 613 {
 614 #ifdef _X1TWIN
 615         if(pce->is_cart_inserted()) {
 616                 return pceevent->get_sound_buffer_ptr();
 617         }
 618 #endif
 619         return event->get_sound_buffer_ptr();
 620 }
 621
 622 #ifdef USE_SOUND_VOLUME
 623 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 624 {
 625         if(ch == 0) {
 626                 psg->set_volume(1, decibel_l, decibel_r);
 627         } else if(ch == 1) {
 628                 if(sound_type >= 1) {
 629                         opm1->set_volume(0, decibel_l, decibel_r);
 630                 }
 631         } else if(ch == 2) {
 632                 if(sound_type >= 2) {
 633                         opm2->set_volume(0, decibel_l, decibel_r);
 634                 }
 635         } else if(ch == 3) {
 636                 drec->set_volume(0, decibel_l, decibel_r);
 637         } else if(ch == 4) {
 638                 fdc->get_context_noise_seek()->set_volume(0, decibel_l, decibel_r);
 639                 fdc->get_context_noise_head_down()->set_volume(0, decibel_l, decibel_r);
 640                 fdc->get_context_noise_head_up()->set_volume(0, decibel_l, decibel_r);
 641         } else if(ch == 5) {
 642                 drec->get_context_noise_play()->set_volume(0, decibel_l, decibel_r);
 643                 drec->get_context_noise_stop()->set_volume(0, decibel_l, decibel_r);
 644                 drec->get_context_noise_fast()->set_volume(0, decibel_l, decibel_r);
 645 #if defined(_X1TWIN)
 646         } else if(ch == 6) {
 647                 pce->set_volume(0, decibel_l, decibel_r);
 648 #endif
 649         }
 650 }
 651 #endif
 652
 653 // ----------------------------------------------------------------------------
 654 // notify key
 655 // ----------------------------------------------------------------------------
 656
 657 void VM::key_down(int code, bool repeat)
 658 {
 659 #ifdef _X1TWIN
 660         if(!repeat && !pce->is_cart_inserted()) {
 661 #else
 662         if(!repeat) {
 663 #endif
 664                 if(pseudo_sub_cpu) {
 665                         psub->key_down(code, false);
 666                 } else {
 667                         kbd->key_down(code, false);
 668                 }
 669         }
 670 }
 671
 672 void VM::key_up(int code)
 673 {
 674 #ifdef _X1TWIN
 675         if(!pce->is_cart_inserted()) {
 676 #endif
 677                 if(pseudo_sub_cpu) {
 678                         psub->key_up(code);
 679                 } else {
 680                         //kbd->key_up(code);
 681                 }
 682 #ifdef _X1TWIN
 683         }
 684 #endif
 685 }
 686
 687 bool VM::get_caps_locked()
 688 {
 689 #ifdef _X1TWIN
 690         if(!pce->is_cart_inserted()) {
 691 #endif
 692                 if(pseudo_sub_cpu) {
 693                         return psub->get_caps_locked();
 694                 } else {
 695                         return kbd->get_caps_locked();
 696                 }
 697 #ifdef _X1TWIN
 698         }
 699         return false;
 700 #endif
 701 }
 702
 703 bool VM::get_kana_locked()
 704 {
 705 #ifdef _X1TWIN
 706         if(!pce->is_cart_inserted()) {
 707 #endif
 708                 if(pseudo_sub_cpu) {
 709                         return psub->get_kana_locked();
 710                 } else {
 711                         return kbd->get_kana_locked();
 712                 }
 713 #ifdef _X1TWIN
 714         }
 715         return false;
 716 #endif
 717 }
 718
 719 // ----------------------------------------------------------------------------
 720 // user interface
 721 // ----------------------------------------------------------------------------
 722
 723 void VM::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
 724 {
 725         fdc->open_disk(drv, file_path, bank);
 726
 727 #ifdef _X1TURBO_FEATURE
 728         if(fdc->get_media_type(drv) == MEDIA_TYPE_2DD) {
 729                 if(fdc->get_drive_type(drv) == DRIVE_TYPE_2D) {
 730                         fdc->set_drive_type(drv, DRIVE_TYPE_2DD);
 731                 }
 732         } else if(fdc->get_media_type(drv) == MEDIA_TYPE_2D) {
 733                 if(fdc->get_drive_type(drv) == DRIVE_TYPE_2DD) {
 734                         fdc->set_drive_type(drv, DRIVE_TYPE_2D);
 735                 }
 736         }
 737 #endif
 738 }
 739
 740 void VM::close_floppy_disk(int drv)
 741 {
 742         fdc->close_disk(drv);
 743 }
 744
 745 bool VM::is_floppy_disk_inserted(int drv)
 746 {
 747         return fdc->is_disk_inserted(drv);
 748 }
 749
 750 void VM::is_floppy_disk_protected(int drv, bool value)
 751 {
 752         fdc->is_disk_protected(drv, value);
 753 }
 754
 755 bool VM::is_floppy_disk_protected(int drv)
 756 {
 757         return fdc->is_disk_protected(drv);
 758 }
 759
 760 uint32_t VM::is_floppy_disk_accessed()
 761 {
 762         return fdc->read_signal(0);
 763 }
 764
 765 void VM::open_hard_disk(int drv, const _TCHAR* file_path)
 766 {
 767         if(drv < USE_HARD_DISK) {
 768                 sasi_hdd[drv >> 1]->open(drv & 1, file_path, 256);
 769         }
 770 }
 771
 772 void VM::close_hard_disk(int drv)
 773 {
 774         if(drv < USE_HARD_DISK) {
 775                 sasi_hdd[drv >> 1]->close(drv & 1);
 776         }
 777 }
 778
 779 bool VM::is_hard_disk_inserted(int drv)
 780 {
 781         if(drv < USE_HARD_DISK) {
 782                 return sasi_hdd[drv >> 1]->mounted(drv & 1);
 783         }
 784         return false;
 785 }
 786
 787 uint32_t VM::is_hard_disk_accessed()
 788 {
 789         uint32_t status = 0;
 790
 791         for(int drv = 0; drv < USE_HARD_DISK; drv++) {
 792                 if(sasi_hdd[drv >> 1]->accessed(drv & 1)) {
 793                         status |= 1 << drv;
 794                 }
 795         }
 796         return status;
 797 }
 798
 799 void VM::play_tape(int drv, const _TCHAR* file_path)
 800 {
 801         bool value = drec->play_tape(file_path);
 802         if(pseudo_sub_cpu) {
 803                 psub->close_tape();
 804                 psub->play_tape(value);
 805         } else {
 806                 sub->close_tape();
 807                 sub->play_tape(value);
 808         }
 809 }
 810
 811 void VM::rec_tape(int drv, const _TCHAR* file_path)
 812 {
 813         bool value = drec->rec_tape(file_path);
 814         if(pseudo_sub_cpu) {
 815                 psub->close_tape();
 816                 psub->rec_tape(value);
 817         } else {
 818                 sub->close_tape();
 819                 sub->rec_tape(value);
 820         }
 821 }
 822
 823 void VM::close_tape(int drv)
 824 {
 825         emu->lock_vm();
 826         drec->close_tape();
 827         emu->unlock_vm();
 828         if(pseudo_sub_cpu) {
 829                 psub->close_tape();
 830         } else {
 831                 sub->close_tape();
 832         }
 833 }
 834
 835 bool VM::is_tape_inserted(int drv)
 836 {
 837         return drec->is_tape_inserted();
 838 }
 839
 840 bool VM::is_tape_playing(int drv)
 841 {
 842         return drec->is_tape_playing();
 843 }
 844
 845 bool VM::is_tape_recording(int drv)
 846 {
 847         return drec->is_tape_recording();
 848 }
 849
 850 int VM::get_tape_position(int drv)
 851 {
 852         return drec->get_tape_position();
 853 }
 854
 855 const _TCHAR* VM::get_tape_message(int drv)
 856 {
 857         return drec->get_message();
 858 }
 859
 860 void VM::push_play(int drv)
 861 {
 862         drec->set_ff_rew(0);
 863         drec->set_remote(true);
 864 }
 865
 866 void VM::push_stop(int drv)
 867 {
 868         drec->set_remote(false);
 869 }
 870
 871 void VM::push_fast_forward(int drv)
 872 {
 873         drec->set_ff_rew(1);
 874         drec->set_remote(true);
 875 }
 876
 877 void VM::push_fast_rewind(int drv)
 878 {
 879         drec->set_ff_rew(-1);
 880         drec->set_remote(true);
 881 }
 882
 883 void VM::push_apss_forward(int drv)
 884 {
 885         drec->do_apss(1);
 886 }
 887
 888 void VM::push_apss_rewind(int drv)
 889 {
 890         drec->do_apss(-1);
 891 }
 892
 893 bool VM::is_frame_skippable()
 894 {
 895 #ifdef _X1TWIN
 896         if(pce->is_cart_inserted()) {
 897                 return pceevent->is_frame_skippable();
 898         }
 899 #endif
 900         return event->is_frame_skippable();
 901 }
 902
 903 #ifdef _X1TWIN
 904 void VM::open_cart(int drv, const _TCHAR* file_path)
 905 {
 906         if(drv == 0) {
 907                 pce->open_cart(file_path);
 908                 pce->reset();
 909                 pcecpu->reset();
 910         }
 911 }
 912
 913 void VM::close_cart(int drv)
 914 {
 915         if(drv == 0) {
 916                 pce->close_cart();
 917                 pce->reset();
 918                 pcecpu->reset();
 919         }
 920 }
 921
 922 bool VM::is_cart_inserted(int drv)
 923 {
 924         if(drv == 0) {
 925                 return pce->is_cart_inserted();
 926         } else {
 927                 return false;
 928         }
 929 }
 930 #endif
 931
 932 void VM::update_config()
 933 {
 934         for(DEVICE* device = first_device; device; device = device->next_device) {
 935                 device->update_config();
 936         }
 937 #ifdef _X1TURBO_FEATURE
 938         update_dipswitch();
 939 #endif
 940 }
 941
 942 #ifdef _X1TURBO_FEATURE
 943 void VM::update_dipswitch()
 944 {
 945         // bit0         0=High 1=Standard
 946         // bit1-3       000=5"2D 001=5"2DD 010=5"2HD
 947         io->set_iovalue_single_r(0x1ff0, (config.monitor_type & 1) | ((config.drive_type & 7) << 1));
 948 }
 949 #endif
 950
 951 #define STATE_VERSION   10
 952
 953 bool VM::process_state(FILEIO* state_fio, bool loading)
 954 {
 955         if(!state_fio->StateCheckUint32(STATE_VERSION)) {
 956                 return false;
 957         }
 958         for(DEVICE* device = first_device; device; device = device->next_device) {
 959                 // Note: typeid(foo).name is fixed by recent ABI.Not decr. 6.
 960                 // const char *name = typeid(*device).name();
 961                 //       But, using get_device_name() instead of typeid(foo).name() 20181008 K.O
 962                 const char *name = device->get_device_name();
 963                 int len = strlen(name);
 964                 if(!state_fio->StateCheckInt32(len)) {
 965                         return false;
 966                 }
 967                 if(!state_fio->StateCheckBuffer(name, len, 1)) {
 968                         return false;
 969                 }
 970                 if(!device->process_state(state_fio, loading)) {
 971                         if(loading) {
 972                                 printf("Data loading Error: DEVID=%d\n", device->this_device_id);
 973                         }
 974                         return false;
 975                 }
 976         }
 977         state_fio->StateBool(pseudo_sub_cpu);
 978         state_fio->StateInt32(sound_type);
 979
 980 #ifdef _X1TURBO_FEATURE
 981         // post process
 982         if(loading) {
 983                 update_dipswitch();
 984         }
 985 #endif
 986         return true;
 987 }