--- xmil/fdd/fdd_2d.c	2004/08/01 05:31:30	1.1
+++ xmil/fdd/fdd_2d.c	2004/08/17 09:35:09	1.9
@@ -1,217 +1,176 @@
 #include	"compiler.h"
 #include	"dosio.h"
 #include	"pccore.h"
-#include	"x1_io.h"
-#include	"x1_fdc.h"
 #include	"fddfile.h"
+#include	"fdd_2d.h"
 #include	"fdd_mtr.h"
 
 
-extern	BYTE		WRITEPT[];
-extern	BYTE		DISKNUM[];
-static	WORD		sec_now[4] = {0, 0, 0, 0};
-static	BYTE		sec_write[4] = {0, 0, 0, 0};
-static	BYTE		sec_data[4][256];
-static	BYTE		hole = 0;
+static const _XDFINFO supportxdf[] = {
+			{0,  80, 16, 1, DISKTYPE_2D},
+			{0, 154, 26, 1, DISKTYPE_2HD}};
 
 
-BYTE changesector2d(void) {
+static REG8 fdd2d_seek(FDDFILE fdd, REG8 media, UINT track) {
 
-	FDDFILE	fdd;
-	FILEH	fh;
-	WORD	sec;
-	long	seekp;
-	short	drv = FDC.drv;
-
-	if (FDC.media) {
-		return(1);
+	if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks)) {
+		return(FDDSTAT_SEEKERR);
 	}
-	fdd = fddfile + drv;
-
-	sec = (WORD)(((FDC.c) << 5) + (FDC.h << 4) + FDC.r - 1);
-	if (sec_now[drv] == sec) {
-		return(0);
-	}
-	fh = file_open(fdd->fname);
-	if (fh == FILEH_INVALID) {
-		sec_now[drv] = -1;
-		return(1);
-	}
-	if ((sec_write[drv]) && (sec_now[drv] != -1)) {
-		seekp = (long)sec_now[drv] << 8;
-		if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||
-			(file_write(fh, sec_data[drv], 256) != 256)) {
-			file_close(fh);
-			sec_now[drv] = -1;
-			return(1);
-		}
-	}
-	sec_write[drv] = 0;
-	sec_now[drv] = sec;
-	seekp = (long)sec << 8;
-	if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||
-		(file_read(fh, sec_data[drv], 256) != 256)) {
-		file_close(fh);
-		sec_now[drv] = -1;
-		return(1);
-	}
-	file_close(fh);
-	return(0);
+	return(0x00);
 }
 
-BRESULT fdd_eject_2d(REG8 drv) {
+static REG8 fdd2d_read(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
+												UINT8 *ptr, UINT *size) {
 
-	FDDFILE	fdd;
+	UINT	secsize;
+	UINT	rsize;
 	FILEH	fh;
-	long	seekp;
-	BRESULT	ret = 0;
+	long	pos;
+	BRESULT	b;
 
-	fdd = fddfile + drv;
-	while(1) {
-		if ((!sec_write[drv]) || (sec_now[drv] == -1)) {
-			break;
-		}
-		seekp = (long)sec_now[drv] << 8;
-		fh = file_open(fdd->fname);
+	if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
+		(sc == 0) || (sc > fdd->inf.xdf.sectors)) {
+		goto fd2r_err;
+	}
+	secsize = 1 << (7 + fdd->inf.xdf.n);
+	rsize = min(secsize, *size);
+	if (ptr) {
+		fh = file_open_rb(fdd->fname);
 		if (fh == FILEH_INVALID) {
-			ret = 1;
-			break;
-		}
-		if ((file_seek(fh, seekp, FSEEK_SET) != seekp) ||
-			(file_write(fh, sec_data[drv], 256) != 256)) {
-			ret = 1;
+			goto fd2r_err;
 		}
-		if (file_close(fh)) {
-			ret = 1;
+		pos = ((track * fdd->inf.xdf.sectors) + (sc - 1)) * secsize;
+		pos += fdd->inf.xdf.headersize;
+		b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
+			(file_read(fh, ptr, rsize) != rsize);
+		file_close(fh);
+		if (b) {
+			goto fd2r_err;
 		}
-		break;
 	}
-	fdd->fname[0] = '\0';
-	DISKNUM[drv] = 0;
-	sec_now[drv] = -1;
-	sec_write[drv] = 0;
-	return(ret);
-}
+	*size = rsize;
+	return(0x00);
 
+fd2r_err:
+	return(FDDSTAT_RECNFND);
+}
 
-BRESULT fdd_set_2d(REG8 drv, const OEMCHAR *fname) {
+static REG8 fdd2d_write(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
+												const UINT8 *ptr, UINT size) {
 
-	FDDFILE	fdd;
-	WORD	attr;
+	UINT	secsize;
+	FILEH	fh;
+	long	pos;
+	BRESULT	b;
 
-	fdd_eject_2d(drv);
-	fdd = fddfile + drv;
-	if ((drv < 0 || drv > 3) ||
-		((attr = file_attr(fname)) & 0x18)) {	// エラー・ディレクトリ・ラベル
-		return(1);
+	if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
+		(sc == 0) || (sc > fdd->inf.xdf.sectors)) {
+		return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
 	}
-	DISKNUM[drv] = DRV_FMT2D;
-	file_cpyname(fdd->fname, fname, NELEMENTS(fdd->fname));
-	WRITEPT[drv] = (BYTE)(attr & 1);
-	return(0);
-}
+	fh = file_open(fdd->fname);
+	if (fh == FILEH_INVALID) {
+		goto fd2w_err;
+	}
+	secsize = 1 << (7 + fdd->inf.xdf.n);
+	pos = ((track * fdd->inf.xdf.sectors) + (sc - 1)) * secsize;
+	size = min(size, secsize);
+	b = (file_seek(fh, pos, FSEEK_SET) != pos) ||
+		(file_write(fh, ptr, size) != size);
+	file_close(fh);
+	if (b) {
+		goto fd2w_err;
+	}
+	return(0x00);
 
-//**********************************************************************
+fd2w_err:
+	return(FDDSTAT_WRITEFAULT);
+}
 
-short fdd_crc_2d(void) {
+static REG8 fdd2d_crc(FDDFILE fdd, REG8 media, UINT track, UINT num,
+												UINT8 *ptr) {
 
-	FDC.crc_dat[0] = FDC.c;
-	FDC.crc_dat[1] = FDC.h;
-	FDC.crc_dat[2] = FDC.r;
-	FDC.crc_dat[3] = 1;
-	FDC.crc_dat[4] = 0;			// CRC(Lo)
-	FDC.crc_dat[5] = 0;			// CRC(Hi)
-	FDC.rreg = FDC.c;			// ??? メルヘンヴェール
-	return(0);
+	if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks) ||
+		(num >= fdd->inf.xdf.sectors)) {
+		return(FDDSTAT_RECNFND);
+	}
+	ptr[0] = (UINT8)(track >> 1);
+	ptr[1] = (UINT8)(track & 1);
+	ptr[2] = (UINT8)(num + 1);
+	ptr[3] = fdd->inf.xdf.n;
+	ptr[4] = 0;										// CRC(Lo)
+	ptr[5] = 0;										// CRC(Hi)
+	return(0x00);
 }
 
 
-BYTE fdd_stat_2d(void) {
+#if defined(SUPPORT_DISKEXT)
+static UINT32 fdd2d_sec(FDDFILE fdd, REG8 media, UINT track, REG8 sc) {
 
-	BYTE	type, cmnd;
-	BYTE	ans = 0;
+	UINT32	ret;
 
-	// NOT READY
-	if (DISKNUM[FDC.drv] != DRV_FMT2D) {
-		return(0x80);
+	if ((media != fdd->inf.xdf.media) || (track >= fdd->inf.xdf.tracks)) {
+		return(0);
 	}
-	type = FDC.type;
-	cmnd = (BYTE)(FDC.cmnd >> 4);
-
-	if (type == 0 || type == 1 || type == 4 ||					// !!!
-		cmnd == 0x0a || cmnd == 0x0b || cmnd == 0x0f) {
-		if (WRITEPT[FDC.drv]) {				// WRITE PROTECT
-			ans |= 0x40;
-		}
+	if ((sc == 0) || (sc > fdd->inf.xdf.sectors)) {
+		ret = fdd->inf.xdf.sectors;
 	}
-	if ((type == 1 || type == 2) &&
-		((FDC.c >= 40) || (FDC.h > 1) || (FDC.r > 16) || (FDC.media))) {
-		ans |= 0x10;					// SEEK ERROR / RECORD NOT FOUND
+	else {
+		ret = sc;
 	}
-
-	if (type == 1 || type == 4) {
-		if (type == 1) {
-			ans |= 0x20;					// HEAD ENGAGED (X1 デハ ツネニ 1)
-			if (FDC.c == 0) {
-				ans |= 0x04;					// TRACK00
-			}
-		}
-		if (++hole < 8) {
-			ans |= 0x02;					// INDEX
-		}
-	}
-	else if (!(ans & 0xf0)) {
-		if (FDDMTR_BUSY) {
-			ans |= 0x01;
-		}
-		if ((type == 2) && (FDC.r) && (FDC.off < 256)) {
-			ans |= 0x03;					// DATA REQUEST / BUSY
-		}
-		else if (cmnd == 0x0f) {
-			ans |= 0x04;					// error!
-		}
-	}
-	return(ans);
+	return((16 << fdd->inf.xdf.sectors) + ret);
 }
+#endif
 
 
-//**********************************************************************
-
-void fdd_read_2d(void) {
+// ----
 
-	if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {
-		FDC.data = sec_data[FDC.drv][FDC.off];
-	}
-}
+BRESULT fdd2d_set(FDDFILE fdd, const OEMCHAR *fname) {
 
+	short		attr;
+	FILEH		fh;
+	UINT		fdsize;
+const _XDFINFO	*xdf;
+const _XDFINFO	*xdfterm;
+	UINT		size;
 
-void fdd_write_2d(void) {
+	attr = file_attr(fname);
+	if (attr & 0x18) {
+		return(FAILURE);
+	}
+	fh = file_open(fname);
+	if (fh == FILEH_INVALID) {
+		return(FAILURE);
+	}
+	fdsize = file_getsize(fh);
+	file_close(fh);
 
-	if (((fdd_stat_2d() & 0xf3) == 3) && (!changesector2d())) {
-		sec_data[FDC.drv][FDC.off] = FDC.data;
-		sec_write[FDC.drv] = 1;
+	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) {
 
-BYTE fdd_incoff_2d(void) {
-
-	BYTE cmnd;
-
-	if (++FDC.off < 256) {
-		return(0);
-	}
-	cmnd = (BYTE)(FDC.cmnd >> 4);
-	if (cmnd == 0x09 || cmnd == 0x0b) {
-		if (FDC.r < 16) {
-			FDC.r++;
-			FDC.rreg++;
-			FDC.off = 0;
-			return(0);
-		}
-		FDC.rreg = FDC.r + 1;
-	}
-	FDC.off = 256;
-	return(1);
+	(void)fdd;
 }