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

Diff for /np2/fdd/sxsi.c between versions 1.8 and 1.15

version 1.8, 2004/01/26 14:49:14 version 1.15, 2005/02/12 12:40:39
Line 19  const SASIHDD sasihdd[7] = { Line 19  const SASIHDD sasihdd[7] = {
                                 {33, 6, 615},                   // 30MB                                  {33, 6, 615},                   // 30MB
                                 {33, 8, 615}};                  // 40MB                                  {33, 8, 615}};                  // 40MB
   
   #if 0
 static const _SXSIDEV defide = {615*33*8, 615, 256, 33, 8,  static const _SXSIDEV defide = {615*33*8, 615, 256, 33, 8,
                                                                 SXSITYPE_IDE | SXSITYPE_HDD, 256, 0, {0x00}};                                                                  SXSITYPE_IDE | SXSITYPE_HDD, 256, 0, {0x00}};
 static const _SXSIDEV defscsi = {40*16*32*8, 40*16, 256, 32, 8,  static const _SXSIDEV defscsi = {40*16*32*8, 40*16, 256, 32, 8,
                                                                 SXSITYPE_SCSI | SXSITYPE_HDD, 220, 0, {0x00}};                                                                  SXSITYPE_SCSI | SXSITYPE_HDD, 220, 0, {0x00}};
   #endif
   
   
         _SXSIDEV        sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];          _SXSIDEV        sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];
Line 35  const SASIHDD *sasi; Line 37  const SASIHDD *sasi;
         UINT            i;          UINT            i;
   
         sasi = sasihdd;          sasi = sasihdd;
         for (i=0; i<sizeof(sasihdd)/sizeof(SASIHDD); i++) {          for (i=0; i<NELEMENTS(sasihdd); i++, sasi++) {
                 if ((sxsi->size == 256) &&                  if ((sxsi->size == 256) &&
                         (sxsi->sectors == sasi->sectors) &&                          (sxsi->sectors == sasi->sectors) &&
                         (sxsi->surfaces == sasi->surfaces) &&                          (sxsi->surfaces == sasi->surfaces) &&
Line 46  const SASIHDD *sasi; Line 48  const SASIHDD *sasi;
         }          }
 }  }
   
   
 // ----  // ----
   
 void sxsi_initialize(void) {  void sxsi_initialize(void) {
Line 53  void sxsi_initialize(void) { Line 56  void sxsi_initialize(void) {
         UINT    i;          UINT    i;
   
         ZeroMemory(sxsi_dev, sizeof(sxsi_dev));          ZeroMemory(sxsi_dev, sizeof(sxsi_dev));
         for (i=0; i<(sizeof(sxsi_dev)/sizeof(_SXSIDEV)); i++) {          for (i=0; i<NELEMENTS(sxsi_dev); i++) {
                 sxsi_dev[i].fh = (long)FILEH_INVALID;                  sxsi_dev[i].fh = (long)FILEH_INVALID;
         }          }
 }  }
Line 63  SXSIDEV sxsi_getptr(REG8 drv) { Line 66  SXSIDEV sxsi_getptr(REG8 drv) {
         UINT    num;          UINT    num;
   
         num = drv & 0x0f;          num = drv & 0x0f;
         if (!(drv & 0x20)) {                    // SASI or IDE          if (!(drv & 0x20)) {                                    // SASI or IDE
                 if (num < 2) {                  if (num < SASIHDD_MAX) {
                         return(sxsi_dev + num);                          return(sxsi_dev + num);
                 }                  }
         }          }
   #if defined(SUPPORT_SCSI)
         else {          else {
                 if (num < 4) {                          // SCSI                  if (num < SCSIHDD_MAX) {                        // SCSI
                         return(sxsi_dev + SASIHDD_MAX + num);                          return(sxsi_dev + SASIHDD_MAX + num);
                 }                  }
         }          }
   #endif
         return(NULL);          return(NULL);
 }  }
   
 const char *sxsi_getname(REG8 drv) {  const OEMCHAR *sxsi_getname(REG8 drv) {
   
         SXSIDEV sxsi;          SXSIDEV sxsi;
   
Line 87  const char *sxsi_getname(REG8 drv) { Line 92  const char *sxsi_getname(REG8 drv) {
         return(NULL);          return(NULL);
 }  }
   
 BOOL sxsi_hddopen(REG8 drv, const char *file) {  BRESULT sxsi_hddopen(REG8 drv, const OEMCHAR *file) {
   
         SXSIDEV sxsi;          SXSIDEV         sxsi;
         FILEH   fh;          FILEH           fh;
 const char      *ext;  const OEMCHAR   *ext;
         UINT16  type;          UINT16          type;
         long    totals;          long            totals;
         UINT32  headersize;          UINT32          headersize;
         UINT32  surfaces;          UINT32          surfaces;
         UINT32  cylinders;          UINT32          cylinders;
         UINT32  sectors;          UINT32          sectors;
         UINT32  size;          UINT32          size;
   
         if ((file == NULL) || (file[0] == '\0')) {          if ((file == NULL) || (file[0] == '\0')) {
                 goto sxsiope_err1;                  goto sxsiope_err1;
Line 111  const char *ext; Line 116  const char *ext;
         if (fh == FILEH_INVALID) {          if (fh == FILEH_INVALID) {
                 goto sxsiope_err1;                  goto sxsiope_err1;
         }          }
         ext = file_getext((char *)file);          ext = file_getext(file);
         type = SXSITYPE_HDD;          type = SXSITYPE_HDD;
         if ((!file_cmpname(ext, str_thd)) && (!(drv & 0x20))) {          if ((!file_cmpname(ext, str_thd)) && (!(drv & 0x20))) {
                 THDHDR thd;                                             // T98 HDD (IDE)                  THDHDR thd;                                             // T98 HDD (IDE)
Line 125  const char *ext; Line 130  const char *ext;
                 size = 256;                  size = 256;
                 totals = cylinders * sectors * surfaces;                  totals = cylinders * sectors * surfaces;
         }          }
         else if ((!file_cmpname(ext, str_hdi)) && (!(drv & 0x20))) {  
                 HDIHDR hdi;                                             // ANEX86 HDD (SASI) thanx Mamiya  
                 if (file_read(fh, &hdi, sizeof(hdi)) != sizeof(hdi)) {  
                         goto sxsiope_err2;  
                 }  
                 headersize = LOADINTELDWORD(hdi.headersize);  
                 surfaces = LOADINTELDWORD(hdi.surfaces);  
                 cylinders = LOADINTELDWORD(hdi.cylinders);  
                 sectors = LOADINTELDWORD(hdi.sectors);  
                 size = LOADINTELDWORD(hdi.sectorsize);  
                 totals = cylinders * sectors * surfaces;  
         }  
         else if ((!file_cmpname(ext, str_nhd)) && (!(drv & 0x20))) {          else if ((!file_cmpname(ext, str_nhd)) && (!(drv & 0x20))) {
                 NHDHDR nhd;                                             // T98Next HDD (IDE)                  NHDHDR nhd;                                             // T98Next HDD (IDE)
                 if ((file_read(fh, &nhd, sizeof(nhd)) != sizeof(nhd)) ||                  if ((file_read(fh, &nhd, sizeof(nhd)) != sizeof(nhd)) ||
Line 150  const char *ext; Line 143  const char *ext;
                 size = LOADINTELWORD(nhd.sectorsize);                  size = LOADINTELWORD(nhd.sectorsize);
                 totals = cylinders * sectors * surfaces;                  totals = cylinders * sectors * surfaces;
         }          }
           else if ((!file_cmpname(ext, str_hdi)) && (!(drv & 0x20))) {
                   HDIHDR hdi;                                             // ANEX86 HDD (SASI) thanx Mamiya
                   if (file_read(fh, &hdi, sizeof(hdi)) != sizeof(hdi)) {
                           goto sxsiope_err2;
                   }
                   headersize = LOADINTELDWORD(hdi.headersize);
                   surfaces = LOADINTELDWORD(hdi.surfaces);
                   cylinders = LOADINTELDWORD(hdi.cylinders);
                   sectors = LOADINTELDWORD(hdi.sectors);
                   size = LOADINTELDWORD(hdi.sectorsize);
                   totals = cylinders * sectors * surfaces;
           }
         else if ((!file_cmpname(ext, str_hdd)) && (drv & 0x20)) {          else if ((!file_cmpname(ext, str_hdd)) && (drv & 0x20)) {
                 VHDHDR vhd;                                             // Virtual98 HDD (SCSI)                  VHDHDR vhd;                                             // Virtual98 HDD (SCSI)
                 if ((file_read(fh, &vhd, sizeof(vhd)) != sizeof(vhd)) ||                  if ((file_read(fh, &vhd, sizeof(vhd)) != sizeof(vhd)) ||
                         (memcmp(vhd.sig, sig_vhd, 5))) {                          (memcmp(vhd.sig, sig_vhd, 5))) {
                         goto sxsiope_err2;                          goto sxsiope_err2;
                 }                  }
                 headersize = 220;                  headersize = sizeof(vhd);
                 surfaces = vhd.surfaces;                  surfaces = vhd.surfaces;
                 cylinders = LOADINTELWORD(vhd.cylinders);                  cylinders = LOADINTELWORD(vhd.cylinders);
                 sectors = vhd.sectors;                  sectors = vhd.sectors;
Line 191  const char *ext; Line 196  const char *ext;
         sxsi->type = type;          sxsi->type = type;
         sxsi->headersize = headersize;          sxsi->headersize = headersize;
         sxsi->fh = (long)fh;          sxsi->fh = (long)fh;
         file_cpyname(sxsi->fname, file, sizeof(sxsi->fname));          file_cpyname(sxsi->fname, file, NELEMENTS(sxsi->fname));
         if (type == (SXSITYPE_IDE | SXSITYPE_HDD)) {          if (type == (SXSITYPE_IDE | SXSITYPE_HDD)) {
                 sasihddcheck(sxsi);                  sasihddcheck(sxsi);
         }          }
Line 216  void sxsi_open(void) { Line 221  void sxsi_open(void) {
                         drv++;                          drv++;
                 }                  }
         }          }
   #if defined(SUPPORT_SCSI)
         drv = 0x20;          drv = 0x20;
         for (i=0; i<4; i++) {          for (i=0; i<4; i++) {
                 if (sxsi_hddopen(drv, np2cfg.scsihdd[i]) == SUCCESS) {                  if (sxsi_hddopen(drv, np2cfg.scsihdd[i]) == SUCCESS) {
                         drv++;                          drv++;
                 }                  }
         }          }
   #endif
 }  }
   
 void sxsi_flash(void) {  void sxsi_flash(void) {
Line 230  void sxsi_flash(void) { Line 237  void sxsi_flash(void) {
         SXSIDEV sxsiterm;          SXSIDEV sxsiterm;
   
         sxsi = sxsi_dev;          sxsi = sxsi_dev;
         sxsiterm = sxsi + (sizeof(sxsi_dev)/sizeof(_SXSIDEV));          sxsiterm = sxsi + NELEMENTS(sxsi_dev);
         while(sxsi < sxsiterm) {          while(sxsi < sxsiterm) {
                 if ((FILEH)sxsi->fh != FILEH_INVALID) {                  if ((FILEH)sxsi->fh != FILEH_INVALID) {
                         file_close((FILEH)sxsi->fh);                          file_close((FILEH)sxsi->fh);
Line 246  void sxsi_trash(void) { Line 253  void sxsi_trash(void) {
         SXSIDEV sxsiterm;          SXSIDEV sxsiterm;
   
         sxsi = sxsi_dev;          sxsi = sxsi_dev;
         sxsiterm = sxsi + (sizeof(sxsi_dev)/sizeof(_SXSIDEV));          sxsiterm = sxsi + NELEMENTS(sxsi_dev);
         while(sxsi < sxsiterm) {          while(sxsi < sxsiterm) {
                 if ((FILEH)sxsi->fh != FILEH_INVALID) {                  if ((FILEH)sxsi->fh != FILEH_INVALID) {
                         file_close((FILEH)sxsi->fh);                          file_close((FILEH)sxsi->fh);
Line 259  void sxsi_trash(void) { Line 266  void sxsi_trash(void) {
   
 static SXSIDEV getdrive(REG8 drv) {  static SXSIDEV getdrive(REG8 drv) {
   
         UINT    num;  
         SXSIDEV ret;          SXSIDEV ret;
   
         num = drv & 0x0f;          ret = sxsi_getptr(drv);
         if (num >= 2) {          if ((ret == NULL) || (ret->fname[0] == '\0')) {
                 return(NULL);  
         }  
         num += (drv & 0x20) >> 4;  
         ret = sxsi_dev + num;  
         if (ret->fname[0] == '\0') {  
                 return(NULL);                  return(NULL);
         }          }
         if ((FILEH)ret->fh == FILEH_INVALID) {          if ((FILEH)ret->fh == FILEH_INVALID) {
Line 282  static SXSIDEV getdrive(REG8 drv) { Line 283  static SXSIDEV getdrive(REG8 drv) {
         return(ret);          return(ret);
 }  }
   
 REG8 sxsi_read(REG8 drv, long pos, BYTE *buf, UINT size) {  BOOL sxsi_issasi(void) {
   
           REG8    drv;
           SXSIDEV sxsi;
           BOOL    ret;
           UINT    sxsiif;
   
           ret = FALSE;
           for (drv=0x00; drv<0x04; drv++) {
                   sxsi = sxsi_getptr(drv);
                   if (sxsi) {
                           sxsiif = sxsi->type & SXSITYPE_IFMASK;
                           if (sxsiif == SXSITYPE_SASI) {
                                   ret = TRUE;
                           }
                           else if (sxsiif == SXSITYPE_IDE) {
                                   ret = FALSE;
                                   break;
                           }
                   }
           }
           return(ret);
   }
   
   BOOL sxsi_isscsi(void) {
   
           REG8    drv;
           SXSIDEV sxsi;
   
           for (drv=0x20; drv<0x28; drv++) {
                   sxsi = sxsi_getptr(drv);
                   if ((sxsi) && (sxsi->type)) {
                           return(TRUE);
                   }
           }
           return(FALSE);
   }
   
   BOOL sxsi_iside(void) {
   
           REG8    drv;
           SXSIDEV sxsi;
   
           for (drv=0x00; drv<0x04; drv++) {
                   sxsi = sxsi_getptr(drv);
                   if ((sxsi) && (sxsi->type)) {
                           return(TRUE);
                   }
           }
           return(FALSE);
   }
   
   REG8 sxsi_read(REG8 drv, long pos, UINT8 *buf, UINT size) {
   
 const _SXSIDEV  *sxsi;  const _SXSIDEV  *sxsi;
         long            r;          long            r;
Line 292  const _SXSIDEV *sxsi; Line 345  const _SXSIDEV *sxsi;
         if (sxsi == NULL) {          if (sxsi == NULL) {
                 return(0x60);                  return(0x60);
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          if ((pos < 0) || (pos >= sxsi->totals)) {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);  
         if (r == -1) {  
                 return(0x40);                  return(0x40);
         }          }
           pos = pos * sxsi->size + sxsi->headersize;
           r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
         if (pos != r) {          if (pos != r) {
                 return(0xd0);                  return(0xd0);
         }          }
Line 312  const _SXSIDEV *sxsi; Line 365  const _SXSIDEV *sxsi;
         return(0x00);          return(0x00);
 }  }
   
 REG8 sxsi_write(REG8 drv, long pos, const BYTE *buf, UINT size) {  REG8 sxsi_write(REG8 drv, long pos, const UINT8 *buf, UINT size) {
   
 const _SXSIDEV  *sxsi;  const _SXSIDEV  *sxsi;
         long            r;          long            r;
Line 322  const _SXSIDEV *sxsi; Line 375  const _SXSIDEV *sxsi;
         if (sxsi == NULL) {          if (sxsi == NULL) {
                 return(0x60);                  return(0x60);
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          if ((pos < 0) || (pos >= sxsi->totals)) {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);  
         if (r == -1) {  
                 return(0x40);                  return(0x40);
         }          }
           pos = pos * sxsi->size + sxsi->headersize;
           r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
         if (pos != r) {          if (pos != r) {
                 return(0xd0);                  return(0xd0);
         }          }
Line 347  REG8 sxsi_format(REG8 drv, long pos) { Line 400  REG8 sxsi_format(REG8 drv, long pos) {
 const _SXSIDEV  *sxsi;  const _SXSIDEV  *sxsi;
         long            r;          long            r;
         UINT16          i;          UINT16          i;
         BYTE            work[256];          UINT8           work[256];
         UINT            size;          UINT            size;
         UINT            wsize;          UINT            wsize;
   
Line 355  const _SXSIDEV *sxsi; Line 408  const _SXSIDEV *sxsi;
         if (sxsi == NULL) {          if (sxsi == NULL) {
                 return(0x60);                  return(0x60);
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          if ((pos < 0) || (pos >= sxsi->totals)) {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);  
         if (r == -1) {  
                 return(0x40);                  return(0x40);
         }          }
           pos = pos * sxsi->size + sxsi->headersize;
           r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
         if (pos != r) {          if (pos != r) {
                 return(0xd0);                  return(0xd0);
         }          }
Removed from v.1.8  
changed lines
  Added in v.1.15

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