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

Diff for /np2/bios/bios18.c between versions 1.16 and 1.25

version 1.16, 2004/02/13 08:01:12 version 1.25, 2004/02/26 08:44:32
Line 2 Line 2
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "gdc_sub.h"
 #include        "bios.h"  #include        "bios.h"
 #include        "biosmem.h"  #include        "biosmem.h"
 #include        "font.h"  #include        "font.h"
Line 93  static void bios0x18_10(REG8 curdel) { Line 94  static void bios0x18_10(REG8 curdel) {
         gdcs.textdisp |= GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;          gdcs.textdisp |= GDCSCRN_ALLDRAW2 | GDCSCRN_EXT;
 }  }
   
 void bios0x18_16(BYTE chr, BYTE atr) {  void bios0x18_0a(REG8 mode) {
   
   const CRTDATA   *crt;
   
           gdc_forceready(GDCWORK_MASTER);
   
           gdc.mode1 &= ~(0x2d);
           mem[MEMB_CRT_STS_FLAG] = mode;
           crt = crtdata;
           if (!(np2cfg.dipsw[0] & 1)) {
                   mem[MEMB_CRT_STS_FLAG] |= 0x80;
                   gdc.mode1 |= 0x08;
                   crt += 2;
           }
           if (mode & 0x01) {
                   crt += 1;                                       // 20行
           }
           if (mode & 0x02) {
                   gdc.mode1 |= 0x04;                              // 40桁
           }
           if (mode & 0x04) {
                   gdc.mode1 |= 0x01;                              // アトリビュート
           }
           if (mode & 0x08) {
                   gdc.mode1 |= 0x20;                              // コードアクセス
           }
           mem[MEMB_CRT_RASTER] = crt->raster;
           crtc.reg.pl = crt->pl;
           crtc.reg.bl = crt->bl;
           crtc.reg.cl = crt->cl;
           crtc.reg.ssl = 0;
           gdc_restorekacmode();
           bios0x18_10(0);
   }
   
   REG16 bios0x18_14(REG16 seg, REG16 off, REG16 code) {
   
           UINT16  size;
   const BYTE      *p;
           BYTE    buf[32];
           UINT    i;
   
           switch(code >> 8) {
                   case 0x00:                      // 8x8
                           size = 0x0101;
                           i286_memword_write(seg, off, 0x0101);
                           p = fontrom + 0x82000 + ((code & 0xff) << 4);
                           i286_memstr_write(seg, off + 2, p, 8);
                           break;
   
                   case 0x28:                      // 8x16 KANJI
                   case 0x29:
                   case 0x2a:
                   case 0x2b:
                           size = 0x0102;
                           i286_memword_write(seg, off, 0x0102);
                           p = fontrom;
                           p += (code & 0x7f) << 12;
                           p += (((code >> 8) - 0x20) & 0x7f) << 4;
                           i286_memstr_write(seg, off + 2, p, 16);
                           break;
   
                   case 0x80:                      // 8x16 ANK
                           size = 0x0102;
                           p = fontrom + 0x80000 + ((code & 0xff) << 4);
                           i286_memstr_write(seg, off + 2, p, 16);
                           break;
   
                   default:
                           size = 0x0202;
                           p = fontrom;
                           p += (code & 0x7f) << 12;
                           p += (((code >> 8) - 0x20) & 0x7f) << 4;
                           for (i=0; i<16; i++, p++) {
                                   buf[i*2+0] = *p;
                                   buf[i*2+1] = *(p+0x800);
                           }
                           i286_memstr_write(seg, off + 2, buf, 32);
                           break;
           }
           i286_memword_write(seg, off, size);
           return(size);
   }
   
   static void bios0x18_1a(REG16 seg, REG16 off, REG16 code) {
   
           BYTE    *p;
           BYTE    buf[32];
           UINT    i;
   
           if (((code >> 8) & 0x7e) == 0x76) {
                   i286_memstr_read(seg, off + 2, buf, 32);
                   p = fontrom;
                   p += (code & 0x7f) << 12;
                   p += (((code >> 8) - 0x20) & 0x7f) << 4;
                   for (i=0; i<16; i++, p++) {
                           *p = buf[i*2+0];
                           *(p+0x800) = buf[i*2+1];
                   }
                   cgwindow.writable |= 0x80;
           }
   }
   
   void bios0x18_16(REG8 chr, REG8 atr) {
   
         UINT32  i;          UINT32  i;
   
Line 107  void bios0x18_16(BYTE chr, BYTE atr) { Line 211  void bios0x18_16(BYTE chr, BYTE atr) {
         gdcs.textdisp |= GDCSCRN_ALLDRAW;          gdcs.textdisp |= GDCSCRN_ALLDRAW;
 }  }
   
 #define SWAPU16(a, b) { UINT16 tmp; tmp = (a); (a) = (b); (b) = tmp; }  void bios0x18_40(void) {
   
 static REG8 swapbit(REG8 bit) {          gdc_forceready(GDCWORK_SLAVE);
           if (!(gdcs.grphdisp & GDCSCRN_ENABLE)) {
                   gdcs.grphdisp |= GDCSCRN_ENABLE;
                   screenupdate |= 2;
           }
           mem[MEMB_PRXCRT] |= 0x80;
   }
   
         REG8    ret;  void bios0x18_41(void) {
   
         ret = 0;          gdc_forceready(GDCWORK_SLAVE);
         while(bit) {          if (gdcs.grphdisp & GDCSCRN_ENABLE) {
                 ret = (ret << 1) + (bit & 1);                  gdcs.grphdisp &= ~(GDCSCRN_ENABLE);
                 bit >>= 1;                  screenupdate |= 2;
         }          }
         return(ret);          mem[MEMB_PRXCRT] &= 0x7f;
 }  }
   
 static void setbiosgdc(UINT32 csrw, const GDCVECT *vect, UINT vcnt,  void bios0x18_42(REG8 mode) {
                                                                                                                                 UINT8 ope) {  
           BOOL    b;
   
           gdc_forceready(GDCWORK_SLAVE);
           ZeroMemory(&gdc.s.para[GDC_SCROLL], 8);
           if ((mode & 0xc0) == 0xc0) {            // ALL
                   b = FALSE;
                   if ((mem[MEMB_PRXDUPD] & 0x24) == 0x20) {
                           mem[MEMB_PRXDUPD] ^= 4;
                           gdc.clock |= 3;
                           CopyMemory(gdc.s.para + GDC_SYNC, sync400m, 8);
                           gdc.s.para[GDC_PITCH] = 80;
                           gdcs.grphdisp |= GDCSCRN_EXT;
                           mem[MEMB_PRXDUPD] |= 0x08;
                   }
           }
           else {
                   b = TRUE;
                   if ((mem[MEMB_PRXDUPD] & 0x24) == 0x24) {
                           mem[MEMB_PRXDUPD] ^= 4;
                           gdc.clock &= ~3;
                           CopyMemory(gdc.s.para + GDC_SYNC,
                                                   (mem[MEMB_PRXCRT] & 0x40)?sync200m:sync200l, 8);
                           gdc.s.para[GDC_PITCH] = 40;
                           gdcs.grphdisp |= GDCSCRN_EXT;
                           mem[MEMB_PRXDUPD] |= 0x08;
                   }
                   if (mode & 0x40) {                              // UPPER
                           gdc.s.para[GDC_SCROLL+0] = (200*40) & 0xff;
                           gdc.s.para[GDC_SCROLL+1] = (200*40) >> 8;
                   }
           }
           if ((!b) || (!(mem[MEMB_PRXCRT] & 0x40))) {
                   gdc.mode1 &= ~(0x10);
                   gdc.s.para[GDC_CSRFORM] = 0;
           }
           else {
                   gdc.mode1 |= 0x10;
                   gdc.s.para[GDC_CSRFORM] = 1;
           }
           gdcs.disp = (mode >> 4) & 1;
           if (!(mode & 0x20)) {
                   gdc.mode1 &= ~0x04;
           }
           else {
                   gdc.mode2 |= 0x04;
           }
           gdcs.grphdisp |= GDCSCRN_ALLDRAW2;
           screenupdate |= 2;
   }
   
   static void setbiosgdc(UINT32 csrw, const GDCVECT *vect, UINT8 ope) {
   
         gdc.s.para[GDC_CSRW + 0] = (BYTE)csrw;          gdc.s.para[GDC_CSRW + 0] = (BYTE)csrw;
         gdc.s.para[GDC_CSRW + 1] = (BYTE)(csrw >> 8);          gdc.s.para[GDC_CSRW + 1] = (BYTE)(csrw >> 8);
         gdc.s.para[GDC_CSRW + 2] = (BYTE)(csrw >> 16);          gdc.s.para[GDC_CSRW + 2] = (BYTE)(csrw >> 16);
   
         vcnt = min(vcnt, 11);          gdc.s.para[GDC_VECTW] = vect->ope;
         if (vcnt) {          gdc_vectreset(&gdc.s);
                 CopyMemory(gdc.s.para + GDC_VECTW, vect, vcnt);  
         }  
   
         gdc.s.para[GDC_WRITE] = ope;          gdc.s.para[GDC_WRITE] = ope;
         mem[MEMB_PRXDUPD] &= ~3;          mem[MEMB_PRXDUPD] &= ~3;
Line 139  static void setbiosgdc(UINT32 csrw, cons Line 298  static void setbiosgdc(UINT32 csrw, cons
 }  }
   
   
 static void bios18_47(void) {  static void bios0x18_47(void) {
   
         UCWTBL          ucw;          UCWTBL          ucw;
         GDCVECT         vect;          GDCVECT         vect;
Line 156  static void bios18_47(void) { Line 315  static void bios18_47(void) {
         SINT16          dx;          SINT16          dx;
         SINT16          dy;          SINT16          dy;
   
         // GDCバッファを空に          gdc_forceready(GDCWORK_SLAVE);
         if (gdc.s.cnt) {  
                 gdc_work(GDCWORK_SLAVE);  
         }  
         gdc_forceready(&gdc.s);  
   
         i286_memstr_read(CPU_DS, CPU_BX, &ucw, sizeof(ucw));          i286_memstr_read(CPU_DS, CPU_BX, &ucw, sizeof(ucw));
   
         GBSX1 = LOADINTELWORD(ucw.GBSX1);          GBSX1 = LOADINTELWORD(ucw.GBSX1);
         GBSY1 = LOADINTELWORD(ucw.GBSY1);          GBSY1 = LOADINTELWORD(ucw.GBSY1);
         GBSX2 = LOADINTELWORD(ucw.GBSX2);          GBSX2 = LOADINTELWORD(ucw.GBSX2);
Line 172  static void bios18_47(void) { Line 325  static void bios18_47(void) {
         data = 0;          data = 0;
         data2 = 0;          data2 = 0;
         if (ucw.GBDTYP == 0x01) {          if (ucw.GBDTYP == 0x01) {
                 func = gdcsub_line;                  func = gdcsub_vectl;
                 if ((GBSX1 > GBSX2) ||                  gdcsub_setvectl(&vect, GBSX1, GBSY1, GBSX2, GBSY2);
                         ((GBSX1 == GBSX2) && (GBSY1 > GBSY2))) {  
                         SWAPU16(GBSX1, GBSX2);  
                         SWAPU16(GBSY1, GBSY2);  
                 }  
                 dx = GBSX2 - GBSX1;  
                 dy = GBSY2 - GBSY1;  
                 if (dy > 0) {  
                         if (dx < dy) {  
                                 vect.ope = 0;  
                                 SWAPU16(dx, dy);  
                         }  
                         else {  
                                 vect.ope = 1;  
                         }  
                 }  
                 else {  
                         dy = -dy;  
                         if (dx > dy) {  
                                 vect.ope = 2;  
                         }  
                         else {  
                                 vect.ope = 3;  
                                 SWAPU16(dx, dy);  
                         }  
                 }  
                 vect.ope += 0x08;  
                 STOREINTELWORD(vect.DC, dx);  
                 data = dy * 2;  
                 STOREINTELWORD(vect.D1, data);  
                 data -= dx;  
                 STOREINTELWORD(vect.D, data);  
                 data -= dx;  
                 STOREINTELWORD(vect.D2, data);  
         }          }
         else if (ucw.GBDTYP <= 0x02) {          else if (ucw.GBDTYP <= 0x02) {
                 func = gdcsub_box;                  func = gdcsub_vectr;
                 vect.ope = 0x40 + (ucw.GBDSP & 7);                  vect.ope = 0x40 + (ucw.GBDSP & 7);
                 dx = GBSX2 - GBSX1;                  dx = GBSX2 - GBSX1;
                 if (dx < 0) {                  if (dx < 0) {
Line 251  static void bios18_47(void) { Line 371  static void bios18_47(void) {
                 STOREINTELWORD(vect.DM, data);                  STOREINTELWORD(vect.DM, data);
         }          }
         else {          else {
                 func = gdcsub_circle;                  func = gdcsub_vectc;
                 vect.ope = 0x20 + (ucw.GBDSP & 7);                  vect.ope = 0x20 + (ucw.GBDSP & 7);
                 vect.DC[0] = ucw.GBLNG1[0];                  vect.DC[0] = ucw.GBLNG1[0];
                 vect.DC[1] = ucw.GBLNG1[1];                  vect.DC[1] = ucw.GBLNG1[1];
Line 270  static void bios18_47(void) { Line 390  static void bios18_47(void) {
         }          }
         csrw = (GBSY1 * 40) + (GBSX1 >> 4);          csrw = (GBSY1 * 40) + (GBSX1 >> 4);
         csrw += (GBSX1 & 0xf) << 20;          csrw += (GBSX1 & 0xf) << 20;
         GBMDOTI = (swapbit(ucw.GBMDOTI[0]) << 8) + swapbit(ucw.GBMDOTI[1]);          GBMDOTI = (GDCPATREVERSE(ucw.GBMDOTI[0]) << 8) +
                                                                                           GDCPATREVERSE(ucw.GBMDOTI[1]);
         if ((CPU_CH & 0x30) == 0x30) {          if ((CPU_CH & 0x30) == 0x30) {
                 ope = (ucw.GBON_PTN & 1)?GDCOPE_SET:GDCOPE_CLEAR;                  ope = (ucw.GBON_PTN & 1)?GDCOPE_SET:GDCOPE_CLEAR;
                 func(csrw + 0x4000, &vect, GBMDOTI, ope);                  func(csrw + 0x4000, &vect, GBMDOTI, ope);
Line 288  static void bios18_47(void) { Line 409  static void bios18_47(void) {
   
         // 最後に使った奴を記憶          // 最後に使った奴を記憶
         *(UINT16 *)(mem + MEMW_PRXGLS) = *(UINT16 *)(ucw.GBMDOTI);          *(UINT16 *)(mem + MEMW_PRXGLS) = *(UINT16 *)(ucw.GBMDOTI);
         *(UINT16 *)(gdc.s.para + GDC_TEXTW) = *(UINT16 *)(ucw.GBMDOTI);          STOREINTELWORD(mem + GDC_TEXTW, GBMDOTI);
         setbiosgdc(csrw, &vect, (ucw.GBDTYP != 0x01)?11:9, ope);          setbiosgdc(csrw, &vect, ope);
 }  }
   
 static void bios18_49(void) {  static void bios0x18_49(void) {
   
         UCWTBL          ucw;          UCWTBL          ucw;
         UINT            i;          UINT            i;
Line 304  static void bios18_49(void) { Line 425  static void bios18_49(void) {
         UINT32          csrw;          UINT32          csrw;
         UINT8           ope;          UINT8           ope;
   
         // GDCバッファを空に          gdc_forceready(GDCWORK_SLAVE);
         if (gdc.s.cnt) {  
                 gdc_work(GDCWORK_SLAVE);  
         }  
         gdc_forceready(&gdc.s);  
   
         i286_memstr_read(CPU_DS, CPU_BX, &ucw, sizeof(ucw));          i286_memstr_read(CPU_DS, CPU_BX, &ucw, sizeof(ucw));
         for (i=0; i<8; i++) {          for (i=0; i<8; i++) {
                 mem[MEMW_PRXGLS + i] = ucw.GBMDOTI[i];                  mem[MEMW_PRXGLS + i] = ucw.GBMDOTI[i];
                 pat[i] = swapbit(ucw.GBMDOTI[i]);                  pat[i] = GDCPATREVERSE(ucw.GBMDOTI[i]);
                 gdc.s.para[GDC_TEXTW + i] = pat[i];                  gdc.s.para[GDC_TEXTW + i] = pat[i];
         }          }
         vect.ope = 0x10 + (ucw.GBDSP & 7);          vect.ope = 0x10 + (ucw.GBDSP & 7);
Line 325  static void bios18_49(void) { Line 442  static void bios18_49(void) {
         }          }
         else {          else {
                 STOREINTELWORD(vect.DC, 7);                  STOREINTELWORD(vect.DC, 7);
                 vect.D[0] = gdc.s.para[GDC_VECTW + 3];                  STOREINTELWORD(vect.D, 7);
                 vect.D[1] = gdc.s.para[GDC_VECTW + 4];  
         }          }
   
         GBSX1 = LOADINTELWORD(ucw.GBSX1);          GBSX1 = LOADINTELWORD(ucw.GBSX1);
Line 352  static void bios18_49(void) { Line 468  static void bios18_49(void) {
         }          }
   
         // 最後に使った奴を記憶          // 最後に使った奴を記憶
         setbiosgdc(csrw, &vect, 5, ope);          setbiosgdc(csrw, &vect, ope);
 }  }
   
   
Line 364  void bios0x18(void) { Line 480  void bios0x18(void) {
                 BOOL    b;                  BOOL    b;
                 UINT16  w;                  UINT16  w;
                 UINT32  d;                  UINT32  d;
 const CRTDATA   *crt;                  UINT8   col[4];
         }               tmp;          }               tmp;
   
         UINT    pos;          UINT    pos;
         BYTE    buf[34];  
         BYTE    *p;          BYTE    *p;
         int             i;          int             i;
   
Line 434  const CRTDATA *crt; Line 549  const CRTDATA *crt;
                         }                          }
                         break;                          break;
   
                 case 0x0a:                                              // CRTモードの設定                  case 0x0a:                                              // CRTモードの設定(15/24khz)
                         // GDCバッファを空に                          bios0x18_0a(CPU_AL);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         gdc.mode1 &= ~(0x2d);  
                         mem[MEMB_CRT_STS_FLAG] = CPU_AL;  
                         tmp.crt = crtdata;  
                         if (!(np2cfg.dipsw[0] & 1)) {  
                                 mem[MEMB_CRT_STS_FLAG] |= 0x80;  
                                 gdc.mode1 |= 0x08;  
                                 tmp.crt += 2;  
                         }  
                         if (CPU_AL & 0x01) {  
                                 tmp.crt += 1;                                   // 20行  
                         }  
                         if (CPU_AL & 0x02) {  
                                 gdc.mode1 |= 0x04;                              // 40桁  
                         }  
                         if (CPU_AL & 0x04) {  
                                 gdc.mode1 |= 0x01;                              // アトリビュート  
                         }  
                         if (CPU_AL & 0x08) {  
                                 gdc.mode1 |= 0x20;                              // コードアクセス  
                         }  
                         mem[MEMB_CRT_RASTER] = tmp.crt->raster;  
                         crtc.reg.pl = tmp.crt->pl;  
                         crtc.reg.bl = tmp.crt->bl;  
                         crtc.reg.cl = tmp.crt->cl;  
                         crtc.reg.ssl = 0;  
                         gdc_restorekacmode();  
                         bios0x18_10(0);  
                         break;                          break;
   
                 case 0x0b:                                              // CRTモードのセンス                  case 0x0b:                                              // CRTモードのセンス
Line 489  const CRTDATA *crt; Line 572  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x0e:                                              // 一つの表示領域の設定                  case 0x0e:                                              // 一つの表示領域の設定
                         // GDCバッファを空に                          gdc_forceready(GDCWORK_MASTER);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         ZeroMemory(&gdc.m.para[GDC_SCROLL], 16);                          ZeroMemory(&gdc.m.para[GDC_SCROLL], 16);
                         tmp.w = CPU_DX >> 1;                          tmp.w = CPU_DX >> 1;
Line 509  const CRTDATA *crt; Line 588  const CRTDATA *crt;
                         screenupdate |= 2;                          screenupdate |= 2;
                         break;                          break;
   
                 case 0x0f:                                              // 複数の表示領域の設定                  case 0x0f:                                              // 複数の表示領域の設定(15/24khz)
                           gdc_forceready(GDCWORK_MASTER);
   
                         SETBIOSMEM16(0x0053e, CPU_CX);                          SETBIOSMEM16(0x0053e, CPU_CX);
                         SETBIOSMEM16(0x00540, CPU_BX);                          SETBIOSMEM16(0x00540, CPU_BX);
                         mem[0x00547] = CPU_DH;                          mem[0x00547] = CPU_DH;
Line 542  const CRTDATA *crt; Line 623  const CRTDATA *crt;
                         screenupdate |= 2;                          screenupdate |= 2;
                         break;                          break;
   
                 case 0x10:                                              // カーソルタイプの設定                  case 0x10:                                              // カーソルタイプの設定(15/24khz)
                         // GDCバッファを空に                          gdc_forceready(GDCWORK_MASTER);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         bios0x18_10((REG8)(CPU_AL & 1));                          bios0x18_10((REG8)(CPU_AL & 1));
                         break;                          break;
   
                 case 0x11:                                              // カーソルの表示開始                  case 0x11:                                              // カーソルの表示開始
                         // GDCバッファを空に                          gdc_forceready(GDCWORK_MASTER);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         if (gdc.m.para[GDC_CSRFORM] != (mem[MEMB_CRT_RASTER] | 0x80)) {                          if (gdc.m.para[GDC_CSRFORM] != (mem[MEMB_CRT_RASTER] | 0x80)) {
                                 gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER] | 0x80;                                  gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER] | 0x80;
Line 566  const CRTDATA *crt; Line 639  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x12:                                              // カーソルの表示停止                  case 0x12:                                              // カーソルの表示停止
                         // GDCバッファを空に                          gdc_forceready(GDCWORK_MASTER);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         if (gdc.m.para[GDC_CSRFORM] != mem[MEMB_CRT_RASTER]) {                          if (gdc.m.para[GDC_CSRFORM] != mem[MEMB_CRT_RASTER]) {
                                 gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER];                                  gdc.m.para[GDC_CSRFORM] = mem[MEMB_CRT_RASTER];
Line 579  const CRTDATA *crt; Line 648  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x13:                                              // カーソル位置の設定                  case 0x13:                                              // カーソル位置の設定
                         // GDCバッファを空に                          gdc_forceready(GDCWORK_MASTER);
                         if (gdc.m.cnt) {  
                                 gdc_work(GDCWORK_MASTER);  
                         }  
                         gdc_forceready(&gdc.m);  
   
                         tmp.w = CPU_DX >> 1;                          tmp.w = CPU_DX >> 1;
                         if (LOADINTELWORD(gdc.m.para + GDC_CSRW) != tmp.w) {                          if (LOADINTELWORD(gdc.m.para + GDC_CSRW) != tmp.w) {
Line 593  const CRTDATA *crt; Line 658  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x14:                                              // フォントパターンの読み出し                  case 0x14:                                              // フォントパターンの読み出し
                         switch(CPU_DH) {                          bios0x18_14(CPU_BX, CPU_CX, CPU_DX);
                                 case 0x00:                      // 8x8  
                                         i286_memword_write(CPU_BX, CPU_CX, 0x0101);  
                                         i286_memstr_write(CPU_BX, CPU_CX + 2,  
                                                                 fontrom + 0x82000 + (CPU_DL << 4), 8);  
                                         break;  
   
                                 case 0x28:                      // 8x16 KANJI  
                                 case 0x29:  
                                 case 0x2a:  
                                 case 0x2b:  
                                         i286_memword_write(CPU_BX, CPU_CX, 0x0102);  
                                         i286_memstr_write(CPU_BX, CPU_CX + 2,  
                                                                 fontrom + ((CPU_DL & 0x7f) << 12)  
                                                                                 + ((CPU_DH - 0x20) << 4), 16);  
                                         break;  
   
                                 case 0x80:                      // 8x16 ANK  
                                         i286_memword_write(CPU_BX, CPU_CX, 0x0102);  
                                         i286_memstr_write(CPU_BX, CPU_CX + 2,  
                                                                 fontrom + 0x80000 + (CPU_DL << 4), 16);  
                                         break;  
   
                                 default:  
                                         buf[0] = 0x02;  
                                         buf[1] = 0x02;  
                                         p = fontrom + ((CPU_DL & 0x7f) << 12)  
                                                                 + (((CPU_DH - 0x20) & 0x7f) << 4);  
                                         for (i=1; i<17; i++, p++) {  
                                                 buf[i*2+0] = *p;  
                                                 buf[i*2+1] = *(p+0x800);  
                                         }  
                                         i286_memstr_write(CPU_BX, CPU_CX, buf, 34);  
                                         break;  
                         }  
                         break;                          break;
   
                 case 0x15:                                              // ライトペン位置読みだし                  case 0x15:                                              // ライトペン位置読みだし
Line 649  const CRTDATA *crt; Line 680  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x1a:                                              // ユーザー文字の定義                  case 0x1a:                                              // ユーザー文字の定義
                         if ((CPU_DH & 0x7e) == 0x76) {                          bios0x18_1a(CPU_BX, CPU_CX, CPU_DX);
                                 i286_memstr_read(CPU_BX, CPU_CX + 2, buf, 32);  
                                 p = fontrom + ((CPU_DL & 0x7f) << 12)  
                                                         + (((CPU_DH - 0x20) & 0x7f) << 4);  
                                 for (i=0; i<16; i++, p++) {  
                                         *p = buf[i*2+0];  
                                         *(p+0x800) = buf[i*2+1];  
                                 }  
                                 cgwindow.writable |= 0x80;  
                         }  
                         break;                          break;
   
                 case 0x1b:                                              // KCGアクセスモードの設定                  case 0x1b:                                              // KCGアクセスモードの設定
Line 678  const CRTDATA *crt; Line 700  const CRTDATA *crt;
                         break;                          break;
   
                 case 0x40:                                              // グラフィック画面の表示開始                  case 0x40:                                              // グラフィック画面の表示開始
                         // GDCバッファを空に                          bios0x18_40();
                         if (gdc.s.cnt) {  
                                 gdc_work(GDCWORK_SLAVE);  
                         }  
                         if (!(gdcs.grphdisp & GDCSCRN_ENABLE)) {  
                                 gdcs.grphdisp |= GDCSCRN_ENABLE;  
                                 screenupdate |= 2;  
                         }  
                         mem[MEMB_PRXCRT] |= 0x80;  
                         break;                          break;
   
                 case 0x41:                                              // グラフィック画面の表示終了                  case 0x41:                                              // グラフィック画面の表示終了
                         // GDCバッファを空に                          bios0x18_41();
                         if (gdc.s.cnt) {  
                                 gdc_work(GDCWORK_SLAVE);  
                         }  
                         gdc_forceready(&gdc.s);  
                         if (gdcs.grphdisp & GDCSCRN_ENABLE) {  
                                 gdcs.grphdisp &= ~(GDCSCRN_ENABLE);  
                                 screenupdate |= 2;  
                         }  
                         mem[MEMB_PRXCRT] &= 0x7f;  
                         break;                          break;
   
                 case 0x42:                                              // 表示領域の設定                  case 0x42:                                              // 表示領域の設定
                         // GDCバッファを空に                          bios0x18_42(CPU_CH);
                         if (gdc.s.cnt) {  
                                 gdc_work(GDCWORK_SLAVE);  
                         }  
                         gdc_forceready(&gdc.s);  
   
                         ZeroMemory(&gdc.s.para[GDC_SCROLL], 8);  
                         if ((CPU_CH & 0xc0) == 0xc0) {          // ALL  
                                 tmp.b = FALSE;  
                                 if ((mem[MEMB_PRXDUPD] & 0x24) == 0x20) {  
                                         mem[MEMB_PRXDUPD] ^= 4;  
                                         gdc.clock |= 3;  
                                         CopyMemory(gdc.s.para + GDC_SYNC, sync400m, 8);  
                                         gdc.s.para[GDC_PITCH] = 80;  
                                         gdcs.grphdisp |= GDCSCRN_EXT;  
                                         mem[MEMB_PRXDUPD] |= 0x08;  
                                 }  
                         }  
                         else {  
                                 tmp.b = TRUE;  
                                 if ((mem[MEMB_PRXDUPD] & 0x24) == 0x24) {  
                                         mem[MEMB_PRXDUPD] ^= 4;  
                                         gdc.clock &= ~3;  
                                         CopyMemory(gdc.s.para + GDC_SYNC,  
                                                 (mem[MEMB_PRXCRT] & 0x40)?sync200m:sync200l, 8);  
                                         gdc.s.para[GDC_PITCH] = 40;  
                                         gdcs.grphdisp |= GDCSCRN_EXT;  
                                         mem[MEMB_PRXDUPD] |= 0x08;  
                                 }  
                                 if (CPU_CH & 0x40) {                    // UPPER  
                                         gdc.s.para[GDC_SCROLL+0] = (200*40) & 0xff;  
                                         gdc.s.para[GDC_SCROLL+1] = (200*40) >> 8;  
                                 }  
                         }  
                         if ((!tmp.b) || (!(mem[MEMB_PRXCRT] & 0x40))) {  
                                 gdc.mode1 &= ~(0x10);  
                                 gdc.s.para[GDC_CSRFORM] = 0;  
                         }  
                         else {  
                                 gdc.mode1 |= 0x10;  
                                 gdc.s.para[GDC_CSRFORM] = 1;  
                         }  
                         gdcs.disp = (CPU_CH >> 4) & 1;  
                         gdcs.grphdisp |= GDCSCRN_ALLDRAW2;  
                         screenupdate |= 2;  
                         break;                          break;
   
                 case 0x43:                                              // パレットの設定                  case 0x43:                                              // パレットの設定
                         i286_memstr_read(CPU_DS, CPU_BX + offsetof(UCWTBL, GBCPC),                          i286_memstr_read(CPU_DS, CPU_BX + offsetof(UCWTBL, GBCPC),
                                                                                                                                         buf, 4);                                                                                                                                  tmp.col, 4);
                         tmp.d = LOADINTELDWORD(buf);                          for (i=0; i<4; i++) {
                         for (i=8; i--;) {                                  gdc_setdegitalpal(6 - (i*2), (REG8)(tmp.col[i] >> 4));
                                 gdc_setdegitalpal(i, (REG8)(tmp.d & 15));                                  gdc_setdegitalpal(7 - (i*2), (REG8)(tmp.col[i] & 15));
                                 tmp.d >>= 4;  
                         }                          }
                         break;                          break;
   
Line 766  const CRTDATA *crt; Line 726  const CRTDATA *crt;
 //                      }  //                      }
                         break;                          break;
   
                   case 0x45:
                   case 0x46:
                           TRACEOUT(("unsupport bios 18-%.2x", CPU_AH));
                           break;
   
                 case 0x47:                                              // 直線、矩形の描画                  case 0x47:                                              // 直線、矩形の描画
                 case 0x48:                                              // 円の描画                  case 0x48:                                              // 円の描画
                         bios18_47();                          bios0x18_47();
                         break;                          break;
   
                 case 0x49:                                              // グラフィック文字の描画                  case 0x49:                                              // グラフィック文字の描画
                         bios18_49();                          bios0x18_49();
                         break;                          break;
   
                 case 0x4a:                                              // 描画モードの設定                  case 0x4a:                                              // 描画モードの設定
Removed from v.1.16  
changed lines
  Added in v.1.25

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