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         decl_state();
 475 }
 476
 477 VM::~VM()
 478 {
 479         // delete all devices
 480         for(DEVICE* device = first_device; device;) {
 481                 DEVICE *next_device = device->next_device;
 482                 device->release();
 483                 delete device;
 484                 device = next_device;
 485         }
 486 }
 487
 488 DEVICE* VM::get_device(int id)
 489 {
 490         for(DEVICE* device = first_device; device; device = device->next_device) {
 491                 if(device->this_device_id == id) {
 492                         return device;
 493                 }
 494         }
 495         return NULL;
 496 }
 497
 498 // ----------------------------------------------------------------------------
 499 // drive virtual machine
 500 // ----------------------------------------------------------------------------
 501
 502 void VM::reset()
 503 {
 504         // reset all devices
 505         for(DEVICE* device = first_device; device; device = device->next_device) {
 506                 device->reset();
 507         }
 508         pio->write_signal(SIG_I8255_PORT_B, 0x00, 0x08);        // busy = low
 509         psg->set_reg(0x2e, 0);  // set prescaler
 510 }
 511
 512 void VM::special_reset()
 513 {
 514         // nmi reset
 515         cpu->write_signal(SIG_CPU_NMI, 1, 1);
 516 }
 517
 518 void VM::run()
 519 {
 520         event->drive();
 521 #ifdef _X1TWIN
 522         if(pce->is_cart_inserted()) {
 523                 pceevent->drive();
 524         }
 525 #endif
 526 }
 527
 528 double VM::get_frame_rate()
 529 {
 530 #ifdef _X1TWIN
 531         if(pce->is_cart_inserted()) {
 532                 return pceevent->get_frame_rate();
 533         }
 534 #endif
 535         return event->get_frame_rate();
 536 }
 537
 538 // ----------------------------------------------------------------------------
 539 // debugger
 540 // ----------------------------------------------------------------------------
 541
 542 #ifdef USE_DEBUGGER
 543 DEVICE *VM::get_cpu(int index)
 544 {
 545         if(index == 0) {
 546                 return cpu;
 547         } else if(index == 1) {
 548                 return cpu_sub;
 549         } else if(index == 2) {
 550                 return cpu_kbd;
 551 #ifdef _X1TWIN
 552         } else if(index == 3 && pce->is_cart_inserted()) {
 553                 return pcecpu;
 554 #endif
 555         }
 556         return NULL;
 557 }
 558 #endif
 559
 560 // ----------------------------------------------------------------------------
 561 // draw screen
 562 // ----------------------------------------------------------------------------
 563
 564 void VM::draw_screen()
 565 {
 566         display->draw_screen();
 567 #ifdef _X1TWIN
 568         if(pce->is_cart_inserted()) {
 569                 pce->draw_screen();
 570         }
 571 #endif
 572 }
 573
 574 // ----------------------------------------------------------------------------
 575 // soud manager
 576 // ----------------------------------------------------------------------------
 577
 578 void VM::initialize_sound(int rate, int samples)
 579 {
 580         // init sound manager
 581         event->initialize_sound(rate, samples);
 582 #ifdef _X1TWIN
 583         pceevent->initialize_sound(rate, samples);
 584 #endif
 585
 586         // init sound gen
 587         if(sound_type >= 1) {
 588                 opm1->initialize_sound(rate, 4000000, samples, 0);
 589         }
 590         if(sound_type == 2) {
 591                 opm2->initialize_sound(rate, 4000000, samples, 0);
 592         }
 593         psg->initialize_sound(rate, 2000000, samples, 0, 0);
 594 #ifdef _X1TWIN
 595         pce->initialize_sound(rate);
 596 #endif
 597 }
 598
 599 uint16_t* VM::create_sound(int* extra_frames)
 600 {
 601 #ifdef _X1TWIN
 602         if(pce->is_cart_inserted()) {
 603                 uint16_t* buffer = pceevent->create_sound(extra_frames);
 604                 for(int i = 0; i < *extra_frames; i++) {
 605                         event->drive();
 606                 }
 607                 return buffer;
 608         }
 609 #endif
 610         return event->create_sound(extra_frames);
 611 }
 612
 613 int VM::get_sound_buffer_ptr()
 614 {
 615 #ifdef _X1TWIN
 616         if(pce->is_cart_inserted()) {
 617                 return pceevent->get_sound_buffer_ptr();
 618         }
 619 #endif
 620         return event->get_sound_buffer_ptr();
 621 }
 622
 623 #ifdef USE_SOUND_VOLUME
 624 void VM::set_sound_device_volume(int ch, int decibel_l, int decibel_r)
 625 {
 626         if(ch == 0) {
 627                 psg->set_volume(1, decibel_l, decibel_r);
 628         } else if(ch == 1) {
 629                 if(sound_type >= 1) {
 630                         opm1->set_volume(0, decibel_l, decibel_r);
 631                 }
 632         } else if(ch == 2) {
 633                 if(sound_type >= 2) {
 634                         opm2->set_volume(0, decibel_l, decibel_r);
 635                 }
 636         } else if(ch == 3) {
 637                 drec->set_volume(0, decibel_l, decibel_r);
 638         } else if(ch == 4) {
 639                 fdc->get_context_noise_seek()->set_volume(0, decibel_l, decibel_r);
 640                 fdc->get_context_noise_head_down()->set_volume(0, decibel_l, decibel_r);
 641                 fdc->get_context_noise_head_up()->set_volume(0, decibel_l, decibel_r);
 642         } else if(ch == 5) {
 643                 drec->get_context_noise_play()->set_volume(0, decibel_l, decibel_r);
 644                 drec->get_context_noise_stop()->set_volume(0, decibel_l, decibel_r);
 645                 drec->get_context_noise_fast()->set_volume(0, decibel_l, decibel_r);
 646 #if defined(_X1TWIN)
 647         } else if(ch == 6) {
 648                 pce->set_volume(0, decibel_l, decibel_r);
 649 #endif
 650         }
 651 }
 652 #endif
 653
 654 // ----------------------------------------------------------------------------
 655 // notify key
 656 // ----------------------------------------------------------------------------
 657
 658 void VM::key_down(int code, bool repeat)
 659 {
 660 #ifdef _X1TWIN
 661         if(!repeat && !pce->is_cart_inserted()) {
 662 #else
 663         if(!repeat) {
 664 #endif
 665                 if(pseudo_sub_cpu) {
 666                         psub->key_down(code, false);
 667                 } else {
 668                         kbd->key_down(code, false);
 669                 }
 670         }
 671 }
 672
 673 void VM::key_up(int code)
 674 {
 675 #ifdef _X1TWIN
 676         if(!pce->is_cart_inserted()) {
 677 #endif
 678                 if(pseudo_sub_cpu) {
 679                         psub->key_up(code);
 680                 } else {
 681                         //kbd->key_up(code);
 682                 }
 683 #ifdef _X1TWIN
 684         }
 685 #endif
 686 }
 687
 688 bool VM::get_caps_locked()
 689 {
 690 #ifdef _X1TWIN
 691         if(!pce->is_cart_inserted()) {
 692 #endif
 693                 if(pseudo_sub_cpu) {
 694                         return psub->get_caps_locked();
 695                 } else {
 696                         return kbd->get_caps_locked();
 697                 }
 698 #ifdef _X1TWIN
 699         }
 700         return false;
 701 #endif
 702 }
 703
 704 bool VM::get_kana_locked()
 705 {
 706 #ifdef _X1TWIN
 707         if(!pce->is_cart_inserted()) {
 708 #endif
 709                 if(pseudo_sub_cpu) {
 710                         return psub->get_kana_locked();
 711                 } else {
 712                         return kbd->get_kana_locked();
 713                 }
 714 #ifdef _X1TWIN
 715         }
 716         return false;
 717 #endif
 718 }
 719
 720 // ----------------------------------------------------------------------------
 721 // user interface
 722 // ----------------------------------------------------------------------------
 723
 724 void VM::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
 725 {
 726         fdc->open_disk(drv, file_path, bank);
 727
 728 #ifdef _X1TURBO_FEATURE
 729         if(fdc->get_media_type(drv) == MEDIA_TYPE_2DD) {
 730                 if(fdc->get_drive_type(drv) == DRIVE_TYPE_2D) {
 731                         fdc->set_drive_type(drv, DRIVE_TYPE_2DD);
 732                 }
 733         } else if(fdc->get_media_type(drv) == MEDIA_TYPE_2D) {
 734                 if(fdc->get_drive_type(drv) == DRIVE_TYPE_2DD) {
 735                         fdc->set_drive_type(drv, DRIVE_TYPE_2D);
 736                 }
 737         }
 738 #endif
 739 }
 740
 741 void VM::close_floppy_disk(int drv)
 742 {
 743         fdc->close_disk(drv);
 744 }
 745
 746 bool VM::is_floppy_disk_inserted(int drv)
 747 {
 748         return fdc->is_disk_inserted(drv);
 749 }
 750
 751 void VM::is_floppy_disk_protected(int drv, bool value)
 752 {
 753         fdc->is_disk_protected(drv, value);
 754 }
 755
 756 bool VM::is_floppy_disk_protected(int drv)
 757 {
 758         return fdc->is_disk_protected(drv);
 759 }
 760
 761 uint32_t VM::is_floppy_disk_accessed()
 762 {
 763         return fdc->read_signal(0);
 764 }
 765
 766 void VM::open_hard_disk(int drv, const _TCHAR* file_path)
 767 {
 768         if(drv < USE_HARD_DISK) {
 769                 sasi_hdd[drv >> 1]->open(drv & 1, file_path, 256);
 770         }
 771 }
 772
 773 void VM::close_hard_disk(int drv)
 774 {
 775         if(drv < USE_HARD_DISK) {
 776                 sasi_hdd[drv >> 1]->close(drv & 1);
 777         }
 778 }
 779
 780 bool VM::is_hard_disk_inserted(int drv)
 781 {
 782         if(drv < USE_HARD_DISK) {
 783                 return sasi_hdd[drv >> 1]->mounted(drv & 1);
 784         }
 785         return false;
 786 }
 787
 788 uint32_t VM::is_hard_disk_accessed()
 789 {
 790         uint32_t status = 0;
 791
 792         for(int drv = 0; drv < USE_HARD_DISK; drv++) {
 793                 if(sasi_hdd[drv >> 1]->accessed(drv & 1)) {
 794                         status |= 1 << drv;
 795                 }
 796         }
 797         return status;
 798 }
 799
 800 void VM::play_tape(int drv, const _TCHAR* file_path)
 801 {
 802         bool value = drec->play_tape(file_path);
 803         if(pseudo_sub_cpu) {
 804                 psub->close_tape();
 805                 psub->play_tape(value);
 806         } else {
 807                 sub->close_tape();
 808                 sub->play_tape(value);
 809         }
 810 }
 811
 812 void VM::rec_tape(int drv, const _TCHAR* file_path)
 813 {
 814         bool value = drec->rec_tape(file_path);
 815         if(pseudo_sub_cpu) {
 816                 psub->close_tape();
 817                 psub->rec_tape(value);
 818         } else {
 819                 sub->close_tape();
 820                 sub->rec_tape(value);
 821         }
 822 }
 823
 824 void VM::close_tape(int drv)
 825 {
 826         emu->lock_vm();
 827         drec->close_tape();
 828         emu->unlock_vm();
 829         if(pseudo_sub_cpu) {
 830                 psub->close_tape();
 831         } else {
 832                 sub->close_tape();
 833         }
 834 }
 835
 836 bool VM::is_tape_inserted(int drv)
 837 {
 838         return drec->is_tape_inserted();
 839 }
 840
 841 bool VM::is_tape_playing(int drv)
 842 {
 843         return drec->is_tape_playing();
 844 }
 845
 846 bool VM::is_tape_recording(int drv)
 847 {
 848         return drec->is_tape_recording();
 849 }
 850
 851 int VM::get_tape_position(int drv)
 852 {
 853         return drec->get_tape_position();
 854 }
 855
 856 const _TCHAR* VM::get_tape_message(int drv)
 857 {
 858         return drec->get_message();
 859 }
 860
 861 void VM::push_play(int drv)
 862 {
 863         drec->set_ff_rew(0);
 864         drec->set_remote(true);
 865 }
 866
 867 void VM::push_stop(int drv)
 868 {
 869         drec->set_remote(false);
 870 }
 871
 872 void VM::push_fast_forward(int drv)
 873 {
 874         drec->set_ff_rew(1);
 875         drec->set_remote(true);
 876 }
 877
 878 void VM::push_fast_rewind(int drv)
 879 {
 880         drec->set_ff_rew(-1);
 881         drec->set_remote(true);
 882 }
 883
 884 void VM::push_apss_forward(int drv)
 885 {
 886         drec->do_apss(1);
 887 }
 888
 889 void VM::push_apss_rewind(int drv)
 890 {
 891         drec->do_apss(-1);
 892 }
 893
 894 bool VM::is_frame_skippable()
 895 {
 896 #ifdef _X1TWIN
 897         if(pce->is_cart_inserted()) {
 898                 return pceevent->is_frame_skippable();
 899         }
 900 #endif
 901         return event->is_frame_skippable();
 902 }
 903
 904 #ifdef _X1TWIN
 905 void VM::open_cart(int drv, const _TCHAR* file_path)
 906 {
 907         if(drv == 0) {
 908                 pce->open_cart(file_path);
 909                 pce->reset();
 910                 pcecpu->reset();
 911         }
 912 }
 913
 914 void VM::close_cart(int drv)
 915 {
 916         if(drv == 0) {
 917                 pce->close_cart();
 918                 pce->reset();
 919                 pcecpu->reset();
 920         }
 921 }
 922
 923 bool VM::is_cart_inserted(int drv)
 924 {
 925         if(drv == 0) {
 926                 return pce->is_cart_inserted();
 927         } else {
 928                 return false;
 929         }
 930 }
 931 #endif
 932
 933 void VM::update_config()
 934 {
 935         for(DEVICE* device = first_device; device; device = device->next_device) {
 936                 device->update_config();
 937         }
 938 #ifdef _X1TURBO_FEATURE
 939         update_dipswitch();
 940 #endif
 941 }
 942
 943 #ifdef _X1TURBO_FEATURE
 944 void VM::update_dipswitch()
 945 {
 946         // bit0         0=High 1=Standard
 947         // bit1-3       000=5"2D 001=5"2DD 010=5"2HD
 948         io->set_iovalue_single_r(0x1ff0, (config.monitor_type & 1) | ((config.drive_type & 7) << 1));
 949 }
 950 #endif
 951
 952 #define STATE_VERSION   10
 953 #include "../../statesub.h"
 954 #include "../../qt/gui/csp_logger.h"
 955 extern CSP_Logger DLL_PREFIX_I *csp_logger;
 956
 957 void VM::decl_state(void)
 958 {
 959 #if defined(_X1)
 960         state_entry = new csp_state_utils(STATE_VERSION, 0, _T("CSP::X1_HEAD"), csp_logger);
 961 #elif defined(_X1TURBO)
 962         state_entry = new csp_state_utils(STATE_VERSION, 0, _T("CSP::X1_TURBO_HEAD"), csp_logger);
 963 #elif defined(_X1TURBOZ)
 964         state_entry = new csp_state_utils(STATE_VERSION, 0, _T("CSP::X1_TURBO_Z_HEAD"), csp_logger);
 965 #elif defined(_X1TWIN)
 966         state_entry = new csp_state_utils(STATE_VERSION, 0, _T("CSP::X1_TWIN_HEAD"), csp_logger);
 967 #else
 968         state_entry = new csp_state_utils(STATE_VERSION, 0, _T("CSP::X1_SERIES_HEAD"), csp_logger);
 969 #endif
 970
 971         DECL_STATE_ENTRY_BOOL(pseudo_sub_cpu);
 972         DECL_STATE_ENTRY_INT32(sound_type);
 973         for(DEVICE* device = first_device; device; device = device->next_device) {
 974                 device->decl_state();
 975         }
 976 }
 977 void VM::save_state(FILEIO* state_fio)
 978 {
 979         if(state_entry != NULL) state_entry->save_state(state_fio);
 980
 981         for(DEVICE* device = first_device; device; device = device->next_device) {
 982                 device->save_state(state_fio);
 983         }
 984 }
 985
 986 bool VM::load_state(FILEIO* state_fio)
 987 {
 988         bool mb = false;
 989         if(state_entry != NULL) {
 990                 mb = state_entry->load_state(state_fio);
 991         }
 992         if(!mb) return false;
 993
 994         int n = 1;
 995         for(DEVICE* device = first_device; device; device = device->next_device) {
 996                 if(!device->load_state(state_fio)) {
 997                         printf("STATE ERROR at device #%d\n", n);
 998                         return false;
 999                 }
1000                 n++;
1001         }
1002 #ifdef _X1TURBO_FEATURE
1003         // post process
1004         update_dipswitch();
1005 #endif
1006         return true;
1007 }
1008