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

Diff for /np2/io/gdc.c between versions 1.2 and 1.10

version 1.2, 2003/10/17 07:17:20 version 1.10, 2003/12/27 11:55:23
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "scrnmng.h"  #include        "scrnmng.h"
 #include        "i286.h"  #include        "cpucore.h"
 #include        "memory.h"  
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "gdc_cmd.tbl"  
 #include        "palettes.h"  
 #include        "vram.h"  #include        "vram.h"
   #include        "palettes.h"
   #include        "gdc_cmd.tbl"
   
   
 #define SEARHC_SYNC  #define SEARHC_SYNC
 #define TURE_SYNC  #define TURE_SYNC
   
 extern BYTE screenupdate;  
   
   static const UINT8 defdegpal[4] = {0x04,0x15,0x26,0x37};
   static const UINT8 defsync[8] = {0x10,0x4e,0x07,0x25,0x07,0x07,0x90,0x65};
   
 static const BYTE defdegpal[4] = {0x04,0x15,0x26,0x37};  
 static const BYTE defsync[8] = {0x10,0x4e,0x07,0x25,0x07,0x07,0x90,0x65};  
   
   void gdc_setdegitalpal(int color, REG8 value) {
 void gdc_setdegitalpal(int color, BYTE value) {  
   
         if (color & 4) {          if (color & 4) {
                 color &= 3;                  color &= 3;
Line 41  void gdc_setdegitalpal(int color, BYTE v Line 38  void gdc_setdegitalpal(int color, BYTE v
         }          }
 }  }
   
 void gdc_setanalogpal(int color, int rgb, BYTE value) {  void gdc_setanalogpal(int color, int rgb, REG8 value) {
   
         BYTE            *ptr;          UINT8           *ptr;
         PAL1EVENT       *event;          PAL1EVENT       *event;
   
         ptr = ((BYTE *)(gdc.anapal + color)) + rgb;          ptr = ((UINT8 *)(gdc.anapal + color)) + rgb;
         if ((*ptr ^ value) & 0x0f) {          if (((*ptr) ^ value) & 0x0f) {
                 gdcs.palchange = GDCSCRN_REDRAW;                  gdcs.palchange = GDCSCRN_REDRAW;
                 if ((palevent.events < PALEVENTMAX) && (!gdc.vsync)) {                  if (palevent.events < PALEVENTMAX) {
                         event = palevent.event + palevent.events;                          if (!gdc.vsync) {
                         event->clock = nevent.item[NEVENT_FLAMES].clock -                                  event = palevent.event + palevent.events;
                                                                         (nevent.baseclock - nevent.remainclock);                                  event->clock = nevent.item[NEVENT_FLAMES].clock -
                         event->color = (color * sizeof(RGB32)) + rgb;                                                                                          (CPU_BASECLOCK - CPU_REMCLOCK);
                         event->value = value;                                  event->color = (color * sizeof(RGB32)) + rgb;
                         palevent.events++;                                  event->value = (UINT8)value;
                                   palevent.events++;
                           }
                           else {
                                   palevent.vsyncpal = 1;
                           }
                 }                  }
         }          }
         *ptr = value;          *ptr = value;
 }  }
   
 void gdc_setdegpalpack(int color, BYTE value) {  void gdc_setdegpalpack(int color, REG8 value) {
   
         if ((gdc.degpal[color] ^ value) & 0x77) {          if ((gdc.degpal[color] ^ value) & 0x77) {
                 gdcs.palchange = GDCSCRN_REDRAW;                  gdcs.palchange = GDCSCRN_REDRAW;
         }          }
         gdc.degpal[color] = value;          gdc.degpal[color] = (UINT8)value;
 }  }
   
 void gdc_paletteinit(void) {  void gdc_paletteinit(void) {
   
         BYTE    c;          int             c;
   
         CopyMemory(gdc.degpal, defdegpal, 4);          CopyMemory(gdc.degpal, defdegpal, 4);
         for (c=0; c<8; c++) {          for (c=0; c<8; c++) {
Line 128  static void textdraw(void) {         //  Line 130  static void textdraw(void) {         // 
   
 void gdc_work(int id) {  void gdc_work(int id) {
   
         UINT16          i;  
         BYTE            data;  
         GDCDATA         item;          GDCDATA         item;
         BYTE            *dispflag;          UINT8           *dispflag;
           UINT            i;
           BYTE            data;
   
         item = ((id==GDCWORK_MASTER)?(&gdc.m):(&gdc.s));          item = (id==GDCWORK_MASTER)?&gdc.m:&gdc.s;
         dispflag = ((id==GDCWORK_MASTER)?(&gdcs.textdisp):(&gdcs.grphdisp));          dispflag = (id==GDCWORK_MASTER)?&gdcs.textdisp:&gdcs.grphdisp;
   
         for (i=0; i<item->cnt; i++) {          for (i=0; i<item->cnt; i++) {
                 data = (BYTE)item->fifo[i];                  data = (BYTE)item->fifo[i];
Line 148  void gdc_work(int id) { Line 150  void gdc_work(int id) {
                                                 item->rcv = 2;                                                  item->rcv = 2;
                                                 item->paracb = 1;                                                  item->paracb = 1;
                                                 break;                                                  break;
   
                                         case 0x10:                                          case 0x10:
                                         case 0x18:                                          case 0x18:
                                                 item->rcv = 1;                                                  item->rcv = 1;
                                                 item->paracb = 1;                                                  item->paracb = 1;
                                                 break;                                                  break;
   
                                         default:                                          default:
                                                 item->rcv = 0;                                                  item->rcv = 0;
                                                 break;                                                  break;
Line 242  void gdc_restorekacmode(void) { Line 246  void gdc_restorekacmode(void) {
   
 // ---- I/O  // ---- I/O
   
 static void IOOUTCALL gdc_o60(UINT port, BYTE dat) {  static void IOOUTCALL gdc_o60(UINT port, REG8 dat) {
   
         if (gdc.m.cnt < GDCCMD_MAX) {          if (gdc.m.cnt < GDCCMD_MAX) {
                 gdc.m.fifo[gdc.m.cnt++] = dat;                  gdc.m.fifo[gdc.m.cnt++] = dat;
Line 250  static void IOOUTCALL gdc_o60(UINT port, Line 254  static void IOOUTCALL gdc_o60(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_o62(UINT port, BYTE dat) {  static void IOOUTCALL gdc_o62(UINT port, REG8 dat) {
   
         if (gdc.m.cnt < GDCCMD_MAX) {          if (gdc.m.cnt < GDCCMD_MAX) {
                 gdc.m.fifo[gdc.m.cnt++] = 0x100 | dat;                  gdc.m.fifo[gdc.m.cnt++] = 0x100 | dat;
Line 259  static void IOOUTCALL gdc_o62(UINT port, Line 263  static void IOOUTCALL gdc_o62(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_o64(UINT port, BYTE dat) {  static void IOOUTCALL gdc_o64(UINT port, REG8 dat) {
   
         gdc.vsyncint = 1;          gdc.vsyncint = 1;
         (void)port;          (void)port;
         (void)dat;          (void)dat;
 }  }
   
 static void IOOUTCALL gdc_o68(UINT port, BYTE dat) {  static void IOOUTCALL gdc_o68(UINT port, REG8 dat) {
   
         BYTE    bit;          REG8    bit;
   
         if (!(dat & 0xf0)) {                                                                    // ver0.28          if (!(dat & 0xf0)) {                                                                    // ver0.28
                 bit = 1 << ((dat >> 1) & 7);                  bit = 1 << ((dat >> 1) & 7);
Line 296  static void IOOUTCALL gdc_o68(UINT port, Line 300  static void IOOUTCALL gdc_o68(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_o6a(UINT port, BYTE dat) {  static void IOOUTCALL gdc_o6a(UINT port, REG8 dat) {
   
         BYTE    bit;          REG8    bit;
   
         if (!(dat & 0xf8)) {          if (!(dat & 0xf8)) {
                 bit = (dat >> 1) & 3;                  bit = (dat >> 1) & 3;
Line 331  static void IOOUTCALL gdc_o6a(UINT port, Line 335  static void IOOUTCALL gdc_o6a(UINT port,
         else {          else {
                 switch(dat) {                  switch(dat) {
                         case 0x40:                          case 0x40:
                           case 0x80:                                      // EPSON?
                                 gdc.display &= ~1;                                  gdc.display &= ~1;
                                 gdcs.textdisp |= GDCSCRN_EXT;                                  gdcs.textdisp |= GDCSCRN_EXT;
                                 break;                                  break;
   
                         case 0x41:                          case 0x41:
                           case 0x81:                                      // EPSON?
                                 gdc.display |= 1;                                  gdc.display |= 1;
                                 gdcs.textdisp |= GDCSCRN_EXT;                                  gdcs.textdisp |= GDCSCRN_EXT;
                                 break;                                  break;
Line 364  static void IOOUTCALL gdc_o6a(UINT port, Line 370  static void IOOUTCALL gdc_o6a(UINT port,
         (void)port;          (void)port;
 }  }
   
 static BYTE IOINPCALL gdc_i60(UINT port) {  static REG8 IOINPCALL gdc_i60(UINT port) {
   
         BYTE    ret;          REG8    ret;
         long    remain;          SINT32  remain;
   
         ret = 0x80 | gdc.vsync;         // | m_drawing;          ret = 0x80 | gdc.vsync;         // | m_drawing;
         remain = nevent_getremain(NEVENT_FLAMES);          remain = nevent_getremain(NEVENT_FLAMES);
Line 389  static BYTE IOINPCALL gdc_i60(UINT port) Line 395  static BYTE IOINPCALL gdc_i60(UINT port)
                 gdc_work(GDCWORK_MASTER);                  gdc_work(GDCWORK_MASTER);
         }          }
 #ifdef SEARHC_SYNC  #ifdef SEARHC_SYNC
         if ((i286reg.inport) && (nevent.remainclock >= 5)) {          if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {
                 UINT16 jadr = 0xfa74;                  UINT16 jadr = 0xfa74;
                 UINT16 memv;                  UINT16 memv;
                 memv = i286_memoryread_w(i286reg.inport);                  memv = i286_memoryread_w(CPU_INPADRS);
                 while((memv == 0x00eb) || (memv == 0x5fe6)) {                  while((memv == 0x00eb) || (memv == 0x5fe6)) {
                         jadr -= 0x200;                          jadr -= 0x200;
                         i286reg.inport += 2;                          CPU_INPADRS += 2;
                         memv = i286_memoryread_w(i286reg.inport);                          memv = i286_memoryread_w(CPU_INPADRS);
                 }                  }
                 if ((memv == 0x20a8) || (memv == 0x2024)) {                  if ((memv == 0x20a8) || (memv == 0x2024)) {
                         memv = i286_memoryread_w(i286reg.inport + 2);                          memv = i286_memoryread_w(CPU_INPADRS + 2);
                         if (memv == jadr) {                                     // je                          if (memv == jadr) {                                     // je
                                 if (!gdc.vsync) {                                  if (!gdc.vsync) {
                                         nevent.remainclock = -1;                                          CPU_REMCLOCK = -1;
                                 }                                  }
                         }                          }
                         else if (memv == (jadr + 1)) {          // jne                          else if (memv == (jadr + 1)) {          // jne
                                 if (gdc.vsync) {                                  if (gdc.vsync) {
                                         nevent.remainclock = -1;                                          CPU_REMCLOCK = -1;
                                 }                                  }
                         }                          }
                 }                  }
         }          }
 #endif  #endif
 #ifdef TURE_SYNC                                // クロックイベントの誤差修正  #ifdef TURE_SYNC                                // クロックイベントの誤差修正
         if (nevent.item[NEVENT_FLAMES].clock <          if (nevent.item[NEVENT_FLAMES].clock < (CPU_BASECLOCK - CPU_REMCLOCK)) {
                                                                 (nevent.baseclock - nevent.remainclock)) {  
                 ret ^= 0x20;                  ret ^= 0x20;
         }          }
 #endif  #endif
Line 423  static BYTE IOINPCALL gdc_i60(UINT port) Line 428  static BYTE IOINPCALL gdc_i60(UINT port)
         return(ret);          return(ret);
 }  }
   
 static BYTE IOINPCALL gdc_i62(UINT port) {  static REG8 IOINPCALL gdc_i62(UINT port) {
   
         if (gdc.m.snd) {          if (gdc.m.snd) {
                 gdc.m.snd--;                  gdc.m.snd--;
Line 433  static BYTE IOINPCALL gdc_i62(UINT port) Line 438  static BYTE IOINPCALL gdc_i62(UINT port)
         return(0xff);          return(0xff);
 }  }
   
 static BYTE IOINPCALL gdc_i68(UINT port) {  static REG8 IOINPCALL gdc_i68(UINT port) {
   
         (void)port;          (void)port;
         return(gdc.mode1);          return(gdc.mode1);
 }  }
   
 static BYTE IOINPCALL gdc_i6a(UINT port) {  static REG8 IOINPCALL gdc_i6a(UINT port) {
   
         (void)port;          (void)port;
         return(gdc.mode2);          return(gdc.mode2);
 }  }
   
   
 static void IOOUTCALL gdc_oa0(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oa0(UINT port, REG8 dat) {
   
         if (gdc.s.cnt < GDCCMD_MAX) {          if (gdc.s.cnt < GDCCMD_MAX) {
                 gdc.s.fifo[gdc.s.cnt++] = dat;                  gdc.s.fifo[gdc.s.cnt++] = dat;
         }          }
   //      TRACEOUT(("GDC-B %.2x", dat));
         if (gdc.s.paracb) {                                             // ver0.29          if (gdc.s.paracb) {                                             // ver0.29
                 gdc_work(GDCWORK_SLAVE);                  gdc_work(GDCWORK_SLAVE);
         }          }
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oa2(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oa2(UINT port, REG8 dat) {
   
         if (gdc.s.cnt < GDCCMD_MAX) {          if (gdc.s.cnt < GDCCMD_MAX) {
                 gdc.s.fifo[gdc.s.cnt++] = 0x100 | dat;                  gdc.s.fifo[gdc.s.cnt++] = 0x100 | dat;
         }          }
   //      TRACEOUT(("GDC-A %.2x", dat));
         gdc_work(GDCWORK_SLAVE);          gdc_work(GDCWORK_SLAVE);
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oa4(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oa4(UINT port, REG8 dat) {
   
         if ((gdcs.disp ^ dat) & 1) {          if ((gdcs.disp ^ dat) & 1) {
                 gdcs.disp = dat & 1;                  gdcs.disp = dat & 1;
Line 475  static void IOOUTCALL gdc_oa4(UINT port, Line 482  static void IOOUTCALL gdc_oa4(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oa6(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oa6(UINT port, REG8 dat) {
   
         if ((gdcs.access ^ dat) & 1) {          if ((gdcs.access ^ dat) & 1) {
                 gdcs.access = dat & 1;                  gdcs.access = dat & 1;
Line 486  static void IOOUTCALL gdc_oa6(UINT port, Line 493  static void IOOUTCALL gdc_oa6(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oa8(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oa8(UINT port, REG8 dat) {
   
         if (gdc.analog) {          if (gdc.analog) {
                 gdc.palnum = dat & 0x0f;                  gdc.palnum = dat & 0x0f;
Line 497  static void IOOUTCALL gdc_oa8(UINT port, Line 504  static void IOOUTCALL gdc_oa8(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oaa(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oaa(UINT port, REG8 dat) {
   
         if (gdc.analog) {          if (gdc.analog) {
                 gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.g), dat);                  gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.g), dat);
Line 508  static void IOOUTCALL gdc_oaa(UINT port, Line 515  static void IOOUTCALL gdc_oaa(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oac(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oac(UINT port, REG8 dat) {
   
         if (gdc.analog) {          if (gdc.analog) {
                 gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.r), dat);                  gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.r), dat);
Line 519  static void IOOUTCALL gdc_oac(UINT port, Line 526  static void IOOUTCALL gdc_oac(UINT port,
         (void)port;          (void)port;
 }  }
   
 static void IOOUTCALL gdc_oae(UINT port, BYTE dat) {  static void IOOUTCALL gdc_oae(UINT port, REG8 dat) {
   
         if (gdc.analog) {          if (gdc.analog) {
                 gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.b), dat);                  gdc_setanalogpal(gdc.palnum, offsetof(RGB32, p.b), dat);
Line 530  static void IOOUTCALL gdc_oae(UINT port, Line 537  static void IOOUTCALL gdc_oae(UINT port,
         (void)port;          (void)port;
 }  }
   
 static BYTE IOINPCALL gdc_ia0(UINT port) {  static REG8 IOINPCALL gdc_ia0(UINT port) {
   
         BYTE    ret;          REG8    ret;
         SINT32  remain;          SINT32  remain;
   
         ret = 0x80 | gdc.vsync | gdc.s_drawing;          ret = 0x80 | gdc.vsync | gdc.s_drawing;
Line 555  static BYTE IOINPCALL gdc_ia0(UINT port) Line 562  static BYTE IOINPCALL gdc_ia0(UINT port)
                 gdc_work(GDCWORK_SLAVE);                  gdc_work(GDCWORK_SLAVE);
         }          }
 #ifdef SEARHC_SYNC  #ifdef SEARHC_SYNC
         if ((i286reg.inport) && (nevent.remainclock >= 5)) {          if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {
                 UINT16 jadr = 0xfa74;                  UINT16 jadr = 0xfa74;
                 UINT16 memv;                  UINT16 memv;
                 memv = i286_memoryread_w(i286reg.inport);                  memv = i286_memoryread_w(CPU_INPADRS);
                 while((memv == 0x00eb) || (memv == 0x5fe6)) {                  while((memv == 0x00eb) || (memv == 0x5fe6)) {
                         jadr -= 0x200;                          jadr -= 0x200;
                         i286reg.inport += 2;                          CPU_INPADRS += 2;
                         memv = i286_memoryread_w(i286reg.inport);                          memv = i286_memoryread_w(CPU_INPADRS);
                 }                  }
                 if ((memv == 0x20a8) || (memv == 0x2024)) {                  if ((memv == 0x20a8) || (memv == 0x2024)) {
                         memv = i286_memoryread_w(i286reg.inport + 2);                          memv = i286_memoryread_w(CPU_INPADRS + 2);
                         if (memv == jadr) {                                     // je                          if (memv == jadr) {                                     // je
                                 if (!gdc.vsync) {                                  if (!gdc.vsync) {
                                         nevent.remainclock = -1;                                          CPU_REMCLOCK = -1;
                                 }                                  }
                         }                          }
                         else if (memv == (jadr + 1)) {          // jne                          else if (memv == (jadr + 1)) {          // jne
                                 if (gdc.vsync) {                                  if (gdc.vsync) {
                                         nevent.remainclock = -1;                                          CPU_REMCLOCK = -1;
                                 }                                  }
                         }                          }
                 }                  }
         }          }
 #endif  #endif
 #ifdef TURE_SYNC                                // クロックイベントの誤差修正  #ifdef TURE_SYNC                                // クロックイベントの誤差修正
         if (nevent.item[NEVENT_FLAMES].clock <          if (nevent.item[NEVENT_FLAMES].clock < (CPU_BASECLOCK - CPU_REMCLOCK)) {
                                                                 (nevent.baseclock - nevent.remainclock)) {  
                 ret ^= 0x20;                  ret ^= 0x20;
         }          }
 #endif  #endif
Line 589  static BYTE IOINPCALL gdc_ia0(UINT port) Line 595  static BYTE IOINPCALL gdc_ia0(UINT port)
         return(ret);          return(ret);
 }  }
   
 static BYTE IOINPCALL gdc_ia2(UINT port) {  static REG8 IOINPCALL gdc_ia2(UINT port) {
   
         if (gdc.s.snd) {          if (gdc.s.snd) {
                 gdc.s.snd--;                  gdc.s.snd--;
Line 599  static BYTE IOINPCALL gdc_ia2(UINT port) Line 605  static BYTE IOINPCALL gdc_ia2(UINT port)
         return(0xff);          return(0xff);
 }  }
   
 static BYTE IOINPCALL gdc_ia4(UINT port) {  static REG8 IOINPCALL gdc_ia4(UINT port) {
   
         (void)port;          (void)port;
         return(gdcs.disp);          return(gdcs.disp);
 }  }
   
 static BYTE IOINPCALL gdc_ia6(UINT port) {  static REG8 IOINPCALL gdc_ia6(UINT port) {
   
         (void)port;          (void)port;
         return(gdcs.access);          return(gdcs.access);
Removed from v.1.2  
changed lines
  Added in v.1.10

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