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

Diff for /xmil/fdd/fddfile.c between versions 1.2 and 1.9

version 1.2, 2004/08/02 11:48:13 version 1.9, 2008/06/02 20:07:31
Line 5 Line 5
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  #include        "iocore.h"
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "x1_io.h"  
 #include        "x1_fdc.h"  
 #include        "fdd_2d.h"  #include        "fdd_2d.h"
 #include        "fdd_d88.h"  #include        "fdd_d88.h"
   
   
         _FDDFILE        fddfile[MAX_FDDFILE];          _FDDFILE        fddfile[MAX_FDDFILE];
   
 extern  BYTE            WRITEPT[];  
 extern  BYTE            DISKNUM[];  
   
   static REG8 dummyseek(FDDFILE fdd, REG8 media, UINT track) {
   
           (void)fdd;
           (void)media;
           (void)track;
           return(FDDSTAT_SEEKERR);
   }
   
   static REG8 dummyread(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   UINT8 *ptr, UINT *size) {
   
           (void)fdd;
           (void)media;
           (void)track;
           (void)sc;
           (void)ptr;
           (void)size;
           return(FDDSTAT_RECNFND);
   }
   
   static REG8 dummywrite(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                   const UINT8 *ptr, UINT size) {
   
           (void)fdd;
           (void)media;
           (void)track;
           (void)sc;
           (void)ptr;
           (void)size;
           return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
   }
   
   static REG8 dummycrc(FDDFILE fdd, REG8 media, UINT track, UINT num,
                                                                                                   UINT8 *ptr) {
   
           (void)fdd;
           (void)media;
           (void)track;
           (void)num;
           (void)ptr;
           return(FDDSTAT_RECNFND);
   }
   
   static UINT32 getfdtype(const OEMCHAR *fname) {
   
   const OEMCHAR   *ext;
   
           ext = file_getext(fname);
           if ((!milstr_cmp(ext, str_d88)) || (!milstr_cmp(ext, str_88d))) {
                   return(FTYPE_D88);
           }
           return(FTYPE_BETA);
   }
   
   static void setempty(FDDFILE fdd) {
   
           ZeroMemory(fdd, sizeof(_FDDFILE));
           fdd->seek = dummyseek;
           fdd->read = dummyread;
           fdd->write = dummywrite;
           fdd->wrtrk = dummywrite;
           fdd->crc = dummycrc;
   }
   
   
   /* ---- */
   
 void fddfile_initialize(void) {  void fddfile_initialize(void) {
   
           UINT    i;
   
           for (i=0; i<MAX_FDDFILE; i++) {
                   setempty(fddfile + i);
           }
 }  }
   
 const OEMCHAR *fdd_diskname(REG8 drv) {  const OEMCHAR *fddfile_diskname(REG8 drv) {
   
         if (drv >= MAX_FDDFILE) {          if (drv >= MAX_FDDFILE) {
                 return(str_null);                  return(str_null);
Line 28  const OEMCHAR *fdd_diskname(REG8 drv) { Line 96  const OEMCHAR *fdd_diskname(REG8 drv) {
         return(fddfile[drv].fname);          return(fddfile[drv].fname);
 }  }
   
 BRESULT fdd_diskready(REG8 drv) {  BRESULT fddfile_diskready(REG8 drv) {
   
         if ((drv >= MAX_FDDFILE) || (fddfile[drv].fname[0] == '\0')) {          if ((drv >= MAX_FDDFILE) || (fddfile[drv].type == DISKTYPE_NOTREADY)) {
                 return(FALSE);                  return(FALSE);
         }          }
         return(TRUE);          return(TRUE);
 }  }
   
   BRESULT fddfile_diskprotect(REG8 drv) {
   
 // ----          if ((drv >= MAX_FDDFILE) || (!fddfile[drv].protect)) {
                   return(FALSE);
 static REG8 getfdtype(const OEMCHAR *fname) {  
   
 const OEMCHAR   *ext;  
   
         ext = file_getext(fname);  
         if (!milstr_cmp(ext, str_e2d)) {  
                 return(DRV_FMT2D);  
         }  
         if ((!milstr_cmp(ext, str_d88)) || (!milstr_cmp(ext, str_88d))) {  
                 return(DRV_FMT88);  
         }          }
         return(DRV_EMPTY);          return(TRUE);
 }  }
   
 BRESULT fdd_set(REG8 drv, const OEMCHAR *fname, UINT ftype, int ro) {  BRESULT fddfile_set(REG8 drv, const OEMCHAR *fname, UINT32 ftype, int ro) {
   
           FDDFILE fdd;
           BRESULT r;
   
         fdd_eject(drv);  
         if (drv >= MAX_FDDFILE) {          if (drv >= MAX_FDDFILE) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         switch(getfdtype(fname)) {          fddfile_eject(drv);
                 case DRV_EMPTY:          fdd = fddfile + drv;
                         return(FAILURE);          if (ftype == FTYPE_NONE) {
                   ftype = getfdtype(fname);
                 case DRV_FMT2D:          }
                         return(fdd2d_set(drv, fname));          switch(ftype) {
                   case FTYPE_BETA:
                           r = fdd2d_set(fdd, fname);
                           break;
   
                   case FTYPE_D88:
                           r = fddd88_set(fdd, fname);
                           break;
   
                 default:                  default:
                         return(fddd88_set(drv, fname));                          r = FAILURE;
                           break;
           }
           if (r == SUCCESS) {
                   fdd->ftype = ftype;
                   milstr_ncpy(fdd->fname, fname, NELEMENTS(fdd->fname));
                   if (ro) {
                           fdd->protect = TRUE;
                   }
         }          }
         return(FAILURE);          return(r);
 }  }
   
 BRESULT fdd_eject(REG8 drv) {  void fddfile_eject(REG8 drv) {
   
         FDDFILE         fdd;          FDDFILE fdd;
   
         if (drv >= MAX_FDDFILE) {          if (drv >= MAX_FDDFILE) {
                 return(FAILURE);                  return;
         }          }
         fdd = fddfile + drv;          fdd = fddfile + drv;
         switch(DISKNUM[drv]) {          switch(fdd->type) {
                 case DRV_EMPTY:                  case DISKTYPE_BETA:
                         return(FAILURE);                          fdd2d_eject(fdd);
   
                 case DRV_FMT2D:                  case DISKTYPE_D88:
                         return(fdd2d_eject(drv));                          fddd88_eject(fdd);
   
                 default:  
                         return(fddd88_eject(drv));  
         }          }
         return(FAILURE);          setempty(fdd);
 }  }
   
Removed from v.1.2  
changed lines
  Added in v.1.9

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