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

Diff for /np2/bios/bios.c between versions 1.53 and 1.62

version 1.53, 2004/03/04 17:36:05 version 1.62, 2004/03/31 19:23:37
Line 8 Line 8
 #include        "biosmem.h"  #include        "biosmem.h"
 #include        "sxsibios.h"  #include        "sxsibios.h"
 #include        "lio.h"  #include        "lio.h"
   #include        "vram.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
 #include        "fdfmt.h"  #include        "fdfmt.h"
 #include        "keytable.res"  #include        "keytable.res"
 #include        "itfrom.res"  #include        "itfrom.res"
 #include        "startup.res"  #include        "startup.res"
 #include        "biosboot.res"  #include        "biosfd80.res"
   
   
 #define BIOS_SIMULATE  #define BIOS_SIMULATE
Line 23 Line 24
   
 static const char neccheck[] = "Copyright (C) 1983 by NEC Corporation";  static const char neccheck[] = "Copyright (C) 1983 by NEC Corporation";
   
                                                 // 00/05/18 MS-DOS6.2 on PC-9801VX calling proc  typedef struct {
 static const BYTE printmain[] = {0x90, 0x5a, 0x1f, 0xcf};          UINT8   port;
           UINT8   data;
   } IODATA;
   
   static const IODATA iodata[] = {
                           // DMA
                                   {0x29, 0x00}, {0x29, 0x01}, {0x29, 0x02}, {0x29, 0x03},
                                   {0x27, 0x00}, {0x21, 0x00}, {0x23, 0x00}, {0x25, 0x00},
                                   {0x1b, 0x00}, {0x11, 0x40},
   
                           // PIT
                                   {0x77, 0x30}, {0x71, 0x00}, {0x71, 0x00},
                                   {0x77, 0x76}, {0x73, 0xcd}, {0x73, 0x04},
                                   {0x77, 0xb6},
   
                           // PIC
                                   {0x00, 0x11}, {0x02, 0x08}, {0x02, 0x80}, {0x02, 0x1d},
                                   {0x08, 0x11}, {0x0a, 0x10}, {0x0a, 0x07}, {0x0a, 0x09},
                                   {0x02, 0x7d}, {0x0a, 0x71}};
   
   static const UINT8 msw_default[8] =
                                                           {0x48, 0x05, 0x04, 0x00, 0x01, 0x00, 0x00, 0x6e};
   
   
   static void bios_itfprepare(void) {
   
   const IODATA    *p;
   const IODATA    *pterm;
   
           crtc_biosreset();
           gdc_biosreset();
   
           p = iodata;
           pterm = iodata + (sizeof(iodata) / sizeof(IODATA));
           while(p < pterm) {
                   iocore_out8(p->port, p->data);
                   p++;
           }
   }
   
   static void bios_memclear(void) {
   
           ZeroMemory(mem, 0xa0000);
           ZeroMemory(mem + 0x100000, 0x10000);
           if (CPU_EXTMEM) {
                   ZeroMemory(CPU_EXTMEM, CPU_EXTMEMSIZE);
           }
           bios0x18_16(0x20, 0xe1);
           ZeroMemory(mem + VRAM0_B, 0x18000);
           ZeroMemory(mem + VRAM0_E, 0x08000);
           ZeroMemory(mem + VRAM1_B, 0x18000);
           ZeroMemory(mem + VRAM1_E, 0x08000);
   #if defined(SUPPORT_PC9821)
           ZeroMemory(vramex, sizeof(vramex));
   #endif
   }
   
 static void bios_reinitbyswitch(void) {  static void bios_reinitbyswitch(void) {
   
Line 34  static void bios_reinitbyswitch(void) { Line 89  static void bios_reinitbyswitch(void) {
         BYTE    biosflag;          BYTE    biosflag;
         UINT8   boot;          UINT8   boot;
   
 #if defined(CPUCORE_IA32)  
         UINT16  org_cs;  
         UINT16  org_ip;  
   
         org_cs = CPU_CS;  
         org_ip = CPU_IP;  
         CPU_SHUT();  
         CPU_CS = org_cs;  
         CPU_IP = org_ip;  
         SETBIOSMEM16(0x00486, CPU_DX);  
 #endif  
   
         if (!(np2cfg.dipsw[2] & 0x80)) {          if (!(np2cfg.dipsw[2] & 0x80)) {
 #if defined(CPUCORE_IA32)  #if defined(CPUCORE_IA32)
                 mem[MEMB_SYS_TYPE] = 0x03;              // 80386〜                  mem[MEMB_SYS_TYPE] = 0x03;              // 80386〜
Line 115  static void bios_reinitbyswitch(void) { Line 158  static void bios_reinitbyswitch(void) {
         mem[0x45c] = 0x40;          mem[0x45c] = 0x40;
 #endif  #endif
   
           // FDC
           if (fdc.support144) {
                   mem[MEMB_F144_SUP] |= fdc.equip;
           }
   
         // IDE initialize          // IDE initialize
         if (pccore.hddif & PCHDD_IDE) {          if (pccore.hddif & PCHDD_IDE) {
                 mem[MEMB_SYS_TYPE] |= 0x80;             // IDE                  mem[MEMB_SYS_TYPE] |= 0x80;             // IDE
Line 123  static void bios_reinitbyswitch(void) { Line 171  static void bios_reinitbyswitch(void) {
         }          }
 }  }
   
 static void bios_memclear(void) {  
   
         ZeroMemory(mem, 0xa0000);  
         ZeroMemory(mem + VRAM1_B, 0x18000);  
         ZeroMemory(mem + VRAM1_E, 0x08000);  
 }  
   
 static void bios_vectorset(void) {  static void bios_vectorset(void) {
   
         UINT    i;          UINT    i;
   
         for (i=0; i<0x400; i+=4) {  
                 SETBIOSMEM16(i+0, BIOSOFST_IRET);  
                 SETBIOSMEM16(i+2, BIOS_SEG);  
         }  
         for (i=0; i<0x20; i++) {          for (i=0; i<0x20; i++) {
                 *(UINT16 *)(mem + (i*4)) = *(UINT16 *)(mem + 0xfd868 + (i*2));                  *(UINT16 *)(mem + (i*4)) = *(UINT16 *)(mem + BIOS_BASE + BIOS_TABLE + (i*2));
                   SETBIOSMEM16((i * 4) + 2, BIOS_SEG);
         }          }
         SETBIOSMEM32(0x1e*4, 0xe8000000);          SETBIOSMEM32(0x1e*4, 0xe8000000);
 }  }
Line 155  static void bios_screeninit(void) { Line 193  static void bios_screeninit(void) {
 }  }
   
   
 // CDSで見てる為、変更…(涙  
 static const UINT16 biosoffset[0x20] = {  
                         BIOSOFST_IRET,  BIOSOFST_IRET,  BIOSOFST_02,    BIOSOFST_IRET,  
                         BIOSOFST_IRET,  BIOSOFST_IRET,  BIOSOFST_IRET,  BIOSOFST_IRET,  
   
                         BIOSOFST_08,    BIOSOFST_09,    BIOSOFST_EOIM,  BIOSOFST_EOIM,  
                         BIOSOFST_0c,    BIOSOFST_EOIM,  BIOSOFST_EOIM,  BIOSOFST_EOIM,  
   
                         BIOSOFST_EOIS,  BIOSOFST_EOIS,  BIOSOFST_12,    BIOSOFST_13,  
                         BIOSOFST_EOIS,  BIOSOFST_EOIS,  BIOSOFST_EOIS,  BIOSOFST_EOIS,  
   
                         BIOSOFST_18,    BIOSOFST_19,    BIOSOFST_1a,    BIOSOFST_1b,  
                         BIOSOFST_1c,    BIOSOFST_IRET,  BIOSOFST_1e,    BIOSOFST_1f};  
   
   
 void bios_initialize(void) {  void bios_initialize(void) {
   
         char    path[MAX_PATH];          char    path[MAX_PATH];
         FILEH   fh;          FILEH   fh;
         UINT    i;          UINT    i;
           UINT32  tmp;
         UINT    pos;          UINT    pos;
   
         biosrom = FALSE;          biosrom = FALSE;
   
         // まぁDISK BASIC動くようになるからいいんじゃないですか？  
         // BASIC BIOSは 8086コードのように見えるけど…  
         getbiospath(path, str_biosrom, sizeof(path));          getbiospath(path, str_biosrom, sizeof(path));
         fh = file_open_rb(path);          fh = file_open_rb(path);
         if (fh != FILEH_INVALID) {          if (fh != FILEH_INVALID) {
                 if (file_read(fh, mem + 0x0e8000, 0x18000) == 0x18000) {                  biosrom = (file_read(fh, mem + 0x0e8000, 0x18000) == 0x18000);
                         TRACEOUT(("load bios.rom"));  
                         biosrom = TRUE;  
                 }  
                 file_close(fh);                  file_close(fh);
         }          }
         if (!biosrom) {          if (biosrom) {
                   TRACEOUT(("load bios.rom"));
                   // PnP BIOSを潰す
                   for (i=0; i<0x10000; i+=0x10) {
                           tmp = LOADINTELDWORD(mem + 0xf0000 + i);
                           if (tmp == 0x506e5024) {
                                   TRACEOUT(("found PnP BIOS at %.5x", 0xf0000 + i));
                                   STOREINTELDWORD(mem + 0xf0000 + i, 0x32504e24);
                           }
                   }
           }
           else {
                 CopyMemory(mem + 0x0e8000, nosyscode, sizeof(nosyscode));                  CopyMemory(mem + 0x0e8000, nosyscode, sizeof(nosyscode));
         }          }
   
 #if defined(BIOS_SIMULATE)  #if defined(SUPPORT_PC9821)
         // BIOS hookのアドレス変更          getbiospath(path, "bios9821.rom", sizeof(path));
         for (i=0; i<0x20; i++) {          fh = file_open_rb(path);
                 STOREINTELWORD(mem + 0xfd868 + i*2, biosoffset[i]);          if (fh != FILEH_INVALID) {
         }                  if (file_read(fh, mem + 0x0d8000, 0x2000) == 0x2000) {
         SETBIOSMEM16(BIOS_BASE + BIOSOFST_IRET, 0x50cf);                          // IDE BIOSを潰す
         SETBIOSMEM16(BIOS_BASE + BIOSOFST_WAIT, 0xcf90);                          TRACEOUT(("load bios9821.rom"));
         for (i=(BIOS_BASE+BIOSOFST_EOIM); i<=(BIOS_BASE+BIOSOFST_1f); i+=2) {                          STOREINTELWORD(mem + 0x0d8009, 0);
                 SETBIOSMEM16(i, 0xcf90);                  }
                   file_close(fh);
         }          }
         CopyMemory(mem + BIOS_BASE + BIOSOFST_PRT, printmain, sizeof(printmain));  #endif
   
 //      bios_vectorset();  #if defined(BIOS_SIMULATE)
           CopyMemory(mem + BIOS_BASE, biosfd80, sizeof(biosfd80));
         if (!biosrom) {          if (!biosrom) {
                 lio_initialize();                  lio_initialize();
         }          }
   
         SETBIOSMEM16(0xfd800, 0xcb90);  
         SETBIOSMEM16(0xfd802, 0xcb90);  
         for (i=0; i<8; i+=2) {          for (i=0; i<8; i+=2) {
                 STOREINTELWORD(mem + 0xfd800 + 0x1aaf + i, 0x1ab7);                  STOREINTELWORD(mem + 0xfd800 + 0x1aaf + i, 0x1ab7);
                 STOREINTELWORD(mem + 0xfd800 + 0x1ad7 + i, 0x1adf);                  STOREINTELWORD(mem + 0xfd800 + 0x1ad7 + i, 0x1adf);
Line 233  void bios_initialize(void) { Line 262  void bios_initialize(void) {
                 CopyMemory(mem + 0xf538e, itfrom + pos, 0x27);                  CopyMemory(mem + 0xf538e, itfrom + pos, 0x27);
         }          }
   
 //      bios_reinitbyswitch();          CopyMemory(mem + 0x0fd800 + 0x0e00, keytable[0], 0x300);
 //      mem[MEMB_CRT_STS_FLAG] = 0x84;          // -> bios_screeninit()  
 //      mem[MEMB_BIOS_FLAG0] = 0x03;  
 //      mem[MEMB_F2DD_MODE] = 0xff;  
 //      SETBIOSMEM16(MEMW_DISK_EQUIP, 0x0003);  
         mem[0x005ae] |= 0x03;                                                                                   // ver0.31  
   
         CopyMemory(mem + 0x0fde00, keytable[0], 0x300);  
 //      bios0x09_init();  
   
         CopyMemory(mem + ITF_ADRS, itfrom, sizeof(itfrom));          CopyMemory(mem + ITF_ADRS, itfrom, sizeof(itfrom));
         mem[ITF_ADRS + 0x7ff0] = 0xea;          mem[ITF_ADRS + 0x7ff0] = 0xea;
Line 252  void bios_initialize(void) { Line 273  void bios_initialize(void) {
         else if ((pccore.model & PCMODELMASK) == PCMODEL_VM) {          else if ((pccore.model & PCMODELMASK) == PCMODEL_VM) {
                 mem[ITF_ADRS + 0x7ff1] = 0x08;                  mem[ITF_ADRS + 0x7ff1] = 0x08;
         }          }
   
         CopyMemory(mem + 0xfd800 + 0x2400, biosboot, sizeof(biosboot));  
 #else  #else
         fh = file_open_c("itf.rom");          fh = file_open_c("itf.rom");
         if (fh != FILEH_INVALID) {          if (fh != FILEH_INVALID) {
Line 267  void bios_initialize(void) { Line 286  void bios_initialize(void) {
         CopyMemory(mem + 0x1e8000, mem + 0x0e8000, 0x10000);          CopyMemory(mem + 0x1e8000, mem + 0x0e8000, 0x10000);
 }  }
   
 static void bios_boot(void) {  
   
         if (!(sysport.c & 0x80)) {  static void bios_itfcall(void) {
                 CPU_SP = GETBIOSMEM16(0x00404);  
                 CPU_SS = GETBIOSMEM16(0x00406);  
 //              TRACEOUT(("CPU Reset... SS:SP = %.4x:%.4x", CPU_SS, CPU_SP));  
         }  
         else {  
 //              bios_memclear();  
                 bios_vectorset();  
                 bios0x09_init();  
                 bios_reinitbyswitch();  
   
                 if (sysport.c & 0x20) {  
                         CPU_CS = 0x0000;  
                         CPU_IP = 0x04f8;  
                         CPU_DS = 0x0000;  
                         CPU_DX = 0x43d;  
                         CPU_AL = 0x10;  
                         mem[0x004f8] = 0xee;            // out  dx, al  
                         mem[0x004f9] = 0xea;            // call far  
                         SETBIOSMEM16(0x004fa, 0x0000);  
                         SETBIOSMEM16(0x004fc, 0xffff);  
                 }  
                 else {  
                         CPU_IP = 0x0002;  
                 }  
         }  
 }  
   
 // テスト(こんなんじゃだめぽ          int             i;
 static void bios0x1f(void) {  
   
         BYTE    work[256];          bios_itfprepare();
         UINT32  src;          bios_memclear();
         UINT32  dst;          bios_vectorset();
         UINT    leng;          bios0x09_init();
         UINT    l;          bios_reinitbyswitch();
           bios0x18_0c();
         if (CPU_AH == 0x90) {  
                 MEML_READSTR(CPU_ES, CPU_BX + 0x10, work, 0x10);          if (!np2cfg.ITF_WORK) {
                 src = work[2] + (work[3] << 8) + (work[4] << 16) + CPU_SI;                  for (i=0; i<8; i++) {
                 dst = work[10] + (work[11] << 8) + (work[12] << 16) + CPU_DI;                          mem[MEMB_MSW + (i*4)] = msw_default[i];
                 leng = LOW16(CPU_CX - 1) + 1;                  }
                 TRACEOUT(("protect bios: memmove"));                  CPU_FLAGL |= C_FLAG;
                 TRACEOUT(("%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",  
                                 work[0], work[1], work[2], work[3],  
                                 work[4], work[5], work[6], work[7]));  
                 TRACEOUT(("%.2x %.2x %.2x %.2x %.2x %.2x %.2x %.2x",  
                                 work[8], work[9], work[10], work[11],  
                                 work[12], work[13], work[14], work[15]));  
                 TRACEOUT(("SI=%.4x DI=%.4x CX=%.4x", CPU_SI, CPU_DI, CPU_CX));  
                 TRACEOUT(("src:%08x dst:%08x leng:%08x", src, dst, leng));  
                 do {  
                         l = min(leng, 256);  
                         MEML_READ(src, work, l);  
                         MEML_WRITE(dst, work, l);  
                         src += l;  
                         dst += l;  
                         leng -= l;  
                 } while(leng);  
         }          }
         else {          else {
                 TRACEOUT(("unsupport protect bios AH=%.2x", CPU_AH));                  CPU_DX = 0x43d;
                   CPU_AL = 0x10;
                   mem[0x004f8] = 0xee;            // out  dx, al
                   mem[0x004f9] = 0xea;            // call far
                   SETBIOSMEM16(0x004fa, 0x0000);
                   SETBIOSMEM16(0x004fc, 0xffff);
                   CPU_FLAGL &= ~C_FLAG;
         }          }
 }  }
   
   
 UINT MEMCALL biosfunc(UINT32 adrs) {  UINT MEMCALL biosfunc(UINT32 adrs) {
   
         UINT16  bootseg;          UINT16  bootseg;
Line 343  UINT MEMCALL biosfunc(UINT32 adrs) { Line 325  UINT MEMCALL biosfunc(UINT32 adrs) {
                 return(0);                  return(0);
         }          }
   
         switch(adrs) {  //      TRACEOUT(("biosfunc(%x)", adrs));
                 case BIOS_BASE + BIOSOFST_EOIM:  #if defined(CPUCORE_IA32) && defined(TRACE)
                         CPU_REMCLOCK -= 300;          if (CPU_STAT_PAGING) {
                         iocore_out8(0x00, 0x20);                  UINT32 pde = i286_memoryread_d(CPU_STAT_PDE_BASE);
                         return(0);                  if (!(pde & CPU_PDE_PRESENT)) {
                           TRACEOUT(("page0: PTE not present"));
                 case BIOS_BASE + BIOSOFST_EOIS:                  }
                         iocore_out8(0x08, 0x20);                  else {
                         if (!pic.pi[1].isr) {                          UINT32 pte = i286_memoryread_d(pde & CPU_PDE_BASEADDR_MASK);
                                 iocore_out8(0x00, 0x20);                          if (!(pte & CPU_PTE_PRESENT)) {
                                   TRACEOUT(("page0: not present"));
                         }                          }
                         return(0);                          else if (pte & CPU_PTE_BASEADDR_MASK) {
                                   TRACEOUT(("page0: physical address != 0 (pte = %.8x)", pte));
                           }
                   }
           }
   #endif
   
                 case BIOS_BASE + BIOSOFST_02:          switch(adrs) {
                         CPU_REMCLOCK -= 300;                  case BIOS_BASE + BIOSOFST_ITF:          // リセット
                         bios0x02();                          bios_itfcall();
                         return(1);                          return(1);
   
                 case BIOS_BASE + BIOSOFST_08:                  case BIOS_BASE + BIOSOFST_INIT:         // ブート
                         CPU_REMCLOCK -= 300;                          bios_reinitbyswitch();
                         bios0x08();                          bios_vectorset();
                           bios_screeninit();
                           if (((pccore.model & PCMODELMASK) >= PCMODEL_VX) &&
                                   (pccore.sound & 0x7e)) {
                                   iocore_out8(0x188, 0x27);
                                   iocore_out8(0x18a, 0x3f);
                           }
                         return(1);                          return(1);
   
                 case BIOS_BASE + BIOSOFST_09:                  case BIOS_BASE + BIOSOFST_09:
                         CPU_REMCLOCK -= 300;                          CPU_REMCLOCK -= 500;
                         bios0x09();                          bios0x09();
                         return(1);                          return(1);
   
Line 396  UINT MEMCALL biosfunc(UINT32 adrs) { Line 390  UINT MEMCALL biosfunc(UINT32 adrs) {
                         bios0x19();                          bios0x19();
                         return(1);                          return(1);
   
                 case BIOS_BASE + BIOSOFST_1a:                  case BIOS_BASE + BIOSOFST_CMT:
                         CPU_REMCLOCK -= 200;                          CPU_REMCLOCK -= 200;
                         bios0x1a();                          bios0x1a_cmt();
                           return(1);
   
                   case BIOS_BASE + BIOSOFST_PRT:
                           CPU_REMCLOCK -= 200;
                           bios0x1a_prt();
                         return(1);                          return(1);
   
                 case BIOS_BASE + BIOSOFST_1b:                  case BIOS_BASE + BIOSOFST_1b:
Line 439  UINT MEMCALL biosfunc(UINT32 adrs) { Line 438  UINT MEMCALL biosfunc(UINT32 adrs) {
                         }                          }
                         return(1);                          return(1);
   
                 case BIOS_BASE + BIOSOFST_PRT:  
                         bios0x1a_main();  
                         return(0);  
   
                 case 0xfd800:                                   // リセット  
                         bios_boot();  
                         return(1);  
   
                 case 0xfd802:                                   // ブート  
                         bios_reinitbyswitch();  
                         bios_vectorset();  
                         bios_screeninit();  
                         if (((pccore.model & PCMODELMASK) >= PCMODEL_VX) &&  
                                 (pccore.sound & 0x7e)) {  
                                 iocore_out8(0x188, 0x27);  
                                 iocore_out8(0x18a, 0x3f);  
                         }  
   
 #if 1                                                                                                                           // ver0.73  
                         CPU_CS = 0xfd80;                        // SASI/SCSIリセット  
                         CPU_IP = 0x2400;  
 #else  
                         bootseg = bootstrapload();  
                         CPU_STI;  
                         CPU_CS = (bootseg != 0)?bootseg:0xe800;  
                         CPU_DS = 0x0000;  
                         CPU_SS = 0x0030;  
                         CPU_SP = 0x00e6;  
                         CPU_IP = 0x0000;  
 #endif  
                         return(1);  
   
                 case 0xfffe8:                                   // ブートストラップロード                  case 0xfffe8:                                   // ブートストラップロード
                         CPU_REMCLOCK -= 2000;                          CPU_REMCLOCK -= 2000;
                         bootseg = bootstrapload();                          bootseg = bootstrapload();
Line 502  UINT MEMCALL biosfunc(UINT32 adrs) { Line 469  UINT MEMCALL biosfunc(UINT32 adrs) {
                 }                  }
                 return(0);                  return(0);
         }          }
           return(0);
         if (biosrom) {  
                 return(0);  
         }  
         CPU_IP--;  
         CPU_REMCLOCK = -1;  
         return(1);  
 }  }
   
Removed from v.1.53  
changed lines
  Added in v.1.62

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