--- np2/cbus/ideio.c	2004/03/22 05:38:47	1.2
+++ np2/cbus/ideio.c	2005/02/12 12:40:38	1.9
@@ -1,6 +1,6 @@
 #include	"compiler.h"
 
-// winでidentifyまでは取得に行くんだけどな…
+// winでidentifyまでは取得に行くんだけどな…ってAnex86も同じか
 
 #if defined(SUPPORT_IDEIO)
 
@@ -33,25 +33,27 @@ static IDEDEV getidedev(void) {
 static IDEDRV getidedrv(void) {
 
 	IDEDEV	dev;
+	IDEDRV	drv;
 
 	dev = getidedev();
 	if (dev) {
-		return(dev->drv + dev->drivesel);
-	}
-	else {
-		return(NULL);
+		drv = dev->drv + dev->drivesel;
+		if (drv->device != IDETYPE_NONE) {
+			return(drv);
+		}
 	}
+	return(NULL);
 }
 
 static const char serial[] = "824919341192        ";
 static const char firm[] = "A5U.1200";
 static const char model[] = "QUANTUM FIREBALL CR                     ";
 
-static BOOL setidentify(IDEDRV drv) {
+static BRESULT setidentify(IDEDRV drv) {
 
 	SXSIDEV sxsi;
 	UINT16	tmp[256];
-	BYTE	*p;
+	UINT8	*p;
 	UINT	i;
 	UINT32	size;
 
@@ -62,17 +64,14 @@ static BOOL setidentify(IDEDRV drv) {
 
 	ZeroMemory(tmp, sizeof(tmp));
 	// とりあえず使ってる部分だけ
-	tmp[0] = 0x045a;
+	tmp[0] = 0x0040;
 	tmp[1] = sxsi->cylinders;
 	tmp[3] = sxsi->surfaces;
 	tmp[4] = sxsi->sectors * 512;
-//	tmp[5] = 0;					// ???
 	tmp[6] = sxsi->sectors;
 	for (i=0; i<10; i++) {
 		tmp[10+i] = (serial[i*2] << 8) + serial[i*2+1];
 	}
-	tmp[20] = 3;
-	tmp[21] = 16;
 	tmp[22] = 4;
 	for (i=0; i<4; i++) {
 		tmp[23+i] = (firm[i*2] << 8) + firm[i*2+1];
@@ -80,32 +79,36 @@ static BOOL setidentify(IDEDRV drv) {
 	for (i=0; i<20; i++) {
 		tmp[27+i] = (model[i*2] << 8) + model[i*2+1];
 	}
-//	tmp[47] = 0;				// multiple
-	tmp[49] = 0x0f00;
-	tmp[50] = 0x4000;
+#if IDEIO_MULTIPLE_MAX > 0
+	tmp[47] = 0x8000 | IDEIO_MULTIPLE_MAX;	// multiple
+#endif
+	tmp[49] = 0x0000;			// LBA(1 << 9)
 	tmp[51] = 0x0200;
-	tmp[52] = 0x0200;
-	tmp[53] = 0x0007;
+	tmp[53] = 0x0001;
 	tmp[54] = sxsi->cylinders;
 	tmp[55] = sxsi->surfaces;
 	tmp[56] = sxsi->sectors;
 	size = sxsi->cylinders * sxsi->surfaces * sxsi->sectors;
 	tmp[57] = (UINT16)size;
 	tmp[58] = (UINT16)(size >> 16);
-//	tmp[59] = 0;
+#if IDEIO_MULTIPLE_MAX > 0
+	tmp[59] = 0x0100 | drv->mulmode;	// current multiple mode
+#endif
 	tmp[60] = (UINT16)size;
 	tmp[61] = (UINT16)(size >> 16);
-	tmp[63] = 0x0407;
+	tmp[63] = 0x0000;			// no support multiword DMA
 
-	tmp[80] = 0x001e;
-	tmp[81] = 0x0011;
+	tmp[80] = 0x0006;			// only support ATA-1/2
+	tmp[81] = 0;
+	tmp[82] = 0x0000;			// DEVICE RESET(1 << 9)
 
 	p = drv->buf;
 	for (i=0; i<256; i++) {
-		p[0] = (BYTE)tmp[i];
-		p[1] = (BYTE)(tmp[i] >> 8);
+		p[0] = (UINT8)tmp[i];
+		p[1] = (UINT8)(tmp[i] >> 8);
 		p += 2;
 	}
+	drv->bufdir = IDEDIR_IN;
 	drv->bufpos = 0;
 	drv->bufsize = 512;
 	return(SUCCESS);
@@ -113,16 +116,19 @@ static BOOL setidentify(IDEDRV drv) {
 
 static void setintr(IDEDRV drv) {
 
-	ideio.bank[0] = ideio.bank[1] | 0x80;			// ????
-	pic_setirq(IDE_IRQ);
+	if (!(drv->ctrl & IDECTRL_NIEN)) {
+		TRACEOUT(("ideio: setintr()"));
+		ideio.bank[0] = ideio.bank[1] | 0x80;			// ????
+		pic_setirq(IDE_IRQ);
+	}
 }
 
 static void cmdabort(IDEDRV drv) {
 
+	TRACEOUT(("ideio: cmdabort()"));
 	drv->status = IDESTAT_DRDY | IDESTAT_ERR;
 	drv->error = IDEERR_ABRT;
-	ideio.bank[0] = ideio.bank[1] | 0x80;			// ????
-	pic_setirq(IDE_IRQ);
+	setintr(drv);
 }
 
 static void panic(const char *str, ...) {
@@ -143,36 +149,50 @@ static void panic(const char *str, ...) 
 
 static void incsec(IDEDRV drv) {
 
-	if (drv->dr & IDEDEV_LBA) {
-		TRACEOUT(("ideio: incsec() LBA mode?"));
-		return;
-	}
-	drv->sn++;
-	if (drv->sn <= drv->sectors) {
-		return;
+	if (!(drv->dr & IDEDEV_LBA)) {
+		drv->sn++;
+		if (drv->sn <= drv->sectors) {
+			return;
+		}
+		drv->sn = 1;
+		drv->hd++;
+		if (drv->hd < drv->surfaces) {
+			return;
+		}
+		drv->hd = 0;
+		drv->cy++;
 	}
-	drv->sn = 1;
-	drv->hd++;
-	if (drv->hd < drv->surfaces) {
-		return;
+	else {
+		TRACEOUT(("ideio: incsec() LBA mode?"));
+		drv->sn++;
+		if (drv->sn) {
+			return;
+		}
+		drv->cy++;
+		if (drv->cy) {
+			return;
+		}
+		drv->hd++;
 	}
-	drv->hd = 0;
-	drv->cy++;
 }
 
-static long getcursec(const _IDEDRV *drv) {
+static long getcursec(const IDEDRV drv) {
 
 	long	ret;
 
-	if (drv->dr & IDEDEV_LBA) {
+	if (!(drv->dr & IDEDEV_LBA)) {
+		ret = drv->cy;
+		ret *= drv->surfaces;
+		ret += drv->hd;
+		ret *= drv->sectors;
+		ret += (drv->sn - 1);
+	}
+	else {
 		TRACEOUT(("ideio: getcursec() LBA mode?"));
-		return(-1);
+		ret = drv->sn;
+		ret |= (drv->cy << 8);
+		ret |= (drv->hd << 24);
 	}
-	ret = drv->cy;
-	ret *= drv->surfaces;
-	ret += drv->hd;
-	ret *= drv->sectors;
-	ret += (drv->sn - 1);
 	return(ret);
 }
 
@@ -184,18 +204,22 @@ static void readsec(IDEDRV drv) {
 		goto read_err;
 	}
 	sec = getcursec(drv);
-	TRACEOUT(("readsec->drv %d sec %x", drv->sxsidrv, sec));
+	TRACEOUT(("readsec->drv %d sec %x cnt %d thr %d",
+								drv->sxsidrv, sec, drv->mulcnt, drv->multhr));
 	if (sxsi_read(drv->sxsidrv, sec, drv->buf, 512)) {
-		TRACEOUT(("readerror!"));
+		TRACEOUT(("read error!"));
 		goto read_err;
 	}
 	drv->bufdir = IDEDIR_IN;
 	drv->bufpos = 0;
 	drv->bufsize = 512;
 
-	drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;
-	drv->error = 0;
-	setintr(drv);
+	if ((drv->mulcnt & (drv->multhr - 1)) == 0) {
+		drv->status = IDESTAT_DRDY | IDESTAT_DSC | IDESTAT_DRQ;
+		drv->error = 0;
+		setintr(drv);
+	}
+	drv->mulcnt++;
 	return;
 
 read_err:
@@ -239,17 +263,20 @@ static void IOOUTCALL ideio_o642(UINT po
 		drv->wp = dat;
 		TRACEOUT(("ideio set WP %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o644(UINT port, REG8 dat) {
 
 	IDEDRV	drv;
 
+	(void)port;
 	drv = getidedrv();
 	if (drv) {
 		drv->sc = dat;
 		TRACEOUT(("ideio set SC %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o646(UINT port, REG8 dat) {
@@ -261,6 +288,7 @@ static void IOOUTCALL ideio_o646(UINT po
 		drv->sn = dat;
 		TRACEOUT(("ideio set SN %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o648(UINT port, REG8 dat) {
@@ -273,6 +301,7 @@ static void IOOUTCALL ideio_o648(UINT po
 		drv->cy |= dat;
 		TRACEOUT(("ideio set CYL %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o64a(UINT port, REG8 dat) {
@@ -285,6 +314,7 @@ static void IOOUTCALL ideio_o64a(UINT po
 		drv->cy |= dat << 8;
 		TRACEOUT(("ideio set CYH %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o64c(UINT port, REG8 dat) {
@@ -306,11 +336,48 @@ static void IOOUTCALL ideio_o64c(UINT po
 	dev->drv[drvnum].dr = dat & 0xf0;
 	dev->drv[drvnum].hd = dat & 0x0f;
 	TRACEOUT(("ideio set DRHD %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o64e(UINT port, REG8 dat) {
 
 	IDEDRV	drv;
+	IDEDEV	dev;
+
+	// execute device diagnostic
+	if (dat == 0x90) {
+		TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
+		TRACEOUT(("ideio: execute device diagnostic"));
+		dev = getidedev();
+		if (dev) {
+			IDEDRV d;
+			int i;
+
+			for (i = 0; i < 2; i++) {
+				d = dev->drv + i;
+				d->hd = 0x00;
+				d->sc = 0x01;
+				d->sn = 0x01;
+				d->cy = 0x0000;
+				d->status = IDESTAT_DRDY;
+				d->error = 0x01;
+				if (i == 0) {
+					if (dev->drv[0].device == IDETYPE_NONE) {
+						d->error = 0x00;
+					}
+					if (dev->drv[1].device == IDETYPE_NONE) {
+						d->error |= 0x80;
+					}
+				}
+				else {
+					if (dev->drv[1].device == IDETYPE_NONE) {
+						d->error = 0x00;
+					}
+				}
+			}
+		}
+		return;
+	}
 
 	drv = getidedrv();
 	if (drv == NULL) {
@@ -319,21 +386,50 @@ static void IOOUTCALL ideio_o64e(UINT po
 	drv->cmd = dat;
 	TRACEOUT(("ideio set cmd %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
 	switch(dat) {
-		case 0x08:		// atapi reset
-			if (drv->device == IDETYPE_CDROM) {
-				drv->hd = 0;
-				drv->sc = 1;
-				drv->sn = 1;
+		case 0x08:		// device reset
+			TRACEOUT(("ideio: device reset"));
+			if (drv->device == IDETYPE_NONE) {
+				cmdabort(drv);
+				break;
+			}
+			else if (drv->device == IDETYPE_HDD) {
+				drv->hd = 0x00;
+				drv->sc = 0x01;
+				drv->sn = 0x01;
+				drv->cy = 0x0000;
+			}
+			else if (drv->device == IDETYPE_CDROM) {
+				drv->hd = 0x10;
+				drv->sc = 0x01;
+				drv->sn = 0x01;
 				drv->cy = 0xeb14;
-				drv->status = 0;
-				drv->error = 0;
 			}
+			drv->status = 0x00;
+			drv->error = 0x01;
+			dev = getidedev();
+			if (dev) {
+				if (dev->drivesel == 0) {
+					if (dev->drv[0].device == IDETYPE_NONE) {
+						drv->error = 0x00;
+					}
+					if (dev->drv[1].device == IDETYPE_NONE) {
+						drv->error |= 0x80;
+					}
+				}
+				else {
+					if (dev->drv[1].device == IDETYPE_NONE) {
+						drv->error = 0x00;
+					}
+				}
+			}
+			setintr(drv);
 			break;
 
 		case 0x10:		// calibrate
 //		case 0x11: case 0x12: case 0x13: case 0x14: case 0x15:
 //		case 0x16: case 0x17: case 0x18: case 0x19: case 0x1a:
 //		case 0x1b: case 0x1c: case 0x1d: case 0x1e: case 0x1f:
+			TRACEOUT(("ideio: calibrate"));
 			if (drv->device) {
 				drv->status = IDESTAT_DRDY | IDESTAT_DSC;
 				drv->error = 0;
@@ -347,13 +443,16 @@ static void IOOUTCALL ideio_o64e(UINT po
 
 		case 0x20:		// read (with retry)
 		case 0x21:		// read
+			TRACEOUT(("ideio: read sector"));
+			drv->mulcnt = 0;
+			drv->multhr = 1;
 			readsec(drv);
 			break;
 
 		case 0x91:		// set parameters
 			TRACEOUT(("ideio: set parameters dh=%x sec=%x",
 											drv->dr | drv->hd, drv->sc));
-			if (drv->device) {
+			if (drv->device != IDETYPE_NONE) {
 				drv->surfaces = drv->hd + 1;
 				drv->sectors = drv->sc;
 				drv->status &= ~(IDESTAT_BSY | IDESTAT_DRQ | IDESTAT_ERR);
@@ -379,6 +478,7 @@ static void IOOUTCALL ideio_o64e(UINT po
 			}
 			break;
 
+		case 0xa1:		// identify
 		case 0xec:		// identify
 			TRACEOUT(("ideio: identify"));
 			if (setidentify(drv) == SUCCESS) {
@@ -391,10 +491,45 @@ static void IOOUTCALL ideio_o64e(UINT po
 			}
 			break;
 
+		case 0xc4:		// read multiple
+#if IDEIO_MULTIPLE_MAX > 0
+			TRACEOUT(("ideio: read multiple"));
+			drv->mulcnt = 0;
+			drv->multhr = drv->mulmode;
+			readsec(drv);
+#else
+			cmdabort(drv);
+#endif
+			break;
+
+		case 0xc6:		// set multiple mode
+			TRACEOUT(("ideio: set multiple mode"));
+			switch(drv->sc) {
+#if IDEIO_MULTIPLE_MAX > 0
+				case 2: case 4: case 8: case 16: case 32: case 64: case 128:
+					if (drv->sc <= IDEIO_MULTIPLE_MAX) {
+						drv->mulmode = drv->sc;
+						setintr(drv);
+						break;
+					}
+					/*FALLTHROUGH*/
+#endif
+				default:
+					cmdabort(drv);
+					break;
+			}
+			break;
+
+		case 0xef:		// set features
+			TRACEOUT(("ideio: set features reg = %.2x", drv->wp));
+			cmdabort(drv);
+			break;
+
 		default:
-			panic("command:%.2x", dat);
+			panic("ideio: unknown command %.2x", dat);
 			break;
 	}
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o74c(UINT port, REG8 dat) {
@@ -427,12 +562,16 @@ static void IOOUTCALL ideio_o74c(UINT po
 			}
 		}
 	}
-	TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));
+	TRACEOUT(("ideio interrupt %sable", (dat & IDECTRL_NIEN) ? "dis" : "en"));
+	TRACEOUT(("ideio devctrl %.2x [%.4x:%.8x]", dat, CPU_CS, CPU_EIP));
+	(void)port;
 }
 
 static void IOOUTCALL ideio_o74e(UINT port, REG8 dat) {
 
 	TRACEOUT(("ideio %.4x,%.2x [%.4x:%.8x]", port, dat, CPU_CS, CPU_EIP));
+	(void)port;
+	(void)dat;
 }
 
 
@@ -442,6 +581,8 @@ static REG8 IOINPCALL ideio_i642(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		drv->status &= ~IDESTAT_ERR;
@@ -458,6 +599,8 @@ static REG8 IOINPCALL ideio_i644(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		TRACEOUT(("ideio get SC %.2x [%.4x:%.8x]", drv->sc, CPU_CS, CPU_EIP));
@@ -472,6 +615,8 @@ static REG8 IOINPCALL ideio_i646(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		TRACEOUT(("ideio get SN %.2x [%.4x:%.8x]", drv->sn, CPU_CS, CPU_EIP));
@@ -486,6 +631,8 @@ static REG8 IOINPCALL ideio_i648(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		TRACEOUT(("ideio get CYL %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
@@ -500,6 +647,8 @@ static REG8 IOINPCALL ideio_i64a(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		TRACEOUT(("ideio get CYH %.4x [%.4x:%.8x]", drv->cy, CPU_CS, CPU_EIP));
@@ -515,6 +664,8 @@ static REG8 IOINPCALL ideio_i64c(UINT po
 	IDEDRV	drv;
 	REG8	ret;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		ret = drv->dr | drv->hd;
@@ -530,10 +681,16 @@ static REG8 IOINPCALL ideio_i64e(UINT po
 
 	IDEDRV	drv;
 
+	(void)port;
+
 	drv = getidedrv();
 	if (drv) {
 		TRACEOUT(("ideio status %.2x [%.4x:%.8x]",
 											drv->status, CPU_CS, CPU_EIP));
+		if (!(drv->ctrl & IDECTRL_NIEN)) {
+			TRACEOUT(("ideio: resetirq"));
+			pic_resetirq(IDE_IRQ);
+		}
 		return(drv->status);
 	}
 	else {
@@ -543,8 +700,19 @@ static REG8 IOINPCALL ideio_i64e(UINT po
 
 static REG8 IOINPCALL ideio_i74c(UINT port) {
 
-	TRACEOUT(("ideio %.4x [%.4x:%.8x]", port, CPU_CS, CPU_EIP));
-	return(0xff);
+	IDEDRV	drv;
+
+	(void)port;
+
+	drv = getidedrv();
+	if (drv) {
+		TRACEOUT(("ideio alt status %.2x [%.4x:%.8x]",
+											drv->status, CPU_CS, CPU_EIP));
+		return(drv->status);
+	}
+	else {
+		return(0xff);
+	}
 }
 
 
@@ -553,14 +721,14 @@ static REG8 IOINPCALL ideio_i74c(UINT po
 void IOOUTCALL ideio_w16(UINT port, REG16 value) {
 
 	IDEDRV	drv;
-	BYTE	*p;
+	UINT8	*p;
 
 	drv = getidedrv();
 	if ((drv != NULL) &&
 		(drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_OUT)) {
 		p = drv->buf + drv->bufpos;
-		p[0] = (BYTE)value;
-		p[1] = (BYTE)(value >> 8);
+		p[0] = (UINT8)value;
+		p[1] = (UINT8)(value >> 8);
 		TRACEOUT(("ide-data send %4x (%.4x) [%.4x:%.8x]",
 										value, drv->bufpos, CPU_CS, CPU_EIP));
 		drv->bufpos += 2;
@@ -573,13 +741,16 @@ void IOOUTCALL ideio_w16(UINT port, REG1
 			}
 		}
 	}
+	(void)port;
 }
 
-REG16 IOOUTCALL ideio_r16(UINT port) {
+REG16 IOINPCALL ideio_r16(UINT port) {
 
 	IDEDRV	drv;
 	REG16	ret;
-	BYTE	*p;
+	UINT8	*p;
+
+	(void)port;
 
 	drv = getidedrv();
 	if (drv == NULL) {
@@ -589,7 +760,7 @@ REG16 IOOUTCALL ideio_r16(UINT port) {
 	if ((drv->status & IDESTAT_DRQ) && (drv->bufdir == IDEDIR_IN)) {
 		p = drv->buf + drv->bufpos;
 		ret = p[0] + (p[1] << 8);
-		TRACEOUT(("ide-data recv %4x (%.4x) [%.4x:%.8x]",
+		TRACEOUT(("ide-data recv %.4x (%.4x) [%.4x:%.8x]",
 										ret, drv->bufpos, CPU_CS, CPU_EIP));
 		drv->bufpos += 2;
 		if (drv->bufpos >= drv->bufsize) {
@@ -597,6 +768,7 @@ REG16 IOOUTCALL ideio_r16(UINT port) {
 			switch(drv->cmd) {
 				case 0x20:
 				case 0x21:
+				case 0xc4:
 					incsec(drv);
 					drv->sc--;
 					if (drv->sc) {
@@ -633,10 +805,12 @@ static void devinit(IDEDRV drv, REG8 sxs
 		drv->device = IDETYPE_HDD;
 		drv->surfaces = sxsi->surfaces;
 		drv->sectors = sxsi->sectors;
+		drv->mulmode = 1;
 	}
 	else {
 		drv->status = IDESTAT_ERR;
 		drv->error = IDEERR_TR0;
+		drv->device = IDETYPE_NONE;
 	}
 }
 
@@ -706,5 +880,5 @@ void ideio_bind(void) {
 		iocore_attachinp(0x074c, ideio_i74c);
 	}
 }
-#endif
 
+#endif	/* SUPPORT_IDEIO */