[BACK]Return to fdd_2d.c CVS log [TXT] [DIR] Up to [RetroPC.NET] / xmil / fdd

Diff for /xmil/fdd/fdd_2d.c between versions 1.1 and 1.5

version 1.1, 2004/08/01 05:31:30 version 1.5, 2004/08/09 04:47:53
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "x1_io.h"  #include        "iocore.h"
 #include        "x1_fdc.h"  
 #include        "fddfile.h"  #include        "fddfile.h"
   #include        "fdd_2d.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
   
   
 extern  BYTE            WRITEPT[];  
 extern  BYTE            DISKNUM[];  
 static  WORD            sec_now[4] = {0, 0, 0, 0};  static  WORD            sec_now[4] = {0, 0, 0, 0};
 static  BYTE            sec_write[4] = {0, 0, 0, 0};  static  BYTE            sec_write[4] = {0, 0, 0, 0};
 static  BYTE            sec_data[4][256];  static  BYTE            sec_data[4][256];
 static  BYTE            hole = 0;  static  BYTE            hole = 0;
   
   
 BYTE changesector2d(void) {  static BYTE changesector2d(void) {
   
         FDDFILE fdd;          FDDFILE fdd;
         FILEH   fh;          FILEH   fh;
         WORD    sec;          WORD    sec;
         long    seekp;          long    seekp;
         short   drv = FDC.drv;          short   drv = fdc.drv;
   
         if (FDC.media) {          if (fdc.s.media != DISKTYPE_2D) {
                 return(1);                  return(1);
         }          }
         fdd = fddfile + drv;          fdd = fddfile + drv;
   
         sec = (WORD)(((FDC.c) << 5) + (FDC.h << 4) + FDC.r - 1);          sec = (WORD)(((fdc.c) << 5) + (fdc.h << 4) + fdc.r - 1);
         if (sec_now[drv] == sec) {          if (sec_now[drv] == sec) {
                 return(0);                  return(0);
         }          }
Line 59  BYTE changesector2d(void) { Line 57  BYTE changesector2d(void) {
         return(0);          return(0);
 }  }
   
 BRESULT fdd_eject_2d(REG8 drv) {  
   
         FDDFILE fdd;  
         FILEH   fh;  
         long    seekp;  
         BRESULT ret = 0;  
   
         fdd = fddfile + drv;  
         while(1) {  
                 if ((!sec_write[drv]) || (sec_now[drv] == -1)) {  
                         break;  
                 }  
                 seekp = (long)sec_now[drv] << 8;  
                 fh = file_open(fdd->fname);  
                 if (fh == FILEH_INVALID) {  
                         ret = 1;  
                         break;  
                 }  
                 if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||  
                         (file_write(fh, sec_data[drv], 256) != 256)) {  
                         ret = 1;  
                 }  
                 if (file_close(fh)) {  
                         ret = 1;  
                 }  
                 break;  
         }  
         fdd->fname[0] = '\0';  
         DISKNUM[drv] = 0;  
         sec_now[drv] = -1;  
         sec_write[drv] = 0;  
         return(ret);  
 }  
   
   
 BRESULT fdd_set_2d(REG8 drv, const OEMCHAR *fname) {  
   
         FDDFILE fdd;  
         WORD    attr;  
   
         fdd_eject_2d(drv);  
         fdd = fddfile + drv;  
         if ((drv < 0 || drv > 3) ||  
                 ((attr = file_attr(fname)) & 0x18)) {   // エラー・ディレクトリ・ラベル  
                 return(1);  
         }  
         DISKNUM[drv] = DRV_FMT2D;  
         file_cpyname(fdd->fname, fname, NELEMENTS(fdd->fname));  
         WRITEPT[drv] = (BYTE)(attr & 1);  
         return(0);  
 }  
   
 //**********************************************************************  //**********************************************************************
   
 short fdd_crc_2d(void) {  BRESULT fdd2d_crc(FDDFILE fdd) {
   
         FDC.crc_dat[0] = FDC.c;          fdc.s.buffer[0] = fdc.c;
         FDC.crc_dat[1] = FDC.h;          fdc.s.buffer[1] = fdc.h;
         FDC.crc_dat[2] = FDC.r;          fdc.s.buffer[2] = fdc.r;
         FDC.crc_dat[3] = 1;          fdc.s.buffer[3] = 1;
         FDC.crc_dat[4] = 0;                     // CRC(Lo)          fdc.s.buffer[4] = 0;                    // CRC(Lo)
         FDC.crc_dat[5] = 0;                     // CRC(Hi)          fdc.s.buffer[5] = 0;                    // CRC(Hi)
         FDC.rreg = FDC.c;                       // ??? メルヘンヴェール          fdc.s.bufsize = 6;
         return(0);          fdc.rreg = fdc.c;                                                               // メルヘンヴェール
           (void)fdd;
           return(SUCCESS);
 }  }
   
   
 BYTE fdd_stat_2d(void) {  BYTE fdd_stat_2d(void) {
   
         BYTE    type, cmnd;          FDDFILE fdd;
           REG8    cmd;
           BYTE    type;
         BYTE    ans = 0;          BYTE    ans = 0;
   
           fdd = fddfile + fdc.drv;
   
         // NOT READY          // NOT READY
         if (DISKNUM[FDC.drv] != DRV_FMT2D) {          if (fdd->type != DISKTYPE_BETA) {
                 return(0x80);                  return(0x80);
         }          }
         type = FDC.type;          type = fdc.type;
         cmnd = (BYTE)(FDC.cmnd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
   
         if (type == 0 || type == 1 || type == 4 ||                                      // !!!          if (type == 0 || type == 1 || type == 4 ||                                      // !!!
                 cmnd == 0x0a || cmnd == 0x0b || cmnd == 0x0f) {                  cmd == 0x0a || cmd == 0x0b || cmd == 0x0f) {
                 if (WRITEPT[FDC.drv]) {                         // WRITE PROTECT                  if (fdd->protect) {                             // WRITE PROTECT
                         ans |= 0x40;                          ans |= 0x40;
                 }                  }
         }          }
         if ((type == 1 || type == 2) &&          if ((type == 1 || type == 2) &&
                 ((FDC.c >= 40) || (FDC.h > 1) || (FDC.r > 16) || (FDC.media))) {                  ((fdc.c >= 40) || (fdc.h > 1) || (fdc.r > 16) ||
                   (fdc.s.media != DISKTYPE_2D))) {
                 ans |= 0x10;                                    // SEEK ERROR / RECORD NOT FOUND                  ans |= 0x10;                                    // SEEK ERROR / RECORD NOT FOUND
         }          }
   
         if (type == 1 || type == 4) {          if (type == 1 || type == 4) {
                 if (type == 1) {                  if (type == 1) {
                         ans |= 0x20;                                    // HEAD ENGAGED (X1 デハ ツネニ 1)                          ans |= 0x20;                                    // HEAD ENGAGED (X1 デハ ツネニ 1)
                         if (FDC.c == 0) {                          if (fdc.c == 0) {
                                 ans |= 0x04;                                    // TRACK00                                  ans |= 0x04;                                    // TRACK00
                         }                          }
                 }                  }
Line 164  BYTE fdd_stat_2d(void) { Line 120  BYTE fdd_stat_2d(void) {
                 if (FDDMTR_BUSY) {                  if (FDDMTR_BUSY) {
                         ans |= 0x01;                          ans |= 0x01;
                 }                  }
                 if ((type == 2) && (FDC.r) && (FDC.off < 256)) {                  if ((type == 2) && (fdc.r) && (fdc.off < 256)) {
                         ans |= 0x03;                                    // DATA REQUEST / BUSY                          ans |= 0x03;                                    // DATA REQUEST / BUSY
                 }                  }
                 else if (cmnd == 0x0f) {                  else if (cmd == 0x0f) {
                         ans |= 0x04;                                    // error!                          ans |= 0x04;                                    // error!
                 }                  }
         }          }
Line 180  BYTE fdd_stat_2d(void) { Line 136  BYTE fdd_stat_2d(void) {
 void fdd_read_2d(void) {  void fdd_read_2d(void) {
   
         if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {          if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {
                 FDC.data = sec_data[FDC.drv][FDC.off];                  fdc.data = sec_data[fdc.drv][fdc.off];
         }          }
 }  }
   
Line 188  void fdd_read_2d(void) { Line 144  void fdd_read_2d(void) {
 void fdd_write_2d(void) {  void fdd_write_2d(void) {
   
         if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {          if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {
                 sec_data[FDC.drv][FDC.off] = FDC.data;                  sec_data[fdc.drv][fdc.off] = fdc.data;
                 sec_write[FDC.drv] = 1;                  sec_write[fdc.drv] = 1;
         }          }
 }  }
   
   
 BYTE fdd_incoff_2d(void) {  BYTE fdd_incoff_2d(void) {
   
         BYTE cmnd;          REG8    cmd;
   
         if (++FDC.off < 256) {          if (++fdc.off < 256) {
                 return(0);                  return(0);
         }          }
         cmnd = (BYTE)(FDC.cmnd >> 4);          cmd = (REG8)(fdc.cmd >> 4);
         if (cmnd == 0x09 || cmnd == 0x0b) {          if ((cmd == 0x09) || (cmd == 0x0b)) {
                 if (FDC.r < 16) {                  if (fdc.r < 16) {
                         FDC.r++;                          fdc.r++;
                         FDC.rreg++;                          fdc.rreg++;
                         FDC.off = 0;                          fdc.off = 0;
                         return(0);                          return(0);
                 }                  }
                 FDC.rreg = FDC.r + 1;                  fdc.rreg = fdc.r + 1;
         }          }
         FDC.off = 256;          fdc.off = 256;
         return(1);          return(1);
 }  }
   
   
   
   // ----
   
   BRESULT fdd2d_set(FDDFILE fdd, REG8 drv, const OEMCHAR *fname) {
   
           short   attr;
   
           attr = file_attr(fname);
           if (attr & 0x18) {
                   return(FAILURE);
           }
           fdd->type = DISKTYPE_BETA;
           fdd->protect = (UINT8)(attr & 1);
           sec_now[drv] = -1;
           sec_write[drv] = 0;
           return(SUCCESS);
   }
   
   BRESULT fdd2d_eject(FDDFILE fdd, REG8 drv) {
   
           FILEH   fh;
           long    seekp;
           BRESULT ret = 0;
   
           while(1) {
                   if ((!sec_write[drv]) || (sec_now[drv] == -1)) {
                           break;
                   }
                   seekp = (long)sec_now[drv] << 8;
                   fh = file_open(fdd->fname);
                   if (fh == FILEH_INVALID) {
                           ret = 1;
                           break;
                   }
                   if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||
                           (file_write(fh, sec_data[drv], 256) != 256)) {
                           ret = 1;
                   }
                   if (file_close(fh)) {
                           ret = 1;
                   }
                   break;
           }
           fdd->fname[0] = '\0';
           fdd->type = DISKTYPE_NOTREADY;
           sec_now[drv] = -1;
           sec_write[drv] = 0;
           return(ret);
   }
   
Removed from v.1.1  
changed lines
  Added in v.1.5

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