[BACK]Return to pccore.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / np2

Diff for /np2/pccore.c between versions 1.28 and 1.100

version 1.28, 2003/12/08 06:24:03 version 1.100, 2005/03/05 06:02:28
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
   #include        "strres.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "soundmng.h"  #include        "soundmng.h"
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "timemng.h"  #include        "timemng.h"
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "memory.h"  
 #include        "np2ver.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "cbuscore.h"  #include        "cbuscore.h"
 #include        "pc9861k.h"  #include        "pc9861k.h"
 #include        "mpu98ii.h"  #include        "mpu98ii.h"
   #include        "amd98.h"
 #include        "bios.h"  #include        "bios.h"
 #include        "biosmem.h"  #include        "biosmem.h"
 #include        "vram.h"  #include        "vram.h"
Line 20 Line 21
 #include        "maketext.h"  #include        "maketext.h"
 #include        "maketgrp.h"  #include        "maketgrp.h"
 #include        "makegrph.h"  #include        "makegrph.h"
   #include        "makegrex.h"
 #include        "sound.h"  #include        "sound.h"
 #include        "fmboard.h"  #include        "fmboard.h"
 #include        "beep.h"  #include        "beep.h"
   #include        "s98.h"
 #include        "font.h"  #include        "font.h"
 #include        "diskdrv.h"  #include        "diskdrv.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
 #include        "sxsi.h"  #include        "sxsi.h"
   #if defined(SUPPORT_HOSTDRV)
   #include        "hostdrv.h"
   #endif
   #include        "np2ver.h"
 #include        "calendar.h"  #include        "calendar.h"
 #include        "timing.h"  #include        "timing.h"
 //#include      "hostdrv.h"  #include        "keystat.h"
 #include        "debugsub.h"  #include        "debugsub.h"
   
   
         const char      np2version[] = NP2VER_CORE;  const OEMCHAR np2version[] = OEMTEXT(NP2VER_CORE);
   
   #if defined(_WIN32_WCE)
   #define PCBASEMULTIPLE  2
   #else
   #define PCBASEMULTIPLE  4
   #endif
   
   
         NP2CFG  np2cfg = {          NP2CFG  np2cfg = {
                                 0, 1, 0, 32, 0, 0, 0x40,                                  0, 1, 0, 32, 0, 0, 0x40,
                                 0, 0, 0, 0,                                  0, 0, 0, 0,
                                 {0x3e, 0x63, 0x7a}, 0,                                  {0x3e, 0x73, 0x7b}, 0,
                                 0, 0, {1, 1, 6, 1, 8, 1},                                  0, 0, {1, 1, 6, 1, 8, 1},
   
                                 "VX", PCBASECLOCK25, 4,                                  OEMTEXT("VX"), PCBASECLOCK25, PCBASEMULTIPLE,
                                 {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e},                                  {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e},
                                 1, 1, 2, 1, 0x000000, 0xffffff,                                  1, 1, 2, 1, 0x000000, 0xffffff,
                                 22050, 800, 4, 0,                                  22050, 500, 4, 0,
                                 {0, 0, 0}, 0xd1, 0x7f, 0xd1, 0, 0, 1,                                  {0, 0, 0}, 0xd1, 0x7f, 0xd1, 0, 0, 1,
                                 3, {0x0c, 0x0c, 0x08, 0x06, 0x03, 0x0c}, 64, 64, 64, 64, 64,                                  3, {0x0c, 0x0c, 0x08, 0x06, 0x03, 0x0c}, 64, 64, 64, 64, 64,
                                 1, 0x82,                                  1, 0x82,
                                 0, {0x17, 0x04, 0x1f}, {0x0c, 0x0c, 0x02, 0x10, 0x3f, 0x3f},                                  0, {0x17, 0x04, 0x1f}, {0x0c, 0x0c, 0x02, 0x10, 0x3f, 0x3f},
                                 1, 80, 0,                                  3, 1, 80, 0, 0,
                                 {"", ""}, "", ""};                                  {OEMTEXT(""), OEMTEXT("")},
   #if defined(SUPPORT_SCSI)
                                   {OEMTEXT(""), OEMTEXT(""), OEMTEXT(""), OEMTEXT("")},
   #endif
                                   OEMTEXT(""), OEMTEXT(""), OEMTEXT("")};
   
         PCCORE  pc = {  PCBASECLOCK25,          PCCORE  pccore = {      PCBASECLOCK25, PCBASEMULTIPLE,
                                         4,                                                  0, PCMODEL_VX, 0, 0, {0x3e, 0x73, 0x7b}, 0,
                                         4 * PCBASECLOCK25,                                                  0, 0,
                                         4 * PCBASECLOCK25 * 50 / 3104,                                                  PCBASECLOCK25 * PCBASEMULTIPLE};
                                         4 * PCBASECLOCK25 * 5 / 3104,  
                                         4 * PCBASECLOCK25 / 120,  
                                         4 * PCBASECLOCK25 / 1920,  
                                         4 * PCBASECLOCK25 / 3125,  
                                         4 * PCBASECLOCK25 / 56400,  
                                         100, 20, 0, PCMODEL_VX};  
   
                                                                         // on=0, off=1  
 //      BYTE    dip_default[3] = {0x3e, 0x63, 0x7a};  
 static const BYTE msw_default[8] =  
                                                         {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e};  
   
         BYTE    screenupdate = 3;          UINT8   screenupdate = 3;
         int             screendispflag = 1;          int             screendispflag = 1;
         int             soundrenewal = 0;          int             soundrenewal = 0;
         BOOL    drawframe;          BOOL    drawframe;
         UINT    drawcount = 0;          UINT    drawcount = 0;
           BOOL    hardwarereset = FALSE;
         BYTE    mem[0x200000];  
   
   
 // ---------------------------------------------------------------------------  // ---------------------------------------------------------------------------
   
 void getbiospath(char *path, const char *fname, int maxlen) {  void getbiospath(OEMCHAR *path, const OEMCHAR *fname, int maxlen) {
   
 const char      *p;  
   
         p = np2cfg.biospath;  const OEMCHAR   *p;
   
         p = np2cfg.biospath;          p = np2cfg.biospath;
         if (p[0]) {          if (p[0]) {
Line 100  const char *p; Line 104  const char *p;
   
 // ----  // ----
   
 static void setvsyncclock(void) {  static void pccore_set(void) {
   
           UINT8   model;
           UINT32  multiple;
           UINT8   extsize;
   
           ZeroMemory(&pccore, sizeof(pccore));
           model = PCMODEL_VX;
           if (!milstr_cmp(np2cfg.model, str_VM)) {
                   model = PCMODEL_VM;
           }
           else if (!milstr_cmp(np2cfg.model, str_EPSON)) {
                   model = PCMODEL_EPSON | PCMODEL_VM;
           }
           pccore.model = model;
   
         UINT    vfp;          if (np2cfg.baseclock >= ((PCBASECLOCK25 + PCBASECLOCK20) / 2)) {
         UINT    vbp;                  pccore.baseclock = PCBASECLOCK25;                       // 2.5MHz
         UINT    lf;                  pccore.cpumode = 0;
         UINT    disp;  
         UINT    vs;  
         UINT    maxy;  
         UINT    cnt;  
   
         vfp = gdc.m.para[GDC_SYNC + 5] & 0x3f;  
         if (!vfp) {  
                 vfp = 1;  
         }  
         vbp = gdc.m.para[GDC_SYNC + 7] >> 2;  
         if (!vbp) {  
                 vbp = 1;  
         }  
         lf = LOADINTELWORD(gdc.m.para + GDC_SYNC + 6);  
         lf &= 0x3ff;  
         if (!lf) {  
                 lf = 1024;  
         }  
         disp = vfp + vbp + lf;  
         vs = LOADINTELWORD(gdc.m.para + GDC_SYNC + 4);  
         vs = (vs >> 5) & 0x1f;  
         if (!vs) {  
                 vs = 1;  
         }  
         maxy = disp + vs;  
         cnt = (pc.realclock * 5) / 282;  
         pc.raster = cnt / maxy;  
         pc.hsync = (pc.raster * 4) / 5;  
         pc.dispclock = pc.raster * disp;  
         pc.vsyncclock = cnt - pc.dispclock;  
 }  
   
 static void setpcclock(UINT base, UINT multiple) {  
   
         pc.model = PCMODEL_VX;  
   
         if (base >= ((PCBASECLOCK25 + PCBASECLOCK20) / 2)) {  
                 pc.baseclock = PCBASECLOCK25;                   // 2.5MHz  
                 pc.cpumode = 0;  
         }          }
         else {          else {
                 pc.baseclock = PCBASECLOCK20;                   // 2.0MHz                  pccore.baseclock = PCBASECLOCK20;                       // 2.0MHz
                 pc.cpumode = CPUMODE_8MHz;                  pccore.cpumode = CPUMODE_8MHZ;
         }          }
           multiple = np2cfg.multiple;
         if (multiple == 0) {          if (multiple == 0) {
                 multiple = 1;                  multiple = 1;
         }          }
         else if (multiple > 32) {          else if (multiple > 32) {
                 multiple = 32;                  multiple = 32;
         }          }
         pc.multiple = multiple;          pccore.multiple = multiple;
         pc.realclock = pc.baseclock * multiple;          pccore.realclock = pccore.baseclock * multiple;
         pc.raster = pc.realclock / 24816;                                                       // ver0.28  
         pc.hsync = (pc.raster * 4) / 5;                                                         // ver0.28          // HDDの接続 (I/Oの使用状態が変わるので..
         pc.dispclock = pc.realclock * 50 / 3102;          if (np2cfg.dipsw[1] & 0x20) {
         pc.vsyncclock = pc.realclock * 5 / 3102;                  pccore.hddif |= PCHDD_IDE;
         pc.mouseclock = pc.realclock / 120;          }
         pc.keyboardclock = pc.realclock / 1920;  
         pc.midiclock = pc.realclock / 3125;          // 拡張メモリ
         pc.frame1000 = pc.realclock / 56400;          extsize = 0;
           if (!(np2cfg.dipsw[2] & 0x80)) {
                   extsize = min(np2cfg.EXTMEM, 13);
           }
           pccore.extmem = extsize;
           CopyMemory(pccore.dipsw, np2cfg.dipsw, 3);
   
           // サウンドボードの接続
           pccore.sound = np2cfg.SOUND_SW;
   
           // その他CBUSの接続
           pccore.device = 0;
           if (np2cfg.pc9861enable) {
                   pccore.device |= PCCBUS_PC9861K;
           }
           if (np2cfg.mpuenable) {
                   pccore.device |= PCCBUS_MPU98;
           }
 }  }
   
   
 // --------------------------------------------------------------------------  // --------------------------------------------------------------------------
   
   #if !defined(DISABLE_SOUND)
 static void sound_init(void) {  static void sound_init(void) {
   
         UINT    rate;          UINT    rate;
Line 179  static void sound_init(void) { Line 177  static void sound_init(void) {
                 rate = 0;                  rate = 0;
         }          }
         sound_create(rate, np2cfg.delayms);          sound_create(rate, np2cfg.delayms);
           fddmtrsnd_initialize(rate);
         beep_initialize(rate);          beep_initialize(rate);
         beep_setvol(np2cfg.BEEP_VOL);          beep_setvol(np2cfg.BEEP_VOL);
         tms3631_initialize(rate);          tms3631_initialize(rate);
Line 193  static void sound_init(void) { Line 192  static void sound_init(void) {
         adpcm_setvol(np2cfg.vol_adpcm);          adpcm_setvol(np2cfg.vol_adpcm);
         pcm86gen_initialize(rate);          pcm86gen_initialize(rate);
         pcm86gen_setvol(np2cfg.vol_pcm);          pcm86gen_setvol(np2cfg.vol_pcm);
           cs4231_initialize(rate);
           amd98_initialize(rate);
 }  }
   
 static void sound_term(void) {  static void sound_term(void) {
   
         soundmng_stop();          soundmng_stop();
           amd98_deinitialize();
         rhythm_deinitialize();          rhythm_deinitialize();
           beep_deinitialize();
           fddmtrsnd_deinitialize();
         sound_destroy();          sound_destroy();
 }  }
   #endif
   
 void pccore_init(void) {  void pccore_init(void) {
   
Line 209  void pccore_init(void) { Line 214  void pccore_init(void) {
         pal_initlcdtable();          pal_initlcdtable();
         pal_makelcdpal();          pal_makelcdpal();
         pal_makeskiptable();          pal_makeskiptable();
         dispsync_init();          dispsync_initialize();
         sxsi_initialize();          sxsi_initialize();
   
         font_init();          font_initialize();
         font_load(np2cfg.fontfile, TRUE);          font_load(np2cfg.fontfile, TRUE);
         maketext_init();          maketext_initialize();
         makegrph_init();          makegrph_initialize();
         gdcsub_init();          gdcsub_initialize();
         fddfile_init();          fddfile_initialize();
   
   #if !defined(DISABLE_SOUND)
         sound_init();          sound_init();
   #endif
   
         mpu98ii_construct();  
         rs232c_construct();          rs232c_construct();
         pc9861k_construct();          mpu98ii_construct();
           pc9861k_initialize();
   
         iocore_create();          iocore_create();
   
   #if defined(SUPPORT_HOSTDRV)
           hostdrv_initialize();
   #endif
 }  }
   
 void pccore_term(void) {  void pccore_term(void) {
   
   #if defined(SUPPORT_HOSTDRV)
           hostdrv_deinitialize();
   #endif
   
   #if !defined(DISABLE_SOUND)
         sound_term();          sound_term();
   #endif
   
         fdd_eject(0);          fdd_eject(0);
         fdd_eject(1);          fdd_eject(1);
         fdd_eject(2);          fdd_eject(2);
         fdd_eject(3);          fdd_eject(3);
   
         extmemmng_clear();  
   
         iocore_destroy();          iocore_destroy();
   
         pc9861k_destruct();          pc9861k_deinitialize();
         rs232c_destruct();  
         mpu98ii_destruct();          mpu98ii_destruct();
           rs232c_destruct();
   
         sxsi_trash();          sxsi_alltrash();
   
           CPU_DEINITIALIZE();
 }  }
   
   
Line 256  void pccore_cfgupdate(void) { Line 273  void pccore_cfgupdate(void) {
   
         renewal = FALSE;          renewal = FALSE;
         for (i=0; i<8; i++) {          for (i=0; i<8; i++) {
                 if (np2cfg.memsw[i] != mem[MEMB_MSW + i*4]) {                  if (np2cfg.memsw[i] != mem[MEMX_MSW + i*4]) {
                         np2cfg.memsw[i] = mem[MEMB_MSW + i*4];                          np2cfg.memsw[i] = mem[MEMX_MSW + i*4];
                         renewal = TRUE;                          renewal = TRUE;
                 }                  }
         }          }
Line 270  void pccore_reset(void) { Line 287  void pccore_reset(void) {
   
         int             i;          int             i;
   
 //      reset_hostdrv();          soundmng_stop();
   #if !defined(DISABLE_SOUND)
         ZeroMemory(mem, 0x10fff0);                                                                      // ver0.28          if (soundrenewal) {
                   soundrenewal = 0;
                   sound_term();
                   sound_init();
           }
   #endif
           ZeroMemory(mem, 0x110000);
         ZeroMemory(mem + VRAM1_B, 0x18000);          ZeroMemory(mem + VRAM1_B, 0x18000);
         ZeroMemory(mem + VRAM1_E, 0x08000);          ZeroMemory(mem + VRAM1_E, 0x08000);
         ZeroMemory(mem + FONT_ADRS, 0x08000);          ZeroMemory(mem + FONT_ADRS, 0x08000);
   
           //メモリスイッチ
           for (i=0; i<8; i++) {
                   mem[0xa3fe2 + i*4] = np2cfg.memsw[i];
           }
   
           pccore_set();
           nevent_allreset();
   
         CPU_RESET();          CPU_RESET();
           CPU_SETEXTSIZE((UINT32)pccore.extmem);
   
         CPU_TYPE = 0;          CPU_TYPE = 0;
         if (np2cfg.dipsw[2] & 0x80) {          if (np2cfg.dipsw[2] & 0x80) {
                 CPU_TYPE = CPUTYPE_V30;                  CPU_TYPE = CPUTYPE_V30;
         }          }
           if (pccore.model & PCMODEL_EPSON) {                     // RAM ctrl
         //メモリスイッチ                  CPU_RAM_D000 = 0xffff;
         for (i=0; i<8; i++) {  
                 mem[0xa3fe2 + i*4] = np2cfg.memsw[i];  
         }          }
   
         fddfile_reset2dmode();          // HDDセット
         bios0x18_16(0x20, 0xe1);          sxsihdd_allbind();
   #if defined(SUPPORT_SASI)
         soundmng_stop();          if (sxsi_issasi()) {
         if (soundrenewal) {                  pccore.hddif &= ~PCHDD_IDE;
                 soundrenewal = 0;                  pccore.hddif |= PCHDD_SASI;
                 sound_term();                  TRACEOUT(("supported SASI"));
                 sound_init();          }
   #endif
   #if defined(SUPPORT_SCSI)
           if (sxsi_isscsi()) {
                   pccore.hddif |= PCHDD_SCSI;
                   TRACEOUT(("supported SCSI"));
         }          }
   #endif
   
         setpcclock(np2cfg.baseclock, np2cfg.multiple);  
         sound_changeclock();          sound_changeclock();
         beep_changeclock();          beep_changeclock();
         nevent_init();  
   
         sound_reset();          sound_reset();
           fddmtrsnd_bind();
   
           fddfile_reset2dmode();
           bios0x18_16(0x20, 0xe1);
   
         iocore_reset();                                                         // サウンドでpicを呼ぶので…          iocore_reset();                                                         // サウンドでpicを呼ぶので…
         cbuscore_reset();          cbuscore_reset();
         fmboard_reset(np2cfg.SOUND_SW);          fmboard_reset(pccore.sound);
   
           i286_memorymap((pccore.model & PCMODEL_EPSON)?1:0);
         iocore_build();          iocore_build();
         iocore_bind();          iocore_bind();
         cbuscore_bind();          cbuscore_bind();
         fmboard_bind();          fmboard_bind();
   
         timing_reset();          fddmtr_initialize();
         fddmtr_init();          calendar_initialize();
         calendar_init();          vram_initialize();
         vram_init();  
   
         pal_change(1);          pal_change(1);
   
         bios_init();          bios_initialize();
         sxsi_open();  
           CS_BASE = 0xf0000;
           CPU_CS = 0xf000;
           CPU_IP = 0xfff0;
   
         if (np2cfg.ITF_WORK) {  
                 CS_BASE = 0xf0000;  
                 CPU_CS = 0xf000;  
                 CPU_IP = 0xfff0;  
         }  
         else {  
                 for (i=0; i<8; i++) {  
                         mem[0xa3fe2 + i*4] = msw_default[i];  
                 }  
                 CS_BASE = 0xfd800;  
                 CPU_CS = 0xfd80;  
                 CPU_IP = 0x0002;  
         }  
         CPU_CLEARPREFETCH();          CPU_CLEARPREFETCH();
         sysmng_cpureset();          sysmng_cpureset();
   
   #if defined(SUPPORT_HOSTDRV)
           hostdrv_reset();
   #endif
   
           timing_reset();
         soundmng_play();          soundmng_play();
 }  }
   
 static void drawscreen(void) {  static void drawscreen(void) {
   
         BYTE    timing;          UINT8   timing;
           void    (VRAMCALL * grphfn)(int page, int alldraw);
           UINT8   bit;
   
         tramflag.timing++;          tramflag.timing++;
         timing = ((LOADINTELWORD(gdc.m.para + GDC_CSRFORM + 1)) >> 5) & 0x3e;          timing = ((LOADINTELWORD(gdc.m.para + GDC_CSRFORM + 1)) >> 5) & 0x3e;
Line 359  static void drawscreen(void) { Line 394  static void drawscreen(void) {
                 tramflag.renewal |= 1;                  tramflag.renewal |= 1;
         }          }
   
         if ((gdcs.textdisp & GDCSCRN_EXT) ||                                            // ver0.28          if (gdcs.textdisp & GDCSCRN_EXT) {
                 (gdcs.grphdisp & GDCSCRN_EXT)) {                  gdc_updateclock();
                 setvsyncclock();  
         }          }
   
         if (drawframe) {          if (!drawframe) {
                 if ((gdcs.textdisp & GDCSCRN_EXT) ||                                    // ver0.26                  return;
                         (gdcs.grphdisp & GDCSCRN_EXT)) {          }
                         if (dispsync_renewalvertical()) {          if ((gdcs.textdisp & GDCSCRN_EXT) || (gdcs.grphdisp & GDCSCRN_EXT)) {
                                 gdcs.textdisp |= GDCSCRN_ALLDRAW2;                  if (dispsync_renewalvertical()) {
                                 gdcs.grphdisp |= GDCSCRN_ALLDRAW2;                          gdcs.textdisp |= GDCSCRN_ALLDRAW2;
                         }                          gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
                 }  
                                                                                                                                 // ver0.28/pr4  
                 if (gdcs.textdisp & GDCSCRN_EXT) {  
                         gdcs.textdisp &= ~GDCSCRN_EXT;  
                         dispsync_renewalhorizontal();  
                         tramflag.renewal |= 1;  
                         if (dispsync_renewalmode()) {  
                                 screenupdate |= 2;  
                         }  
                 }                  }
                                                                                                                                 // ver0.28/pr4          }
                 if (gdcs.palchange) {                                                                   // grphを先に          if (gdcs.textdisp & GDCSCRN_EXT) {
                         gdcs.palchange = 0;                  gdcs.textdisp &= ~GDCSCRN_EXT;
                         pal_change(0);                  dispsync_renewalhorizontal();
                         screenupdate |= 1;                  tramflag.renewal |= 1;
                   if (dispsync_renewalmode()) {
                           screenupdate |= 2;
                 }                  }
                 if (gdcs.grphdisp & GDCSCRN_EXT) {          }
                         gdcs.grphdisp &= ~GDCSCRN_EXT;          if (gdcs.palchange) {
                         if (((gdc.clock & 0x80) && (gdc.clock != 0x83)) ||                  gdcs.palchange = 0;
                                 (gdc.clock == 0x03)) {                  pal_change(0);
                                 gdc.clock ^= 0x80;                  screenupdate |= 1;
                                 gdcs.grphdisp |= GDCSCRN_ALLDRAW2;          }
           if (gdcs.grphdisp & GDCSCRN_EXT) {
                   gdcs.grphdisp &= ~GDCSCRN_EXT;
                   if (((gdc.clock & 0x80) && (gdc.clock != 0x83)) ||
                           (gdc.clock == 0x03)) {
                           gdc.clock ^= 0x80;
                           gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
                   }
           }
           if (gdcs.grphdisp & GDCSCRN_ENABLE) {
                   if (!(gdc.mode1 & 2)) {
                           grphfn = makegrph;
                           bit = GDCSCRN_MAKE;
                           if (gdcs.disp) {
                                   bit <<= 1;
                           }
   #if defined(SUPPORT_PC9821)
                           if (gdc.analog & 2) {
                                   grphfn = makegrphex;
                                   if (gdc.analog & 4) {
                                           bit = GDCSCRN_MAKE | (GDCSCRN_MAKE << 1);
                                   }
                           }
   #endif
                           if (gdcs.grphdisp & bit) {
                                   (*grphfn)(gdcs.disp, gdcs.grphdisp & bit & GDCSCRN_ALLDRAW2);
                                   gdcs.grphdisp &= ~bit;
                                   screenupdate |= 1;
                         }                          }
                 }                  }
                 if (gdcs.grphdisp & GDCSCRN_ENABLE) {                  else if (gdcs.textdisp & GDCSCRN_ENABLE) {
                         if (!(gdc.mode1 & 2)) {                          if (!gdcs.disp) {
                                 if (!gdcs.disp) {                                  if ((gdcs.grphdisp & GDCSCRN_MAKE) ||
                                         if (gdcs.grphdisp & GDCSCRN_MAKE) {                                          (gdcs.textdisp & GDCSCRN_MAKE)) {
                                                 makegrph(0, gdcs.grphdisp & GDCSCRN_ALLDRAW);                                          if (!(gdc.mode1 & 0x4)) {
                                                 gdcs.grphdisp &= ~GDCSCRN_MAKE;                                                  maketextgrph(0, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                                 screenupdate |= 1;                                                                  gdcs.grphdisp & GDCSCRN_ALLDRAW);
                                         }                                          }
                                 }                                          else {
                                 else {                                                  maketextgrph40(0, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                         if (gdcs.grphdisp & (GDCSCRN_MAKE << 1)) {                                                                  gdcs.grphdisp & GDCSCRN_ALLDRAW);
                                                 makegrph(1, gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);  
                                                 screenupdate |= 1;  
                                         }                                          }
                                           gdcs.grphdisp &= ~GDCSCRN_MAKE;
                                           screenupdate |= 1;
                                 }                                  }
                         }                          }
                         else if (gdcs.textdisp & GDCSCRN_ENABLE) {                          else {
                                 if (!gdcs.disp) {                                  if ((gdcs.grphdisp & (GDCSCRN_MAKE << 1)) ||
                                         if ((gdcs.grphdisp & GDCSCRN_MAKE) ||                                          (gdcs.textdisp & GDCSCRN_MAKE)) {
                                                 (gdcs.textdisp & GDCSCRN_MAKE)) {                                          if (!(gdc.mode1 & 0x4)) {
                                                 if (!(gdc.mode1 & 0x4)) {                                                  maketextgrph(1, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                                         maketextgrph(0, gdcs.textdisp & GDCSCRN_ALLDRAW,                                                                  gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));
                                                                         gdcs.grphdisp & GDCSCRN_ALLDRAW);  
                                                 }  
                                                 else {  
                                                         maketextgrph40(0, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & GDCSCRN_ALLDRAW);  
                                                 }  
                                                 gdcs.grphdisp &= ~GDCSCRN_MAKE;  
                                                 screenupdate |= 1;  
                                         }                                          }
                                 }                                          else {
                                 else {                                                  maketextgrph40(1, gdcs.textdisp & GDCSCRN_ALLDRAW,
                                         if ((gdcs.grphdisp & (GDCSCRN_MAKE << 1)) ||                                                                  gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));
                                                 (gdcs.textdisp & GDCSCRN_MAKE)) {  
                                                 if (!(gdc.mode1 & 0x4)) {  
                                                         maketextgrph(1, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 }  
                                                 else {  
                                                         maketextgrph40(1, gdcs.textdisp & GDCSCRN_ALLDRAW,  
                                                                         gdcs.grphdisp & (GDCSCRN_ALLDRAW << 1));  
                                                 }  
                                                 gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);  
                                                 screenupdate |= 1;  
                                         }                                          }
                                           gdcs.grphdisp &= ~(GDCSCRN_MAKE << 1);
                                           screenupdate |= 1;
                                 }                                  }
                         }                          }
                 }                  }
           }
                 if (gdcs.textdisp & GDCSCRN_ENABLE) {          if (gdcs.textdisp & GDCSCRN_ENABLE) {
                         if (tramflag.renewal) {                  if (tramflag.renewal) {
                                 gdcs.textdisp |= maketext_curblink();                          gdcs.textdisp |= maketext_curblink();
                         }                  }
                         if ((cgwindow.writable & 0x80) && (tramflag.gaiji)) {                  if ((cgwindow.writable & 0x80) && (tramflag.gaiji)) {
                                 gdcs.textdisp |= GDCSCRN_ALLDRAW;                          gdcs.textdisp |= GDCSCRN_ALLDRAW;
                   }
                   cgwindow.writable &= ~0x80;
                   if (gdcs.textdisp & GDCSCRN_MAKE) {
                           if (!(gdc.mode1 & 0x4)) {
                                   maketext(gdcs.textdisp & GDCSCRN_ALLDRAW);
                         }                          }
                         cgwindow.writable &= ~0x80;                          else {
                         if (gdcs.textdisp & GDCSCRN_MAKE) {                                  maketext40(gdcs.textdisp & GDCSCRN_ALLDRAW);
                                 if (!(gdc.mode1 & 0x4)) {  
                                         maketext(gdcs.textdisp & GDCSCRN_ALLDRAW);  
                                 }  
                                 else {  
                                         maketext40(gdcs.textdisp & GDCSCRN_ALLDRAW);  
                                 }  
                                 gdcs.textdisp &= ~GDCSCRN_MAKE;  
                                 screenupdate |= 1;  
                         }                          }
                 }                          gdcs.textdisp &= ~GDCSCRN_MAKE;
                 if (screenupdate) {                          screenupdate |= 1;
                         screenupdate = scrndraw_draw((BYTE)(screenupdate & 2));  
                         drawcount++;  
                 }                  }
         }          }
           if (screenupdate) {
                   screenupdate = scrndraw_draw((UINT8)(screenupdate & 2));
                   drawcount++;
           }
 }  }
   
 void screendisp(NEVENTITEM item) {  void screendisp(NEVENTITEM item) {
Line 479  void screendisp(NEVENTITEM item) { Line 514  void screendisp(NEVENTITEM item) {
         gdc_work(GDCWORK_SLAVE);          gdc_work(GDCWORK_SLAVE);
         gdc.vsync = 0;          gdc.vsync = 0;
         screendispflag = 0;          screendispflag = 0;
         if (!np2cfg.DISPSYNC) {                                                                                 // ver0.29          if (!np2cfg.DISPSYNC) {
                 drawscreen();                  drawscreen();
         }          }
         pi = &pic.pi[0];          pi = &pic.pi[0];
Line 492  void screendisp(NEVENTITEM item) { Line 527  void screendisp(NEVENTITEM item) {
   
 void screenvsync(NEVENTITEM item) {  void screenvsync(NEVENTITEM item) {
   
         vramop.tramwait = np2cfg.wait[1];          MEMWAIT_TRAM = np2cfg.wait[1];
         vramop.vramwait = np2cfg.wait[3];          MEMWAIT_VRAM = np2cfg.wait[3];
         vramop.grcgwait = np2cfg.wait[5];          MEMWAIT_GRCG = np2cfg.wait[5];
         gdc_work(GDCWORK_MASTER);          gdc_work(GDCWORK_MASTER);
         gdc.vsync = 0x20;          gdc.vsync = 0x20;
         if (gdc.vsyncint) {          if (gdc.vsyncint) {
                 gdc.vsyncint = 0;                  gdc.vsyncint = 0;
                 pic_setirq(2);                  pic_setirq(2);
         }          }
         nevent_set(NEVENT_FLAMES, pc.vsyncclock, screendisp, NEVENT_RELATIVE);          nevent_set(NEVENT_FLAMES, gdc.vsyncclock, screendisp, NEVENT_RELATIVE);
   
         // drawscreenで pc.vsyncclockが変更される可能性があります               // ver0.28          // drawscreenで pccore.vsyncclockが変更される可能性があります
         if (np2cfg.DISPSYNC) {                                                                                  // ver0.29          if (np2cfg.DISPSYNC) {
                 drawscreen();                  drawscreen();
         }          }
         (void)item;          (void)item;
Line 519  static int execcnt = 0; Line 554  static int execcnt = 0;
 int piccnt = 0;  int piccnt = 0;
 #endif  #endif
   
   
   void pccore_postevent(UINT32 event) {   // yet!
   
           (void)event;
   }
   
 void pccore_exec(BOOL draw) {  void pccore_exec(BOOL draw) {
   
         drawframe = draw;          drawframe = draw;
         keyext_flash();  //      keystat_sync();
         soundmng_sync();          soundmng_sync();
         mouseif_sync();          mouseif_sync();
         pal_eventclear();          pal_eventclear();
   
         gdc.vsync = 0;          gdc.vsync = 0;
         screendispflag = 1;          screendispflag = 1;
         vramop.tramwait = np2cfg.wait[0];          MEMWAIT_TRAM = np2cfg.wait[0];
         vramop.vramwait = np2cfg.wait[2];          MEMWAIT_VRAM = np2cfg.wait[2];
         vramop.grcgwait = np2cfg.wait[4];          MEMWAIT_GRCG = np2cfg.wait[4];
         nevent_set(NEVENT_FLAMES, pc.dispclock, screenvsync, NEVENT_RELATIVE);          nevent_set(NEVENT_FLAMES, gdc.dispclock, screenvsync, NEVENT_RELATIVE);
   
 //      nevent_get1stevent();  //      nevent_get1stevent();
   
         while(screendispflag) {          while(screendispflag) {
 #if defined(TRACE)  #if defined(TRACE)
         resetcnt++;                  resetcnt++;
 #endif  #endif
                 pic_irq();                  pic_irq();
                 if (CPU_RESETREQ) {                  if (CPU_RESETREQ) {
                         CPU_RESETREQ = 0;                          CPU_RESETREQ = 0;
                         CPU_CS = 0xf000;                          CPU_SHUT();
                         CS_BASE = 0xf0000;  
                         CPU_IP = 0xfff0;  
 #if defined(CPUCORE_IA32)  
                         CPU_DX = 0x0300;  
 #endif  
                         CPU_CLEARPREFETCH();  
                 }                  }
   
 #if 1 // ndef TRACE  
                 if (CPU_REMCLOCK > 0) {                  if (CPU_REMCLOCK > 0) {
                         if (!(CPU_TYPE & CPUTYPE_V30)) {                          if (!(CPU_TYPE & CPUTYPE_V30)) {
                                 CPU_EXEC();                                  CPU_EXEC();
Line 561  void pccore_exec(BOOL draw) { Line 594  void pccore_exec(BOOL draw) {
                                 CPU_EXECV30();                                  CPU_EXECV30();
                         }                          }
                 }                  }
 #else  
                 while(CPU_REMCLOCK > 0) {  
                         TRACEOUT(("%.4x:%.4x", CPU_CS, CPU_IP));  
                         i286_step();  
                 }  
 #endif  
                 nevent_progress();                  nevent_progress();
         }          }
         artic_callback();          artic_callback();
         mpu98ii_callback();          mpu98ii_callback();
         diskdrv_callback();          diskdrv_callback();
         calendar_inc();          calendar_inc();
           S98_sync();
         sound_sync();                                                                                                   // happy!          sound_sync();                                                                                                   // happy!
   
           if (hardwarereset) {
                   hardwarereset = FALSE;
                   pccore_cfgupdate();
                   pccore_reset();
           }
   
 #if defined(TRACE)  #if defined(TRACE)
         execcnt++;          execcnt++;
         if (execcnt >= 60) {          if (execcnt >= 60) {
                 TRACEOUT(("resetcnt = %d / pic %d", resetcnt, piccnt));  //              TRACEOUT(("resetcnt = %d / pic %d", resetcnt, piccnt));
                 execcnt = 0;                  execcnt = 0;
                 resetcnt = 0;                  resetcnt = 0;
                 piccnt = 0;                  piccnt = 0;
Removed from v.1.28  
changed lines
  Added in v.1.100

RetroPC.NET-CVS <cvs@retropc.net>