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

Diff for /np2/io/gdc.c between versions 1.13 and 1.16

version 1.13, 2004/02/07 21:23:22 version 1.16, 2004/02/11 17:39:59
Line 6 Line 6
 #include        "vram.h"  #include        "vram.h"
 #include        "palettes.h"  #include        "palettes.h"
 #include        "gdc_cmd.tbl"  #include        "gdc_cmd.tbl"
   #include        "timing.h"
   
   
 #define SEARHC_SYNC  #define SEARCH_SYNC
 #define TURE_SYNC  #define TURE_SYNC
   
   typedef struct {
           UINT32  clock;
           UINT    minx;
           UINT    maxx;
           UINT    miny;
           UINT    maxy;
   } GDCCLK;
   
   static const GDCCLK gdcclk[] = {
                           {14318180 / 8, 112 - 8, 112 + 8, 200, 300},
                           {21052600 / 8, 106 - 6, 106 + 6, 400, 575},
                           {25056815 / 8, 106 - 6, 106 + 6, 400, 575},
                           {25175000 / 8, 100 - 4, 100 + 4, 400, 575}};
   
   
 static const UINT8 defdegpal[4] = {0x04,0x15,0x26,0x37};  static const UINT8 defdegpal[4] = {0x04,0x15,0x26,0x37};
 static const UINT8 defsync15[8] = {0x10,0x4e,0x07,0x25,0x0d,0x0f,0xc8,0x94};  
 static const UINT8 defsync24[8] = {0x10,0x4e,0x07,0x25,0x07,0x07,0x90,0x65};  static const UINT8 defsyncm15[8] = {0x10,0x4e,0x07,0x25,0x0d,0x0f,0xc8,0x94};
   static const UINT8 defsyncs15[8] = {0x06,0x26,0x03,0x11,0x86,0x0f,0xc8,0x94};
   
   static const UINT8 defsyncm24[8] = {0x10,0x4e,0x07,0x25,0x07,0x07,0x90,0x65};
   static const UINT8 defsyncs24[8] = {0x06,0x26,0x03,0x11,0x83,0x07,0x90,0x65};
   
   
 void gdc_setdegitalpal(int color, REG8 value) {  void gdc_setdegitalpal(int color, REG8 value) {
Line 96  void gdc_paletteinit(void) { Line 115  void gdc_paletteinit(void) {
   
 static void vectdraw(void) {  static void vectdraw(void) {
   
         UINT32  csrw;          UINT32          csrw;
         UINT16  textw;  const GDCVECT   *vect;
           REG16           textw;
           REG8            ope;
   
         csrw = LOADINTELDWORD(gdc.s.para + GDC_CSRW);          csrw = LOADINTELDWORD(gdc.s.para + GDC_CSRW);
           vect = (GDCVECT *)(gdc.s.para + GDC_VECTW);
         textw = LOADINTELWORD(gdc.s.para + GDC_TEXTW);          textw = LOADINTELWORD(gdc.s.para + GDC_TEXTW);
           ope = gdc.s.para[GDC_WRITE];
   
         if (gdc.s.para[GDC_VECTW] & 0x8) {          if (vect->ope & 0x08) {
                 gdcsub_line(csrw, (GDCVECT *)(gdc.s.para + GDC_VECTW),                  gdcsub_line(csrw, vect, textw, ope);
                                                                                         textw, gdc.s.para[GDC_WRITE]);          }
           if (vect->ope & 0x10) {         // undocumented
                   gdcsub_txt(csrw, vect, textw, ope);
         }          }
         if (gdc.s.para[GDC_VECTW] & 0x20) {          if (vect->ope & 0x20) {
                 gdcsub_circle(csrw, (GDCVECT *)(gdc.s.para + GDC_VECTW),                  gdcsub_circle(csrw, vect, textw, ope);
                                                                                         textw, gdc.s.para[GDC_WRITE]);  
         }          }
         if (gdc.s.para[GDC_VECTW] & 0x40) {          if (vect->ope & 0x40) {
                 gdcsub_box(csrw, (GDCVECT *)(gdc.s.para + GDC_VECTW),                  gdcsub_box(csrw, vect, textw, ope);
                                                                                         textw, gdc.s.para[GDC_WRITE]);  
         }          }
 }  }
   
 static void textdraw(void) {                                                                    // ver0.30  static void textdraw(void) {
   
         UINT32  csrw;          UINT32          csrw;
         UINT16  textw;  const GDCVECT   *vect;
           REG16           textw;
           REG8            ope;
   
         if (gdc.s.para[GDC_VECTW] & 0x10) {          csrw = LOADINTELDWORD(gdc.s.para + GDC_CSRW);
                 csrw = LOADINTELDWORD(gdc.s.para + GDC_CSRW);          vect = (GDCVECT *)(gdc.s.para + GDC_VECTW);
                 textw = LOADINTELWORD(gdc.s.para + GDC_TEXTW);          textw = gdc.s.para[GDC_TEXTW + 7];
                 gdcsub_text(csrw, (GDCVECT *)(gdc.s.para + GDC_VECTW),          textw = (textw << 8) + textw;
                                                                                         textw, gdc.s.para[GDC_WRITE]);          ope = gdc.s.para[GDC_WRITE];
   
           if (vect->ope & 0x08) {         // undocumented
                   gdcsub_line(csrw, vect, textw, ope);
           }
           if (vect->ope & 0x10) {
                   gdcsub_text(csrw, vect, gdc.s.para + GDC_TEXTW, ope);
           }
           if (vect->ope & 0x20) {         // undocumented
                   gdcsub_circle(csrw, vect, textw, ope);
           }
           if (vect->ope & 0x40) {         // undocumented
                   gdcsub_box(csrw, vect, textw, ope);
         }          }
 }  }
   
Line 193  void gdc_work(int id) { Line 230  void gdc_work(int id) {
                                                 textdraw();                                                  textdraw();
                                         }                                          }
                                         break;                                          break;
                                   
                         }                          }
                         item->ptr = gdc_cmd[data].pos;                          item->ptr = gdc_cmd[data].pos;
                         item->rcv = gdc_cmd[data].outdatas;                          item->rcv = gdc_cmd[data].outdatas;
Line 234  void gdc_forceready(GDCDATA item) { Line 270  void gdc_forceready(GDCDATA item) {
         item->snd = 0;          item->snd = 0;
 }  }
   
 void gdc_updateclock(void) {  
   
         UINT    vfp;  void gdc_updateclock(void) {
         UINT    vbp;  
         UINT    lf;  
         UINT    vs;  
         UINT    maxy;  
         UINT    cnt;  
   
         vfp = gdc.m.para[GDC_SYNC + 5] & 0x3f;          UINT            tmp;
         if (!vfp) {          UINT            cr;
                 vfp = 1;          UINT            hfbs;
         }          UINT            vfbs;
         vbp = gdc.m.para[GDC_SYNC + 7] >> 2;          UINT            lf;
         if (!vbp) {          UINT            x;
                 vbp = 1;          UINT            y;
         }          UINT            cnt;
         lf = LOADINTELWORD(gdc.m.para + GDC_SYNC + 6);  const GDCCLK    *clk;
         lf &= 0x3ff;          UINT32          hclock;
         if (!lf) {  
                 lf = 1024;          cr = gdc.m.para[GDC_SYNC + 1] + 2;
         }          tmp = LOADINTELWORD(gdc.m.para + GDC_SYNC + 2);
         vs = LOADINTELWORD(gdc.m.para + GDC_SYNC + 4);          hfbs = tmp & 0x1f;                                                                      // HS
         vs = (vs >> 5) & 0x1f;          hfbs += tmp >> 10;                                                                      // HFP
         if (!vs) {          vfbs = (tmp >> 5) & 0x1f;                                                       // VS
                 vs = 1;          hfbs += gdc.m.para[GDC_SYNC + 4] & 0x3f;                        // HFP
         }          vfbs += gdc.m.para[GDC_SYNC + 5] & 0x3f;                        // VFP
         maxy = lf + vfp + vbp + vs;          tmp = LOADINTELWORD(gdc.m.para + GDC_SYNC + 6);
         cnt = (pccore.realclock * 5) / 282;          lf = ((tmp - 1) & 0x3ff) + 1;
         gdc.rasterclock = cnt / maxy;          vfbs += tmp >> 10;                                                                      // VBP
         gdc.hsyncclock = (gdc.rasterclock * 4) / 5;  
           hfbs += 3;
           x = cr + hfbs;
           if (!vfbs) {
                   vfbs = 1;
           }
           y = lf + vfbs;
   //      TRACEOUT(("h %d:%d / v %d:%d", cr, x, lf, y));
   
           if (!(gdc.crt15khz & 2)) {                                                      // 24.83±300Hz
                   clk = gdcclk + 1;
           }
           else {                                                                                          // 15.98±300Hz
                   clk = gdcclk;
           }
   
           if (x < clk->minx) {
                   cr = (clk->minx * cr) / x;
                   x = clk->minx;
           }
           else if (x > clk->maxx) {
                   cr = (clk->maxx * cr) / x;
                   x = clk->maxx;
           }
           if (y < clk->miny) {
                   lf = (clk->miny * lf) / y;
                   y = clk->miny;
           }
           else if (y > clk->maxy) {
                   lf = (clk->maxy * lf) / y;
                   y = clk->maxy;
           }
           hclock = clk->clock / x;
           cnt = (pccore.baseclock * y) / hclock;
           cnt *= pccore.multiple;
           gdc.rasterclock = cnt / y;
           gdc.hsyncclock = (gdc.rasterclock * cr) / x;
         gdc.dispclock = gdc.rasterclock * lf;          gdc.dispclock = gdc.rasterclock * lf;
         gdc.vsyncclock = cnt - gdc.dispclock;          gdc.vsyncclock = cnt - gdc.dispclock;
           timing_setrate(y, hclock);
 }  }
   
 void gdc_restorekacmode(void) {  void gdc_restorekacmode(void) {
Line 414  static void IOOUTCALL gdc_o6e(UINT port, Line 481  static void IOOUTCALL gdc_o6e(UINT port,
   
         switch(dat) {          switch(dat) {
                 case 0:                  case 0:
                         gdc.crt15khz = 0;                          gdc.crt15khz &= ~1;
                         gdcs.textdisp |= GDCSCRN_ALLDRAW2;                          gdcs.textdisp |= GDCSCRN_ALLDRAW2;
                         break;                          break;
   
                 case 1:                  case 1:
                         gdc.crt15khz = 1;                          gdc.crt15khz |= 1;
                         gdcs.textdisp |= GDCSCRN_ALLDRAW2;                          gdcs.textdisp |= GDCSCRN_ALLDRAW2;
                         break;                          break;
         }          }
Line 450  static REG8 IOINPCALL gdc_i60(UINT port) Line 517  static REG8 IOINPCALL gdc_i60(UINT port)
         else {          else {
                 gdc_work(GDCWORK_MASTER);                  gdc_work(GDCWORK_MASTER);
         }          }
 #ifdef SEARHC_SYNC  #ifdef SEARCH_SYNC
         if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {          if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {
                 UINT16 jadr = 0xfa74;                  UINT16 jadr = 0xfa74;
                 UINT16 memv;                  UINT16 memv;
Line 616  static REG8 IOINPCALL gdc_ia0(UINT port) Line 683  static REG8 IOINPCALL gdc_ia0(UINT port)
         }          }
         else {          else {
                 gdc_work(GDCWORK_SLAVE);                  gdc_work(GDCWORK_SLAVE);
                   TRACEOUT(("gdc.s.cnt=%d", gdc.s.cnt));
         }          }
 #ifdef SEARHC_SYNC  #ifdef SEARCH_SYNC
         if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {          if ((CPU_INPADRS) && (CPU_REMCLOCK >= 5)) {
                 UINT16 jadr = 0xfa74;                  UINT16 jadr = 0xfa74;
                 UINT16 memv;                  UINT16 memv;
Line 702  void gdc_reset(void) { Line 770  void gdc_reset(void) {
                 gdc.m.para[GDC_CSRFORM + 0] = 0x0f;                  gdc.m.para[GDC_CSRFORM + 0] = 0x0f;
                 gdc.m.para[GDC_CSRFORM + 1] = 0xc0;                  gdc.m.para[GDC_CSRFORM + 1] = 0xc0;
                 gdc.m.para[GDC_CSRFORM + 2] = 0x7b;                  gdc.m.para[GDC_CSRFORM + 2] = 0x7b;
                 CopyMemory(gdc.m.para + GDC_SYNC, defsync24, 8);                  CopyMemory(gdc.m.para + GDC_SYNC, defsyncm24, 8);
                 gdc.s.para[GDC_CSRFORM + 0] = 1;                  gdc.s.para[GDC_CSRFORM + 0] = 1;
                 CopyMemory(gdc.s.para + GDC_SYNC, defsync24, 8);                  CopyMemory(gdc.s.para + GDC_SYNC, defsyncs24, 8);
         }          }
         else {          else {
                 gdc.crt15khz = 1;                  gdc.crt15khz = 3;
                 gdc.mode1 = 0x80;                  gdc.mode1 = 0x80;
                 gdc.m.para[GDC_CSRFORM + 0] = 0x07;                  gdc.m.para[GDC_CSRFORM + 0] = 0x07;
                 gdc.m.para[GDC_CSRFORM + 1] = 0xc0;                  gdc.m.para[GDC_CSRFORM + 1] = 0xc0;
                 gdc.m.para[GDC_CSRFORM + 2] = 0x3b;                  gdc.m.para[GDC_CSRFORM + 2] = 0x3b;
                 CopyMemory(gdc.m.para + GDC_SYNC, defsync15, 8);                  CopyMemory(gdc.m.para + GDC_SYNC, defsyncm15, 8);
                 CopyMemory(gdc.s.para + GDC_SYNC, defsync15, 8);                  CopyMemory(gdc.s.para + GDC_SYNC, defsyncs15, 8);
         }          }
   
         gdc.clock = 0;          gdc.clock = 0;
Line 724  void gdc_reset(void) { Line 792  void gdc_reset(void) {
   
         gdcs.textdisp = GDCSCRN_ENABLE | GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;          gdcs.textdisp = GDCSCRN_ENABLE | GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;
         gdcs.grphdisp = GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;          gdcs.grphdisp = GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;
         gdc.display = (np2cfg.color16 & 1) << 1;          if (np2cfg.color16 & 1) {
                   gdc.s.para[GDC_SYNC] = 0x16;
                   gdc.display = 2;
           }
         gdc.bitac = 0xff;          gdc.bitac = 0xff;
   
 #if 0   // bind で計算される筈  #if 0   // bind で計算される筈
Removed from v.1.13  
changed lines
  Added in v.1.16

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