Compaq Deskpro 386 RAM relocation vs BIOS ROM physical memory MMIO? \ VOGONS

Compaq Deskpro 386 RAM relocation vs BIOS ROM physical memory MMIO?

Topic actions

Post a reply

First post, by superfury

Posted on 2017-03-21, 14:08

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5466
Joined: 2014-03-08, 11:25
Location: Netherlands

I've been reading this(first entry):
http://www.pcjs.org/blog/2015/04/16/

If I understand this correctly, there's three kinds of memory mapping going on:
1. The actual ROM(combined from the 2 ROMs) is mapped at the high addresses (FFFF0000-FFFF7FFF and FFFF8000-FFFFFFFF), the ROMs being interleaved of course.
2. The low RAM at A0000-FFFFF can be remapped to FA0000-FFFFF, so essentially it's making the memory area at FA0000-FFFFFF access physical memory at A0000-FFFFF instead?
3. The ROM that's mapped in the HMA (A0000-FFFFF) is the same as the 80386 location(at FFFF0000-FFFFFFFF), being mapped to the same ROMs.

As far as I can see from the ioports.lst documentation, the reserved memory address(0x80C00000) can do the following:
1. Setting bit 0 ignores any writes to the currently mapped location at 0xFE0000-0xFFFFFF.
2. Clearing bit 1 disables the RAM at A0000-FFFFF and moves it to the high memory at 0xFA0000-0xFFFFFF.

Is this correct?

My code currently does the following:
= 0x80C00000 behaviour:
- Setting bit 0 protects physical memory addresses 0xFE0000-0xFFFFFF from being overwritten with new values.
- Setting bit 1 makes CPU physical addresses 0xE0000-0xFFFFF remap to physical memory 0xFE0000-0xFFFFFF(applying protection of this area after this is done). So accessing address E0000 actually access RAM location FE0000(which might be write-protected).

General behaviour:
- The CPU accessing addresses FA0000-FFFFFF is always remapped to physical memory addresses A0000-FFFFF without protection.

Is this behaviour correct?

1//Memory hole start/end locations!
2#define LOW_MEMORYHOLE_START 0xA0000
3#define LOW_MEMORYHOLE_END 0x100000
4#define MID_MEMORYHOLE_START 0xF00000
5#define MID_MEMORYHOLE_END 0x1000000
6#define HIGH_MEMORYHOLE_START 0xC0000000
7#define HIGH_MEMORYHOLE_END 0x100000000
8
9OPTINLINE void applyMemoryHoles(uint_32 *realaddress, byte *nonexistant, byte iswrite)
10{
11	INLINEREGISTER byte memloc; //What memory block?
12	INLINEREGISTER byte memoryhole;
13	memloc = 0; //Default: first memory block: low memory!
14	memoryhole = 0; //Default: memory unavailable!
15	if (*realaddress>=LOW_MEMORYHOLE_START) //Start of first hole?
16	{
17		if (*realaddress<LOW_MEMORYHOLE_END) //First hole?
18		{
19			memoryhole = 1; //First memory hole!
20		}
21		else //Mid memory?
22		{
23			memloc = 1; //Second memory block: mid memory!
24			if (*realaddress>=MID_MEMORYHOLE_START) //Start of second hole?
25			{
26				if (*realaddress<MID_MEMORYHOLE_END) //Second hole?
27				{
28					memoryhole = 2; //Second memory hole!
29				}
30				else //High memory?
31				{
32					memloc = 2; //Third memory block!
33					if ((*realaddress>=HIGH_MEMORYHOLE_START) && ((uint_64)*realaddress<(uint_64)HIGH_MEMORYHOLE_END)) //Start of third hole?
34					{
35						memoryhole = 3; //Third memory hole!
36					}
37					else
38					{
39						memloc = 3; //Fourth memory block!
40					}
41				}
42			}
43		}
44	}
45
46	if (memoryhole) //Memory hole?
47	{
48		*nonexistant = 1; //We're non-existant!
49		if (BIOSROM_LowMemoryBecomesHighMemory && (memoryhole==1)) //Move memory FE0000-FFFFFF to E0000-FFFFF?
50		{
51			if ((*realaddress>=0xE0000) && (*realaddress<=0xFFFFF)) //Low memory hole to remap to the available memory hole memory? This is the size that's defined in MMU_RESERVEDMEMORY!
52			{
53				memloc = 2; //We're the second block instead!
54				*realaddress += MIN(MMU.size,MMU.maxsize?MMU.maxsize:MMU.size)-0xE0000; //Patch to physical FE0000-FFFFFF reserved memory range to use!
55				return; //Apply the new block instead!
56			}
57		}
58		else if ((is_Compaq==1) && (memoryhole==2)) //Compaq remaps RAM from A0000-FFFFF to FA0000-FFFFFF.
59		{
60			//This should be correct, according to PCem: https://bitbucket.org/pcem_emulator/pcem/src/66eec7c1b664f2f1496b5ed3763ec2b2738a6fab/src/compaq.c?at=default

…Show last 33 lines

61			if ((*realaddress>=0xFA0000) && (*realaddress<=0xFFFFFF)) //Remapped RAM area addressed?
62			{
63				*nonexistant = 0; //We're to be used directly!
64				*realaddress &= 0xFFFFF; //Remap the low RAM area high!
65			}
66		}
67	}
68	else //Plain memory?
69	{
70		*nonexistant = 0; //We're to be used directly!
71		if ((MoveLowMemoryHigh&1) && (memloc) && (is_Compaq!=1)) //Move first block lower?
72		{
73			*realaddress -= (LOW_MEMORYHOLE_END - LOW_MEMORYHOLE_START); //Patch into memory hole!
74		}
75		if ((MoveLowMemoryHigh&2) && (memloc>=2)) //Move second block lower?
76		{
77			*realaddress -= (MID_MEMORYHOLE_END - MID_MEMORYHOLE_START); //Patch into memory hole!
78		}
79		if ((MoveLowMemoryHigh&4) && (memloc>=3)) //Move third block lower?
80		{
81			*realaddress -= (uint_32)((uint_64)HIGH_MEMORYHOLE_END - (uint_64)HIGH_MEMORYHOLE_START); //Patch into memory hole!
82		}
83		if ((*realaddress >= MMU.size) || ((*realaddress>=MMU.maxsize) && MMU.maxsize)) //Reserved memory?
84		{
85			*nonexistant = 2; //Reserved for reading only!
86		}
87	}
88	if (memoryprotect_FE0000 && (*realaddress>=0xFE0000) && (*realaddress<=0xFFFFFF) && iswrite) //Memory protected?
89	{
90		*nonexistant = 1; //We're non-existant!
91		return; //Abort!
92	}
93}

Configuration register in memory:

1	if ((realaddress==0x80C00000) && (EMULATED_CPU>=CPU_80386) && (is_Compaq==1)) //Compaq special register?
2	{
3		memoryprotect_FE0000 = (value&1); //Write-protect 128KB RAM at 0xFE0000?
4		if (value&2) //128KB RAM only addressed at FE0000? Otherwise, relocated to (F(general documentation)/0(IOPORTS.LST)?)E0000.
5		{
6			BIOSROM_LowMemoryBecomesHighMemory = BIOSROM_DisableLowMemory = 0; //Normal low memory!
7		}
8		else
9		{
10			BIOSROM_LowMemoryBecomesHighMemory = BIOSROM_DisableLowMemory = 1; //Low memory becomes high memory!
11		}
12	}

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 1 of 2, by superfury

Posted on 2017-03-21, 14:52

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5466
Joined: 2014-03-08, 11:25
Location: Netherlands

A little revision, according to the new documentation:

1OPTINLINE void applyMemoryHoles(uint_32 *realaddress, byte *nonexistant, byte iswrite)
2{
3	INLINEREGISTER byte memloc; //What memory block?
4	INLINEREGISTER byte memoryhole;
5	memloc = 0; //Default: first memory block: low memory!
6	memoryhole = 0; //Default: memory unavailable!
7	if (*realaddress>=LOW_MEMORYHOLE_START) //Start of first hole?
8	{
9		if (*realaddress<LOW_MEMORYHOLE_END) //First hole?
10		{
11			memoryhole = 1; //First memory hole!
12		}
13		else //Mid memory?
14		{
15			memloc = 1; //Second memory block: mid memory!
16			if (*realaddress>=MID_MEMORYHOLE_START) //Start of second hole?
17			{
18				if (*realaddress<MID_MEMORYHOLE_END) //Second hole?
19				{
20					memoryhole = 2; //Second memory hole!
21				}
22				else //High memory?
23				{
24					memloc = 2; //Third memory block!
25					if ((*realaddress>=HIGH_MEMORYHOLE_START) && ((uint_64)*realaddress<(uint_64)HIGH_MEMORYHOLE_END)) //Start of third hole?
26					{
27						memoryhole = 3; //Third memory hole!
28					}
29					else
30					{
31						memloc = 3; //Fourth memory block!
32					}
33				}
34			}
35		}
36	}
37
38	if (memoryhole) //Memory hole?
39	{
40		*nonexistant = 1; //We're non-existant!
41		if (BIOSROM_LowMemoryBecomesHighMemory && (memoryhole==1)) //Move memory FE0000-FFFFFF to E0000-FFFFF?
42		{
43			if ((*realaddress>=0xE0000) && (*realaddress<=0xFFFFF)) //Low memory hole to remap to the available memory hole memory? This is the size that's defined in MMU_RESERVEDMEMORY!
44			{
45				memloc = 2; //We're the second block instead!
46				*realaddress |= 0xF00000; //Patch to physical FE0000-FFFFFF reserved memory range to use!
47			}
48		}
49	}
50	else //Plain memory?
51	{
52		*nonexistant = 0; //We're to be used directly!
53		if ((MoveLowMemoryHigh&1) && (memloc) && (is_Compaq!=1)) //Move first block lower?
54		{
55			*realaddress -= (LOW_MEMORYHOLE_END - LOW_MEMORYHOLE_START); //Patch into memory hole!
56		}
57		if ((MoveLowMemoryHigh&2) && (memloc>=2)) //Move second block lower?
58		{
59			*realaddress -= (MID_MEMORYHOLE_END - MID_MEMORYHOLE_START); //Patch into memory hole!
60		}

…Show last 32 lines

61		if ((MoveLowMemoryHigh&4) && (memloc>=3)) //Move third block lower?
62		{
63			*realaddress -= (uint_32)((uint_64)HIGH_MEMORYHOLE_END - (uint_64)HIGH_MEMORYHOLE_START); //Patch into memory hole!
64		}
65		if ((*realaddress >= MMU.size) || ((*realaddress>=MMU.maxsize) && MMU.maxsize)) //Reserved memory?
66		{
67			*nonexistant = 2; //Reserved for reading only!
68		}
69	}
70	if ((*realaddress>=0xFE0000) && (*realaddress<=0xFFFFFF)) //Special area addressed?
71	{
72		if (memoryprotect_FE0000 && iswrite) //Memory protected?
73		{
74			*nonexistant = 1; //We're non-existant!
75			return; //Abort!
76		}
77		//Reading or not protected?
78		if (is_Compaq!=1) //Special XT 386 handling?
79		{
80			*realaddress -= MIN(MMU.size,MMU.maxsize?MMU.maxsize:MMU.size)-0xE0000; //Patch to physical FE0000-FFFFFF reserved memory range to use!
81		}
82	}
83	if (is_Compaq==1) //Compaq remaps RAM from A0000-FFFFF to FA0000-FFFFFF.
84	{
85		//This should be correct, according to PCem: https://bitbucket.org/pcem_emulator/pcem/src/66eec7c1b664f2f1496b5ed3763ec2b2738a6fab/src/compaq.c?at=default
86		if ((*realaddress>=0xFA0000) && (*realaddress<=0xFFFFFF)) //Remapped RAM area addressed?
87		{
88			*nonexistant = 0; //We're to be used directly!
89			*realaddress &= 0xFFFFF; //Remap the low RAM area high!
90		}
91	}
92}

Is this correct?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Reply 2 of 2, by superfury

Posted on 2017-06-06, 18:39

superfury Offline

Rank l33t++

Rank: l33t++
Posts: 5466
Joined: 2014-03-08, 11:25
Location: Netherlands

I've improved the memory allocation a bit:

1OPTINLINE void applyMemoryHoles(uint_32 *realaddress, byte *nonexistant, byte iswrite)
2{
3	uint_32 originaladdress = *realaddress; //Original address!
4	INLINEREGISTER byte memloc; //What memory block?
5	INLINEREGISTER byte memoryhole;
6	memloc = 0; //Default: first memory block: low memory!
7	memoryhole = 0; //Default: memory unavailable!
8	if (*realaddress>=LOW_MEMORYHOLE_START) //Start of first hole?
9	{
10		if (*realaddress<LOW_MEMORYHOLE_END) //First hole?
11		{
12			memoryhole = 1; //First memory hole!
13		}
14		else //Mid memory?
15		{
16			memloc = 1; //Second memory block: mid memory!
17			if (*realaddress>=MID_MEMORYHOLE_START) //Start of second hole?
18			{
19				if (*realaddress<MID_MEMORYHOLE_END) //Second hole?
20				{
21					memoryhole = 2; //Second memory hole!
22				}
23				else //High memory?
24				{
25					memloc = 2; //Third memory block!
26					if ((*realaddress>=HIGH_MEMORYHOLE_START) && ((uint_64)*realaddress<(uint_64)HIGH_MEMORYHOLE_END)) //Start of third hole?
27					{
28						memoryhole = 3; //Third memory hole!
29					}
30					else
31					{
32						memloc = 3; //Fourth memory block!
33					}
34				}
35			}
36		}
37	}
38
39	if (memoryhole) //Memory hole?
40	{
41		*nonexistant = 1; //We're non-existant!
42		if (BIOSROM_LowMemoryBecomesHighMemory && (memoryhole==1) && BIOSROM_LowMemoryBecomesHighMemory) //Compaq remaps RAM from E0000-FFFFF to FE0000-FFFFFF.
43		{
44			if ((originaladdress>=0xE0000) && (originaladdress<=0xFFFFF)) //Low memory hole to remap to the available memory hole memory? This is the size that's defined in MMU_RESERVEDMEMORY!
45			{
46				memloc = 2; //We're the second block instead!
47				originaladdress |= 0xF00000; //Patch to physical FE0000-FFFFFF reserved memory range to use!
48			}
49		}
50	}
51	else //Plain memory?
52	{
53		*nonexistant = 0; //We're to be used directly!
54		if ((MoveLowMemoryHigh&1) && (memloc)) //Move first block lower?
55		{
56			*realaddress -= (LOW_MEMORYHOLE_END - LOW_MEMORYHOLE_START); //Patch into memory hole!
57		}
58		if ((MoveLowMemoryHigh&2) && (memloc>=2)) //Move second block lower?
59		{
60			*realaddress -= (MID_MEMORYHOLE_END - MID_MEMORYHOLE_START); //Patch into memory hole!

…Show last 21 lines

61		}
62		if ((MoveLowMemoryHigh&4) && (memloc>=3)) //Move third block lower?
63		{
64			*realaddress -= (uint_32)((uint_64)HIGH_MEMORYHOLE_END - (uint_64)HIGH_MEMORYHOLE_START); //Patch into memory hole!
65		}
66	}
67	if ((originaladdress>=0xFE0000) && (originaladdress<=0xFFFFFF)) //Special area addressed?
68	{
69		if (memoryprotect_FE0000 && iswrite) //Memory protected?
70		{
71			*nonexistant = 1; //We're non-existant!
72			return; //Abort!
73		}
74		//Reading or not protected?
75		if (((EMULATED_CPU==CPU_80386) && is_XT) || (is_Compaq==1)) //Compaq or XT reserved area?
76		{
77			*realaddress += MMU.size-0xFE0000; //Patch to physical FE0000-FFFFFF reserved memory range to use!
78			*nonexistant = 3; //Reserved memory!
79		}
80	}
81}

Now the Compaq Deskpro 80386 detects the FE0000-FFFFFF memory correctly. But for some reason it keeps complaining about memory range 0xFA0000-0xXXXXXX? What memory does it expect to have there?

Author of the UniPCemu emulator.
UniPCemu Git repository
UniPCemu for Android, Windows, PSP, Vita and Switch on itch.io

Go to top of page Go to top of page

Back to PC Emulation

Main menu

Common searches