[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.4 and 1.7

version 1.4, 2004/08/08 09:12:06 version 1.7, 2004/08/13 01:35:59
Line 7 Line 7
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
   
   
 static  WORD            sec_now[4] = {0, 0, 0, 0};  static REG8 fdd2d_seek(FDDFILE fdd, REG8 media, UINT track) {
 static  BYTE            sec_write[4] = {0, 0, 0, 0};  
 static  BYTE            sec_data[4][256];  
 static  BYTE            hole = 0;  
   
           if ((media != 0) || (track >= 80)) {
                   return(FDDSTAT_SEEKERR);
           }
           (void)fdd;
           return(0x00);
   }
   
 BYTE changesector2d(void) {  static REG8 fdd2d_read(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   UINT8 *ptr, UINT *size) {
   
         FDDFILE fdd;          UINT    secsize;
         FILEH   fh;          FILEH   fh;
         WORD    sec;          long    pos;
         long    seekp;          BRESULT b;
         short   drv = fdc.drv;  
   
         if (fdc.media) {          if ((media != 0) || (track >= 80) || (sc == 0) || (sc > 16)) {
                 return(1);                  goto fd2r_err;
         }          }
         fdd = fddfile + drv;          secsize = min(*size, 256);
           if (ptr) {
         sec = (WORD)(((fdc.c) << 5) + (fdc.h << 4) + fdc.r - 1);                  fh = file_open_rb(fdd->fname);
         if (sec_now[drv] == sec) {                  if (fh == FILEH_INVALID) {
                 return(0);                          goto fd2r_err;
         }  
         fh = file_open(fdd->fname);  
         if (fh == FILEH_INVALID) {  
                 sec_now[drv] = -1;  
                 return(1);  
         }  
         if ((sec_write[drv]) && (sec_now[drv] != -1)) {  
                 seekp = (long)sec_now[drv] << 8;  
                 if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||  
                         (file_write(fh, sec_data[drv], 256) != 256)) {  
                         file_close(fh);  
                         sec_now[drv] = -1;  
                         return(1);  
                 }                  }
         }                  pos = ((track * 16) + (sc - 1)) * 256;
         sec_write[drv] = 0;                  b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
         sec_now[drv] = sec;                          (file_read(fh, ptr, secsize) != secsize);
         seekp = (long)sec << 8;  
         if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||  
                 (file_read(fh, sec_data[drv], 256) != 256)) {  
                 file_close(fh);                  file_close(fh);
                 sec_now[drv] = -1;                  if (b) {
                 return(1);                          goto fd2r_err;
                   }
         }          }
         file_close(fh);          *size = secsize;
         return(0);          return(0x00);
 }  
   
   fd2r_err:
           return(FDDSTAT_RECNFND);
   
 //**********************************************************************  
   
 short fdd_crc_2d(void) {  
   
         fdc.crc_dat[0] = fdc.c;  
         fdc.crc_dat[1] = fdc.h;  
         fdc.crc_dat[2] = fdc.r;  
         fdc.crc_dat[3] = 1;  
         fdc.crc_dat[4] = 0;                     // CRC(Lo)  
         fdc.crc_dat[5] = 0;                     // CRC(Hi)  
         fdc.rreg = fdc.c;                       // ??? メルヘンヴェール  
         return(0);  
 }  }
   
   static REG8 fdd2d_write(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   const UINT8 *ptr, UINT size) {
   
 BYTE fdd_stat_2d(void) {          FILEH   fh;
           long    pos;
         FDDFILE fdd;          BRESULT b;
         REG8    cmd;  
         BYTE    type;  
         BYTE    ans = 0;  
   
         fdd = fddfile + fdc.drv;  
   
         // NOT READY  
         if (fdd->type != DISKTYPE_BETA) {  
                 return(0x80);  
         }  
         type = fdc.type;  
         cmd = (REG8)(fdc.cmd >> 4);  
   
         if (type == 0 || type == 1 || type == 4 ||                                      // !!!          if ((media != 0) || (track >= 80) || (sc == 0) || (sc > 16)) {
                 cmd == 0x0a || cmd == 0x0b || cmd == 0x0f) {                  return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
                 if (fdd->protect) {                             // WRITE PROTECT  
                         ans |= 0x40;  
                 }  
         }  
         if ((type == 1 || type == 2) &&  
                 ((fdc.c >= 40) || (fdc.h > 1) || (fdc.r > 16) || (fdc.media))) {  
                 ans |= 0x10;                                    // SEEK ERROR / RECORD NOT FOUND  
         }          }
           fh = file_open(fdd->fname);
         if (type == 1 || type == 4) {          if (fh == FILEH_INVALID) {
                 if (type == 1) {                  goto fd2w_err;
                         ans |= 0x20;                                    // HEAD ENGAGED (X1 デハ ツネニ 1)  
                         if (fdc.c == 0) {  
                                 ans |= 0x04;                                    // TRACK00  
                         }  
                 }  
                 if (++hole < 8) {  
                         ans |= 0x02;                                    // INDEX  
                 }  
         }          }
         else if (!(ans & 0xf0)) {          pos = ((track * 16) + (sc - 1)) * 256;
                 if (FDDMTR_BUSY) {          size = min(size, 256);
                         ans |= 0x01;          b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
                 }                  (file_write(fh, ptr, size) != size);
                 if ((type == 2) && (fdc.r) && (fdc.off < 256)) {          file_close(fh);
                         ans |= 0x03;                                    // DATA REQUEST / BUSY          if (b) {
                 }                  goto fd2w_err;
                 else if (cmd == 0x0f) {  
                         ans |= 0x04;                                    // error!  
                 }  
         }          }
         return(ans);          return(0x00);
 }  
   
   
 //**********************************************************************  fd2w_err:
           return(FDDSTAT_WRITEFAULT);
 void fdd_read_2d(void) {  
   
         if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {  
                 fdc.data = sec_data[fdc.drv][fdc.off];  
         }  
 }  }
   
   static REG8 fdd2d_crc(FDDFILE fdd, REG8 media, UINT track, UINT num,
                                                                                                   UINT8 *ptr) {
   
 void fdd_write_2d(void) {          if ((media != 0) || (track >= 80) || (num >= 16)) {
                   return(FDDSTAT_RECNFND);
         if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {  
                 sec_data[fdc.drv][fdc.off] = fdc.data;  
                 sec_write[fdc.drv] = 1;  
         }          }
           ptr[0] = (UINT8)(track >> 1);
           ptr[1] = (UINT8)(track & 1);
           ptr[2] = (UINT8)(num + 1);
           ptr[3] = 1;
           ptr[4] = 0;                                                                             // CRC(Lo)
           ptr[5] = 0;                                                                             // CRC(Hi)
   //      fdc.s.rreg = fdc.s.c;                                                   // メルヘンヴェール
           (void)fdd;
           return(0x00);
 }  }
   
   
 BYTE fdd_incoff_2d(void) {  #if defined(SUPPORT_DISKEXT)
   static UINT32 fdd2d_sec(FDDFILE fdd, REG8 media, UINT track, REG8 sc) {
   
         REG8    cmd;          UINT32  ret;
   
         if (++fdc.off < 256) {          if ((media != 0) || (track >= 80)) {
                 return(0);                  return(0);
         }          }
         cmd = (REG8)(fdc.cmd >> 4);          if ((sc == 0) || (sc > 16)) {
         if ((cmd == 0x09) || (cmd == 0x0b)) {                  ret = 16;
                 if (fdc.r < 16) {          }
                         fdc.r++;          else {
                         fdc.rreg++;                  ret = sc;
                         fdc.off = 0;  
                         return(0);  
                 }  
                 fdc.rreg = fdc.r + 1;  
         }          }
         fdc.off = 256;          return((16 << 16) + ret);
         return(1);  
 }  }
   #endif
   
   
 // ----  // ----
   
 BRESULT fdd2d_set(FDDFILE fdd, REG8 drv, const OEMCHAR *fname) {  BRESULT fdd2d_set(FDDFILE fdd, const OEMCHAR *fname) {
   
         short   attr;          short   attr;
   
Line 180  BRESULT fdd2d_set(FDDFILE fdd, REG8 drv, Line 123  BRESULT fdd2d_set(FDDFILE fdd, REG8 drv,
         if (attr & 0x18) {          if (attr & 0x18) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         file_cpyname(fdd->fname, fname, NELEMENTS(fdd->fname));  
         fdd->type = DISKTYPE_BETA;          fdd->type = DISKTYPE_BETA;
         fdd->protect = (UINT8)(attr & 1);          fdd->protect = (UINT8)(attr & 1);
         sec_now[drv] = -1;          fdd->seek = fdd2d_seek;
         sec_write[drv] = 0;          fdd->read = fdd2d_read;
           fdd->write = fdd2d_write;
           fdd->crc = fdd2d_crc;
   #if defined(SUPPORT_DISKEXT)
           fdd->sec = fdd2d_sec;
   #endif
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 BRESULT fdd2d_eject(FDDFILE fdd, REG8 drv) {  void fdd2d_eject(FDDFILE fdd) {
   
         FILEH   fh;  
         long    seekp;  
         BRESULT ret = 0;  
   
         while(1) {          (void)fdd;
                 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.4  
changed lines
  Added in v.1.7

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