[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.6 and 1.9

version 1.6, 2004/08/10 08:28:48 version 1.9, 2004/08/17 09:35:09
Line 1 Line 1
 #include        "compiler.h"  #include        "compiler.h"
 #include        "dosio.h"  #include        "dosio.h"
 #include        "pccore.h"  #include        "pccore.h"
 #include        "iocore.h"  
 #include        "fddfile.h"  #include        "fddfile.h"
 #include        "fdd_2d.h"  #include        "fdd_2d.h"
 #include        "fdd_mtr.h"  #include        "fdd_mtr.h"
   
   
   static const _XDFINFO supportxdf[] = {
                           {0,  80, 16, 1, DISKTYPE_2D},
                           {0, 154, 26, 1, DISKTYPE_2HD}};
   
   
 static REG8 fdd2d_seek(FDDFILE fdd, REG8 media, UINT track) {  static REG8 fdd2d_seek(FDDFILE fdd, REG8 media, UINT track) {
   
         if ((media != 0) || (track >= 80)) {          if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks)) {
                 return(FDDSTAT_SEEKERR);                  return(FDDSTAT_SEEKERR);
         }          }
         (void)fdd;  
         return(0x00);          return(0x00);
 }  }
   
Line 20  static REG8 fdd2d_read(FDDFILE fdd, REG8 Line 23  static REG8 fdd2d_read(FDDFILE fdd, REG8
                                                                                                 UINT8 *ptr, UINT *size) {                                                                                                  UINT8 *ptr, UINT *size) {
   
         UINT    secsize;          UINT    secsize;
           UINT    rsize;
         FILEH   fh;          FILEH   fh;
         long    pos;          long    pos;
         BRESULT b;          BRESULT b;
   
         if ((media != 0) || (track >= 80) || (sc == 0) || (sc > 16)) {          if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
                   (sc == 0) || (sc > fdd->inf.xdf.sectors)) {
                 goto fd2r_err;                  goto fd2r_err;
         }          }
         secsize = min(*size, 256);          secsize = 1 << (7 + fdd->inf.xdf.n);
           rsize = min(secsize, *size);
         if (ptr) {          if (ptr) {
                 fh = file_open_rb(fdd->fname);                  fh = file_open_rb(fdd->fname);
                 if (fh == FILEH_INVALID) {                  if (fh == FILEH_INVALID) {
                         goto fd2r_err;                          goto fd2r_err;
                 }                  }
                 pos = ((track * 16) + (sc - 1)) * 256;                  pos = ((track * fdd->inf.xdf.sectors) + (sc - 1)) * secsize;
                   pos += fdd->inf.xdf.headersize;
                 b = (file_seek(fh, pos, FSEEK_SET) != pos) ||                  b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
                         (file_read(fh, ptr, secsize) != secsize);                          (file_read(fh, ptr, rsize) != rsize);
                 file_close(fh);                  file_close(fh);
                 if (b) {                  if (b) {
                         goto fd2r_err;                          goto fd2r_err;
                 }                  }
         }          }
         *size = secsize;          *size = rsize;
         return(0x00);          return(0x00);
   
 fd2r_err:  fd2r_err:
Line 51  fd2r_err: Line 58  fd2r_err:
 static REG8 fdd2d_write(FDDFILE fdd, REG8 media, UINT track, REG8 sc,  static REG8 fdd2d_write(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
                                                                                                 const UINT8 *ptr, UINT size) {                                                                                                  const UINT8 *ptr, UINT size) {
   
           UINT    secsize;
         FILEH   fh;          FILEH   fh;
         long    pos;          long    pos;
         BRESULT b;          BRESULT b;
   
         if ((media != 0) || (track >= 80) || (sc == 0) || (sc > 16)) {          if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
                   (sc == 0) || (sc > fdd->inf.xdf.sectors)) {
                 return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);                  return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
         }          }
         fh = file_open(fdd->fname);          fh = file_open(fdd->fname);
         if (fh == FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 goto fd2w_err;                  goto fd2w_err;
         }          }
         pos = ((track * 16) + (sc - 1)) * 256;          secsize = 1 << (7 + fdd->inf.xdf.n);
         size = min(size, 256);          pos = ((track * fdd->inf.xdf.sectors) + (sc - 1)) * secsize;
           size = min(size, secsize);
         b = (file_seek(fh, pos, FSEEK_SET) != pos) ||          b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
                 (file_write(fh, ptr, size) != size);                  (file_write(fh, ptr, size) != size);
         file_close(fh);          file_close(fh);
Line 79  fd2w_err: Line 89  fd2w_err:
 static REG8 fdd2d_crc(FDDFILE fdd, REG8 media, UINT track, UINT num,  static REG8 fdd2d_crc(FDDFILE fdd, REG8 media, UINT track, UINT num,
                                                                                                 UINT8 *ptr) {                                                                                                  UINT8 *ptr) {
   
         if ((media != 0) || (track >= 80) || (num >= 16)) {          if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
                   (num >= fdd->inf.xdf.sectors)) {
                 return(FDDSTAT_RECNFND);                  return(FDDSTAT_RECNFND);
         }          }
         ptr[0] = (UINT8)(track >> 1);          ptr[0] = (UINT8)(track >> 1);
         ptr[1] = (UINT8)(track & 1);          ptr[1] = (UINT8)(track & 1);
         ptr[2] = (UINT8)(num + 1);          ptr[2] = (UINT8)(num + 1);
         ptr[3] = 1;          ptr[3] = fdd->inf.xdf.n;
         ptr[4] = 0;                                                                             // CRC(Lo)          ptr[4] = 0;                                                                             // CRC(Lo)
         ptr[5] = 0;                                                                             // CRC(Hi)          ptr[5] = 0;                                                                             // CRC(Hi)
 //      fdc.s.rreg = fdc.s.c;                                                   // メルヘンヴェール  
         (void)fdd;  
         return(0x00);          return(0x00);
 }  }
   
   
   #if defined(SUPPORT_DISKEXT)
   static UINT32 fdd2d_sec(FDDFILE fdd, REG8 media, UINT track, REG8 sc) {
   
           UINT32  ret;
   
           if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks)) {
                   return(0);
           }
           if ((sc == 0) || (sc > fdd->inf.xdf.sectors)) {
                   ret = fdd->inf.xdf.sectors;
           }
           else {
                   ret = sc;
           }
           return((16 << fdd->inf.xdf.sectors) + ret);
   }
   #endif
   
   
 // ----  // ----
   
 BRESULT fdd2d_set(FDDFILE fdd, const OEMCHAR *fname) {  BRESULT fdd2d_set(FDDFILE fdd, const OEMCHAR *fname) {
   
         short   attr;          short           attr;
           FILEH           fh;
           UINT            fdsize;
   const _XDFINFO  *xdf;
   const _XDFINFO  *xdfterm;
           UINT            size;
   
         attr = file_attr(fname);          attr = file_attr(fname);
         if (attr & 0x18) {          if (attr & 0x18) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         fdd->type = DISKTYPE_BETA;          fh = file_open(fname);
         fdd->protect = (UINT8)(attr & 1);          if (fh == FILEH_INVALID) {
         fdd->seek = fdd2d_seek;                  return(FAILURE);
         fdd->read = fdd2d_read;          }
         fdd->write = fdd2d_write;          fdsize = file_getsize(fh);
         fdd->crc = fdd2d_crc;          file_close(fh);
         return(SUCCESS);  
           xdf = supportxdf;
           xdfterm = supportxdf + NELEMENTS(supportxdf);
           while(xdf < xdfterm) {
                   size = xdf->tracks;
                   size *= xdf->sectors;
                   size <<= (7 + xdf->n);
                   if (size == fdsize) {
                           file_cpyname(fdd->fname, fname, sizeof(fdd->fname));
                           fdd->type = DISKTYPE_BETA;
                           fdd->protect = (UINT8)(attr & 1);
                           fdd->seek = fdd2d_seek;
                           fdd->read = fdd2d_read;
                           fdd->write = fdd2d_write;
                           fdd->crc = fdd2d_crc;
   #if defined(SUPPORT_DISKEXT)
                           fdd->sec = fdd2d_sec;
   #endif
                           fdd->inf.xdf = *xdf;
                           return(SUCCESS);
                   }
                   xdf++;
           }
           return(FAILURE);
 }  }
   
 void fdd2d_eject(FDDFILE fdd) {  void fdd2d_eject(FDDFILE fdd) {
Removed from v.1.6  
changed lines
  Added in v.1.9

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