--- np2/i386c/memory.c	2004/03/02 16:31:21	1.12
+++ np2/i386c/memory.c	2004/03/10 23:01:08	1.19
@@ -796,12 +796,11 @@ REG8 MEMCALL i286_memoryread(UINT32 addr
 
 	UINT32	pos;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < I286_MEMREADMAX) {
 		return(mem[addr]);
 	}
 	else if (addr >= USE_HIMEM) {
-		pos = addr - 0x100000;
+		pos = (addr & CPU_ADRSMASK) - 0x100000;
 		if (pos < CPU_EXTMEMSIZE) {
 			return(CPU_EXTMEM[pos]);
 		}
@@ -814,6 +813,7 @@ REG8 MEMCALL i286_memoryread(UINT32 addr
 		}
 #endif
 		else {
+//			TRACEOUT(("out of mem (read8): %x", addr));
 			return(0xff);
 		}
 	}
@@ -827,13 +827,12 @@ REG16 MEMCALL i286_memoryread_w(UINT32 a
 	UINT32	pos;
 	REG16	ret;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < (I286_MEMREADMAX - 1)) {
 		return(LOADINTELWORD(mem + addr));
 	}
 	else if ((addr + 1) & 0x7fff) {				// non 32kb boundary
 		if (addr >= USE_HIMEM) {
-			pos = addr - 0x100000;
+			pos = (addr & CPU_ADRSMASK) - 0x100000;
 			if (pos < CPU_EXTMEMSIZE) {
 				return(LOADINTELWORD(CPU_EXTMEM + pos));
 			}
@@ -846,6 +845,7 @@ REG16 MEMCALL i286_memoryread_w(UINT32 a
 			}
 #endif
 			else {
+//				TRACEOUT(("out of mem (read16): %x", addr));
 				return(0xffff);
 			}
 		}
@@ -863,12 +863,11 @@ UINT32 MEMCALL i286_memoryread_d(UINT32 
 	UINT32	pos;
 	UINT32	ret;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < (I286_MEMREADMAX - 3)) {
 		return(LOADINTELDWORD(mem + addr));
 	}
 	else if (addr >= USE_HIMEM) {
-		pos = addr - 0x100000;
+		pos = (addr & CPU_ADRSMASK) - 0x100000;
 		if ((pos + 3) < CPU_EXTMEMSIZE) {
 			return(LOADINTELDWORD(CPU_EXTMEM + pos));
 		}
@@ -889,12 +888,11 @@ void MEMCALL i286_memorywrite(UINT32 add
 
 	UINT32	pos;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < I286_MEMWRITEMAX) {
 		mem[addr] = (BYTE)value;
 	}
 	else if (addr >= USE_HIMEM) {
-		pos = addr - 0x100000;
+		pos = (addr & CPU_ADRSMASK) - 0x100000;
 		if (pos < CPU_EXTMEMSIZE) {
 			CPU_EXTMEM[pos] = (BYTE)value;
 		}
@@ -907,7 +905,7 @@ void MEMCALL i286_memorywrite(UINT32 add
 		}
 #endif
 		else {
-			TRACEOUT(("mem_w %x %x", addr, value));
+//			TRACEOUT(("out of mem (write8): %x", addr));
 		}
 	}
 	else {
@@ -919,13 +917,12 @@ void MEMCALL i286_memorywrite_w(UINT32 a
 
 	UINT32	pos;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < (I286_MEMWRITEMAX - 1)) {
 		STOREINTELWORD(mem + addr, value);
 	}
 	else if ((addr + 1) & 0x7fff) {				// non 32kb boundary
 		if (addr >= USE_HIMEM) {
-			pos = addr - 0x100000;
+			pos = (addr & CPU_ADRSMASK) - 0x100000;
 			if (pos < CPU_EXTMEMSIZE) {
 				STOREINTELWORD(CPU_EXTMEM + pos, value);
 			}
@@ -937,6 +934,9 @@ void MEMCALL i286_memorywrite_w(UINT32 a
 				mem9821_ww(addr, value);
 			}
 #endif
+			else {
+//				TRACEOUT(("out of mem (write16): %x", addr));
+			}
 		}
 		else {
 			memfn.wr16[(addr >> 15) & 0x1f](addr, value);
@@ -952,13 +952,12 @@ void MEMCALL i286_memorywrite_d(UINT32 a
 
 	UINT32	pos;
 
-	addr &= CPU_ADRSMASK;
 	if (addr < (I286_MEMWRITEMAX - 3)) {
 		STOREINTELDWORD(mem + addr, value);
 		return;
 	}
 	else if (addr >= USE_HIMEM) {
-		pos = addr - 0x100000;
+		pos = (addr & CPU_ADRSMASK) - 0x100000;
 		if ((pos + 3) < CPU_EXTMEMSIZE) {
 			STOREINTELDWORD(CPU_EXTMEM + pos, value);
 			return;
@@ -975,7 +974,7 @@ void MEMCALL i286_memorywrite_d(UINT32 a
 	}
 }
 
-#ifdef NP2_MEMORY_ASM
+#if 0
 REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {
 
 	UINT32	address;
@@ -1027,121 +1026,234 @@ void MEMCALL i286_memword_write(UINT seg
 		i286_memorywrite_w(address, value);
 	}
 }
-#endif /* NP2_MEMORY_ASM */
+#endif
 
-void MEMCALL i286_memstr_read(UINT seg, UINT off, void *dat, UINT leng) {
+void MEMCALL memp_read(UINT32 address, void *dat, UINT leng) {
 
-	BYTE	*out;
-	UINT32	adrs;
-	UINT	size;
+	BYTE *out = (BYTE *)dat;
+	UINT pos;
+	UINT diff;
 
-	out = (BYTE *)dat;
-	adrs = seg << 4;
-	off = LOW16(off);
-	if ((I286_MEMREADMAX >= 0x10000) &&
-		(adrs < (I286_MEMREADMAX - 0x10000))) {
-		if (leng) {
-			size = 0x10000 - off;
-			if (size >= leng) {
-				CopyMemory(out, mem + adrs + off, leng);
-				return;
-			}
-			CopyMemory(out, mem + adrs + off, size);
-			out += size;
-			leng -= size;
-		}
-		while(leng >= 0x10000) {
-			CopyMemory(out, mem + adrs, 0x10000);
-			out += 0x10000;
-			leng -= 0x10000;
+	/* fast memory access */
+	if (address + leng < I286_MEMREADMAX) {
+		CopyMemory(dat, mem + address, leng);
+		return;
+	} else if (address >= USE_HIMEM) {
+		pos = (address & CPU_ADRSMASK) - 0x100000;
+		if (pos + leng < CPU_EXTMEMSIZE) {
+			CopyMemory(dat, CPU_EXTMEM + pos, leng);
+			return;
 		}
-		if (leng) {
-			CopyMemory(out, mem + adrs, leng);
+		if (pos < CPU_EXTMEMSIZE) {
+			diff = CPU_EXTMEMSIZE - pos;
+			CopyMemory(out, CPU_EXTMEM + pos, diff);
+			out += diff;
+			leng -= diff;
+			address += diff;
 		}
 	}
-	else {
-		while(leng--) {
-			*out++ = i286_memoryread(adrs + off);
-			off = LOW16(off + 1);
+
+	/* slow memory access */
+	while (leng-- > 0) {
+		*out++ = i286_memoryread(address++);
+	}
+}
+
+void MEMCALL memp_write(UINT32 address, const void *dat, UINT leng) {
+
+	const BYTE *out = (BYTE *)dat;
+	UINT pos;
+	UINT diff;
+
+	/* fast memory access */
+	if (address + leng < I286_MEMREADMAX) {
+		CopyMemory(mem + address, dat, leng);
+		return;
+	} else if (address >= USE_HIMEM) {
+		pos = (address & CPU_ADRSMASK) - 0x100000;
+		if (pos + leng < CPU_EXTMEMSIZE) {
+			CopyMemory(CPU_EXTMEM + pos, dat, leng);
+			return;
+		}
+		if (pos < CPU_EXTMEMSIZE) {
+			diff = CPU_EXTMEMSIZE - pos;
+			CopyMemory(CPU_EXTMEM + pos, dat, diff);
+			out += diff;
+			leng -= diff;
+			address += diff;
 		}
 	}
+
+	/* slow memory access */
+	while (leng-- > 0) {
+		i286_memorywrite(address++, *out++);
+	}
 }
 
-void MEMCALL i286_memstr_write(UINT seg, UINT off, const void *dat, UINT leng) {
 
-	BYTE	*out;
-	UINT32	adrs;
-	UINT	size;
+// ---- Logical Space (BIOS)
 
-	out = (BYTE *)dat;
-	adrs = seg << 4;
-	off = LOW16(off);
-	if ((I286_MEMWRITEMAX >= 0x10000) &&
-		(adrs < (I286_MEMWRITEMAX - 0x10000))) {
-		if (leng) {
-			size = 0x10000 - off;
-			if (size >= leng) {
-				CopyMemory(mem + adrs + off, out, leng);
-				return;
-			}
-			CopyMemory(mem + adrs + off, out, size);
-			out += size;
-			leng -= size;
+static UINT32 physicaladdr(UINT32 addr) {
+
+	UINT32	a;
+	UINT32	pde;
+	UINT32	pte;
+
+	if (CPU_STAT_PAGING) {
+		a = CPU_STAT_PDE_BASE + ((addr >> 20) & 0xffc);
+		pde = i286_memoryread_d(a);
+		if (!(pde & CPU_PDE_PRESENT)) {
+			goto retdummy;
 		}
-		while(leng >= 0x10000) {
-			CopyMemory(mem + adrs, out, 0x10000);
-			out += 0x10000;
-			leng -= 0x10000;
+#if 0
+		if (!(pde & CPU_PDE_ACCESS)) {
+			i286_memorywrite_d(a, pde | CPU_PDE_ACCESS);
 		}
-		if (leng) {
-			CopyMemory(mem + adrs, out, leng);
+#endif
+		a = (pde & CPU_PDE_BASEADDR_MASK) + ((addr >> 10) & 0xffc);
+		pte = cpu_memoryread_d(a);
+		if (!(pte & CPU_PTE_PRESENT)) {
+			goto retdummy;
+		}
+#if 0
+		if (!(pte & CPU_PTE_ACCESS)) {
+			i286_memorywrite_d(a, pte | CPU_PTE_ACCESS);
 		}
+#endif
+		addr = (pte & CPU_PTE_BASEADDR_MASK) + (addr & 0x00000fff);
+	}
+	return(addr);
+
+retdummy:
+	return(0x01000000);		// てきとーにメモリが存在しない場所
+}
+
+
+REG8 MEMCALL meml_read8(UINT seg, UINT off) {
+
+	UINT32	addr;
+
+	addr = (seg << 4) + LOW16(off);
+	if (CPU_STAT_PAGING) {
+		addr = physicaladdr(addr);
+	}
+	return(i286_memoryread(addr));
+}
+
+REG16 MEMCALL meml_read16(UINT seg, UINT off) {
+
+	UINT32	addr;
+
+	addr = (seg << 4) + LOW16(off);
+	if (!CPU_STAT_PAGING) {
+		return(i286_memoryread_w(addr));
+	}
+	else if ((addr + 1) & 0xfff) {
+		return(i286_memoryread_w(physicaladdr(addr)));
+	}
+	return(meml_read8(seg, off) + (meml_read8(seg, off + 1) << 8));
+}
+
+void MEMCALL meml_write8(UINT seg, UINT off, REG8 dat) {
+
+	UINT32	addr;
+
+	addr = (seg << 4) + LOW16(off);
+	if (CPU_STAT_PAGING) {
+		addr = physicaladdr(addr);
+	}
+	i286_memorywrite(addr, dat);
+}
+
+void MEMCALL meml_write16(UINT seg, UINT off, REG16 dat) {
+
+	UINT32	addr;
+
+	addr = (seg << 4) + LOW16(off);
+	if (!CPU_STAT_PAGING) {
+		i286_memorywrite_w(addr, dat);
+	}
+	else if ((addr + 1) & 0xfff) {
+		i286_memorywrite_w(physicaladdr(addr), dat);
 	}
 	else {
-		while(leng--) {
-			i286_memorywrite(adrs + off, *out++);
-			off = LOW16(off + 1);
-		}
+		meml_write8(seg, off, (REG8)dat);
+		meml_write8(seg, off + 1, (REG8)(dat >> 8));
 	}
 }
 
-void MEMCALL i286_memx_read(UINT32 address, void *dat, UINT leng) {
+void MEMCALL meml_readstr(UINT seg, UINT off, void *dat, UINT leng) {
 
-	if ((address + leng) < I286_MEMREADMAX) {
-		CopyMemory(dat, mem + address, leng);
+	UINT32	adrs;
+	UINT	size;
+
+	while(leng) {
+		off = LOW16(off);
+		adrs = (seg << 4) + off;
+		size = 0x1000 - (adrs & 0xfff);
+		size = min(size, leng);
+		size = min(size, 0x10000 - off);
+		memp_read(physicaladdr(adrs), dat, size);
+		off += size;
+		dat = ((BYTE *)dat) + size;
+		leng -= size;
+	}
+}
+
+void MEMCALL meml_writestr(UINT seg, UINT off, const void *dat, UINT leng) {
+
+	UINT32	adrs;
+	UINT	size;
+
+	while(leng) {
+		off = LOW16(off);
+		adrs = (seg << 4) + off;
+		size = 0x1000 - (adrs & 0xfff);
+		size = min(size, leng);
+		size = min(size, 0x10000 - off);
+		memp_write(physicaladdr(adrs), dat, size);
+		off += size;
+		dat = ((BYTE *)dat) + size;
+		leng -= size;
+	}
+}
+
+void MEMCALL meml_read(UINT32 address, void *dat, UINT leng) {
+
+	UINT	size;
+
+	if (!CPU_STAT_PAGING) {
+		memp_read(address, dat, leng);
 	}
 	else {
-		BYTE *out = (BYTE *)dat;
-		if (address < I286_MEMREADMAX) {
-			CopyMemory(out, mem + address, I286_MEMREADMAX - address);
-			out += I286_MEMREADMAX - address;
-			leng -= I286_MEMREADMAX - address;
-			address = I286_MEMREADMAX;
-		}
-		while(leng--) {
-			*out++ = i286_memoryread(address++);
+		while(leng) {
+			size = 0x1000 - (address & 0xfff);
+			size = min(size, leng);
+			memp_read(physicaladdr(address), dat, size);
+			address += size;
+			dat = ((BYTE *)dat) + size;
+			leng -= size;
 		}
 	}
 }
 
-void MEMCALL i286_memx_write(UINT32 address, const void *dat, UINT leng) {
+void MEMCALL meml_write(UINT32 address, const void *dat, UINT leng) {
 
-const BYTE	*out;
+	UINT	size;
 
-	if ((address + leng) < I286_MEMWRITEMAX) {
-		CopyMemory(mem + address, dat, leng);
+	if (!CPU_STAT_PAGING) {
+		memp_write(address, dat, leng);
 	}
 	else {
-		out = (BYTE *)dat;
-		if (address < I286_MEMWRITEMAX) {
-			CopyMemory(mem + address, out, I286_MEMWRITEMAX - address);
-			out += I286_MEMWRITEMAX - address;
-			leng -= I286_MEMWRITEMAX - address;
-			address = I286_MEMWRITEMAX;
-		}
-		while(leng--) {
-			i286_memorywrite(address++, *out++);
+		while(leng) {
+			size = 0x1000 - (address & 0xfff);
+			size = min(size, leng);
+			memp_write(physicaladdr(address), dat, size);
+			address += size;
+			dat = ((BYTE *)dat) + size;
+			leng -= size;
 		}
 	}
 }
 #endif
+