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

Diff for /np2/bios/bios1b.c between versions 1.9 and 1.35

version 1.9, 2004/01/05 12:54:56 version 1.35, 2005/05/15 18:48:36
Line 2 Line 2
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
   #include        "scsicmd.h"
 #include        "bios.h"  #include        "bios.h"
 #include        "biosmem.h"  #include        "biosmem.h"
   #include        "sxsibios.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
 #include        "sxsi.h"  #include        "sxsi.h"
Line 15  enum { Line 17  enum {
 };  };
   
   
                 char    fdmode = 0;  // ---- FDD
 static  BYTE    work[65536];  
 static  BYTE    mtr_c = 0;  
 static  UINT    mtr_r = 0;  
   
   static BOOL setfdcmode(REG8 drv, REG8 type, REG8 rpm) {
   
 // ---- FDD          if (drv >= 4) {
                   return(FAILURE);
           }
           if ((rpm) && (!fdc.support144)) {
                   return(FAILURE);
           }
           fdc.chgreg = type;
           fdc.rpm[drv] = rpm;
           if (type & 2) {
                   CTRL_FDMEDIA = DISKTYPE_2HD;
           }
           else {
                   CTRL_FDMEDIA = DISKTYPE_2DD;
           }
           return(SUCCESS);
   }
   
 static void init_fdd_equip(void) {  void fddbios_equip(REG8 type, BOOL clear) {
   
         UINT16  diskequip;          REG16   diskequip;
   
         diskequip = GETBIOSMEM16(MEMW_DISK_EQUIP);          diskequip = GETBIOSMEM16(MEMW_DISK_EQUIP);
         diskequip &= 0x0f00;          if (clear) {
         diskequip |= (UINT16)(~fdmode) & 3;                  diskequip &= 0x0f00;
         diskequip |= (UINT16)fdmode << 12;          }
           if (type & 1) {
                   diskequip &= 0xfff0;
                   diskequip |= (fdc.equip & 0x0f);
           }
           else {
                   diskequip &= 0x0fff;
                   diskequip |= (fdc.equip & 0x0f) << 12;
           }
         SETBIOSMEM16(MEMW_DISK_EQUIP, diskequip);          SETBIOSMEM16(MEMW_DISK_EQUIP, diskequip);
 }  }
   
Line 45  static void biosfd_setchrn(void) { Line 68  static void biosfd_setchrn(void) {
 #if 0  #if 0
 static void biosfd_resultout(UINT32 result) {  static void biosfd_resultout(UINT32 result) {
   
         BYTE    *ptr;          UINT8   *ptr;
   
         ptr = mem + 0x00564 + (fdc.us*8);          ptr = mem + 0x00564 + (fdc.us*8);
         ptr[0] = (BYTE)(result & 0xff) | (fdc.hd << 2) | fdc.us;          ptr[0] = (UINT8)(result & 0xff) | (fdc.hd << 2) | fdc.us;
         ptr[1] = (BYTE)(result >> 8);          ptr[1] = (UINT8)(result >> 8);
         ptr[2] = (BYTE)(result >> 16);          ptr[2] = (UINT8)(result >> 16);
         ptr[3] = fdc.C;          ptr[3] = fdc.C;
         ptr[4] = fdc.H;          ptr[4] = fdc.H;
         ptr[5] = fdc.R;          ptr[5] = fdc.R;
Line 59  static void biosfd_resultout(UINT32 resu Line 82  static void biosfd_resultout(UINT32 resu
 }  }
 #endif  #endif
   
 static BOOL biosfd_seek(BYTE track, BOOL ndensity) {  static BOOL biosfd_seek(REG8 track, BOOL ndensity) {
   
         if (ndensity) {          if (ndensity) {
                 if (track < 42) {                  if (track < 42) {
Line 70  static BOOL biosfd_seek(BYTE track, BOOL Line 93  static BOOL biosfd_seek(BYTE track, BOOL
                 }                  }
         }          }
         fdc.ncn = track;          fdc.ncn = track;
         mtr_c = track;  
         if (fdd_seek()) {          if (fdd_seek()) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 static UINT16 fdfmt_biospara(BYTE fmt, BYTE rpm) {                                      // ver0.31  static UINT16 fdfmt_biospara(REG8 type, REG8 rpm, REG8 fmt) {
   
         UINT    seg;          UINT    seg;
         UINT    off;          UINT    off;
Line 87  static UINT16 fdfmt_biospara(BYTE fmt, B Line 109  static UINT16 fdfmt_biospara(BYTE fmt, B
         if (n >= 4) {          if (n >= 4) {
                 n = 3;                  n = 3;
         }          }
         if (CTRL_FDMEDIA == DISKTYPE_2HD) {          if (type & 2) {
                 seg = GETBIOSMEM16(MEMW_F2HD_P_SEG);                  seg = GETBIOSMEM16(MEMW_F2HD_P_SEG);
                 off = GETBIOSMEM16(MEMW_F2HD_P_OFF);                  off = GETBIOSMEM16(MEMW_F2HD_P_OFF);
         }          }
Line 99  static UINT16 fdfmt_biospara(BYTE fmt, B Line 121  static UINT16 fdfmt_biospara(BYTE fmt, B
                 off = 0x2361;                                                                   // see bios.cpp                  off = 0x2361;                                                                   // see bios.cpp
         }          }
         off += fdc.us * 2;          off += fdc.us * 2;
         off = i286_memword_read(seg, off);          off = MEML_READ16(seg, off);
         off += n * 8;          off += n * 8;
         if (!(CPU_AH & 0x40)) {          if (!(CPU_AH & 0x40)) {
                 off += 4;                  off += 4;
Line 107  static UINT16 fdfmt_biospara(BYTE fmt, B Line 129  static UINT16 fdfmt_biospara(BYTE fmt, B
         if (fmt) {          if (fmt) {
                 off += 2;                  off += 2;
         }          }
         return(i286_memword_read(seg, LOW16(off)));          return(MEML_READ16(seg, off));
 }  }
   
 static void change_rpm(BYTE rpm) {                                                                      // ver0.31  
   
         if (np2cfg.usefd144) {  
                 fdc.rpm = rpm;  
         }  
 }  
   
   
   
 enum {  enum {
         FDCBIOS_NORESULT,          FDCBIOS_NORESULT,
Line 133  enum { Line 147  enum {
   
 static void fdd_int(int result) {  static void fdd_int(int result) {
   
         if (result == FDCBIOS_NORESULT) {                                               // ver0.29          if (result == FDCBIOS_NORESULT) {
                 return;                  return;
         }          }
         switch(CPU_AH & 0x0f) {          switch(CPU_AH & 0x0f) {
Line 146  static void fdd_int(int result) { Line 160  static void fdd_int(int result) {
                 case 0x0a:                                                              // READ ID                  case 0x0a:                                                              // READ ID
                 case 0x0d:                                                              // フォーマット                  case 0x0d:                                                              // フォーマット
                         break;                          break;
   
                 default:                  default:
                         return;                          return;
         }          }
Line 182  static void fdd_int(int result) { Line 197  static void fdd_int(int result) {
                         fdc.stat[fdc.us] |= FDCRLT_IC0 | FDCRLT_NW;                          fdc.stat[fdc.us] |= FDCRLT_IC0 | FDCRLT_NW;
                         fdcsend_error7();                          fdcsend_error7();
                         break;                          break;
   
                   default:
                           return;
         }          }
           if (fdc.chgreg & 1) {
                   mem[MEMB_DISK_INTL] &= ~(0x01 << fdc.us);
           }
           else {
                   mem[MEMB_DISK_INTH] &= ~(0x10 << fdc.us);
           }
           CPU_IP = BIOSOFST_WAIT;
 }  }
   
 #if 1  #if 1
Line 210  static void b0patch(void) { Line 235  static void b0patch(void) {
                         REG8    c;                          REG8    c;
                         REG8    cl;                          REG8    cl;
                         REG8    last;                          REG8    last;
                         addr = ES_BASE + CPU_BP;                          addr = CPU_BP;
                         size = CPU_BX;                          size = CPU_BX;
                         cnt = 0;                          cnt = 0;
                         last = 0;                          last = 0;
                         while(size--) {                          while(size--) {
                                 c = i286_memoryread(addr++);                                  c = MEML_READ8(ES_BASE, addr++);
                                 cl = 0;                                  cl = 0;
                                 do {                                  do {
                                         REG8 now = c & 0x80;                                          REG8 now = c & 0x80;
Line 239  static void b0patch(void) { Line 264  static void b0patch(void) {
                         }                          }
                 }                  }
                 if ((b0p.pos >> 3) < CPU_BX) {                  if ((b0p.pos >> 3) < CPU_BX) {
                         UINT32 addr;                          UINT addr;
                         REG8 c;                          REG8 c;
                         addr = ES_BASE + CPU_BP + (b0p.pos >> 3);                          addr = CPU_BP + (b0p.pos >> 3);
                         c = i286_memoryread(addr);                          c = MEML_READ8(CPU_ES, addr);
                         c ^= (1 << (b0p.pos & 7));                          c ^= (1 << (b0p.pos & 7));
                         b0p.pos++;                          b0p.pos++;
                         i286_memorywrite(addr, c);                          MEML_WRITE8(CPU_ES, addr, c);
                 }                  }
         }          }
 }  }
Line 255  static void b0clr(void) { Line 280  static void b0clr(void) {
 }  }
 #endif  #endif
   
 static BYTE fdd_operate(BYTE type, BOOL ndensity, BYTE rpm) {           // ver0.31  static REG8 fdd_operate(REG8 type, REG8 rpm, BOOL ndensity) {
   
         BYTE    ret_ah = 0x60;          REG8    ret_ah = 0x60;
         UINT16  size;          UINT16  size;
         UINT16  pos;          UINT16  pos;
         UINT16  accesssize;          UINT16  accesssize;
         UINT16  secsize;          UINT16  secsize;
         UINT16  para;          UINT16  para;
         BYTE    s;          UINT8   s;
         BYTE    ID[4];          UINT8   ID[4];
         BYTE    hd;          UINT8   hd;
         int             result = FDCBIOS_NORESULT;          int             result = FDCBIOS_NORESULT;
         UINT32  addr;          UINT32  addr;
           UINT8   mtr_c;
           UINT    mtr_r;
           UINT    fmode;
   
         mtr_c = 0xff;          mtr_c = fdc.ncn;
         mtr_r = 0;          mtr_r = 0;
   
   
         // とりあえずBIOSの時は無視する          // とりあえずBIOSの時は無視する
         fdc.mf = 0xff;                                          // ver0.29          fdc.mf = 0xff;
   
 //      TRACE_("int 1Bh", CPU_AH);  //      TRACE_("int 1Bh", CPU_AH);
   
         change_rpm(rpm);                                                                                                // ver0.31          if (setfdcmode((REG8)(CPU_AL & 3), type, rpm) != SUCCESS) {
                   return(0x40);
           }
   
         if ((CPU_AH & 0x0f) != 0x0a) {          if ((CPU_AH & 0x0f) != 0x0a) {
                 fdc.crcn = 0;                  fdc.crcn = 0;
         }          }
         if ((CPU_AH & 0x0f) != 0x03) {          if ((CPU_AH & 0x0f) != 0x03) {
                 CTRL_FDMEDIA = type;                  if (type & 2) {
                 switch(type) {                          if (pic.pi[1].imr & PIC_INT42) {
                         case DISKTYPE_2HD:                                  return(0x40);
                                 if (pic.pi[1].imr & PIC_INT42) {                          }
                                         return(0xd0);                  }
                                 }                  else {
                                 break;                          if (pic.pi[1].imr & PIC_INT41) {
                         case DISKTYPE_2DD:                                  return(0x40);
                                 if (pic.pi[1].imr & PIC_INT41) {                          }
                                         return(0xd0);  
                                 }  
                                 break;  
                 }                  }
                 if (fdc.us != (CPU_AL & 0x03)) {                  if (fdc.us != (CPU_AL & 0x03)) {
                         fdc.us = CPU_AL & 0x03;                          fdc.us = CPU_AL & 0x03;
Line 307  static BYTE fdd_operate(BYTE type, BOOL  Line 334  static BYTE fdd_operate(BYTE type, BOOL 
                 }                  }
                 if (!fdd_diskready(fdc.us)) {                  if (!fdd_diskready(fdc.us)) {
                         fdd_int(FDCBIOS_NONREADY);                          fdd_int(FDCBIOS_NONREADY);
                         if (CPU_AH == 0x84) {                                                           // ver0.28                          ret_ah = 0x60;
                                 return(0x68);                   // 新センスは 両用ドライブ情報も                          if ((CPU_AX & 0x8f40) == 0x8400) {
                         }                                  ret_ah |= 8;                                    // 1MB/640KB両用ドライブ
                         if (CPU_AH == 0xc4) {                                                           // ver0.31                                  if ((CPU_AH & 0x40) && (fdc.support144)) {
                                 if (np2cfg.usefd144) {                                          ret_ah |= 4;                            // 1.44対応ドライブ
                                         return(0x6c);  
                                 }                                  }
                                 return(0x68);  
                         }                          }
                         return(0x60);                          return(ret_ah);
                 }                  }
         }          }
   
         // 2DDのモード選択                                                      // ver0.29          // モード選択                                                                                                   // ver0.78
         if (type == DISKTYPE_2DD) {          fmode = (type & 1)?MEMB_F2HD_MODE:MEMB_F2DD_MODE;
                 if (!(mem[MEMB_F2DD_MODE] & (0x10 << fdc.us))) {          if (!(CPU_AL & 0x80)) {
                         ndensity = 1;                  if (!(mem[fmode] & (0x10 << fdc.us))) {
                           ndensity = TRUE;
                 }                  }
         }          }
   
Line 352  static BYTE fdd_operate(BYTE type, BOOL  Line 378  static BYTE fdd_operate(BYTE type, BOOL 
                                 }                                  }
                         }                          }
                         biosfd_setchrn();                          biosfd_setchrn();
                         para = fdfmt_biospara(0, rpm);                          para = fdfmt_biospara(type, rpm, 0);
                         if (!para) {                          if (!para) {
                                 ret_ah = 0xd0;                                  ret_ah = 0xd0;
                                 break;                                  break;
Line 375  static BYTE fdd_operate(BYTE type, BOOL  Line 401  static BYTE fdd_operate(BYTE type, BOOL 
                                         break;                                          break;
                                 }                                  }
                                 size -= accesssize;                                  size -= accesssize;
                                 mtr_r += accesssize;                                            // ver0.26                                  mtr_r += accesssize;
                                 if ((fdc.R++ == (BYTE)para) && (CPU_AH & 0x80) && (!fdc.hd)) {                                  if ((fdc.R++ == (UINT8)para) &&
                                           (CPU_AH & 0x80) && (!fdc.hd)) {
                                         fdc.hd = 1;                                          fdc.hd = 1;
                                         fdc.H = 1;                                          fdc.H = 1;
                                         fdc.R = 1;                                          fdc.R = 1;
Line 396  static BYTE fdd_operate(BYTE type, BOOL  Line 423  static BYTE fdd_operate(BYTE type, BOOL 
                         break;                          break;
   
                 case 0x03:                                                              // 初期化                  case 0x03:                                                              // 初期化
                         init_fdd_equip();                          fddbios_equip(type, FALSE);
                         ret_ah = 0x00;                          ret_ah = 0x00;
                         break;                          break;
   
Line 412  static BYTE fdd_operate(BYTE type, BOOL  Line 439  static BYTE fdd_operate(BYTE type, BOOL 
                                 ret_ah |= 0x01;                                  ret_ah |= 0x01;
                         }                          }
                         else {                                                          // 2DD                          else {                                                          // 2DD
                                 if (mem[0x005ca] & (0x01 << fdc.us)) {                                  if (mem[fmode] & (0x01 << fdc.us)) {
                                         ret_ah++;                                          ret_ah |= 0x01;
                                 }                                  }
                                 if (mem[0x005ca] & (0x10 << fdc.us)) {                          // ver0.30                                  if (mem[fmode] & (0x10 << fdc.us)) {
                                         ret_ah |= 0x04;                                          ret_ah |= 0x04;
                                 }                                  }
                         }                          }
                         if (CPU_AH & 0x80) {                            // ver0.30                          if ((CPU_AX & 0x8f40) == 0x8400) {
                                 ret_ah |= 8;                                    // 1MB/640KB両用ドライブ                                  ret_ah |= 8;                                    // 1MB/640KB両用ドライブ
                                 if ((CPU_AH & 0x40) &&                                  if ((CPU_AH & 0x40) && (fdc.support144)) {
                                         (np2cfg.usefd144)) {            // ver0.31  
                                         ret_ah |= 4;                            // 1.44対応ドライブ                                          ret_ah |= 4;                            // 1.44対応ドライブ
                                 }                                  }
                         }                          }
Line 440  static BYTE fdd_operate(BYTE type, BOOL  Line 466  static BYTE fdd_operate(BYTE type, BOOL 
                                 }                                  }
                         }                          }
                         biosfd_setchrn();                          biosfd_setchrn();
                         para = fdfmt_biospara(0, rpm);                          para = fdfmt_biospara(type, rpm, 0);
                         if (!para) {                          if (!para) {
                                 ret_ah = 0xd0;                                  ret_ah = 0xd0;
                                 break;                                  break;
Line 465  static BYTE fdd_operate(BYTE type, BOOL  Line 491  static BYTE fdd_operate(BYTE type, BOOL 
                                 else {                                  else {
                                         accesssize = size;                                          accesssize = size;
                                 }                                  }
                                 i286_memx_read(addr, fdc.buf, accesssize);                                  MEML_READ(addr, fdc.buf, accesssize);
                                 if (fdd_write()) {                                  if (fdd_write()) {
                                         break;                                          break;
                                 }                                  }
                                 addr += accesssize;                                  addr += accesssize;
                                 size -= accesssize;                                  size -= accesssize;
                                 mtr_r += accesssize;                                            // ver0.26                                  mtr_r += accesssize;
                                 if ((fdc.R++ == (BYTE)para) && (CPU_AH & 0x80) && (!fdc.hd)) {                                  if ((fdc.R++ == (UINT8)para) &&
                                           (CPU_AH & 0x80) && (!fdc.hd)) {
                                         fdc.hd = 1;                                          fdc.hd = 1;
                                         fdc.H = 1;                                          fdc.H = 1;
                                         fdc.R = 1;                                          fdc.R = 1;
Line 486  static BYTE fdd_operate(BYTE type, BOOL  Line 513  static BYTE fdd_operate(BYTE type, BOOL 
                                 result = FDCBIOS_SUCCESS;                                  result = FDCBIOS_SUCCESS;
                         }                          }
                         else {                          else {
                                 ret_ah = fddlasterror;                  // 0xc0         // ver0.28                                  ret_ah = fddlasterror;                  // 0xc0
                                 result = FDCBIOS_WRITEERROR;                                  result = FDCBIOS_WRITEERROR;
                         }                          }
                         break;                          break;
Line 504  static BYTE fdd_operate(BYTE type, BOOL  Line 531  static BYTE fdd_operate(BYTE type, BOOL 
                                 }                                  }
                         }                          }
                         biosfd_setchrn();                          biosfd_setchrn();
                         para = fdfmt_biospara(0, rpm);                          para = fdfmt_biospara(type, rpm, 0);
                         if (!para) {                          if (!para) {
                                 ret_ah = 0xd0;                                  ret_ah = 0xd0;
                                 break;                                  break;
Line 533  static BYTE fdd_operate(BYTE type, BOOL  Line 560  static BYTE fdd_operate(BYTE type, BOOL 
                                 if (fdd_read()) {                                  if (fdd_read()) {
                                         break;                                          break;
                                 }                                  }
                                 i286_memx_write(addr, fdc.buf, accesssize);                                  MEML_WRITE(addr, fdc.buf, accesssize);
                                 addr += accesssize;                                  addr += accesssize;
                                 size -= accesssize;                                  size -= accesssize;
                                 mtr_r += accesssize;                                            // ver0.26                                  mtr_r += accesssize;
                                 if (fdc.R++ == (BYTE)para) {                                  if (fdc.R++ == (UINT8)para) {
                                         if ((CPU_AH & 0x80) && (!fdc.hd)) {                                          if ((CPU_AH & 0x80) && (!fdc.hd)) {
                                                 fdc.hd = 1;                                                  fdc.hd = 1;
                                                 fdc.H = 1;                                                  fdc.H = 1;
Line 574  static BYTE fdd_operate(BYTE type, BOOL  Line 601  static BYTE fdd_operate(BYTE type, BOOL 
                         }                          }
 #endif  #endif
                         else {                          else {
                                 ret_ah = fddlasterror;                          // 0xc0;        // ver0.28                                  ret_ah = fddlasterror;                          // 0xc0;
                                 result = FDCBIOS_READERROR;                                  result = FDCBIOS_READERROR;
                         }                          }
                         break;                          break;
Line 586  static BYTE fdd_operate(BYTE type, BOOL  Line 613  static BYTE fdd_operate(BYTE type, BOOL 
                         break;                          break;
   
                 case 0x0a:                                              // READ ID                  case 0x0a:                                              // READ ID
                         fdc.mf = CPU_AH & 0x40;                                                 // ver0.29                          fdc.mf = CPU_AH & 0x40;
                         if (CPU_AH & 0x10) {                                                    // ver0.28                          if (CPU_AH & 0x10) {
                                 if (!biosfd_seek(CPU_CL, ndensity)) {                                  if (!biosfd_seek(CPU_CL, ndensity)) {
                                         result = FDCBIOS_SEEKSUCCESS;                                          result = FDCBIOS_SEEKSUCCESS;
                                 }                                  }
Line 598  static BYTE fdd_operate(BYTE type, BOOL  Line 625  static BYTE fdd_operate(BYTE type, BOOL 
                                 }                                  }
                         }                          }
                         if (fdd_readid()) {                          if (fdd_readid()) {
                                 ret_ah = fddlasterror;                  // 0xa0;        // ver0.28                                  ret_ah = fddlasterror;                  // 0xa0;
                                 break;                                  break;
                         }                          }
                         if (fdc.N < 8) {                                                                // ver0.26                          if (fdc.N < 8) {
                                 mtr_r += 128 << fdc.N;                                  mtr_r += 128 << fdc.N;
                         }                          }
                         else {                          else {
Line 625  static BYTE fdd_operate(BYTE type, BOOL  Line 652  static BYTE fdd_operate(BYTE type, BOOL 
                         }                          }
                         fdc.d = CPU_DL;                          fdc.d = CPU_DL;
                         fdc.N = CPU_CH;                          fdc.N = CPU_CH;
                         para = fdfmt_biospara(1, rpm);                          para = fdfmt_biospara(type, rpm, 1);
                         if (!para) {                          if (!para) {
                                 ret_ah = 0xd0;                                  ret_ah = 0xd0;
                                 break;                                  break;
                         }                          }
                         fdc.sc = (BYTE)para;                          fdc.sc = (UINT8)para;
                         fdd_formatinit();                          fdd_formatinit();
                         pos = CPU_BP;                          pos = CPU_BP;
                         for (s=0; s<fdc.sc; s++) {                          for (s=0; s<fdc.sc; s++) {
                                 i286_memstr_read(CPU_ES, pos, ID, 4);                                  MEML_READSTR(CPU_ES, pos, ID, 4);
                                 fdd_formating(ID);                                  fdd_formating(ID);
                                 pos += 4;                                  pos += 4;
                                   if (ID[3] < 8) {
                                           mtr_r += 128 << ID[3];
                                   }
                                   else {
                                           mtr_r += 128 << 8;
                                   }
                         }                          }
                         ret_ah = 0x00;                          ret_ah = 0x00;
                         break;                          break;
         }  
         fdd_int(result);  
         fddmtr_seek(fdc.us, mtr_c, mtr_r);  
         CPU_IP = BIOSOFST_WAIT;                                                                                 // ver0.30  
         return(ret_ah);  
 }  
   
   
 // ---- SASI  
   
 static void init_sasi_equip(void) {  
   
         UINT16  diskequip;  
         UINT    i;  
         UINT16  bit;  
   
         diskequip = GETBIOSMEM16(MEMW_DISK_EQUIP);  
         diskequip &= 0xf0ff;  
         for (i=0, bit=0x0100; i<2; i++, bit<<=1) {  
                 if (sxsi_hd[i].fname[0]) {  
                         diskequip |= bit;  
                 }  
         }  
         SETBIOSMEM16(MEMW_DISK_EQUIP, diskequip);  
 }  
   
 static void init_scsi_equip(void) {  
   
         UINT    i;  
         BYTE    bit;  
         UINT16  w;  
   
         mem[MEMB_DISK_EQUIPS] = 0;  
         ZeroMemory(&mem[0x00460], 0x20);  
         for (i=0, bit=1; i<2; i++, bit<<=1) {  
                 if (sxsi_hd[i+2].fname[0]) {  
                         mem[MEMB_DISK_EQUIPS] |= bit;  
                         mem[0x00460+i*4] = sxsi_hd[i+2].sectors;  
                         mem[0x00461+i*4] = sxsi_hd[i+2].surfaces;  
                         switch(sxsi_hd[i+2].size) {  
                                 case 256:  
                                         w = 0 << 12;  
                                         break;  
   
                                 case 512:  
                                         w = 1 << 12;  
                                         break;  
   
                                 default:  
                                         w = 2 << 12;  
                                         break;  
                         }  
                         w |= sxsi_hd[i+2].tracks;  
                         SETBIOSMEM16(0x00462+i*4, w);  
                 }  
         }  
 }  
   
 static BYTE sxsi_pos(long *pos) {  
   
         SXSIHDD sxsi;  
         int             np2drv;  
   
         *pos = 0;  
         np2drv = (CPU_AL & 0x20) >> 4;  
         if ((CPU_AL & 0x0f) >= 2) {  
                 return(0x60);  
         }  
         np2drv |= (CPU_AL & 1);  
         sxsi = &sxsi_hd[np2drv];  
         if (CPU_AL & 0x80) {  
                 if ((CPU_DL >= sxsi->sectors) ||  
                         (CPU_DH >= sxsi->surfaces) ||  
                         (CPU_CX >= sxsi->tracks)) {  
                         return(0xd0);  
                 }  
                 (*pos) = ((CPU_CX * sxsi->surfaces) + CPU_DH) * sxsi->sectors  
                                                                                                                         + CPU_DL;  
         }  
         else {  
                 *pos = (CPU_DL << 16) | CPU_CX;  
                 if (!(CPU_AL & 0x20)) {  
                         (*pos) &= 0x1fffff;  
                 }  
                 if ((*pos) >= sxsi->totals) {  
                         return(0xd0);  
                 }  
         }  
         return(0x00);  
 }  
   
   
 UINT8 sxsi_operate(UINT8 type) {  
   
         BYTE    ret_ah = 0x00;  
         BYTE    drv;  
         long    pos;  
 //      int             i;  
   
         drv = (CPU_AL & 0x20) >> 4;  
         if ((CPU_AL & 0x0f) >= 2) {  
                 return(0x60);  
         }  
         drv |= (CPU_AL & 1);  
   
         switch(CPU_AH & 0x0f) {  
                 case 0x01:                                              // ベリファイ  
                 case 0x07:                                              // リトラクト  
                 case 0x0f:                                              // リトラクト  
                         break;  
   
                 case 0x03:                                              // イニシャライズ                  case 0x0e:                                                                                                      // ver0.78
                         if (type == HDDTYPE_SASI) {                          if (CPU_AH & 0x80) {                    // 密度設定
                                 init_sasi_equip();                                  mem[fmode] &= 0x0f;
                         }                                  mem[fmode] |= (UINT8)((CPU_AH & 0x0f) << 4);
                         else if (type == HDDTYPE_SCSI) {                          }
                                 init_scsi_equip();                          else {                                                  // 面設定
                                   mem[fmode] &= 0xf0;
                                   mem[fmode] |= (UINT8)(CPU_AH & 0x0f);
                         }                          }
                         break;  
   
                 case 0x04:                                              // センス  
                         ret_ah = 0x00;                          ret_ah = 0x00;
                         if ((CPU_AH == 0x04) && (type == HDDTYPE_SASI)) {  
                                 ret_ah = 0x04;  
                         }  
                         else if ((CPU_AH == 0x44) && (type == HDDTYPE_SCSI)) {  
                                 CPU_BX = 1;  
                         }  
                         else if (CPU_AH == 0x84) {  
                                 CPU_BX = sxsi_hd[drv].size;  
                                 CPU_CX = sxsi_hd[drv].tracks;  
                                 CPU_DH = sxsi_hd[drv].surfaces;  
                                 CPU_DL = sxsi_hd[drv].sectors;  
                         }  
                         break;  
   
                 case 0x05:                                              // データの書き込み  
                         i286_memx_read(ES_BASE + CPU_BP, work, CPU_BX);  
                         ret_ah = sxsi_pos(&pos);  
                         if (!ret_ah) {  
                                 ret_ah = sxsi_write(CPU_AL, pos, work, CPU_BX);  
                         }  
                         break;  
   
                 case 0x06:                                              // データの読み込み  
                         ret_ah = sxsi_pos(&pos);  
                         if (!ret_ah) {  
                                 ret_ah = sxsi_read(CPU_AL, pos, work, CPU_BX);  
                                 if (ret_ah < 0x20) {  
                                         i286_memx_write(ES_BASE + CPU_BP, work, CPU_BX);  
                                 }  
                         }  
                         break;  
   
                 case 0x0d:                                              // フォーマット  
                         if (CPU_DL) {  
                                 ret_ah = 0x30;  
                                 break;  
                         }  
                         i286_memstr_read(CPU_ES, CPU_BP, work, CPU_BX);  
                         ret_ah = sxsi_pos(&pos);  
                         if (!ret_ah) {  
                                 ret_ah = sxsi_format(CPU_AL, pos);  
                         }  
                         break;  
   
                 default:  
                         ret_ah = 0x40;  
                         break;                          break;
         }          }
           fdd_int(result);
           if (mtr_c != fdc.ncn) {
                   fddmtr_seek(fdc.us, mtr_c, mtr_r);
           }
         return(ret_ah);          return(ret_ah);
 }  }
   
   
 // -------------------------------------------------------------------- BIOS  // -------------------------------------------------------------------- BIOS
   
 static UINT16 boot_fd1(BYTE rpm) {                                                                      // ver0.31  static UINT16 boot_fd1(REG8 type, REG8 rpm) {
   
         UINT    remain;          UINT    remain;
         UINT    size;          UINT    size;
         UINT32  pos;          UINT32  pos;
         UINT16  bootseg;          UINT16  bootseg;
   
         change_rpm(rpm);                                                                                                // ver0.31          if (setfdcmode(fdc.us, type, rpm) != SUCCESS) {
                   return(0);
           }
         if (biosfd_seek(0, 0)) {          if (biosfd_seek(0, 0)) {
                 return(0);                  return(0);
         }          }
Line 867  static UINT16 boot_fd1(BYTE rpm) {       Line 749  static UINT16 boot_fd1(BYTE rpm) {      
         return(bootseg);          return(bootseg);
 }  }
   
 static UINT16 boot_fd(BYTE drv, BYTE type) {                                            // ver0.27  static UINT16 boot_fd(REG8 drv, REG8 type) {
   
         UINT16  bootseg;          UINT16  bootseg;
   
         if (drv >= 4) {          if (drv >= 4) {
                 return(0);                  return(0);
         }          }
         fdc.us = drv & 3;          fdc.us = drv;
         if (!fdd_diskready(fdc.us)) {          if (!fdd_diskready(fdc.us)) {
                 return(0);                  return(0);
         }          }
   
         // 2HD          // 2HD
         if (type & 1) {          if (type & 1) {
                 CTRL_FDMEDIA = DISKTYPE_2HD;  
                 // 1.25MB                  // 1.25MB
                 bootseg = boot_fd1(0);                  bootseg = boot_fd1(3, 0);
                 if (bootseg) {                  if (bootseg) {
                         mem[MEMB_DISK_BOOT] = (BYTE)(0x90+drv);                          mem[MEMB_DISK_BOOT] = (UINT8)(0x90 + drv);
                           fddbios_equip(3, TRUE);
                         return(bootseg);                          return(bootseg);
                 }                  }
                 // 1.44MB                  // 1.44MB
                 bootseg = boot_fd1(1);                  bootseg = boot_fd1(3, 1);
                 if (bootseg) {                  if (bootseg) {
                         mem[MEMB_DISK_BOOT] = (BYTE)(0x30+drv);                          mem[MEMB_DISK_BOOT] = (UINT8)(0x30 + drv);
                           fddbios_equip(3, TRUE);
                         return(bootseg);                          return(bootseg);
                 }                  }
         }          }
         if (type & 2) {                                                                         // ver0.29          if (type & 2) {
                 // 2DD                  // 2DD
                 CTRL_FDMEDIA = DISKTYPE_2DD;                  bootseg = boot_fd1(0, 0);
                 bootseg = boot_fd1(0);  
                 if (bootseg) {                  if (bootseg) {
                         mem[MEMB_DISK_BOOT] = (BYTE)(0x70+drv);                          mem[MEMB_DISK_BOOT] = (UINT8)(0x70 + drv);
                         fdmode = 3;                          fddbios_equip(0, TRUE);
                         return(bootseg);                          return(bootseg);
                 }                  }
         }          }
         return(0);          return(0);
 }  }
   
 static UINT16 boot_hd(BYTE drv) {                                                                       // ver0.27  static REG16 boot_hd(REG8 drv) {
   
         BYTE    ret;          REG8    ret;
   
         ret = sxsi_read(drv, 0, mem + 0x1fc00, 0x400);          ret = sxsi_read(drv, 0, mem + 0x1fc00, 0x400);
         if (ret < 0x20) {          if (ret < 0x20) {
Line 920  static UINT16 boot_hd(BYTE drv) {        Line 802  static UINT16 boot_hd(BYTE drv) {       
         return(0);          return(0);
 }  }
   
 UINT16 bootstrapload(void) {                                                                            // ver0.27  REG16 bootstrapload(void) {
   
         BYTE    i;          UINT8   i;
         UINT16  bootseg;          REG16   bootseg;
   
         fdmode = 0;  //      fdmode = 0;
         bootseg = 0;          bootseg = 0;
         switch(mem[MEMB_MSW5] & 0xf0) {         // うぐぅ…本当はALレジスタの値から          switch(mem[MEMB_MSW5] & 0xf0) {         // うぐぅ…本当はALレジスタの値から
                 case 0x00:                                      // ノーマル                  case 0x00:                                      // ノーマル
                         break;                          break;
   
                 case 0x20:                                      // 640KB FDD                  case 0x20:                                      // 640KB FDD
                         for (i=0; (i<4) && (!bootseg); i++) {                          for (i=0; (i<4) && (!bootseg); i++) {
                                 if (fdd_diskready(i)) {                                  if (fdd_diskready(i)) {
Line 937  UINT16 bootstrapload(void) {          // Line 820  UINT16 bootstrapload(void) {          //
                                 }                                  }
                         }                          }
                         break;                          break;
   
                 case 0x40:                                      // 1.2MB FDD                  case 0x40:                                      // 1.2MB FDD
                         for (i=0; (i<4) && (!bootseg); i++) {                          for (i=0; (i<4) && (!bootseg); i++) {
                                 if (fdd_diskready(i)) {                                  if (fdd_diskready(i)) {
Line 944  UINT16 bootstrapload(void) {          // Line 828  UINT16 bootstrapload(void) {          //
                                 }                                  }
                         }                          }
                         break;                          break;
   
                 case 0x60:                                      // MO                  case 0x60:                                      // MO
                         break;                          break;
   
                 case 0xa0:                                      // SASI 1                  case 0xa0:                                      // SASI 1
                         if (sxsi_hd[0].fname[0]) {                          bootseg = boot_hd(0x80);
                                 bootseg = boot_hd(0x80);  
                         }  
                         break;                          break;
   
                 case 0xb0:                                      // SASI 2                  case 0xb0:                                      // SASI 2
                         if (sxsi_hd[1].fname[0]) {                          bootseg = boot_hd(0x81);
                                 bootseg = boot_hd(0x81);  
                         }  
                         break;                          break;
   
                 case 0xc0:                                      // SCSI                  case 0xc0:                                      // SCSI
                         for (i=0; (i<2) && (!bootseg); i++) {                          for (i=0; (i<4) && (!bootseg); i++) {
                                 if (sxsi_hd[i+2].fname[0]) {                                  bootseg = boot_hd((REG8)(0xa0 + i));
                                         bootseg = boot_hd((BYTE)(0xa0 | i));  
                                 }  
                         }                          }
                         break;                          break;
   
                 default:                                        // ROM                  default:                                        // ROM
                         return(0);                          return(0);
         }          }
Line 972  UINT16 bootstrapload(void) {          // Line 855  UINT16 bootstrapload(void) {          //
                 }                  }
         }          }
         for (i=0; (i<2) && (!bootseg); i++) {          for (i=0; (i<2) && (!bootseg); i++) {
                 if (sxsi_hd[i].fname[0]) {                  bootseg = boot_hd((REG8)(0x80 + i));
                         bootseg = boot_hd((BYTE)(0x80 | i));  
                 }  
         }          }
         for (i=0; (i<2) && (!bootseg); i++) {          for (i=0; (i<4) && (!bootseg); i++) {
                 if (sxsi_hd[i+2].fname[0]) {                  bootseg = boot_hd((REG8)(0xa0 + i));
                         bootseg = boot_hd((BYTE)(0xa0 | i));  
                 }  
         }          }
   
         init_fdd_equip();  
         init_sasi_equip();  
         init_scsi_equip();  
         return(bootseg);          return(bootseg);
 }  }
   
   
 // --------------------------------------------------------------------------  // --------------------------------------------------------------------------
   
 void bios0x1b(void) {  void bios0x1b(void) {
   
         BYTE    ret_ah;          REG8    ret_ah;
         REG8    flag;          REG8    flag;
   
 #if 0                   // bypass to disk bios  #if 1                   // bypass to disk bios
         REG8    seg;          REG8    seg;
           UINT    sp;
   
         seg = mem[0x004b0 + (CPU_AH >> 4)];          seg = mem[MEMX_DISK_XROM + (CPU_AL >> 4)];
         if (seg) {          if (seg) {
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 2), CPU_DS);                  sp = CPU_SP;
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 4), CPU_SI);                  MEML_WRITE16(CPU_SS, sp - 2, CPU_DS);
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 6), CPU_DI);                  MEML_WRITE16(CPU_SS, sp - 4, CPU_SI);
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 8), CPU_ES);                  MEML_WRITE16(CPU_SS, sp - 6, CPU_DI);
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 10), CPU_BP);                  MEML_WRITE16(CPU_SS, sp - 8, CPU_ES);           // +a
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 12), CPU_DX);                  MEML_WRITE16(CPU_SS, sp - 10, CPU_BP);          // +8
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 14), CPU_CX);                  MEML_WRITE16(CPU_SS, sp - 12, CPU_DX);          // +6
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 16), CPU_BX);                  MEML_WRITE16(CPU_SS, sp - 14, CPU_CX);          // +4
                 i286_memword_write(CPU_SS, (REG16)(CPU_SP - 18), CPU_AX);                  MEML_WRITE16(CPU_SS, sp - 16, CPU_BX);          // +2
                 CPU_SP -= 18;                  MEML_WRITE16(CPU_SS, sp - 18, CPU_AX);          // +0
   #if 0
                   TRACEOUT(("call by %.4x:%.4x",
                                                           MEML_READ16(CPU_SS, CPU_SP+2),
                                                           MEML_READ16(CPU_SS, CPU_SP)));
                   TRACEOUT(("bypass to %.4x:0018", seg << 8));
                   TRACEOUT(("AX=%04x BX=%04x %02x:%02x:%02x:%02x ES=%04x BP=%04x",
                                                           CPU_AX, CPU_BX, CPU_CL, CPU_DH, CPU_DL, CPU_CH,
                                                           CPU_ES, CPU_BP));
   #endif
                   sp -= 18;
                   CPU_SP = sp;
                   CPU_BP = sp;
                   CPU_DS = 0x0000;
                   CPU_BX = 0x04B0;
                   CPU_AX = seg << 8;
                 CPU_CS = seg << 8;                  CPU_CS = seg << 8;
                 CPU_IP = 0x18;                  CPU_IP = 0x18;
                 TRACEOUT(("bypass to %.4x:%.4x", CPU_CS, CPU_IP));                  return;
           }
   #endif
   
   #if defined(SUPPORT_SCSI)
           if ((CPU_AL & 0xf0) == 0xc0) {
                   TRACEOUT(("%.4x:%.4x AX=%.4x BX=%.4x CX=%.4x DX=%.4 ES=%.4x BP=%.4x",
                                                           MEML_READ16(CPU_SS, CPU_SP+2),
                                                           MEML_READ16(CPU_SS, CPU_SP),
                                                           CPU_AX, CPU_BX, CPU_CX, CPU_DX, CPU_ES, CPU_BP));
                   scsicmd_bios();
                 return;                  return;
         }          }
 #endif  #endif
   
         switch(CPU_AL & 0xf0) {          switch(CPU_AL & 0xf0) {
                 case 0x90:                  case 0x90:
                         ret_ah = fdd_operate(DISKTYPE_2HD, 0, 0);                          ret_ah = fdd_operate(3, 0, FALSE);
                         break;                          break;
   
                 case 0x30:                  case 0x30:
                 case 0xb0:                  case 0xb0:
                         ret_ah = fdd_operate(DISKTYPE_2HD, 0, 1);                          ret_ah = fdd_operate(3, 1, FALSE);
                         break;                          break;
   
                 case 0x10:                  case 0x10:
                           ret_ah = fdd_operate(1, 0, FALSE);
                           break;
   
                 case 0x70:                  case 0x70:
                 case 0xf0:                  case 0xf0:
                         ret_ah = fdd_operate(DISKTYPE_2DD, 0, 0);                          ret_ah = fdd_operate(0, 0, FALSE);
                         break;                          break;
   
                 case 0x50:                  case 0x50:
                         ret_ah = fdd_operate(DISKTYPE_2DD, 1, 0);                          ret_ah = fdd_operate(0, 0, TRUE);
                         break;                          break;
   
                 case 0x00:                  case 0x00:
                 case 0x80:                  case 0x80:
                         ret_ah = sxsi_operate(HDDTYPE_SASI);                          ret_ah = sasibios_operate();
                         break;                          break;
 #if 0  
   #if defined(SUPPORT_SCSI)
                 case 0x20:                  case 0x20:
                 case 0xa0:                  case 0xa0:
                         ret_ah = sxsi_operate(HDDTYPE_SCSI);                          ret_ah = scsibios_operate();
                         break;                          break;
 #endif  #endif
   
Line 1053  void bios0x1b(void) { Line 959  void bios0x1b(void) {
                         break;                          break;
         }          }
 #if 0  #if 0
         {  
                 static BYTE p = 0;  
                 if ((CPU_CL == 0x4d) && (ret_ah == 0xe0)) {  
                         if (!p) {  
                                 trace_sw = 1;  
                                 p++;  
                                 debug_status();  
                                 memorydump();  
                         }  
                 }  
         }  
 #endif  
 #if 0  
         TRACEOUT(("%04x:%04x AX=%04x BX=%04x %02x:%02x:%02x:%02x\n"     \          TRACEOUT(("%04x:%04x AX=%04x BX=%04x %02x:%02x:%02x:%02x\n"     \
                                                 "ES=%04x BP=%04x \nret=%02x",                                                  "ES=%04x BP=%04x \nret=%02x",
                                                         i286_memword_read(CPU_SS, CPU_SP+2),                                                          MEML_READ16(CPU_SS, CPU_SP+2),
                                                         i286_memword_read(CPU_SS, CPU_SP),                                                          MEML_READ16(CPU_SS, CPU_SP),
                                                         CPU_AX, CPU_BX, CPU_CL, CPU_DH, CPU_DL, CPU_CH,                                                          CPU_AX, CPU_BX, CPU_CL, CPU_DH, CPU_DL, CPU_CH,
                                                         CPU_ES, CPU_BP, ret_ah));                                                          CPU_ES, CPU_BP, ret_ah));
 #endif  #endif
         CPU_AH = ret_ah;          CPU_AH = ret_ah;
         flag = i286_membyte_read(CPU_SS, CPU_SP+4) & 0xfe;          flag = MEML_READ8(CPU_SS, CPU_SP+4) & 0xfe;
         if (ret_ah >= 0x20) {          if (ret_ah >= 0x20) {
                 flag += 1;                  flag += 1;
         }          }
         i286_membyte_write(CPU_SS, CPU_SP + 4, flag);          MEML_WRITE8(CPU_SS, CPU_SP + 4, flag);
   }
   
   UINT bios0x1b_wait(void) {
   
           UINT    addr;
           REG8    bit;
   
           if (fddmtr.busy) {
                   CPU_REMCLOCK = -1;
           }
           else {
                   if (fdc.chgreg & 1) {
                           addr = MEMB_DISK_INTL;
                           bit = 0x01;
                   }
                   else {
                           addr = MEMB_DISK_INTH;
                           bit = 0x10;
                   }
                   bit <<= fdc.us;
                   if (mem[addr] & bit) {
                           mem[addr] &= ~bit;
                           return(0);
                   }
                   else {
                           CPU_REMCLOCK -= 1000;
                   }
           }
           CPU_IP--;
           return(1);
 }  }
   
Removed from v.1.9  
changed lines
  Added in v.1.35

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