--- np2/fdd/sxsi.c	2004/01/22 01:10:04	1.7
+++ np2/fdd/sxsi.c	2005/04/05 09:12:24	1.20
@@ -4,46 +4,82 @@
 #include	"sysmng.h"
 #include	"cpucore.h"
 #include	"pccore.h"
+#include	"iocore.h"
 #include	"sxsi.h"
+#if defined(SUPPORT_IDEIO)
+#include	"ideio.h"
+#endif
 
+	_SXSIDEV	sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];
 
-static const char sig_vhd[] = "VHD";
 
-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}};
-
-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
+// ----
 
-	_SXSIDEV	sxsi_dev[SASIHDD_MAX + SCSIHDD_MAX];
+static BRESULT nc_reopen(SXSIDEV sxsi) {
+
+	(void)sxsi;
+	return(FAILURE);
+}
 
+static REG8	nc_read(SXSIDEV sxsi, long pos, UINT8 *buf, UINT size) {
 
-// SASI規格HDDかチェック
-static void sasihddcheck(SXSIDEV sxsi) {
+	(void)sxsi;
+	(void)pos;
+	(void)buf;
+	(void)size;
+	return(0x60);
+}
 
-const SASIHDD	*sasi;
-	UINT		i;
+static REG8 nc_write(SXSIDEV sxsi, long pos, const UINT8 *buf, UINT size) {
 
-	sasi = sasihdd;
-	for (i=0; i<sizeof(sasihdd)/sizeof(SASIHDD); i++) {
-		if ((sxsi->size == 256) &&
-			(sxsi->sectors == sasi->sectors) &&
-			(sxsi->surfaces == sasi->surfaces) &&
-			(sxsi->cylinders == sasi->cylinders)) {
-			sxsi->type = (UINT16)(SXSITYPE_SASI + (i << 8) + SXSITYPE_HDD);
-			break;
-		}
+	(void)sxsi;
+	(void)pos;
+	(void)buf;
+	(void)size;
+	return(0x60);
+}
+
+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 defined(SUPPORT_IDEIO)
+		ideio_notify(sxsi->drv, 0);
+#endif
+		if (sxsi->flag & SXSIFLAG_FILEOPENED) {
+			(*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;
 	}
 }
 
+
 // ----
 
 void sxsi_initialize(void) {
@@ -51,290 +87,285 @@ void sxsi_initialize(void) {
 	UINT	i;
 
 	ZeroMemory(sxsi_dev, sizeof(sxsi_dev));
-	for (i=0; i<(sizeof(sxsi_dev)/sizeof(_SXSIDEV)); i++) {
-		sxsi_dev[i].fh = (long)FILEH_INVALID;
+	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++) {
+		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) {
 
 	UINT	num;
 
 	num = drv & 0x0f;
-	if (!(drv & 0x20)) {			// SASI or IDE
-		if (num < 2) {
+	if (!(drv & 0x20)) {					// SASI or IDE
+		if (num < SASIHDD_MAX) {
 			return(sxsi_dev + num);
 		}
 	}
+#if defined(SUPPORT_SCSI)
 	else {
-		if (num < 4) {				// SCSI
+		if (num < SCSIHDD_MAX) {			// SCSI
 			return(sxsi_dev + SASIHDD_MAX + num);
 		}
 	}
+#endif
 	return(NULL);
 }
 
-const char *sxsi_getname(REG8 drv) {
+OEMCHAR *sxsi_getfilename(REG8 drv) {
 
 	SXSIDEV	sxsi;
 
 	sxsi = sxsi_getptr(drv);
-	if (sxsi) {
+	if ((sxsi) && (sxsi->flag & SXSIFLAG_READY)) {
 		return(sxsi->fname);
 	}
 	return(NULL);
 }
 
-BOOL sxsi_hddopen(REG8 drv, const char *file) {
+BRESULT sxsi_setdevtype(REG8 drv, UINT8 dev) {
+
+	SXSIDEV	sxsi;
+
+	sxsi = sxsi_getptr(drv);
+	if (sxsi) {
+		if (sxsi->devtype != dev) {
+			sxsi_disconnect(sxsi);
+			sxsi->devtype = dev;
+		}
+		return(SUCCESS);
+	}
+	else {
+		return(FAILURE);
+	}
+}
+
+UINT8 sxsi_getdevtype(REG8 drv) {
+
+	SXSIDEV	sxsi;
+
+	sxsi = sxsi_getptr(drv);
+	if (sxsi) {
+		return(sxsi->devtype);
+	}
+	else {
+		return(SXSIDEV_NC);
+	}
+}
+
+BRESULT sxsi_devopen(REG8 drv, const OEMCHAR *fname) {
 
 	SXSIDEV		sxsi;
-const char		*ext;
-	FILEH		fh;
-	THDHDR		thd;
-	HDIHDR		hdi;
-	VHDHDR		vhd;
+	BRESULT		r;
 
-	if ((file == NULL) || (file[0] == '\0')) {
+	if ((fname == NULL) || (fname[0] == '\0')) {
 		goto sxsiope_err;
 	}
 	sxsi = sxsi_getptr(drv);
 	if (sxsi == NULL) {
 		goto sxsiope_err;
 	}
-	ext = file_getext((char *)file);
-	if ((!file_cmpname(ext, str_thd)) && (!(drv & 0x20))) {
-		fh = file_open(file);								// T98 HDD (IDE)
-		if (fh == FILEH_INVALID) {
-			goto sxsiope_err;
-		}
-		if (file_read(fh, &thd, sizeof(thd)) == sizeof(thd)) {
-			*sxsi = defide;
-			sxsi->cylinders = LOADINTELWORD(thd.cylinders);
-			sxsi->totals = sxsi->cylinders * sxsi->sectors * sxsi->surfaces;
-			sasihddcheck(sxsi);
-			file_cpyname(sxsi->fname, file, sizeof(sxsi->fname));
-			sxsi->fh = (long)fh;
-			return(SUCCESS);
-		}
-		file_close(fh);
-	}
-	else if ((!file_cmpname(ext, str_hdi)) && (!(drv & 0x20))) {
-		fh = file_open(file);				// ANEX86 HDD (SASI) thanx Mamiya
-		if (fh == FILEH_INVALID) {
-			goto sxsiope_err;
-		}
-		if (file_read(fh, &hdi, sizeof(hdi)) == sizeof(hdi)) {
-			*sxsi = defide;
-			sxsi->size = LOADINTELWORD(hdi.sectorsize);
-			sxsi->headersize = LOADINTELDWORD(hdi.headersize);
-			sxsi->cylinders = LOADINTELWORD(hdi.cylinders);
-			sxsi->surfaces = hdi.surfaces[0];
-			sxsi->sectors = hdi.sectors[0];
-			sxsi->totals = sxsi->cylinders * sxsi->sectors * sxsi->surfaces;
-			sasihddcheck(sxsi);
-			file_cpyname(sxsi->fname, file, sizeof(sxsi->fname));
-			sxsi->fh = (long)fh;
-			return(SUCCESS);
-		}
-		file_close(fh);
-	}
-	else if ((!file_cmpname(ext, str_hdd)) && (drv & 0x20)) {
-		TRACEOUT(("insert hdd - %.2x", drv));
-		fh = file_open(file);						// Virtual98 HDD (SCSI)
-		if (fh == FILEH_INVALID) {
-			goto sxsiope_err;
-		}
-		if ((file_read(fh, &vhd, sizeof(vhd)) == sizeof(vhd)) &&
-			(!memcmp(vhd.sig, sig_vhd, 3))) {
-			*sxsi = defscsi;
-			sxsi->totals = (SINT32)LOADINTELDWORD(vhd.totals);
-			sxsi->cylinders = LOADINTELWORD(vhd.cylinders);
-			sxsi->size = LOADINTELWORD(vhd.sectorsize);
-			sxsi->sectors = vhd.sectors;
-			sxsi->surfaces = vhd.surfaces;
-			file_cpyname(sxsi->fname, file, sizeof(sxsi->fname));
-			sxsi->fh = (long)fh;
-			TRACEOUT(("success"));
-			return(SUCCESS);
-		}
-		file_close(fh);
+	switch(sxsi->devtype) {
+		case SXSIDEV_HDD:
+			r = sxsihdd_open(sxsi, fname);
+			break;
+
+		case SXSIDEV_CDROM:
+			r = sxsicd_open(sxsi, fname);
+			break;
+
+		default:
+			r = FAILURE;
+			break;
 	}
+	if (r != SUCCESS) {
+		goto sxsiope_err;
+	}
+	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);
 }
 
-void sxsi_open(void) {
+void sxsi_devclose(REG8 drv) {
 
-	int		i;
-	REG8	drv;
+	SXSIDEV		sxsi;
 
-	sxsi_trash();
-	drv = 0;
-	for (i=0; i<2; i++) {
-		if (sxsi_hddopen(drv, np2cfg.sasihdd[i]) == SUCCESS) {
-			drv++;
-		}
-	}
-	drv = 0x20;
-	for (i=0; i<4; i++) {
-		if (sxsi_hddopen(drv, np2cfg.scsihdd[i]) == SUCCESS) {
-			drv++;
-		}
-	}
+	sxsi = sxsi_getptr(drv);
+	sxsi_disconnect(sxsi);
 }
 
-void sxsi_flash(void) {
+BOOL sxsi_issasi(void) {
 
+	REG8	drv;
 	SXSIDEV	sxsi;
-	SXSIDEV	sxsiterm;
+	BOOL	ret;
 
-	sxsi = sxsi_dev;
-	sxsiterm = sxsi + (sizeof(sxsi_dev)/sizeof(_SXSIDEV));
-	while(sxsi < sxsiterm) {
-		if ((FILEH)sxsi->fh != FILEH_INVALID) {
-			file_close((FILEH)sxsi->fh);
-			sxsi->fh = (long)FILEH_INVALID;
+	ret = FALSE;
+	for (drv=0x00; drv<0x04; drv++) {
+		sxsi = sxsi_getptr(drv);
+		if (sxsi) {
+			if ((drv < 0x02) && (sxsi->devtype == SXSIDEV_HDD)) {
+				if (sxsi->flag & SXSIFLAG_READY) {
+					if (sxsi->mediatype & SXSIMEDIA_INVSASI) {
+						return(FALSE);
+					}
+					ret = TRUE;
+				}
+			}
+			else {
+				return(FALSE);
+			}
 		}
-		sxsi++;
 	}
+	return(ret);
 }
 
-void sxsi_trash(void) {
+BOOL sxsi_isscsi(void) {
 
+	REG8	drv;
 	SXSIDEV	sxsi;
-	SXSIDEV	sxsiterm;
 
-	sxsi = sxsi_dev;
-	sxsiterm = sxsi + (sizeof(sxsi_dev)/sizeof(_SXSIDEV));
-	while(sxsi < sxsiterm) {
-		if ((FILEH)sxsi->fh != FILEH_INVALID) {
-			file_close((FILEH)sxsi->fh);
-			sxsi->fh = (long)FILEH_INVALID;
+	for (drv=0x20; drv<0x28; drv++) {
+		sxsi = sxsi_getptr(drv);
+		if (sxsi_isconnect(sxsi)) {
+			return(TRUE);
 		}
-		sxsi->fname[0] = '\0';
-		sxsi++;
 	}
+	return(FALSE);
 }
 
-static SXSIDEV getdrive(REG8 drv) {
+BOOL sxsi_iside(void) {
 
-	UINT	num;
-	SXSIDEV	ret;
+	REG8	drv;
+	SXSIDEV	sxsi;
 
-	num = drv & 0x0f;
-	if (num >= 2) {
-		return(NULL);
-	}
-	num += (drv & 0x20) >> 4;
-	ret = sxsi_dev + num;
-	if (ret->fname[0] == '\0') {
-		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);
+	for (drv=0x00; drv<0x04; drv++) {
+		sxsi = sxsi_getptr(drv);
+		if (sxsi_isconnect(sxsi)) {
+			return(TRUE);
 		}
 	}
-	sysmng_hddaccess(drv);
-	return(ret);
+	return(FALSE);
 }
 
-REG8 sxsi_read(REG8 drv, long pos, BYTE *buf, UINT size) {
 
-const _SXSIDEV	*sxsi;
-	long		r;
-	UINT		rsize;
 
-	sxsi = getdrive(drv);
-	if (sxsi == NULL) {
-		return(0x60);
-	}
-	pos = pos * sxsi->size + sxsi->headersize;
-	r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
-	if (r == -1) {
-		return(0x40);
-	}
-	if (pos != r) {
-		return(0xd0);
+REG8 sxsi_read(REG8 drv, long pos, UINT8 *buf, UINT size) {
+
+	SXSIDEV	sxsi;
+
+	sxsi = sxsi_getptr(drv);
+	if (sxsi != NULL) {
+		return(sxsi->read(sxsi, pos, buf, size));
 	}
-	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;
+	else {
+		return(0x60);
 	}
-	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;
-	long		r;
-	UINT		wsize;
+	SXSIDEV	sxsi;
 
-	sxsi = getdrive(drv);
-	if (sxsi == NULL) {
-		return(0x60);
+	sxsi = sxsi_getptr(drv);
+	if (sxsi != NULL) {
+		return(sxsi->write(sxsi, pos, buf, size));
 	}
-	pos = pos * sxsi->size + sxsi->headersize;
-	r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
-	if (r == -1) {
-		return(0x40);
-	}
-	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;
+	else {
+		return(0x60);
 	}
-	return(0x00);
 }
 
 REG8 sxsi_format(REG8 drv, long pos) {
 
-const _SXSIDEV	*sxsi;
-	long		r;
-	UINT16		i;
-	BYTE		work[256];
-	UINT		size;
-	UINT		wsize;
+	SXSIDEV	sxsi;
 
-	sxsi = getdrive(drv);
-	if (sxsi == NULL) {
-		return(0x60);
+	sxsi = sxsi_getptr(drv);
+	if (sxsi != NULL) {
+		return(sxsi->format(sxsi, pos));
 	}
-	pos = pos * sxsi->size + sxsi->headersize;
-	r = file_seek((FILEH)sxsi->fh, pos, FSEEK_SET);
-	if (r == -1) {
-		return(0x40);
-	}
-	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);
-			}
-		}
+	else {
+		return(0x60);
 	}
-	return(0x00);
 }