np2/i386c/memory.c - diff

Return to memory.c CVS log

Up to [RetroPC.NET] / np2 / i386c

Diff for /np2/i386c/memory.c between versions 1.2 and 1.12

version 1.2, 2003/12/12 01:04:40	version 1.12, 2004/03/02 16:31:21
Line 5	Line 5
#include "cpucore.h"	#include "cpucore.h"
#include "memory.h"	#include "memory.h"
#include "egcmem.h"	#include "egcmem.h"
	#include "mem9821.h"
#include "pccore.h"	#include "pccore.h"
#include "iocore.h"	#include "iocore.h"
#include "vram.h"	#include "vram.h"
Line 14	Line 15
BYTE mem[0x200000];	BYTE mem[0x200000];


#define USE_HIMEM	#define USE_HIMEM 0x110000

// ---- write byte	// ---- write byte

Line 25 static void MEMCALL i286_wt(UINT32 addre	Line 26 static void MEMCALL i286_wt(UINT32 addre

static void MEMCALL tram_wt(UINT32 address, REG8 value) {	static void MEMCALL tram_wt(UINT32 address, REG8 value) {

CPU_REMCLOCK -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa2000) {	if (address < 0xa2000) {
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
tramupdate[LOW12(address >> 1)] = 1;	tramupdate[LOW12(address >> 1)] = 1;
Line 57 static void MEMCALL tram_wt(UINT32 addre	Line 58 static void MEMCALL tram_wt(UINT32 addre

static void MEMCALL vram_w0(UINT32 address, REG8 value) {	static void MEMCALL vram_w0(UINT32 address, REG8 value) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
vramupdate[LOW15(address)] \|= 1;	vramupdate[LOW15(address)] \|= 1;
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
Line 65 static void MEMCALL vram_w0(UINT32 addre	Line 66 static void MEMCALL vram_w0(UINT32 addre

static void MEMCALL vram_w1(UINT32 address, REG8 value) {	static void MEMCALL vram_w1(UINT32 address, REG8 value) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
mem[address + VRAM_STEP] = (BYTE)value;	mem[address + VRAM_STEP] = (BYTE)value;
vramupdate[LOW15(address)] \|= 2;	vramupdate[LOW15(address)] \|= 2;
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
Line 76 static void MEMCALL grcg_rmw0(UINT32 add	Line 77 static void MEMCALL grcg_rmw0(UINT32 add
REG8 mask;	REG8 mask;
BYTE *vram;	BYTE *vram;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
mask = ~value;	mask = ~value;
address = LOW15(address);	address = LOW15(address);
vramupdate[address] \|= 1;	vramupdate[address] \|= 1;
Line 105 static void MEMCALL grcg_rmw1(UINT32 add	Line 106 static void MEMCALL grcg_rmw1(UINT32 add
REG8 mask;	REG8 mask;
BYTE *vram;	BYTE *vram;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
mask = ~value;	mask = ~value;
address = LOW15(address);	address = LOW15(address);
vramupdate[address] \|= 2;	vramupdate[address] \|= 2;
Line 133 static void MEMCALL grcg_tdw0(UINT32 add	Line 134 static void MEMCALL grcg_tdw0(UINT32 add

BYTE *vram;	BYTE *vram;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
address = LOW15(address);	address = LOW15(address);
vramupdate[address] \|= 1;	vramupdate[address] \|= 1;
gdcs.grphdisp \|= 1;	gdcs.grphdisp \|= 1;
Line 157 static void MEMCALL grcg_tdw1(UINT32 add	Line 158 static void MEMCALL grcg_tdw1(UINT32 add

BYTE *vram;	BYTE *vram;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
address = LOW15(address);	address = LOW15(address);
vramupdate[address] \|= 2;	vramupdate[address] \|= 2;
gdcs.grphdisp \|= 2;	gdcs.grphdisp \|= 2;
Line 179 static void MEMCALL grcg_tdw1(UINT32 add	Line 180 static void MEMCALL grcg_tdw1(UINT32 add

static void MEMCALL egc_wt(UINT32 address, REG8 value) {	static void MEMCALL egc_wt(UINT32 address, REG8 value) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
egc_write(address, value);	egc_write(address, value);
}	}

static void MEMCALL emmc_wt(UINT32 address, REG8 value) {	static void MEMCALL i286_wb(UINT32 address, REG8 value) {

extmem.pageptr[(address >> 14) & 3][LOW14(address)] = (BYTE)value;	mem[address + 0x1c8000 - 0xe8000] = (BYTE)value;
}	}

static void MEMCALL i286_wn(UINT32 address, REG8 value) {	static void MEMCALL i286_wn(UINT32 address, REG8 value) {
Line 203 static REG8 MEMCALL i286_rd(UINT32 addre	Line 205 static REG8 MEMCALL i286_rd(UINT32 addre

static REG8 MEMCALL tram_rd(UINT32 address) {	static REG8 MEMCALL tram_rd(UINT32 address) {

CPU_REMCLOCK -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa4000) {	if (address < 0xa4000) {
return(mem[address]);	return(mem[address]);
}	}
Line 220 static REG8 MEMCALL tram_rd(UINT32 addre	Line 222 static REG8 MEMCALL tram_rd(UINT32 addre

static REG8 MEMCALL vram_r0(UINT32 address) {	static REG8 MEMCALL vram_r0(UINT32 address) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(mem[address]);	return(mem[address]);
}	}

static REG8 MEMCALL vram_r1(UINT32 address) {	static REG8 MEMCALL vram_r1(UINT32 address) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(mem[address + VRAM_STEP]);	return(mem[address + VRAM_STEP]);
}	}

Line 235 static REG8 MEMCALL grcg_tcr0(UINT32 add	Line 237 static REG8 MEMCALL grcg_tcr0(UINT32 add
const BYTE *vram;	const BYTE *vram;
REG8 ret;	REG8 ret;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
vram = mem + LOW15(address);	vram = mem + LOW15(address);
ret = 0;	ret = 0;
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
Line 258 static REG8 MEMCALL grcg_tcr1(UINT32 add	Line 260 static REG8 MEMCALL grcg_tcr1(UINT32 add
const BYTE *vram;	const BYTE *vram;
REG8 ret;	REG8 ret;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + LOW15(address);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
Line 278 const BYTE *vram;	Line 280 const BYTE *vram;

static REG8 MEMCALL egc_rd(UINT32 address) {	static REG8 MEMCALL egc_rd(UINT32 address) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
return(egc_read(address));	return(egc_read(address));
}	}

static REG8 MEMCALL emmc_rd(UINT32 address) {	static REG8 MEMCALL i286_rb(UINT32 address) {

return(extmem.pageptr[(address >> 14) & 3][LOW14(address)]);
}

static REG8 MEMCALL i286_itf(UINT32 address) {

if (CPU_ITFBANK) {	if (CPU_ITFBANK) {
address = ITF_ADRS + LOW15(address);	address += VRAM_STEP;
}	}
return(mem[address]);	return(mem[address]);
}	}
Line 307 static void MEMCALL i286w_wt(UINT32 addr	Line 305 static void MEMCALL i286w_wt(UINT32 addr

static void MEMCALL tramw_wt(UINT32 address, REG16 value) {	static void MEMCALL tramw_wt(UINT32 address, REG16 value) {

	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < 0xa1fff) {	if (address < 0xa1fff) {
STOREINTELWORD(mem + address, value);	STOREINTELWORD(mem + address, value);
tramupdate[LOW12(address >> 1)] = 1;	tramupdate[LOW12(address >> 1)] = 1;
Line 352 static void MEMCALL tramw_wt(UINT32 addr	Line 351 static void MEMCALL tramw_wt(UINT32 addr


#define GRCGW_NON(page) { \	#define GRCGW_NON(page) { \
CPU_REMCLOCK -= vramop.vramwait; \	CPU_REMCLOCK -= MEMWAIT_VRAM; \
STOREINTELWORD(mem + address + VRAM_STEP*(page), value); \	STOREINTELWORD(mem + address + VRAM_STEP*(page), value); \
vramupdate[LOW15(address)] \|= (1 << page); \	vramupdate[LOW15(address)] \|= (1 << page); \
vramupdate[LOW15(address + 1)] \|= (1 << page); \	vramupdate[LOW15(address + 1)] \|= (1 << page); \
Line 361 static void MEMCALL tramw_wt(UINT32 addr	Line 360 static void MEMCALL tramw_wt(UINT32 addr

#define GRCGW_RMW(page) { \	#define GRCGW_RMW(page) { \
BYTE *vram; \	BYTE *vram; \
CPU_REMCLOCK -= vramop.grcgwait; \	CPU_REMCLOCK -= MEMWAIT_GRCG; \
address = LOW15(address); \	address = LOW15(address); \
vramupdate[address] \|= (1 << page); \	vramupdate[address] \|= (1 << page); \
vramupdate[address + 1] \|= (1 << page); \	vramupdate[address + 1] \|= (1 << page); \
Line 407 static void MEMCALL tramw_wt(UINT32 addr	Line 406 static void MEMCALL tramw_wt(UINT32 addr

#define GRCGW_TDW(page) { \	#define GRCGW_TDW(page) { \
BYTE *vram; \	BYTE *vram; \
CPU_REMCLOCK -= vramop.grcgwait; \	CPU_REMCLOCK -= MEMWAIT_GRCG; \
address = LOW15(address); \	address = LOW15(address); \
vramupdate[address] \|= (1 << page); \	vramupdate[address] \|= (1 << page); \
vramupdate[address + 1] \|= (1 << page); \	vramupdate[address + 1] \|= (1 << page); \
Line 441 static void MEMCALL grcgw_tdw1(UINT32 ad	Line 440 static void MEMCALL grcgw_tdw1(UINT32 ad

static void MEMCALL egcw_wt(UINT32 address, REG16 value) {	static void MEMCALL egcw_wt(UINT32 address, REG16 value) {

	CPU_REMCLOCK -= MEMWAIT_GRCG;
if (!(address & 1)) {	if (!(address & 1)) {
egc_write_w(address, value);	egc_write_w(address, value);
}	}
Line 456 static void MEMCALL egcw_wt(UINT32 addre	Line 456 static void MEMCALL egcw_wt(UINT32 addre
}	}
}	}

static void MEMCALL emmcw_wt(UINT32 address, REG16 value) {	static void MEMCALL i286w_wb(UINT32 address, REG16 value) {

BYTE *ptr;	mem[address + 0x1c8000 - 0xe8000] = (BYTE)value;
	mem[address + 0x1c8001 - 0xe8000] = (BYTE)(value >> 8);
if ((address & 0x3fff) != 0x3fff) {
ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
STOREINTELWORD(ptr, value);
}
else {
extmem.pageptr[(address >> 14) & 3][0x3fff] = (BYTE)value;
extmem.pageptr[((address + 1) >> 14) & 3][0] = (BYTE)(value >> 8);
}
}	}

static void MEMCALL i286w_wn(UINT32 address, REG16 value) {	static void MEMCALL i286w_wn(UINT32 address, REG16 value) {
Line 489 static REG16 MEMCALL i286w_rd(UINT32 add	Line 481 static REG16 MEMCALL i286w_rd(UINT32 add

static REG16 MEMCALL tramw_rd(UINT32 address) {	static REG16 MEMCALL tramw_rd(UINT32 address) {

CPU_REMCLOCK -= vramop.tramwait;	CPU_REMCLOCK -= MEMWAIT_TRAM;
if (address < (0xa4000 - 1)) {	if (address < (0xa4000 - 1)) {
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
Line 518 static REG16 MEMCALL tramw_rd(UINT32 add	Line 510 static REG16 MEMCALL tramw_rd(UINT32 add

static REG16 MEMCALL vramw_r0(UINT32 address) {	static REG16 MEMCALL vramw_r0(UINT32 address) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}

static REG16 MEMCALL vramw_r1(UINT32 address) {	static REG16 MEMCALL vramw_r1(UINT32 address) {

CPU_REMCLOCK -= vramop.vramwait;	CPU_REMCLOCK -= MEMWAIT_VRAM;
return(LOADINTELWORD(mem + address + VRAM_STEP));	return(LOADINTELWORD(mem + address + VRAM_STEP));
}	}

Line 533 static REG16 MEMCALL grcgw_tcr0(UINT32 a	Line 525 static REG16 MEMCALL grcgw_tcr0(UINT32 a
BYTE *vram;	BYTE *vram;
REG16 ret;	REG16 ret;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + LOW15(address);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
Line 556 static REG16 MEMCALL grcgw_tcr1(UINT32 a	Line 548 static REG16 MEMCALL grcgw_tcr1(UINT32 a
BYTE *vram;	BYTE *vram;
REG16 ret;	REG16 ret;

CPU_REMCLOCK -= vramop.grcgwait;	CPU_REMCLOCK -= MEMWAIT_GRCG;
ret = 0;	ret = 0;
vram = mem + LOW15(address);	vram = mem + LOW15(address);
if (!(grcg.modereg & 1)) {	if (!(grcg.modereg & 1)) {
Line 578 static REG16 MEMCALL egcw_rd(UINT32 addr	Line 570 static REG16 MEMCALL egcw_rd(UINT32 addr

REG16 ret;	REG16 ret;

	CPU_REMCLOCK -= MEMWAIT_GRCG;
if (!(address & 1)) {	if (!(address & 1)) {
return(egc_read_w(address));	return(egc_read_w(address));
}	}
Line 595 static REG16 MEMCALL egcw_rd(UINT32 addr	Line 588 static REG16 MEMCALL egcw_rd(UINT32 addr
}	}
}	}

static REG16 MEMCALL emmcw_rd(UINT32 address) {	static REG16 MEMCALL i286w_rb(UINT32 address) {

const BYTE *ptr;
REG16 ret;

if ((address & 0x3fff) != 0x3fff) {
ptr = extmem.pageptr[(address >> 14) & 3] + LOW14(address);
return(LOADINTELWORD(ptr));
}
else {
ret = extmem.pageptr[(address >> 14) & 3][0x3fff];
ret += extmem.pageptr[((address + 1) >> 14) & 3][0] << 8;
return(ret);
}
}

static REG16 MEMCALL i286w_itf(UINT32 address) {

if (CPU_ITFBANK) {	if (CPU_ITFBANK) {
address = ITF_ADRS + LOW15(address);	address += VRAM_STEP;
}	}
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
Line 627 typedef REG8 (MEMCALL * MEM8READ)(UINT32	Line 604 typedef REG8 (MEMCALL * MEM8READ)(UINT32
typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);	typedef void (MEMCALL * MEM16WRITE)(UINT32 address, REG16 value);
typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);	typedef REG16 (MEMCALL * MEM16READ)(UINT32 address);

static MEM8WRITE memory_write[] = {	typedef struct {
i286_wt, i286_wt, i286_wt, i286_wt, // 00	MEM8READ rd8[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 20	MEM8WRITE wr8[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 40	MEM16READ rd16[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 60	MEM16WRITE wr16[0x20];
i286_wt, i286_wt, i286_wt, i286_wt, // 80	} MEMFN;
tram_wt, vram_w0, vram_w0, vram_w0, // a0
emmc_wt, emmc_wt, i286_wn, i286_wn, // c0	typedef struct {
vram_w0, i286_wn, i286_wn, i286_wn}; // e0	MEM8READ brd8;
	MEM8READ ird8;
	MEM8WRITE ewr8;
	MEM8WRITE bwr8;
	MEM16READ brd16;
	MEM16READ ird16;
	MEM16WRITE ewr16;
	MEM16WRITE bwr16;
	} MMAPTBL;

	typedef struct {
	MEM8READ rd8;
	MEM8WRITE wr8;
	MEM16READ rd16;
	MEM16WRITE wr16;
	} VACCTBL;

static MEM8READ memory_read[] = {	static MEMFN memfn = {
i286_rd, i286_rd, i286_rd, i286_rd, // 00	{i286_rd, i286_rd, i286_rd, i286_rd, // 00
i286_rd, i286_rd, i286_rd, i286_rd, // 20	i286_rd, i286_rd, i286_rd, i286_rd, // 20
i286_rd, i286_rd, i286_rd, i286_rd, // 40	i286_rd, i286_rd, i286_rd, i286_rd, // 40
i286_rd, i286_rd, i286_rd, i286_rd, // 60	i286_rd, i286_rd, i286_rd, i286_rd, // 60
i286_rd, i286_rd, i286_rd, i286_rd, // 80	i286_rd, i286_rd, i286_rd, i286_rd, // 80
tram_rd, vram_r0, vram_r0, vram_r0, // a0	tram_rd, vram_r0, vram_r0, vram_r0, // a0
emmc_rd, emmc_rd, i286_rd, i286_rd, // c0	i286_rd, i286_rd, i286_rd, i286_rd, // c0
vram_r0, i286_rd, i286_rd, i286_itf}; // f0	vram_r0, i286_rd, i286_rd, i286_rb}, // e0

static MEM16WRITE memword_write[] = {	{i286_wt, i286_wt, i286_wt, i286_wt, // 00
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 00	i286_wt, i286_wt, i286_wt, i286_wt, // 20
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 20	i286_wt, i286_wt, i286_wt, i286_wt, // 40
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 40	i286_wt, i286_wt, i286_wt, i286_wt, // 60
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 60	i286_wt, i286_wt, i286_wt, i286_wt, // 80
i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 80	tram_wt, vram_w0, vram_w0, vram_w0, // a0
tramw_wt, vramw_w0, vramw_w0, vramw_w0, // a0	i286_wn, i286_wn, i286_wn, i286_wn, // c0
emmcw_wt, emmcw_wt, i286w_wn, i286w_wn, // c0	vram_w0, i286_wn, i286_wn, i286_wn}, // e0
vramw_w0, i286w_wn, i286w_wn, i286w_wn}; // e0

static MEM16READ memword_read[] = {	{i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 00
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 00
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 20	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 20
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 40	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 40
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 60	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 60
i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 80	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // 80
tramw_rd, vramw_r0, vramw_r0, vramw_r0, // a0	tramw_rd, vramw_r0, vramw_r0, vramw_r0, // a0
emmcw_rd, emmcw_rd, i286w_rd, i286w_rd, // c0	i286w_rd, i286w_rd, i286w_rd, i286w_rd, // c0
vramw_r0, i286w_rd, i286w_rd, i286w_itf}; // e0	vramw_r0, i286w_rd, i286w_rd, i286w_rb}, // e0

	{i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 00
	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 20
	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 40
	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 60
	i286w_wt, i286w_wt, i286w_wt, i286w_wt, // 80
	tramw_wt, vramw_w0, vramw_w0, vramw_w0, // a0
	i286w_wn, i286w_wn, i286w_wn, i286w_wn, // c0
	vramw_w0, i286w_wn, i286w_wn, i286w_wn}}; // e0

static const MEM8WRITE vram_write[] = {	static const MMAPTBL mmaptbl[2] = {
vram_w0, vram_w1, vram_w0, vram_w1, // 00	{i286_rd, i286_rb, i286_wn, i286_wn,
vram_w0, vram_w1, vram_w0, vram_w1, // 40	i286w_rd, i286w_rb, i286w_wn, i286w_wn},
grcg_tdw0, grcg_tdw1, egc_wt, egc_wt, // 80 tdw/tcr	{i286_rb, i286_rb, i286_wt, i286_wb,
grcg_rmw0, grcg_rmw1, egc_wt, egc_wt}; // c0 rmw	i286w_rb, i286w_rb, i286w_wt, i286w_wb}};

static const MEM8READ vram_read[] = {	static const VACCTBL vacctbl[0x10] = {
vram_r0, vram_r1, vram_r0, vram_r1, // 00	{vram_r0, vram_w0, vramw_r0, vramw_w0}, // 00
vram_r0, vram_r1, vram_r0, vram_r1, // 40	{vram_r1, vram_w1, vramw_r1, vramw_w1},
grcg_tcr0, grcg_tcr1, egc_rd, egc_rd, // 80 tdw/tcr	{vram_r0, vram_w0, vramw_r0, vramw_w0},
vram_r0, vram_r1, egc_rd, egc_rd}; // c0 rmw	{vram_r1, vram_w1, vramw_r1, vramw_w1},
	{vram_r0, vram_w0, vramw_r0, vramw_w0}, // 40
static const MEM16WRITE vramw_write[] = {	{vram_r1, vram_w1, vramw_r1, vramw_w1},
vramw_w0, vramw_w1, vramw_w0, vramw_w1, // 00	{vram_r0, vram_w0, vramw_r0, vramw_w0},
vramw_w0, vramw_w1, vramw_w0, vramw_w1, // 40	{vram_r1, vram_w1, vramw_r1, vramw_w1},
grcgw_tdw0, grcgw_tdw1, egcw_wt, egcw_wt, // 80 tdw/tcr	{grcg_tcr0, grcg_tdw0, grcgw_tcr0, grcgw_tdw0}, // 80 tdw/tcr
grcgw_rmw0, grcgw_rmw1, egcw_wt, egcw_wt}; // c0 rmw	{grcg_tcr1, grcg_tdw1, grcgw_tcr1, grcgw_tdw1},
	{egc_rd, egc_wt, egcw_rd, egcw_wt},
static const MEM16READ vramw_read[] = {	{egc_rd, egc_wt, egcw_rd, egcw_wt},
vramw_r0, vramw_r1, vramw_r0, vramw_r1, // 00	{vram_r0, grcg_rmw0, vramw_r0, grcgw_rmw0}, // c0 rmw
vramw_r0, vramw_r1, vramw_r0, vramw_r1, // 40	{vram_r1, grcg_rmw1, vramw_r1, grcgw_rmw1},
grcgw_tcr0, grcgw_tcr1, egcw_rd, egcw_rd, // 80 tdw/tcr	{egc_rd, egc_wt, egcw_rd, egcw_wt},
vramw_r0, vramw_r1, egcw_rd, egcw_rd}; // c0 rmw	{egc_rd, egc_wt, egcw_rd, egcw_wt}};


static REG8 MEMCALL i286_nonram_r(UINT32 address) {	static REG8 MEMCALL i286_nonram_r(UINT32 address) {
Line 704 static REG16 MEMCALL i286_nonram_rw(UINT	Line 703 static REG16 MEMCALL i286_nonram_rw(UINT
return(0xffff);	return(0xffff);
}	}


	void MEMCALL i286_memorymap(UINT type) {

	const MMAPTBL *mm;

	mm = mmaptbl + (type & 1);

	memfn.rd8[0xe8000 >> 15] = mm->brd8;
	memfn.rd8[0xf0000 >> 15] = mm->brd8;
	memfn.rd8[0xf8000 >> 15] = mm->ird8;

	memfn.wr8[0xd0000 >> 15] = mm->ewr8;
	memfn.wr8[0xd8000 >> 15] = mm->ewr8;
	memfn.wr8[0xe8000 >> 15] = mm->bwr8;
	memfn.wr8[0xf0000 >> 15] = mm->bwr8;
	memfn.wr8[0xf8000 >> 15] = mm->bwr8;

	memfn.rd16[0xe8000 >> 15] = mm->brd16;
	memfn.rd16[0xf0000 >> 15] = mm->brd16;
	memfn.rd16[0xf8000 >> 15] = mm->ird16;

	memfn.wr16[0xd0000 >> 15] = mm->ewr16;
	memfn.wr16[0xd8000 >> 15] = mm->ewr16;
	memfn.wr16[0xe8000 >> 15] = mm->bwr16;
	memfn.wr16[0xf0000 >> 15] = mm->bwr16;
	memfn.wr16[0xf8000 >> 15] = mm->bwr16;
	}

void MEMCALL i286_vram_dispatch(UINT func) {	void MEMCALL i286_vram_dispatch(UINT func) {

UINT proc;	const VACCTBL *vacc;

proc = func & 0x0f;	vacc = vacctbl + (func & 0x0f);
memory_write[0xa8000 >> 15] = vram_write[proc];	#if defined(SUPPORT_PC9821)
memory_write[0xb0000 >> 15] = vram_write[proc];	if (!(func & 0x20)) {
memory_write[0xb8000 >> 15] = vram_write[proc];	#endif
memory_write[0xe0000 >> 15] = vram_write[proc];	memfn.rd8[0xa8000 >> 15] = vacc->rd8;
	memfn.rd8[0xb0000 >> 15] = vacc->rd8;
memory_read[0xa8000 >> 15] = vram_read[proc];	memfn.rd8[0xb8000 >> 15] = vacc->rd8;
memory_read[0xb0000 >> 15] = vram_read[proc];	memfn.rd8[0xe0000 >> 15] = vacc->rd8;
memory_read[0xb8000 >> 15] = vram_read[proc];
memory_read[0xe0000 >> 15] = vram_read[proc];	memfn.wr8[0xa8000 >> 15] = vacc->wr8;
	memfn.wr8[0xb0000 >> 15] = vacc->wr8;
memword_write[0xa8000 >> 15] = vramw_write[proc];	memfn.wr8[0xb8000 >> 15] = vacc->wr8;
memword_write[0xb0000 >> 15] = vramw_write[proc];	memfn.wr8[0xe0000 >> 15] = vacc->wr8;
memword_write[0xb8000 >> 15] = vramw_write[proc];
memword_write[0xe0000 >> 15] = vramw_write[proc];	memfn.rd16[0xa8000 >> 15] = vacc->rd16;
	memfn.rd16[0xb0000 >> 15] = vacc->rd16;
memword_read[0xa8000 >> 15] = vramw_read[proc];	memfn.rd16[0xb8000 >> 15] = vacc->rd16;
memword_read[0xb0000 >> 15] = vramw_read[proc];	memfn.rd16[0xe0000 >> 15] = vacc->rd16;
memword_read[0xb8000 >> 15] = vramw_read[proc];
memword_read[0xe0000 >> 15] = vramw_read[proc];	memfn.wr16[0xa8000 >> 15] = vacc->wr16;
	memfn.wr16[0xb0000 >> 15] = vacc->wr16;
if (!(func & 0x10)) { // degital	memfn.wr16[0xb8000 >> 15] = vacc->wr16;
memory_write[0xe0000 >> 15] = i286_wn;	memfn.wr16[0xe0000 >> 15] = vacc->wr16;
memword_write[0xe0000 >> 15] = i286w_wn;
memory_read[0xe0000 >> 15] = i286_nonram_r;	if (!(func & 0x10)) { // digital
memword_read[0xe0000 >> 15] = i286_nonram_rw;	memfn.wr8[0xe0000 >> 15] = i286_wn;
	memfn.wr16[0xe0000 >> 15] = i286w_wn;
	memfn.rd8[0xe0000 >> 15] = i286_nonram_r;
	memfn.rd16[0xe0000 >> 15] = i286_nonram_rw;
	}
	#if defined(SUPPORT_PC9821)
	}
	else {
	memfn.rd8[0xa8000 >> 15] = mem9821_b0r;
	memfn.rd8[0xb0000 >> 15] = mem9821_b0r;
	memfn.rd8[0xb8000 >> 15] = vacc->rd8;
	memfn.rd8[0xe0000 >> 15] = mem9821_b2r;

	memfn.wr8[0xa8000 >> 15] = mem9821_b0w;
	memfn.wr8[0xb0000 >> 15] = mem9821_b0w;
	memfn.wr8[0xb8000 >> 15] = vacc->wr8;
	memfn.wr8[0xe0000 >> 15] = mem9821_b2w;

	memfn.rd16[0xa8000 >> 15] = mem9821_b0rw;
	memfn.rd16[0xb0000 >> 15] = mem9821_b0rw;
	memfn.rd16[0xb8000 >> 15] = vacc->rd16;
	memfn.rd16[0xe0000 >> 15] = mem9821_b2rw;

	memfn.wr16[0xa8000 >> 15] = mem9821_b0ww;
	memfn.wr16[0xb0000 >> 15] = mem9821_b0ww;
	memfn.wr16[0xb8000 >> 15] = vacc->wr16;
	memfn.wr16[0xe0000 >> 15] = mem9821_b2ww;
}	}
#if defined(USE_ASM)
i286a_vram_dispatch(func);
#endif	#endif
}	}

REG8 MEMCALL __i286_memoryread(UINT32 address) {

if (address < I286_MEMREADMAX) {	REG8 MEMCALL i286_memoryread(UINT32 addr) {
return(mem[address]);
	UINT32 pos;

	addr &= CPU_ADRSMASK;
	if (addr < I286_MEMREADMAX) {
	return(mem[addr]);
}	}
#if defined(USE_HIMEM)	else if (addr >= USE_HIMEM) {
else if (address >= 0x10fff0) {	pos = addr - 0x100000;
address -= 0x100000;	if (pos < CPU_EXTMEMSIZE) {
if (address < CPU_EXTMEMSIZE) {	return(CPU_EXTMEM[pos]);
return(CPU_EXTMEM[address]);	}
	else if ((addr >= 0x00fa0000) && (addr < 0x01000000)) {
	return(memfn.rd8[(addr >> 15) & 0x1f](addr - 0x00f00000));
}	}
	#if defined(SUPPORT_PC9821)
	else if (addr >= 0xfff00000) {
	return(mem9821_r(addr));
	}
	#endif
else {	else {
return(0xff);	return(0xff);
}	}
}	}
#endif
else {	else {
return(memory_read[(address >> 15) & 0x1f](address));	return(memfn.rd8[(addr >> 15) & 0x1f](addr));
}	}
}	}

REG16 MEMCALL __i286_memoryread_w(UINT32 address) {	REG16 MEMCALL i286_memoryread_w(UINT32 addr) {

	UINT32 pos;
REG16 ret;	REG16 ret;

if (address < (I286_MEMREADMAX - 1)) {	addr &= CPU_ADRSMASK;
return(LOADINTELWORD(mem + address));	if (addr < (I286_MEMREADMAX - 1)) {
}	return(LOADINTELWORD(mem + addr));
#if defined(USE_HIMEM)	}
else if (address >= (0x10fff0 - 1)) {	else if ((addr + 1) & 0x7fff) { // non 32kb boundary
address -= 0x100000;	if (addr >= USE_HIMEM) {
if (address == (0x00fff0 - 1)) {	pos = addr - 0x100000;
ret = mem[0x100000 + address];	if (pos < CPU_EXTMEMSIZE) {
}	return(LOADINTELWORD(CPU_EXTMEM + pos));
else if (address < CPU_EXTMEMSIZE) {	}
ret = CPU_EXTMEM[address];	else if ((addr >= 0x00fa0000) && (addr < 0x01000000)) {
}	return(memfn.rd16[(addr >> 15) & 0x1f](addr - 0x00f00000));
else {	}
ret = 0xff;	#if defined(SUPPORT_PC9821)
}	else if (addr >= 0xfff00000) {
address++;	return(mem9821_rw(addr));
if (address < CPU_EXTMEMSIZE) {	}
ret += CPU_EXTMEM[address] << 8;
}
else {
ret += 0xff00;
}
return(ret);
}
#endif	#endif
else if ((address & 0x7fff) != 0x7fff) {	else {
return(memword_read[(address >> 15) & 0x1f](address));	return(0xffff);
	}
	}
	return(memfn.rd16[(addr >> 15) & 0x1f](addr));
}	}
else {	else {
ret = memory_read[(address >> 15) & 0x1f](address);	ret = i286_memoryread(addr);
address++;	ret += (REG16)(i286_memoryread(addr + 1) << 8);
ret += memory_read[(address >> 15) & 0x1f](address) << 8;
return(ret);	return(ret);
}	}
}	}

UINT32 MEMCALL __i286_memoryread_d(UINT32 address) {	UINT32 MEMCALL i286_memoryread_d(UINT32 addr) {

UINT32 ret;

ret = __i286_memoryread_w(address);
ret \|= (UINT32)__i286_memoryread_w(address + 2) << 16;

return ret;
}

void MEMCALL __i286_memorywrite(UINT32 address, REG8 value) {	UINT32 pos;
	UINT32 ret;

if (address < I286_MEMWRITEMAX) {	addr &= CPU_ADRSMASK;
mem[address] = (BYTE)value;	if (addr < (I286_MEMREADMAX - 3)) {
	return(LOADINTELDWORD(mem + addr));
}	}
#if defined(USE_HIMEM)	else if (addr >= USE_HIMEM) {
else if (address >= 0x10fff0) {	pos = addr - 0x100000;
address -= 0x100000;	if ((pos + 3) < CPU_EXTMEMSIZE) {
if (address < CPU_EXTMEMSIZE) {	return(LOADINTELDWORD(CPU_EXTMEM + pos));
CPU_EXTMEM[address] = (BYTE)value;
}	}
}	}
#endif	if (!(addr & 1)) {
	ret = i286_memoryread_w(addr);
	ret += (UINT32)i286_memoryread_w(addr + 2) << 16;
	}
else {	else {
memory_write[(address >> 15) & 0x1f](address, value);	ret = i286_memoryread(addr);
	ret += (UINT32)i286_memoryread_w(addr + 1) << 8;
	ret += (UINT32)i286_memoryread(addr + 3) << 24;
}	}
	return(ret);
}	}

void MEMCALL __i286_memorywrite_w(UINT32 address, REG16 value) {	void MEMCALL i286_memorywrite(UINT32 addr, REG8 value) {

if (address < (I286_MEMWRITEMAX - 1)) {	UINT32 pos;
STOREINTELWORD(mem + address, value);
	addr &= CPU_ADRSMASK;
	if (addr < I286_MEMWRITEMAX) {
	mem[addr] = (BYTE)value;
}	}
#if defined(USE_HIMEM)	else if (addr >= USE_HIMEM) {
else if (address >= (0x10fff0 - 1)) {	pos = addr - 0x100000;
address -= 0x100000;	if (pos < CPU_EXTMEMSIZE) {
if (address == (0x00fff0 - 1)) {	CPU_EXTMEM[pos] = (BYTE)value;
mem[address] = (BYTE)value;	}
	else if ((addr >= 0x00fa0000) && (addr < 0x01000000)) {
	memfn.wr8[(addr >> 15) & 0x1f](addr - 0x00f00000, value);
}	}
else if (address < CPU_EXTMEMSIZE) {	#if defined(SUPPORT_PC9821)
CPU_EXTMEM[address] = (BYTE)value;	else if (addr >= 0xfff00000) {
	mem9821_w(addr, value);
}	}
address++;	#endif
if (address < CPU_EXTMEMSIZE) {	else {
CPU_EXTMEM[address] = (BYTE)(value >> 8);	TRACEOUT(("mem_w %x %x", addr, value));
}	}
}	}
	else {
	memfn.wr8[(addr >> 15) & 0x1f](addr, value);
	}
	}

	void MEMCALL i286_memorywrite_w(UINT32 addr, REG16 value) {

	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;
	if (pos < CPU_EXTMEMSIZE) {
	STOREINTELWORD(CPU_EXTMEM + pos, value);
	}
	else if ((addr >= 0x00fa0000) && (addr < 0x01000000)) {
	memfn.wr16[(addr >> 15) & 0x1f](addr - 0x00f00000, value);
	}
	#if defined(SUPPORT_PC9821)
	else if (addr >= 0xfff00000) {
	mem9821_ww(addr, value);
	}
#endif	#endif
else if ((address & 0x7fff) != 0x7fff) {	}
memword_write[(address >> 15) & 0x1f](address, value);	else {
	memfn.wr16[(addr >> 15) & 0x1f](addr, value);
	}
}	}
else {	else {
memory_write[(address >> 15) & 0x1f](address, (BYTE)value);	i286_memorywrite(addr, (UINT8)value);
address++;	i286_memorywrite(addr + 1, (UINT8)(value >> 8));
memory_write[(address >> 15) & 0x1f](address, (BYTE)(value >> 8));
}	}
}	}

void MEMCALL __i286_memorywrite_d(UINT32 address, UINT32 value) {	void MEMCALL i286_memorywrite_d(UINT32 addr, UINT32 value) {

	UINT32 pos;

__i286_memorywrite_w(address, value & 0xffff);	addr &= CPU_ADRSMASK;
__i286_memorywrite_w(address + 2, (WORD)(value >> 16));	if (addr < (I286_MEMWRITEMAX - 3)) {
	STOREINTELDWORD(mem + addr, value);
	return;
	}
	else if (addr >= USE_HIMEM) {
	pos = addr - 0x100000;
	if ((pos + 3) < CPU_EXTMEMSIZE) {
	STOREINTELDWORD(CPU_EXTMEM + pos, value);
	return;
	}
	}
	if (!(addr & 1)) {
	i286_memorywrite_w(addr, (UINT16)value);
	i286_memorywrite_w(addr + 2, (UINT16)(value >> 16));
	}
	else {
	i286_memorywrite(addr, (UINT8)value);
	i286_memorywrite_w(addr + 1, (UINT16)(value >> 8));
	i286_memorywrite(addr + 3, (UINT8)(value >> 24));
	}
}	}

#if 0	#ifdef NP2_MEMORY_ASM
REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {	REG8 MEMCALL i286_membyte_read(UINT seg, UINT off) {

UINT32 address;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < I286_MEMREADMAX) {	if (address < I286_MEMREADMAX) {
return(mem[address]);	return(mem[address]);
}	}
Line 883 REG16 MEMCALL i286_memword_read(UINT seg	Line 993 REG16 MEMCALL i286_memword_read(UINT seg

UINT32 address;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < (I286_MEMREADMAX - 1)) {	if (address < (I286_MEMREADMAX - 1)) {
return(LOADINTELWORD(mem + address));	return(LOADINTELWORD(mem + address));
}	}
Line 896 void MEMCALL i286_membyte_write(UINT seg	Line 1006 void MEMCALL i286_membyte_write(UINT seg

UINT32 address;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < I286_MEMWRITEMAX) {	if (address < I286_MEMWRITEMAX) {
mem[address] = (BYTE)value;	mem[address] = (BYTE)value;
}	}
Line 909 void MEMCALL i286_memword_write(UINT seg	Line 1019 void MEMCALL i286_memword_write(UINT seg

UINT32 address;	UINT32 address;

address = (seg << 4) + off;	address = (seg << 4) + LOW16(off);
if (address < (I286_MEMWRITEMAX - 1)) {	if (address < (I286_MEMWRITEMAX - 1)) {
STOREINTELWORD(mem + address, value);	STOREINTELWORD(mem + address, value);
}	}
Line 917 void MEMCALL i286_memword_write(UINT seg	Line 1027 void MEMCALL i286_memword_write(UINT seg
i286_memorywrite_w(address, value);	i286_memorywrite_w(address, value);
}	}
}	}
#endif	#endif /* NP2_MEMORY_ASM */

void MEMCALL i286_memstr_read(UINT seg, UINT off, void *dat, UINT leng) {	void MEMCALL i286_memstr_read(UINT seg, UINT off, void *dat, UINT leng) {

Line 927 void MEMCALL i286_memstr_read(UINT seg,	Line 1037 void MEMCALL i286_memstr_read(UINT seg,

out = (BYTE *)dat;	out = (BYTE *)dat;
adrs = seg << 4;	adrs = seg << 4;
	off = LOW16(off);
if ((I286_MEMREADMAX >= 0x10000) &&	if ((I286_MEMREADMAX >= 0x10000) &&
(adrs < (I286_MEMREADMAX - 0x10000))) {	(adrs < (I286_MEMREADMAX - 0x10000))) {
if (leng) {	if (leng) {
Line 956 void MEMCALL i286_memstr_read(UINT seg,	Line 1067 void MEMCALL i286_memstr_read(UINT seg,
}	}
}	}

void MEMCALL i286_memstr_write(UINT seg, UINT off,	void MEMCALL i286_memstr_write(UINT seg, UINT off, const void *dat, UINT leng) {
const void *dat, UINT leng) {

BYTE *out;	BYTE *out;
UINT32 adrs;	UINT32 adrs;
Line 965 void MEMCALL i286_memstr_write(UINT seg,	Line 1075 void MEMCALL i286_memstr_write(UINT seg,

out = (BYTE *)dat;	out = (BYTE *)dat;
adrs = seg << 4;	adrs = seg << 4;
	off = LOW16(off);
if ((I286_MEMWRITEMAX >= 0x10000) &&	if ((I286_MEMWRITEMAX >= 0x10000) &&
(adrs < (I286_MEMWRITEMAX - 0x10000))) {	(adrs < (I286_MEMWRITEMAX - 0x10000))) {
if (leng) {	if (leng) {
Line 1033 const BYTE *out;	Line 1144 const BYTE *out;
}	}
}	}
}	}

#endif	#endif

RetroPC.NET-CVS <cvs@retropc.net>

Removed from v.1.2
changed lines
	Added in v.1.12