--- xmil/fdd/fdd_d88.c	2004/08/02 11:48:13	1.2
+++ xmil/fdd/fdd_d88.c	2004/08/17 09:35:09	1.12
@@ -1,87 +1,37 @@
 #include	"compiler.h"
 #include	"dosio.h"
 #include	"pccore.h"
-#include	"x1_io.h"
-#include	"x1_fdc.h"
-#include	"fdd_mtr.h"
-#include	"fdd_d88.h"
 #include	"fddfile.h"
+#include	"fdd_d88.h"
+#include	"fdd_mtr.h"
 
 
-static	D88_HEADER	d88head[4];
-static	D88_SECTOR	cursec;
-static	short		curdrv = -1;
-static	WORD		curtrk = -1;
-static	BYTE		curtype = 0;
-static	WORD		cursct = -1;
-static	long		curfp = 0;
-static	DWORD		cursize = 0;
-static	BYTE		curwrite = 0;
-static	BYTE		curtrkerr = 0;
-static	BYTE		hole = 0;
-static	BYTE		*curdata;
-static	WORD		crcnum = 0;
-static	BYTE		crcerror = FALSE;
-
-extern	BYTE		WRITEPT[];
-extern	BYTE		DISKNUM[];
-
-extern	WORD		readdiag;
-
-#define		TAO_MODE_GAP	0x4e
-#define		TAO_MODE_SYNC	0x00
-#define		TAO_MODE_AM		0xf5
-#define		TAO_MODE_IM		0xf6
-#define		TAO_MODE_ID		0xfe
-#define		TAO_MODE_DATA	0xfb
-#define		TAO_ENDOFDATA	0xf7
-
-#define		TAO_CMD_GAP		0x4e
-#define		TAO_CMD_SYNC	0x00
-#define		TAO_CMD_IM_IN	0xf6
-#define		TAO_CMD_IM		0xfc
-#define		TAO_CMD_AM_IN	0xf5
-#define		TAO_CMD_IAM		0xfe
-#define		TAO_CMD_DAM		0xfb
-#define		TAO_CMD_DDAM	0xf8
-#define		TAO_CMD_CRC		0xf7
+enum {
+	D88BUFSIZE		= 0x4000
+};
 
 typedef struct {
-	BYTE	mode;
-	BYTE	flag;
-	WORD	cnt;
-	WORD	size;
-	WORD	ptr;
-	WORD	top;
-	WORD	gap;
-	BYTE	sector;
-	WORD	lostdatacnt;
-	BYTE	maxsector;
-	WORD	maxsize;
-} WID_PARA;
-
-#define LOSTDATA_COUNT	256
-
-static	WID_PARA WID_2D	= {TAO_ENDOFDATA, 3, 0, 0, 0, 0, 0, 0, 0, 33, 0x1f80};
-static	WID_PARA WID_2HD= {TAO_ENDOFDATA, 3, 0, 0, 0, 0, 0, 0, 0, 55, 0x2f80};
-static	WID_PARA WID_ERR= {TAO_ENDOFDATA, 4, 0, 0, 0, 0, 0, 0, 0,  0, 0x0000};
-static	WID_PARA tao	= {TAO_ENDOFDATA, 4, 0, 0, 0, 0, 0, 0, 0,  0, 0x0000};
-
-static	BYTE		D88_BUF[0x4000];
-static	BYTE		TAO_BUF[0x3000];
+	FDDFILE	fdd;
+	UINT8	media;
+	UINT8	write;
+	UINT8	padding[2];
+	UINT	track;
+	long	fptr;
+	UINT	size;
+	UINT	sectors;
+	UINT8	buf[D88BUFSIZE];
+} _D88TRK, *D88TRK;
 
+static	_D88TRK		d88trk;
 
-//----------------------------------------------------------------------
 
-static UINT32 nexttrackp(D88_HEADER *head, UINT32 fptr, UINT32 last) {
+static UINT32 nexttrackptr(FDDFILE fdd, UINT32 fptr, UINT32 last) {
 
 	UINT	t;
-const DWORD	*trkp;
 	UINT32	cur;
 
-	trkp = (DWORD *)head->trackp;
 	for (t=0; t<164; t++) {
-		cur = trkp[t];
+		cur = fdd->inf.d88.ptr[t];
 		if ((cur > fptr) && (cur < last)) {
 			last = cur;
 		}
@@ -89,318 +39,434 @@ const DWORD	*trkp;
 	return(last);
 }
 
-
-int curdataflush(void) {
+static BRESULT trackflush(D88TRK trk) {
 
 	FDDFILE	fdd;
 	FILEH	fh;
-	int		ret = 0;
 
-	if ((!curfp) || (!cursize)) {
-		return(-1);
+	fdd = trk->fdd;
+	trk->fdd = NULL;
+	if ((fdd == NULL) || (trk->size == 0) || (!trk->write)) {
+		goto dtfd_exit;
 	}
-	if (!curwrite) {
-		return(0);
-	}
-	curwrite = 0;
-	fdd = fddfile + curdrv;
 	fh = file_open(fdd->fname);
 	if (fh == FILEH_INVALID) {
-		return(-1);
-	}
-	if ((file_seek(fh, curfp, FSEEK_SET) != curfp) ||
-		(file_write(fh, D88_BUF, cursize) != cursize)) {
-		ret = -1;
+		goto dtfd_err1;
 	}
-	if (file_close(fh)) {
-		ret = -1;
+	if ((file_seek(fh, trk->fptr, FSEEK_SET) != trk->fptr) ||
+		(file_write(fh, trk->buf, trk->size) != trk->size)) {
+		goto dtfd_err2;
 	}
-	return(ret);
-}
+	file_close(fh);
+	trk->write = FALSE;
 
+dtfd_exit:
+	return(SUCCESS);
 
-DWORD read_d88track(short drv, WORD track, BYTE type) {
+dtfd_err2:
+	file_close(fh);
 
-	FDDFILE	fdd;
-	FILEH	hdr;
+dtfd_err1:
+	return(FAILURE);
+}
 
-	curdataflush();
-	curdrv = drv;
-	curtrk = track;
-	curtype = type;
-	cursct = -1;
-	curwrite = 0;
-	curtrkerr = 0;
-	crcnum = 0;
-	crcerror = 0;
-
-	if ((drv < 0) || (drv > 3) || (track > 163) ||
-		((type == 0) && (d88head[drv].fd_type == 0x20)) ||
-		((type == 1) && (d88head[drv].fd_type != 0x20)) ||
-		((curfp = d88head[drv].trackp[track]) == 0) ||
-		((cursize = nexttrackp(&d88head[drv], curfp,
-								d88head[drv].fd_size) - curfp) > 0x4000)) {
-		goto readd88_err;
-	}
+static D88TRK trackread(D88TRK trk, FDDFILE fdd, REG8 media, UINT track) {
 
-	fdd = fddfile + drv;
-	if ((hdr = file_open(fdd->fname)) == FILEH_INVALID) {
-		goto readd88_err;
+	FILEH		fh;
+	UINT32		fptr;
+	UINT		size;
+const _D88SEC	*sec;
+	UINT		rem;
+	UINT		maxsectors;
+	UINT		sectors;
+	UINT		secsize;
+
+	trackflush(trk);
+	if (media != (REG8)((fdd->inf.d88.head.fd_type >> 4))) {
+		goto dtrd_err1;
+	}
+	if (track >= 164) {
+		goto dtrd_err1;
+	}
+	fptr = fdd->inf.d88.ptr[track];
+	if (fptr == 0) {
+		goto dtrd_err1;
+	}
+	size = nexttrackptr(fdd, fptr, fdd->inf.d88.fd_size) - fptr;
+	if (size > D88BUFSIZE) {
+		size = D88BUFSIZE;
 	}
-	if (file_seek(hdr, curfp, FSEEK_SET) != curfp) {
-		file_close(hdr);
-		goto readd88_err;
+	fh = file_open_rb(fdd->fname);
+	if (fh == FILEH_INVALID) {
+		goto dtrd_err1;
 	}
-	if (file_read(hdr, D88_BUF, (WORD)cursize) != (WORD)cursize) {
-		file_close(hdr);
-		goto readd88_err;
+	if ((file_seek(fh, (long)fptr, FSEEK_SET) != (long)fptr) ||
+		(file_read(fh, trk->buf, size) != size)) {
+		goto dtrd_err2;
 	}
-	if (file_close(hdr)) {
-		goto readd88_err;
+	file_close(fh);
+
+	trk->fdd = fdd;
+	trk->media = media;
+	trk->write = FALSE;
+	trk->track = track;
+	trk->fptr = fptr;
+	trk->size = size;
+
+	// セクタ数チェック
+	sec = (D88SEC)trk->buf;
+	rem = size;
+	maxsectors = 0;
+	if (rem >= sizeof(_D88SEC)) {
+		maxsectors = LOADINTELWORD(sec->sectors);
+	}
+	sectors = 0;
+	while(sectors < maxsectors) {
+		secsize = LOADINTELWORD(sec->size);
+		secsize += sizeof(_D88SEC);
+		if (rem < secsize) {
+			break;
+		}
+		rem -= secsize;
+		maxsectors = LOADINTELWORD(sec->sectors);
+		sec = (D88SEC)(((UINT8 *)sec) + secsize);
+		sectors++;
 	}
-	return(TRUE);
+	trk->sectors = sectors;
+	return(trk);
 
-readd88_err:
-	curfp = 0;
-	cursize = 0;
-	curtrkerr = 1;
-	return(FALSE);
-}
+dtrd_err2:
+	file_close(fh);
 
+dtrd_err1:
+	return(NULL);
+}
 
+static void drvflush(FDDFILE fdd) {
 
+	D88TRK	trk;
 
-static int seeksector(short drv, WORD track, WORD sector) {
+	trk = &d88trk;
+	if (trk->fdd == fdd) {
+		trackflush(trk);
+	}
+}
 
-static	int		lastflag = FALSE;
+static D88TRK trackseek(FDDFILE fdd, REG8 media, UINT track) {
 
-	BYTE 		*p;
-	WORD		sec;
+	D88TRK	trk;
 
-	if ((curdrv != drv) || (curtrk != track) || (curtype != fdc.media)) {
-		read_d88track(drv, track, fdc.media);
-	}
-	if (curtrkerr) {
-		cursct = sector;
-		goto seekerror;
-	}
-	if (cursct != sector) {
-		cursct = sector;
-		p = D88_BUF;
-		for (sec=0; sec<40;) {
-			if ((WORD)((D88_SECTOR *)p)->r == sector) {
-				memcpy(&cursec, p, sizeof(D88_SECTOR));
-				curdata = p + sizeof(D88_SECTOR);
-				lastflag = TRUE;
-				break;
-			}
-			if (++sec >= ((D88_SECTOR *)p)->sectors) {
-				goto seekerror;
-			}
-			p += ((D88_SECTOR *)p)->size;
-			p += sizeof(D88_SECTOR);
-		}
-		if (sec >= 40) {
-			goto seekerror;
-		}
+	trk = &d88trk;
+	if ((trk->fdd != fdd) || (trk->media != media) || (trk->track != track)) {
+		trk = trackread(trk, fdd, media, track);
 	}
-	return(lastflag);
-
-seekerror:;
-	ZeroMemory(&cursec, sizeof(D88_SECTOR));
-	curdata = &D88_BUF[16];
-	lastflag = FALSE;
-	return(FALSE);
+	return(trk);
 }
 
+static D88SEC sectorseek(const _D88TRK *trk, REG8 r) {
 
-void drvflush(short drv) {
+const _D88SEC	*sec;
+	UINT		sectors;
+	UINT		size;
 
-	if (curdrv == drv) {
-		curdataflush();
-		curdrv = -1;
-		curtrk = -1;
-		cursct = -1;
+	sec = (D88SEC)trk->buf;
+	sectors = trk->sectors;
+	while(sectors) {
+		sectors--;
+		if (sec->r == r) {
+			return((D88SEC)sec);
+		}
+		size = LOADINTELWORD(sec->size);
+		size += sizeof(_D88SEC);
+		sec = (D88SEC)(((UINT8 *)sec) + size);
 	}
+	return(NULL);
 }
 
 
+// ----
 
+static REG8 fddd88_seek(FDDFILE fdd, REG8 media, UINT track) {
 
-//**********************************************************************
+	if (trackseek(fdd, media, track) != NULL) {
+		return(0x00);
+	}
+	else {
+		return(FDDSTAT_SEEKERR);
+	}
+}
 
-short fdd_crc_d88(void) {
+static REG8 fddd88_read(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
+												UINT8 *ptr, UINT *size) {
 
-	WORD		track;
-	BYTE		*p;
-	WORD		sec;
+const _D88TRK	*trk;
+const _D88SEC	*sec;
+	UINT		secsize;
+	REG8		ret;
 
-	ZeroMemory(fdc.crc_dat, 6);
-	if ((track = (WORD)(fdc.c << 1) + (WORD)fdc.h) > 163) {
-		goto crcerror_d88;
+	TRACEOUT(("d88 read %d:%.2x", track, sc));
+	trk = trackseek(fdd, media, track);
+	if (trk == NULL) {
+		goto fd8r_err;
 	}
-	seeksector(fdc.drv, track, fdc.r);
-	if (curtrkerr) {
-		goto crcerror_d88;
+	sec = sectorseek(trk, sc);
+	if (sec == NULL) {
+		goto fd8r_err;
 	}
-	p = D88_BUF;
-	for (sec=0; sec<crcnum;) {
-		if (++sec >= ((D88_SECTOR *)p)->sectors) {
-			goto crcerror_d88;
-		}
-		p += ((D88_SECTOR *)p)->size;
-		p += sizeof(D88_SECTOR);
+	ret = 0x00;
+	if (sec->del_flg) {
+		ret |= FDDSTAT_RECTYPE;
 	}
-	*(long *)fdc.crc_dat = *(long *)p;
-	fdc.rreg = ((D88_SECTOR *)p)->c;				// ??? メルヘンヴェール
-	crcnum++;
-	if (((D88_SECTOR *)p)->stat) {
-		crcerror = TRUE;
+	if (sec->stat) {
+		ret |= FDDSTAT_CRCERR;
 	}
-	else {
-		crcerror = FALSE;
+	secsize = LOADINTELWORD(sec->size);
+	secsize = min(secsize, *size);
+	if ((ptr) && (secsize)) {
+		CopyMemory(ptr, sec + 1, secsize);
 	}
-	return(0);
+	*size = secsize;
+	return(ret);
 
-crcerror_d88:;
-	crcerror = TRUE;
-	return(1);
+fd8r_err:
+	return(FDDSTAT_RECNFND);
 }
 
+static REG8 fddd88_write(FDDFILE fdd, REG8 media, UINT track, REG8 sc,
+												const UINT8 *ptr, UINT size) {
 
-BYTE fdd_stat_d88(void) {
-
-	BYTE		type, cmnd;
-	BYTE		ans = 0;
-	int			seekable;
-	WORD		trk;
+	D88TRK	trk;
+	D88SEC	sec;
+	UINT	secsize;
 
-	if (DISKNUM[fdc.drv] == DRV_EMPTY) {
-		return(0x80);						// NOT READY
+	TRACEOUT(("d88 write %d:%.2x", track, sc));
+	trk = trackseek(fdd, media, track);
+	if (trk == NULL) {
+		goto fd8w_err;
 	}
-	type = fdc.type;
-	cmnd = (BYTE)(fdc.cmnd >> 4);
-	trk = (fdc.c << 1) + (WORD)fdc.h;
-	seekable = seeksector(fdc.drv, trk, fdc.r);
-	if (!fdc.r) {
-		seekable = TRUE;
+	sec = sectorseek(trk, sc);
+	if (sec == NULL) {
+		goto fd8w_err;
 	}
+	secsize = LOADINTELWORD(sec->size);
+	size = min(size, secsize);
+	if (size) {
+		CopyMemory(sec + 1, ptr, size);
+		trk->write = TRUE;
+	}
+	return(0x00);
 
-	if (type == 0 || type == 1 || type == 4 ||
-		cmnd == 0x0a || cmnd == 0x0b || cmnd == 0x0f) {
-		if (d88head[fdc.drv].protect & 0x10) {	// WRITE PROTECT
-			ans |= 0x40;
-		}
+fd8w_err:
+	return(FDDSTAT_RECNFND | FDDSTAT_WRITEFAULT);
+}
+
+static REG8 fddd88_crc(FDDFILE fdd, REG8 media, UINT track, UINT num,
+												UINT8 *ptr) {
+
+const _D88TRK	*trk;
+const _D88SEC	*sec;
+	UINT		sectors;
+	UINT		size;
+
+	trk = trackseek(fdd, media, track);
+	if (trk == NULL) {
+		return(FDDSTAT_RECNFND);
 	}
-	if (type == 2 || cmnd == 0x0f) {
-		if (fdc.r && cursec.del_flg) {
-			ans |= 0x20;					// RECODE TYPE / WRITE FAULT
-		}
+	sec = (D88SEC)trk->buf;
+	sectors = trk->sectors;
+	if (num >= sectors) {
+		return(FDDSTAT_RECNFND);
 	}
-	if (type == 1 || type == 2) {
-		if ((trk > 163) || (!seekable)) {
-			ans |= 0x10;					// SEEK ERROR / RECORD NOT FOUND
-		}
-		if ((!(ans & 0xf0)) && fdc.r && (cursec.stat)) {
-			ans |= 0x08;					// CRC ERROR
-		}
+	while(num) {
+		num--;
+		size = LOADINTELWORD(sec->size);
+		size += sizeof(_D88SEC);
+		sec = (D88SEC)(((UINT8 *)sec) + size);
 	}
-	if (cmnd == 0x0c) {
-		if (curtrkerr) {
-			ans |= 0x10;
-		}
-		if (crcerror) {
-			ans |= 0x08;					// CRC ERROR
-		}
+	ptr[0] = sec->c;
+	ptr[1] = sec->h;
+	ptr[2] = sec->r;
+	ptr[3] = sec->n;
+	ptr[4] = 0;
+	ptr[5] = 0;
+//	fdc.s.rreg = sec->c;								// メルヘンヴェール
+	if (sec->stat) {
+		return(FDDSTAT_CRCERR);
 	}
-	if (type == 1 || type == 4) {
-		if (type == 1) {					// ver0.25
-			ans |= 0x20;					// HEAD ENGAGED (X1 デハ ツネニ 1)
-			if (!fdc.c) {					// TRACK00
-				ans |= 0x04;
-			}
-		}
-		if (++hole < 8) {					// ver0.25
-			ans |= 0x02;					// INDEX
-		}
+	return(0x00);
+}
+
+#if defined(SUPPORT_DISKEXT)
+static UINT32 fddd88_sec(FDDFILE fdd, REG8 media, UINT track, REG8 sc) {
+
+const _D88TRK	*trk;
+const _D88SEC	*sec;
+	UINT		sectors;
+	UINT		num;
+	UINT		size;
+
+	trk = trackseek(fdd, media, track);
+	if (trk == NULL) {
+		return(0);
 	}
-	else if (!(ans & 0xf0)) {
-		if ((type != 4) && (FDDMTR_BUSY)) {
-			ans |= 0x01;
-		}
-		if ((type == 2) && ((WORD)fdc.off < cursec.size)) {
-			ans |= 0x03; 					// DATA REQUEST / BUSY
-		}
-		else if ((cmnd == 0x0e) && (readdiag < 0x1a00)) {
-			ans |= 0x03;
-		}
-		else if ((cmnd == 0x0c) && (fdc.crc_off < 6)) {		// ver0.25
-			ans |= 0x03;
-		}
-		else if (cmnd == 0x0f) {
-			if (tao.flag == 3) {
-				if (++tao.lostdatacnt > LOSTDATA_COUNT) {
-					tao.flag = 4;
-				}
-			}
-			ans |= tao.flag;
+	sec = (D88SEC)trk->buf;
+	sectors = trk->sectors;
+	num = 0;
+	while(num < sectors) {
+		if (sec->r == sc) {
+			break;
 		}
+		size = LOADINTELWORD(sec->size);
+		size += sizeof(_D88SEC);
+		sec = (D88SEC)(((UINT8 *)sec) + size);
+		num++;
 	}
-	return(ans);
+	return((UINT32)(sectors << 16) + num);
 }
+#endif
+
 
+// ----
 
+BRESULT fddd88_set(FDDFILE fdd, const OEMCHAR *fname) {
 
-//**********************************************************************
+	short	attr;
+	FILEH	fh;
+	BOOL	r;
+	UINT8	ptr[D88_TRACKMAX][4];
+	UINT	i;
 
-void fdd_read_d88(void) {
-						// POCO:読めなかったらレジスタを変更させない
-	if ((fdd_stat_d88() & 0xf3) == 3) {
-		fdc.data = curdata[fdc.off];
+	attr = file_attr(fname);
+	if (attr & 0x18) {
+		goto fdst_err;
 	}
-}
+	fh = file_open_rb(fname);
+	if (fh == FILEH_INVALID) {
+		goto fdst_err;
+	}
+	r = (file_read(fh, &fdd->inf.d88.head, sizeof(fdd->inf.d88.head))
+											!= sizeof(fdd->inf.d88.head)) ||
+		(file_read(fh, ptr, sizeof(ptr)) != sizeof(ptr));
+	file_close(fh);
+	if (r) {
+		goto fdst_err;
+	}
+	fdd->inf.d88.fd_size = LOADINTELDWORD(fdd->inf.d88.head.fd_size);
+	for (i=0; i<D88_TRACKMAX; i++) {
+		fdd->inf.d88.ptr[i] = LOADINTELDWORD(ptr[i]);
+	}
+	if (fdd->inf.d88.head.protect & 0x10) {
+		attr |= 1;
+	}
+	fdd->type = DISKTYPE_D88;
+	fdd->protect = (UINT8)(attr & 1);
+	fdd->seek = fddd88_seek;
+	fdd->read = fddd88_read;
+	fdd->write = fddd88_write;
+	fdd->crc = fddd88_crc;
+#if defined(SUPPORT_DISKEXT)
+	fdd->sec = fddd88_sec;
+#endif
+	return(SUCCESS);
 
+fdst_err:
+	return(FAILURE);
+}
 
-void fdd_write_d88(void) {
+void fddd88_eject(FDDFILE fdd) {
 
-	if ((fdd_stat_d88() & 0xf3) == 3) {
-		curdata[fdc.off] = fdc.data;
-		curwrite = 1;
-	}
+	drvflush(fdd);
 }
 
 
-BYTE fdd_incoff_d88(void) {
 
-	BYTE	cmnd;
-	WORD	trk;
 
-	cmnd = (BYTE)(fdc.cmnd >> 4);
-	trk = (fdc.c << 1) + (WORD)fdc.h;
-	seeksector(fdc.drv, trk, fdc.r);
-	if ((WORD)(++fdc.off) < cursec.size) {
-		return(0);
-	}
-	fdc.off = cursec.size;
-	if (cmnd == 0x09 || cmnd == 0x0b) {
-		fdc.rreg = fdc.r + 1;						// ver0.25
-		if (seeksector(fdc.drv, trk, fdc.rreg)) {
-			fdc.r++;
-			fdc.off = 0;
-			return(0);
-		}
-	}
-	return(1);
-}
+
+
+
+
+
+
+
 
 // ---------------------------------------------------------------------------
 
+#if 0
+// ----
+
+static	_D88SEC		cursec;
+static	REG8		curdrv = (REG8)-1;
+static	UINT		curtrk = (UINT)-1;
+static	BYTE		curtype = 0;
+static	UINT		cursct = (UINT)-1;
+static	long		curfp = 0;
+static	UINT		cursize = 0;
+static	BYTE		curwrite = 0;
+static	BYTE		curtrkerr = 0;
+static	BYTE		hole = 0;
+static	BYTE		*curdata;
+// static	UINT		crcnum = 0;
+// static	BYTE		crcerror = FALSE;
+
+extern	WORD		readdiag;
+
+#define		TAO_MODE_GAP	0x4e
+#define		TAO_MODE_SYNC	0x00
+#define		TAO_MODE_AM		0xf5
+#define		TAO_MODE_IM		0xf6
+#define		TAO_MODE_ID		0xfe
+#define		TAO_MODE_DATA	0xfb
+#define		TAO_ENDOFDATA	0xf7
+
+#define		TAO_CMD_GAP		0x4e
+#define		TAO_CMD_SYNC	0x00
+#define		TAO_CMD_IM_IN	0xf6
+#define		TAO_CMD_IM		0xfc
+#define		TAO_CMD_AM_IN	0xf5
+#define		TAO_CMD_IAM		0xfe
+#define		TAO_CMD_DAM		0xfb
+#define		TAO_CMD_DDAM	0xf8
+#define		TAO_CMD_CRC		0xf7
+
+typedef struct {
+	BYTE	mode;
+	BYTE	flag;
+	WORD	cnt;
+	WORD	size;
+	WORD	ptr;
+	WORD	top;
+	WORD	gap;
+	BYTE	sector;
+	WORD	lostdatacnt;
+	BYTE	maxsector;
+	WORD	maxsize;
+} WID_PARA;
+
+#define LOSTDATA_COUNT	256
+
+static	WID_PARA WID_2D	= {TAO_ENDOFDATA, 3, 0, 0, 0, 0, 0, 0, 0, 33, 0x1f80};
+static	WID_PARA WID_2HD= {TAO_ENDOFDATA, 3, 0, 0, 0, 0, 0, 0, 0, 55, 0x2f80};
+static	WID_PARA WID_ERR= {TAO_ENDOFDATA, 4, 0, 0, 0, 0, 0, 0, 0,  0, 0x0000};
+static	WID_PARA tao	= {TAO_ENDOFDATA, 4, 0, 0, 0, 0, 0, 0, 0,  0, 0x0000};
+
+static	BYTE		D88_BUF[0x4000];
+static	BYTE		TAO_BUF[0x3000];
+
+
+// ----
+
 void init_tao_d88(void) {
 
-	if ((fdc.media == 0) && (d88head[fdc.drv].fd_type != 0x20)) {
+	FDDFILE		fdd;
+
+	fdd = fddfile + fdc.s.drv;
+	if (fdc.s.media != (fdd->inf.d88.head.fd_type >> 4)) {
+		tao = WID_ERR;
+	}
+	if (fdc.s.media == DISKTYPE_2D) {
 		tao = WID_2D;
 	}
-	else if ((fdc.media == 1) && (d88head[fdc.drv].fd_type == 0x20)) {
+	else if (fdc.s.media == DISKTYPE_2HD) {
 		tao = WID_2HD;
 	}
 	else {
@@ -408,56 +474,56 @@ void init_tao_d88(void) {
 	}
 }
 
-int fileappend(FILEH hdr, D88_HEADER *head,
-									long ptr, long last, long apsize) {
+static int fileappend(FILEH hdl, FDDFILE fdd,
+									UINT32 ptr, long last, long apsize) {
 
 	long	length;
-	WORD	size;
-	WORD	rsize;
-	int		t;
-	long	*trkp;
+	UINT	size;
+	UINT	rsize;
+	UINT	t;
+	BYTE	tmp[0x400];
+	UINT32	cur;
 
-	if ((length = last - ptr) <= 0) {			// 書き換える必要なし
+	length = last - ptr;
+	if (length <= 0) {							// 書き換える必要なし
 		return(0);
 	}
 	while(length) {
-		if (length >= 0x4000) {
-			size = 0x4000;
+		if (length >= (long)(sizeof(tmp))) {
+			size = sizeof(tmp);
 		}
 		else {
-			size = (WORD)length;
+			size = length;
 		}
-		length -= (long)size;
-		file_seek(hdr, ptr+length, 0);
-		rsize = file_read(hdr, D88_BUF, size);
-		file_seek(hdr, ptr+length+apsize, 0);
-		file_write(hdr, D88_BUF, rsize);
+		length -= size;
+		file_seek(hdl, ptr + length, FSEEK_SET);
+		rsize = file_read(hdl, tmp, size);
+		file_seek(hdl, ptr + length + apsize, FSEEK_SET);
+		file_write(hdl, tmp, rsize);
 	}
-
-	trkp = head->trackp;
-	for (t=0; t<164; t++, trkp++) {
-		if ((*trkp) && (*trkp >= ptr)) {
-			(*trkp) += apsize;
+	for (t=0; t<164; t++) {
+		cur = fdd->inf.d88.ptr[t];
+		if ((cur) && (cur >= ptr)) {
+			fdd->inf.d88.ptr[t] = cur + apsize;
 		}
 	}
 	return(0);
 }
 
+static void endoftrack(void) {
 
-
-void endoftrack(void) {
-
-	FDDFILE		fdd;
-	FILEH		hdr;
-	int			i;
-	WORD		trk;
-	D88_HEADER	*head;
-	long		fpointer;
-	long		endpointer;
-	long		lastpointer;
-	long		trksize;
-	int			ptr;
-	long		apsize;
+	FDDFILE	fdd;
+	FILEH	hdr;
+	int		i;
+	UINT	trk;
+	long	fpointer;
+	long	endpointer;
+	long	lastpointer;
+	long	trksize;
+	long	apsize;
+	D88SEC	p;
+	UINT	secsize;
+	UINT8	ptr[D88_TRACKMAX][4];
 
 	if (!tao.sector) {
 		tao.flag = 4;
@@ -466,58 +532,64 @@ void endoftrack(void) {
 	tao.flag = 0;
 
 	curdataflush();						// write cache flush &
-	curdrv = -1;						// use D88_BUF[] for temp
+	curdrv = (REG8)-1;					// use D88_BUF[] for temp
 
-	head = &d88head[fdc.drv];
-	trk = (fdc.c << 1) + (WORD)fdc.h;
+	fdd = fddfile + fdc.s.drv;
+	trk = (fdc.s.c << 1) + fdc.s.h;
 
-	ptr = 0;
+	p = (D88SEC)TAO_BUF;
 	for (i=0; i<(int)tao.sector; i++) {
-		((D88_SECTOR *)&TAO_BUF[ptr])->sectors = tao.sector;
-		ptr += ((D88_SECTOR *)&TAO_BUF[ptr])->size + 16;
+		STOREINTELWORD(p->sectors, tao.sector);
+		secsize = LOADINTELWORD(p->size);
+		p = (D88SEC)(((UINT8 *)(p + 1)) + secsize);
 	}
 
-	fdd = fddfile + fdc.drv;
 	if ((hdr = file_open(fdd->fname)) == FILEH_INVALID) {
 		return;
 	}
 	lastpointer = file_seek(hdr, 0, 2);
-	if ((fpointer = head->trackp[trk]) == 0) {
-		fpointer = 0;								// 新規トラック
-		for (i=trk; i>=0; i--) {
-			if (head->trackp[i]) {
-				fpointer = head->trackp[i];
+	fpointer = fdd->inf.d88.ptr[trk];
+	if (fpointer == 0) {
+		for (i=trk; i>=0; i--) {					// 新規トラック
+			fpointer = fdd->inf.d88.ptr[i];
+			if (fpointer) {
 				break;
 			}
 		}
 		if (fpointer) {								// ヒットした
-			fpointer = nexttrackp(head, fpointer, lastpointer);
+			fpointer = nexttrackptr(fdd, fpointer, lastpointer);
 		}
 		else {
-			fpointer = sizeof(D88_HEADER);
+			fpointer = D88_HEADERSIZE;
 		}
 		endpointer = fpointer;
 	}
 	else {										// トラックデータは既にある
-		endpointer = nexttrackp(head, fpointer, lastpointer);
+		endpointer = nexttrackptr(fdd, fpointer, lastpointer);
 	}
 	trksize = endpointer - fpointer;
 	if ((apsize = (long)tao.size - trksize) > 0) {
 								// 書き込むデータのほーが大きい
-		fileappend(hdr, head, endpointer, lastpointer, apsize);
-		head->fd_size += apsize;
+		fileappend(hdr, fdd, endpointer, lastpointer, apsize);
+		fdd->inf.d88.fd_size += apsize;
 	}
-	head->trackp[trk] = fpointer;
-	file_seek(hdr, fpointer, 0);
+	STOREINTELDWORD(fdd->inf.d88.head.fd_size, fdd->inf.d88.fd_size);
+	fdd->inf.d88.ptr[trk] = fpointer;
+	for (i=0; i<D88_TRACKMAX; i++) {
+		STOREINTELDWORD(ptr[i], fdd->inf.d88.ptr[i]);
+	}
+	file_seek(hdr, 0, FSEEK_SET);
+	file_write(hdr, &fdd->inf.d88.head, sizeof(fdd->inf.d88.head));
+	file_write(hdr, ptr, sizeof(ptr));
+	file_seek(hdr, fpointer, FSEEK_SET);
 	file_write(hdr, TAO_BUF, tao.size);
-	file_seek(hdr, 0, 0);
-	file_write(hdr, head, sizeof(D88_HEADER));
 	file_close(hdr);
 }
 
-
 void fdd_wtao_d88(BYTE data) {
 
+	D88SEC	p;
+
 	if (tao.flag != 3) {
 		return;
 	}
@@ -534,6 +606,7 @@ void fdd_wtao_d88(BYTE data) {
 				tao.gap = 0;
 			}
 			break;
+
 		case TAO_MODE_GAP:
 			if (data == TAO_MODE_GAP) {
 				if (tao.gap++ > 256) {
@@ -552,6 +625,7 @@ void fdd_wtao_d88(BYTE data) {
 				tao.flag = 4;
 			}
 			break;
+
 		case TAO_MODE_SYNC:
 //			tao.cnt--;								// ver0.26 Zeliard
 			if (data == TAO_CMD_AM_IN) {
@@ -564,6 +638,7 @@ void fdd_wtao_d88(BYTE data) {
 				tao.flag = 4;
 			}
 			break;
+
 		case TAO_MODE_IM:
 			if (data == TAO_CMD_IM) {
 				tao.mode = TAO_ENDOFDATA;
@@ -572,6 +647,7 @@ void fdd_wtao_d88(BYTE data) {
 				tao.flag = 4;
 			}
 			break;
+
 		case TAO_MODE_AM:
 			if (data == TAO_CMD_IAM) {
 				tao.mode = TAO_MODE_ID;
@@ -585,9 +661,11 @@ void fdd_wtao_d88(BYTE data) {
 			else if (data == TAO_CMD_DDAM) {
 				tao.mode = TAO_MODE_DATA;
 				tao.ptr = 0;
-				((D88_SECTOR *)&TAO_BUF[tao.top])->del_flg = 1;
+				p = (D88SEC)(TAO_BUF + tao.top);
+				p->del_flg = 1;
 			}
 			break;
+
 		case TAO_MODE_ID:
 			if ((data == TAO_CMD_IAM) && (!tao.ptr)) {
 				break;
@@ -598,10 +676,11 @@ void fdd_wtao_d88(BYTE data) {
 			}
 			else if (data == TAO_CMD_CRC) {
 				tao.mode = TAO_ENDOFDATA;
-				ZeroMemory(&TAO_BUF[tao.size], 12);
+				ZeroMemory(TAO_BUF + tao.size, 12);
 				tao.size += 12;
 			}
 			break;
+
 		case TAO_MODE_DATA:						// DATA WRITE
 			if ((!tao.ptr) &&
 				((data == TAO_CMD_DAM) || (data == TAO_CMD_DDAM))) {
@@ -609,7 +688,8 @@ void fdd_wtao_d88(BYTE data) {
 			}
 			else if (data == TAO_CMD_CRC) {			// nで判定した方が無難か？
 				tao.mode = TAO_ENDOFDATA;
-				((D88_SECTOR *)&TAO_BUF[tao.top])->size = tao.ptr;
+				p = (D88SEC)(TAO_BUF + tao.top);
+				STOREINTELWORD(p->size, tao.ptr);
 				if (tao.sector++ > tao.maxsector) {
 					tao.flag = 4;
 				}
@@ -621,51 +701,5 @@ void fdd_wtao_d88(BYTE data) {
 			break;
 	}
 }
-
-
-// ----
-
-BRESULT fddd88_eject(REG8 drv) {
-
-	FDDFILE	fdd;
-
-	drvflush(drv);
-	fdd = fddfile + drv;
-	ZeroMemory(&d88head[drv], sizeof(D88_HEADER));
-	fdd->fname[0] = '\0';
-	DISKNUM[drv] = 0;
-	return(SUCCESS);
-}
-
-BRESULT fddd88_set(REG8 drv, const OEMCHAR *fname) {
-
-	FDDFILE	fdd;
-	short	attr;
-	FILEH	fh;
-	UINT	rsize;
-
-	fdd = fddfile + drv;
-	attr = file_attr(fname);
-	if (attr & 0x18) {
-		goto fdst_err;
-	}
-	fh = file_open(fname);
-	if (fh == FILEH_INVALID) {
-		goto fdst_err;
-	}
-	rsize = file_read(fh, &d88head[drv], sizeof(D88_HEADER));
-	file_close(fh);
-	if (rsize != sizeof(D88_HEADER)) {
-		goto fdst_err;
-	}
-	if (attr & 1) {
-		d88head[drv].protect |= (WORD)0x10;
-	}
-	milstr_ncpy(fdd->fname, fname, NELEMENTS(fdd->fname));
-	DISKNUM[drv] = 1;
-	return(SUCCESS);
-
-fdst_err:
-	return(FAILURE);
-}
+#endif