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

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

version 1.15, 2005/02/12 12:40:39 version 1.21, 2005/04/05 20:37:07
Line 4 Line 4
 #include        "sysmng.h"  #include        "sysmng.h"
 #include        "cpucore.h"  #include        "cpucore.h"
 #include        "pccore.h"  #include        "pccore.h"
   #include        "iocore.h"
 #include        "sxsi.h"  #include        "sxsi.h"
   #if defined(SUPPORT_IDEIO)
   #include        "ideio.h"
   #endif
   
           _SXSIDEV        sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];
   
 const char sig_vhd[8] = "VHD1.00";  
 const char sig_nhd[15] = "T98HDDIMAGE.R0";  
   
 const SASIHDD sasihdd[7] = {  // ----
                                 {33, 4, 153},                   // 5MB  
                                 {33, 4, 310},                   // 10MB  
                                 {33, 6, 310},                   // 15MB  
                                 {33, 8, 310},                   // 20MB  
                                 {33, 4, 615},                   // 20MB (not used!)  
                                 {33, 6, 615},                   // 30MB  
                                 {33, 8, 615}};                  // 40MB  
   
 #if 0  
 static const _SXSIDEV defide = {615*33*8, 615, 256, 33, 8,  
                                                                 SXSITYPE_IDE | SXSITYPE_HDD, 256, 0, {0x00}};  
 static const _SXSIDEV defscsi = {40*16*32*8, 40*16, 256, 32, 8,  
                                                                 SXSITYPE_SCSI | SXSITYPE_HDD, 220, 0, {0x00}};  
 #endif  
   
   static BRESULT nc_reopen(SXSIDEV sxsi) {
   
         _SXSIDEV        sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];          (void)sxsi;
           return(FAILURE);
   }
   
   static REG8     nc_read(SXSIDEV sxsi, long pos, UINT8 *buf, UINT size) {
   
 // SASI規格HDDかチェック          (void)sxsi;
 static void sasihddcheck(SXSIDEV sxsi) {          (void)pos;
           (void)buf;
           (void)size;
           return(0x60);
   }
   
 const SASIHDD   *sasi;  static REG8 nc_write(SXSIDEV sxsi, long pos, const UINT8 *buf, UINT size) {
         UINT            i;  
   
         sasi = sasihdd;          (void)sxsi;
         for (i=0; i<NELEMENTS(sasihdd); i++, sasi++) {          (void)pos;
                 if ((sxsi->size == 256) &&          (void)buf;
                         (sxsi->sectors == sasi->sectors) &&          (void)size;
                         (sxsi->surfaces == sasi->surfaces) &&          return(0x60);
                         (sxsi->cylinders == sasi->cylinders)) {  }
                         sxsi->type = (UINT16)(SXSITYPE_SASI + (i << 8) + SXSITYPE_HDD);  
                         break;  static REG8 nc_format(SXSIDEV sxsi, long pos) {
   
           (void)sxsi;
           (void)pos;
           return(0x60);
   }
   
   static void nc_close(SXSIDEV sxsi) {
   
           (void)sxsi;
   }
   
   static void nc_destroy(SXSIDEV sxsi) {
   
           (void)sxsi;
   }
   
   
   static void sxsi_disconnect(SXSIDEV sxsi) {
   
           if (sxsi) {
                   if (sxsi->flag & SXSIFLAG_FILEOPENED) {
   #if defined(SUPPORT_IDEIO)
                           ideio_notify(sxsi->drv, 0);
   #endif
                           (*sxsi->close)(sxsi);
                   }
                   if (sxsi->flag & SXSIFLAG_READY) {
                           (*sxsi->destroy)(sxsi);
                 }                  }
                   sxsi->flag = 0;
                   sxsi->reopen = nc_reopen;
                   sxsi->read = nc_read;
                   sxsi->write = nc_write;
                   sxsi->format = nc_format;
                   sxsi->close = nc_close;
                   sxsi->destroy = nc_destroy;
         }          }
 }  }
   
Line 56  void sxsi_initialize(void) { Line 87  void sxsi_initialize(void) {
         UINT    i;          UINT    i;
   
         ZeroMemory(sxsi_dev, sizeof(sxsi_dev));          ZeroMemory(sxsi_dev, sizeof(sxsi_dev));
           for (i=0; i<SASIHDD_MAX; i++) {
                   sxsi_dev[i].drv = (UINT8)(SXSIDRV_SASI + i);
           }
   #if defined(SUPPORT_SCSI)
           for (i=0; i<SCSIHDD_MAX; i++) {
                   sxsi_dev[SASIHDD_MAX + i].drv = (UINT8)(SXSIDRV_SCSI + i);
           }
   #endif
         for (i=0; i<NELEMENTS(sxsi_dev); i++) {          for (i=0; i<NELEMENTS(sxsi_dev); i++) {
                 sxsi_dev[i].fh = (long)FILEH_INVALID;                  sxsi_disconnect(sxsi_dev + i);
           }
   }
   
   void sxsi_allflash(void) {
   
           SXSIDEV sxsi;
           SXSIDEV sxsiterm;
   
           sxsi = sxsi_dev;
           sxsiterm = sxsi + NELEMENTS(sxsi_dev);
           while(sxsi < sxsiterm) {
                   if (sxsi->flag & SXSIFLAG_FILEOPENED) {
                           sxsi->flag &= ~SXSIFLAG_FILEOPENED;
                           (*sxsi->close)(sxsi);
                   }
                   sxsi++;
           }
   }
   
   void sxsi_alltrash(void) {
   
           SXSIDEV sxsi;
           SXSIDEV sxsiterm;
   
           sxsi = sxsi_dev;
           sxsiterm = sxsi + NELEMENTS(sxsi_dev);
           while(sxsi < sxsiterm) {
                   sxsi_disconnect(sxsi);
                   sxsi++;
           }
   }
   
   BOOL sxsi_isconnect(SXSIDEV sxsi) {
   
           if (sxsi) {
                   switch(sxsi->devtype) {
                           case SXSIDEV_HDD:
                                   if (sxsi->flag & SXSIFLAG_READY) {
                                           return(TRUE);
                                   }
                                   break;
   
                           case SXSIDEV_CDROM:
                                   return(TRUE);
                   }
         }          }
           return(FALSE);
   }
   
   BRESULT sxsi_prepare(SXSIDEV sxsi) {
   
           if ((sxsi == NULL) || (!(sxsi->flag & SXSIFLAG_READY))) {
                   return(FAILURE);
           }
           if (!(sxsi->flag & SXSIFLAG_FILEOPENED)) {
                   if ((*sxsi->reopen)(sxsi) == SUCCESS) {
                           sxsi->flag |= SXSIFLAG_FILEOPENED;
                   }
                   else {
                           return(FAILURE);
                   }
           }
           sysmng_hddaccess(sxsi->drv);
           return(SUCCESS);
 }  }
   
   
   // ----
   
 SXSIDEV sxsi_getptr(REG8 drv) {  SXSIDEV sxsi_getptr(REG8 drv) {
   
         UINT    num;          UINT    num;
Line 81  SXSIDEV sxsi_getptr(REG8 drv) { Line 186  SXSIDEV sxsi_getptr(REG8 drv) {
         return(NULL);          return(NULL);
 }  }
   
 const OEMCHAR *sxsi_getname(REG8 drv) {  OEMCHAR *sxsi_getfilename(REG8 drv) {
   
         SXSIDEV sxsi;          SXSIDEV sxsi;
   
         sxsi = sxsi_getptr(drv);          sxsi = sxsi_getptr(drv);
         if (sxsi) {          if ((sxsi) && (sxsi->flag & SXSIFLAG_READY)) {
                 return(sxsi->fname);                  return(sxsi->fname);
         }          }
         return(NULL);          return(NULL);
 }  }
   
 BRESULT sxsi_hddopen(REG8 drv, const OEMCHAR *file) {  BRESULT sxsi_setdevtype(REG8 drv, UINT8 dev) {
   
         SXSIDEV         sxsi;          SXSIDEV sxsi;
         FILEH           fh;  
 const OEMCHAR   *ext;  
         UINT16          type;  
         long            totals;  
         UINT32          headersize;  
         UINT32          surfaces;  
         UINT32          cylinders;  
         UINT32          sectors;  
         UINT32          size;  
   
         if ((file == NULL) || (file[0] == '\0')) {  
                 goto sxsiope_err1;  
         }  
         sxsi = sxsi_getptr(drv);          sxsi = sxsi_getptr(drv);
         if (sxsi == NULL) {          if (sxsi) {
                 goto sxsiope_err1;                  if (sxsi->devtype != dev) {
         }                          sxsi_disconnect(sxsi);
         fh = file_open(file);                          sxsi->devtype = dev;
         if (fh == FILEH_INVALID) {                  }
                 goto sxsiope_err1;                  return(SUCCESS);
         }  
         ext = file_getext(file);  
         type = SXSITYPE_HDD;  
         if ((!file_cmpname(ext, str_thd)) && (!(drv & 0x20))) {  
                 THDHDR thd;                                             // T98 HDD (IDE)  
                 if (file_read(fh, &thd, sizeof(thd)) != sizeof(thd)) {  
                         goto sxsiope_err2;  
                 }  
                 headersize = 256;  
                 surfaces = 8;  
                 cylinders = LOADINTELWORD(thd.cylinders);  
                 sectors = 33;  
                 size = 256;  
                 totals = cylinders * sectors * surfaces;  
         }  
         else if ((!file_cmpname(ext, str_nhd)) && (!(drv & 0x20))) {  
                 NHDHDR nhd;                                             // T98Next HDD (IDE)  
                 if ((file_read(fh, &nhd, sizeof(nhd)) != sizeof(nhd)) ||  
                         (memcmp(nhd.sig, sig_nhd, 15))) {  
                         goto sxsiope_err2;  
                 }  
                 headersize = LOADINTELDWORD(nhd.headersize);  
                 surfaces = LOADINTELWORD(nhd.surfaces);  
                 cylinders = LOADINTELDWORD(nhd.cylinders);  
                 sectors = LOADINTELWORD(nhd.sectors);  
                 size = LOADINTELWORD(nhd.sectorsize);  
                 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)) {  
                 VHDHDR vhd;                                             // Virtual98 HDD (SCSI)  
                 if ((file_read(fh, &vhd, sizeof(vhd)) != sizeof(vhd)) ||  
                         (memcmp(vhd.sig, sig_vhd, 5))) {  
                         goto sxsiope_err2;  
                 }  
                 headersize = sizeof(vhd);  
                 surfaces = vhd.surfaces;  
                 cylinders = LOADINTELWORD(vhd.cylinders);  
                 sectors = vhd.sectors;  
                 size = LOADINTELWORD(vhd.sectorsize);  
                 totals = (SINT32)LOADINTELDWORD(vhd.totals);  
         }  
         else {  
                 goto sxsiope_err2;  
         }  
   
         // フォーマット確認〜  
         if ((surfaces == 0) || (surfaces >= 256) ||  
                 (cylinders == 0) || (cylinders >= 65536) ||  
                 (sectors == 0) || (sectors >= 256) ||  
                 (size == 0) || ((size & (size - 1)) != 0)) {  
                 goto sxsiope_err2;  
         }  
         if (!(drv & 0x20)) {  
                 type |= SXSITYPE_IDE;  
         }          }
         else {          else {
                 type |= SXSITYPE_SCSI;                  return(FAILURE);
                 if (!(size & 0x700)) {                  // not 256,512,1024  
                         goto sxsiope_err2;  
                 }  
         }  
         sxsi->totals = totals;  
         sxsi->cylinders = (UINT16)cylinders;  
         sxsi->size = (UINT16)size;  
         sxsi->sectors = (UINT8)sectors;  
         sxsi->surfaces = (UINT8)surfaces;  
         sxsi->type = type;  
         sxsi->headersize = headersize;  
         sxsi->fh = (long)fh;  
         file_cpyname(sxsi->fname, file, NELEMENTS(sxsi->fname));  
         if (type == (SXSITYPE_IDE | SXSITYPE_HDD)) {  
                 sasihddcheck(sxsi);  
         }          }
         return(SUCCESS);  
   
 sxsiope_err2:  
         file_close(fh);  
   
 sxsiope_err1:  
         return(FAILURE);  
 }  }
   
 void sxsi_open(void) {  UINT8 sxsi_getdevtype(REG8 drv) {
   
         int             i;          SXSIDEV sxsi;
         REG8    drv;  
   
         sxsi_trash();          sxsi = sxsi_getptr(drv);
         drv = 0;          if (sxsi) {
         for (i=0; i<2; i++) {                  return(sxsi->devtype);
                 if (sxsi_hddopen(drv, np2cfg.sasihdd[i]) == SUCCESS) {  
                         drv++;  
                 }  
         }          }
 #if defined(SUPPORT_SCSI)          else {
         drv = 0x20;                  return(SXSIDEV_NC);
         for (i=0; i<4; i++) {  
                 if (sxsi_hddopen(drv, np2cfg.scsihdd[i]) == SUCCESS) {  
                         drv++;  
                 }  
         }          }
 #endif  
 }  }
   
 void sxsi_flash(void) {  BRESULT sxsi_devopen(REG8 drv, const OEMCHAR *fname) {
   
         SXSIDEV sxsi;          SXSIDEV         sxsi;
         SXSIDEV sxsiterm;          BRESULT         r;
   
         sxsi = sxsi_dev;          if ((fname == NULL) || (fname[0] == '\0')) {
         sxsiterm = sxsi + NELEMENTS(sxsi_dev);                  goto sxsiope_err;
         while(sxsi < sxsiterm) {  
                 if ((FILEH)sxsi->fh != FILEH_INVALID) {  
                         file_close((FILEH)sxsi->fh);  
                         sxsi->fh = (long)FILEH_INVALID;  
                 }  
                 sxsi++;  
         }          }
 }          sxsi = sxsi_getptr(drv);
           if (sxsi == NULL) {
 void sxsi_trash(void) {                  goto sxsiope_err;
           }
           switch(sxsi->devtype) {
                   case SXSIDEV_HDD:
                           r = sxsihdd_open(sxsi, fname);
                           break;
   
         SXSIDEV sxsi;                  case SXSIDEV_CDROM:
         SXSIDEV sxsiterm;                          r = sxsicd_open(sxsi, fname);
                           break;
   
         sxsi = sxsi_dev;                  default:
         sxsiterm = sxsi + NELEMENTS(sxsi_dev);                          r = FAILURE;
         while(sxsi < sxsiterm) {                          break;
                 if ((FILEH)sxsi->fh != FILEH_INVALID) {          }
                         file_close((FILEH)sxsi->fh);          if (r != SUCCESS) {
                 }                  goto sxsiope_err;
                 ZeroMemory(sxsi, sizeof(_SXSIDEV));  
                 sxsi->fh = (long)FILEH_INVALID;  
                 sxsi++;  
         }          }
           file_cpyname(sxsi->fname, fname, NELEMENTS(sxsi->fname));
           sxsi->flag = SXSIFLAG_READY | SXSIFLAG_FILEOPENED;
   #if defined(SUPPORT_IDEIO)
           ideio_notify(sxsi->drv, 1);
   #endif
           return(SUCCESS);
   
   sxsiope_err:
           return(FAILURE);
 }  }
   
 static SXSIDEV getdrive(REG8 drv) {  void sxsi_devclose(REG8 drv) {
   
         SXSIDEV ret;          SXSIDEV         sxsi;
   
         ret = sxsi_getptr(drv);          sxsi = sxsi_getptr(drv);
         if ((ret == NULL) || (ret->fname[0] == '\0')) {          sxsi_disconnect(sxsi);
                 return(NULL);  
         }  
         if ((FILEH)ret->fh == FILEH_INVALID) {  
                 ret->fh = (long)file_open(ret->fname);  
                 if ((FILEH)ret->fh == FILEH_INVALID) {  
                         ret->fname[0] = '\0';  
                         return(NULL);  
                 }  
         }  
         sysmng_hddaccess(drv);  
         return(ret);  
 }  }
   
 BOOL sxsi_issasi(void) {  BOOL sxsi_issasi(void) {
Line 288  BOOL sxsi_issasi(void) { Line 279  BOOL sxsi_issasi(void) {
         REG8    drv;          REG8    drv;
         SXSIDEV sxsi;          SXSIDEV sxsi;
         BOOL    ret;          BOOL    ret;
         UINT    sxsiif;  
   
         ret = FALSE;          ret = FALSE;
         for (drv=0x00; drv<0x04; drv++) {          for (drv=0x00; drv<0x04; drv++) {
                 sxsi = sxsi_getptr(drv);                  sxsi = sxsi_getptr(drv);
                 if (sxsi) {                  if (sxsi) {
                         sxsiif = sxsi->type & SXSITYPE_IFMASK;                          if ((drv < 0x02) && (sxsi->devtype == SXSIDEV_HDD)) {
                         if (sxsiif == SXSITYPE_SASI) {                                  if (sxsi->flag & SXSIFLAG_READY) {
                                 ret = TRUE;                                          if (sxsi->mediatype & SXSIMEDIA_INVSASI) {
                                                   return(FALSE);
                                           }
                                           ret = TRUE;
                                   }
                         }                          }
                         else if (sxsiif == SXSITYPE_IDE) {                          else {
                                 ret = FALSE;                                  return(FALSE);
                                 break;  
                         }                          }
                 }                  }
         }          }
Line 314  BOOL sxsi_isscsi(void) { Line 307  BOOL sxsi_isscsi(void) {
   
         for (drv=0x20; drv<0x28; drv++) {          for (drv=0x20; drv<0x28; drv++) {
                 sxsi = sxsi_getptr(drv);                  sxsi = sxsi_getptr(drv);
                 if ((sxsi) && (sxsi->type)) {                  if (sxsi_isconnect(sxsi)) {
                         return(TRUE);                          return(TRUE);
                 }                  }
         }          }
Line 328  BOOL sxsi_iside(void) { Line 321  BOOL sxsi_iside(void) {
   
         for (drv=0x00; drv<0x04; drv++) {          for (drv=0x00; drv<0x04; drv++) {
                 sxsi = sxsi_getptr(drv);                  sxsi = sxsi_getptr(drv);
                 if ((sxsi) && (sxsi->type)) {                  if (sxsi_isconnect(sxsi)) {
                         return(TRUE);                          return(TRUE);
                 }                  }
         }          }
         return(FALSE);          return(FALSE);
 }  }
   
   
   
 REG8 sxsi_read(REG8 drv, long pos, UINT8 *buf, UINT size) {  REG8 sxsi_read(REG8 drv, long pos, UINT8 *buf, UINT size) {
   
 const _SXSIDEV  *sxsi;          SXSIDEV sxsi;
         long            r;  
         UINT            rsize;  
   
         sxsi = getdrive(drv);          sxsi = sxsi_getptr(drv);
         if (sxsi == NULL) {          if (sxsi != NULL) {
                 return(0x60);                  return(sxsi->read(sxsi, pos, buf, size));
         }  
         if ((pos < 0) || (pos >= sxsi->totals)) {  
                 return(0x40);  
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          else {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);                  return(0x60);
         if (pos != r) {  
                 return(0xd0);  
         }  
         while(size) {  
                 rsize = min(size, sxsi->size);  
                 CPU_REMCLOCK -= rsize;  
                 if (file_read((FILEH)sxsi->fh, buf, rsize) != rsize) {  
                         return(0xd0);  
                 }  
                 buf += rsize;  
                 size -= rsize;  
         }          }
         return(0x00);  
 }  }
   
 REG8 sxsi_write(REG8 drv, long pos, const UINT8 *buf, UINT size) {  REG8 sxsi_write(REG8 drv, long pos, const UINT8 *buf, UINT size) {
   
 const _SXSIDEV  *sxsi;          SXSIDEV sxsi;
         long            r;  
         UINT            wsize;  
   
         sxsi = getdrive(drv);          sxsi = sxsi_getptr(drv);
         if (sxsi == NULL) {          if (sxsi != NULL) {
                 return(0x60);                  return(sxsi->write(sxsi, pos, buf, size));
         }  
         if ((pos < 0) || (pos >= sxsi->totals)) {  
                 return(0x40);  
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          else {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);                  return(0x60);
         if (pos != r) {  
                 return(0xd0);  
         }  
         while(size) {  
                 wsize = min(size, sxsi->size);  
                 CPU_REMCLOCK -= wsize;  
                 if (file_write((FILEH)sxsi->fh, buf, wsize) != wsize) {  
                         return(0x70);  
                 }  
                 buf += wsize;  
                 size -= wsize;  
         }          }
         return(0x00);  
 }  }
   
 REG8 sxsi_format(REG8 drv, long pos) {  REG8 sxsi_format(REG8 drv, long pos) {
   
 const _SXSIDEV  *sxsi;          SXSIDEV sxsi;
         long            r;  
         UINT16          i;  
         UINT8           work[256];  
         UINT            size;  
         UINT            wsize;  
   
         sxsi = getdrive(drv);          sxsi = sxsi_getptr(drv);
         if (sxsi == NULL) {          if (sxsi != NULL) {
                 return(0x60);                  return(sxsi->format(sxsi, pos));
         }  
         if ((pos < 0) || (pos >= sxsi->totals)) {  
                 return(0x40);  
         }          }
         pos = pos * sxsi->size + sxsi->headersize;          else {
         r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);                  return(0x60);
         if (pos != r) {  
                 return(0xd0);  
         }  
         FillMemory(work, sizeof(work), 0xe5);  
         for (i=0; i<sxsi->sectors; i++) {  
                 size = sxsi->size;  
                 while(size) {  
                         wsize = min(size, sizeof(work));  
                         size -= wsize;  
                         CPU_REMCLOCK -= wsize;  
                         if (file_write((FILEH)sxsi->fh, work, wsize) != wsize) {  
                                 return(0x70);  
                         }  
                 }  
         }          }
         return(0x00);  
 }  }
   
Removed from v.1.15  
changed lines
  Added in v.1.21

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