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

Diff for /np2/fdd/fdd_xdf.c between versions 1.1 and 1.5

version 1.1, 2003/10/16 17:58:28 version 1.5, 2004/02/13 14:52:21
Line 9 Line 9
 static const _XDFINFO supportxdf[] = {  static const _XDFINFO supportxdf[] = {
 #if 0  #if 0
                         // 256                          // 256
                         {154, 26, 1, DISKTYPE_2HD, 0},                          {0, 154, 26, 1, DISKTYPE_2HD, 0},
                         // 512                          // 512
                         {154, 15, 2, DISKTYPE_2HD, 0},                          {0, 154, 15, 2, DISKTYPE_2HD, 0},
 #endif  #endif
                         // 1024                          // 1024
                         {154,  8, 3, DISKTYPE_2HD, 0},                          {0, 154,  8, 3, DISKTYPE_2HD, 0},
                         // 1.44MB                          // 1.44MB
                         {160, 18, 2, DISKTYPE_2HD, 1},                          {0, 160, 18, 2, DISKTYPE_2HD, 1},
 };  };
   
   typedef struct {
           BYTE    dummy[4];
           BYTE    fddtype[4];
           BYTE    headersize[4];
           BYTE    fddsize[4];
           BYTE    sectorsize[4];
           BYTE    sectors[4];
           BYTE    surfaces[4];
           BYTE    cylinders[4];
   } FDIHDR;
   
   
 BOOL fddxdf_set(FDDFILE fdd, const char *fname, int ro) {  BOOL fddxdf_set(FDDFILE fdd, const char *fname, int ro) {
   
 const _XDFINFO  *xdf;  const _XDFINFO  *xdf;
         short           attr;          short           attr;
         FILEH           fh;          FILEH           fh;
         UINT            fdsize;          UINT32          fdsize;
         UINT            size;          UINT            size;
   
         attr = file_attr(fname);          attr = file_attr(fname);
Line 36  const _XDFINFO *xdf; Line 47  const _XDFINFO *xdf;
         if (fh == FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         fdsize = file_seek(fh, 0, FSEEK_END);          fdsize = file_getsize(fh);
         file_close(fh);          file_close(fh);
   
         xdf = supportxdf;          xdf = supportxdf;
Line 45  const _XDFINFO *xdf; Line 56  const _XDFINFO *xdf;
                 size *= xdf->sectors;                  size *= xdf->sectors;
                 size <<= (7 + xdf->n);                  size <<= (7 + xdf->n);
                 if (size == fdsize) {                  if (size == fdsize) {
                         milstr_ncpy(fdd->fname, fname, sizeof(fdd->fname));                          file_cpyname(fdd->fname, fname, sizeof(fdd->fname));
                         fdd->type = DISKTYPE_BETA;                          fdd->type = DISKTYPE_BETA;
                         fdd->protect = ((attr & 1) || (ro))?TRUE:FALSE;                          fdd->protect = ((attr & 1) || (ro))?TRUE:FALSE;
                         fdd->inf.xdf = *xdf;                          fdd->inf.xdf = *xdf;
Line 56  const _XDFINFO *xdf; Line 67  const _XDFINFO *xdf;
         return(FAILURE);          return(FAILURE);
 }  }
   
   // こっそり対応したりして
   BOOL fddxdf_setfdi(FDDFILE fdd, const char *fname, int ro) {
   
           short   attr;
           FILEH   fh;
           UINT32  fdsize;
           UINT    r;
           FDIHDR  fdi;
           UINT32  fddtype;
           UINT32  headersize;
           UINT32  size;
           UINT32  sectors;
           UINT32  surfaces;
           UINT32  cylinders;
           UINT8   n;
           UINT8   disktype;
           UINT8   rpm;
   
           attr = file_attr(fname);
           if (attr & 0x18) {
                   return(FAILURE);
           }
           fdsize = 0;
           r = 0;
           fh = file_open_rb(fname);
           if (fh != FILEH_INVALID) {
                   fdsize = file_getsize(fh);
                   r = file_read(fh, &fdi, sizeof(fdi));
                   file_close(fh);
           }
           if (r != sizeof(fdi)) {
                   return(FAILURE);
           }
           fddtype = LOADINTELDWORD(fdi.fddtype);
           headersize = LOADINTELDWORD(fdi.headersize);
           size = LOADINTELDWORD(fdi.sectorsize);
           sectors = LOADINTELDWORD(fdi.sectors);
           surfaces = LOADINTELDWORD(fdi.surfaces);
           cylinders = LOADINTELDWORD(fdi.cylinders);
           if (((size & (size - 1)) != 0) || (!(size & 0x7f80)) ||
                   (sectors == 0) || (sectors >= 256) ||
                   (surfaces != 2) ||
                   (cylinders == 0) || (cylinders >= 128)) {
                   return(FAILURE);
           }
           if (fdsize != (headersize + (size * sectors * surfaces * cylinders))) {
                   return(FAILURE);
           }
           size >>= 8;
           n = 0;
           while(size) {
                   size >>= 1;
                   n++;
           }
           disktype = DISKTYPE_2HD;
           rpm = 0;
           switch(fddtype & 0xf0) {
                   case 0x10:                              // 1MB/640KB - 2DD
                   case 0x70:                              // 640KB - 2DD
                   case 0xf0:
                           disktype = DISKTYPE_2DD;
                           break;
   
                   case 0x30:                              // 1.44MB - 2HD
                   case 0xb0:
                           rpm = 1;
                           break;
   
                   case 0x50:                              // 320KB - 2D
                   case 0xd0:                              // 
                           disktype = DISKTYPE_2D;
                           break;
   
                   case 0x90:                              // 2HD
                           break;
   
                   default:
                           return(FAILURE);
           }
           file_cpyname(fdd->fname, fname, sizeof(fdd->fname));
           fdd->type = DISKTYPE_BETA;
           fdd->protect = ((attr & 1) || (ro))?TRUE:FALSE;
           fdd->inf.xdf.headersize = headersize;
           fdd->inf.xdf.tracks = (UINT8)(cylinders * 2);
           fdd->inf.xdf.sectors = (UINT8)sectors;
           fdd->inf.xdf.n = n;
           fdd->inf.xdf.disktype = disktype;
           fdd->inf.xdf.rpm = rpm;
           return(SUCCESS);
   }
   
 BOOL fddxdf_eject(FDDFILE fdd) {  BOOL fddxdf_eject(FDDFILE fdd) {
   
         fdd->fname[0] = '\0';          fdd->fname[0] = '\0';
Line 66  BOOL fddxdf_eject(FDDFILE fdd) { Line 168  BOOL fddxdf_eject(FDDFILE fdd) {
   
 BOOL fddxdf_diskaccess(FDDFILE fdd) {  BOOL fddxdf_diskaccess(FDDFILE fdd) {
   
         if (CTRL_FDMEDIA != DISKTYPE_2HD) {          if ((fdd->type != DISKTYPE_BETA) ||
                   (CTRL_FDMEDIA != fdd->inf.xdf.disktype)) {
                 return(FAILURE);                  return(FAILURE);
         }          }
         (void)fdd;  
         return(SUCCESS);          return(SUCCESS);
 }  }
   
 BOOL fddxdf_seek(FDDFILE fdd) {  BOOL fddxdf_seek(FDDFILE fdd) {
   
         if ((!fdd->fname[0]) ||          if ((fdd->type != DISKTYPE_BETA) ||
                 (fdd->type != DISKTYPE_BETA) ||                  (CTRL_FDMEDIA != fdd->inf.xdf.disktype) ||
                 (CTRL_FDMEDIA != DISKTYPE_2HD) ||                  (fdc.rpm[fdc.us] != fdd->inf.xdf.rpm) ||
                 (fdc.rpm != fdd->inf.xdf.rpm) ||  
                 (fdc.ncn >= (fdd->inf.xdf.tracks >> 1))) {                  (fdc.ncn >= (fdd->inf.xdf.tracks >> 1))) {
                 return(FAILURE);                  return(FAILURE);
         }          }
Line 87  BOOL fddxdf_seek(FDDFILE fdd) { Line 188  BOOL fddxdf_seek(FDDFILE fdd) {
   
 BOOL fddxdf_seeksector(FDDFILE fdd) {  BOOL fddxdf_seeksector(FDDFILE fdd) {
   
         if ((!fdd->fname[0]) ||          if ((fdd->type != DISKTYPE_BETA) ||
                 (fdd->type != DISKTYPE_BETA) ||                  (CTRL_FDMEDIA != fdd->inf.xdf.disktype) ||
                 (CTRL_FDMEDIA != DISKTYPE_2HD) ||                  (fdc.rpm[fdc.us] != fdd->inf.xdf.rpm) ||
                 (fdc.rpm != fdd->inf.xdf.rpm) ||  
                 (fdc.treg[fdc.us] >= (fdd->inf.xdf.tracks >> 1))) {                  (fdc.treg[fdc.us] >= (fdd->inf.xdf.tracks >> 1))) {
                 fddlasterror = 0xe0;                  fddlasterror = 0xe0;
                 return(FAILURE);                  return(FAILURE);
Line 99  BOOL fddxdf_seeksector(FDDFILE fdd) { Line 199  BOOL fddxdf_seeksector(FDDFILE fdd) {
                 fddlasterror = 0xc0;                  fddlasterror = 0xc0;
                 return(FAILURE);                  return(FAILURE);
         }          }
         // ver0.29  
         if ((fdc.mf != 0xff) && (fdc.mf != 0x40)) {          if ((fdc.mf != 0xff) && (fdc.mf != 0x40)) {
                 fddlasterror = 0xc0;                  fddlasterror = 0xc0;
                 return(FAILURE);                  return(FAILURE);
Line 126  BOOL fddxdf_read(FDDFILE fdd) { Line 225  BOOL fddxdf_read(FDDFILE fdd) {
         seekp *= fdd->inf.xdf.sectors;          seekp *= fdd->inf.xdf.sectors;
         seekp += fdc.R - 1;          seekp += fdc.R - 1;
         seekp <<= (7 + fdd->inf.xdf.n);          seekp <<= (7 + fdd->inf.xdf.n);
           seekp += fdd->inf.xdf.headersize;
         secsize = 128 << fdd->inf.xdf.n;          secsize = 128 << fdd->inf.xdf.n;
   
         hdl = file_open_rb(fdd->fname);          hdl = file_open_rb(fdd->fname);
Line 169  BOOL fddxdf_write(FDDFILE fdd) { Line 269  BOOL fddxdf_write(FDDFILE fdd) {
         seekp *= fdd->inf.xdf.sectors;          seekp *= fdd->inf.xdf.sectors;
         seekp += fdc.R - 1;          seekp += fdc.R - 1;
         seekp <<= (7 + fdd->inf.xdf.n);          seekp <<= (7 + fdd->inf.xdf.n);
           seekp += fdd->inf.xdf.headersize;
         secsize = 128 << fdd->inf.xdf.n;          secsize = 128 << fdd->inf.xdf.n;
   
         hdl = file_open(fdd->fname);          hdl = file_open(fdd->fname);
Line 191  BOOL fddxdf_write(FDDFILE fdd) { Line 292  BOOL fddxdf_write(FDDFILE fdd) {
 BOOL fddxdf_readid(FDDFILE fdd) {  BOOL fddxdf_readid(FDDFILE fdd) {
   
         fddlasterror = 0x00;          fddlasterror = 0x00;
         if ((fdc.rpm != fdd->inf.xdf.rpm) ||          if ((!fdc.mf) ||
                   (fdc.rpm[fdc.us] != fdd->inf.xdf.rpm) ||
                 (fdc.crcn >= fdd->inf.xdf.sectors)) {                  (fdc.crcn >= fdd->inf.xdf.sectors)) {
                 fddlasterror = 0xe0;                  fddlasterror = 0xe0;
                 return(FAILURE);                  return(FAILURE);
Removed from v.1.1  
changed lines
  Added in v.1.5

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