ShuriZma
/
BizHawk
mirror of https://github.com/TASEmulators/BizHawk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
BizHawk/BizHawk.Emulation/Consoles/Intellivision/MemoryMap.cs

776 lines
24 KiB
C#
Raw Normal View History

Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace BizHawk.Emulation.Consoles.Intellivision
{
public sealed partial class Intellivision
{
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
private const string INVALID = "Invalid memory address.";
private const string UNOCCUPIED = "Unoccupied memory address.";
private const string UNOCCUPIED_CART_READ = "Unoccupied memory address available to cartridge not mapped as"
+ " readable.";
private const string UNOCCUPIED_CART_WRITE = "Unoccupied memory address available to cartridge not mapped as"
+ " writable.";
private const string READ_ONLY_STIC = "This STIC Register alias is read-only.";
private const string READ_ONLY_EXEC = "Executive ROM is read-only.";
private const string READ_ONLY_GROM = "Graphics ROM is read-only.";
private const string WRITE_ONLY_STIC = "This STIC Register alias is write-only.";
private const string GARBAGE = "Memory address contains a garbage value, perhaps only in the Intellivision II.";
private const string INTV2_EXEC = "Additional EXEC ROM, Intellivision II only.";
-Made Executive ROM and Graphics ROM read-only. I still haven't made the memory map accessibility limited by the VBlank Period, but I'm assuming that should come way later. -Initialized the memory devices with a tentative size that ignores the unofficial ranges. -Masked addresses to match those sizes (That's my understanding of what the memory map needs to do based on other examples). -Added the ICart interface. -Started the Intellicart parser; got far enough to know that the files I'm working with are not Intellicarts. ^_^
2012-07-15 08:38:50 +00:00
private ushort[] STIC_Registers = new ushort[64];
private ushort[] Scratchpad_RAM = new ushort[240];
private ushort[] PSG_Registers = new ushort[16];
private ushort[] System_RAM = new ushort[352];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
private ushort[] Executive_ROM = new ushort[4096]; // TODO: Intellivision II support?
-Made Executive ROM and Graphics ROM read-only. I still haven't made the memory map accessibility limited by the VBlank Period, but I'm assuming that should come way later. -Initialized the memory devices with a tentative size that ignores the unofficial ranges. -Masked addresses to match those sizes (That's my understanding of what the memory map needs to do based on other examples). -Added the ICart interface. -Started the Intellicart parser; got far enough to know that the files I'm working with are not Intellicarts. ^_^
2012-07-15 08:38:50 +00:00
private ushort[] Graphics_ROM = new ushort[2048];
private ushort[] Graphics_RAM = new ushort[512];
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
private ushort[] Cartridge = new ushort[56320]; // TODO: Resize as cartridge mapping grows.
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
-Made the memory map use ushort arrays because the Intellivision is 16-bit. -Fixed JMP disassembly; I need to return on an invalid opcode because I was breaking out of the inner switch statement, not both that and the outer one.
2012-07-09 23:19:57 +00:00
public ushort ReadMemory(ushort addr)
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
{
-Attempted to parse out memory attributes. --In my test case, only a few segments were set to readable and nothing else was set. 0x1000, which is where the PC is initialized to, certainly isn't in a writable page. --Although I've read that these memory attributes affect the Intellivision and not the Intellicart, I'm pretty sure this has to be implemented in the Intellicart so that my Read/WriteCart functions can choose to respond / not respond depending on these attributes. I very well could be wrong. -Hooked Read/WriteCart into Read/WriteMemory. -Implemented memory attributes into Read/WriteCart. --TODO: Bank-switching. TODO: Fine address table and memory attribute / fine address checksums.
2012-07-17 05:32:00 +00:00
ushort? cart = ReadCart(addr);
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
ushort core;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
switch (addr & 0xF000)
{
case 0x0000:
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
if (addr <= 0x003F)
// TODO: OK only during VBlank Period 1.
core = STIC_Registers[addr];
else if (addr <= 0x007F)
// TODO: OK only during VBlank Period 2.
core = STIC_Registers[addr & 0x003F];
else if (addr <= 0x00FF)
throw new ArgumentException(UNOCCUPIED);
else if (addr <= 0x01EF)
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = Scratchpad_RAM[addr & 0x00EF];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x01FF)
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = PSG_Registers[addr & 0x000F];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x035F)
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = System_RAM[addr & 0x015F];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x03FF)
// TODO: Intellivision II support?
throw new ArgumentException(GARBAGE);
else if (addr <= 0x04FF)
// TODO: Actually map cartridge (on all but Intellivision II) RAM / ROM to decide which path to take.
if (false)
// TODO: Intellivision II support?
throw new ArgumentException(INTV2_EXEC);
else
core = Cartridge[addr & 0x00FF];
else if (addr <= 0x06FF)
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[addr & 0x02FF];
else if (addr <= 0x0CFF)
// TODO: Actually map cartridge (only if no Intellivoice) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[addr & 0x08FF];
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
else
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[addr & 0x0BFF];
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
break;
case 0x1000:
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = Executive_ROM[addr & 0x0FFF];
break;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
case 0x2000:
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0x0C00];
break;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
case 0x3000:
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
if (addr <= 0x37FF)
// TODO: OK only during VBlank Period 2.
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = Graphics_ROM[addr & 0x07FF];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x39FF)
// TODO: OK only during VBlank Period 2.
core = Graphics_RAM[addr & 0x01FF];
else if (addr <= 0x3BFF)
// TODO: OK only during VBlank Period 2.
core = Graphics_RAM[addr & 0x01FF];
else if (addr <= 0x3DFF)
// TODO: OK only during VBlank Period 2.
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
core = Graphics_RAM[addr & 0x01FF];
else
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
// TODO: OK only during VBlank Period 2.
core = Graphics_RAM[addr & 0x01FF];
break;
case 0x4000:
if (addr <= 0x403F)
{
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (true)
{
// TODO: OK only during VBlank Period 1.
if (addr == 0x4021)
// TODO: Switch into Color Stack mode.
core = STIC_Registers[0x0021];
else
throw new ArgumentException(WRITE_ONLY_STIC);
}
else
core = Cartridge[(addr & 0x003F) + 0x1C00];
}
else if (addr <= 0x47FF)
{
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x07FF) + 0x1C00];
}
else if (addr == 0x4800)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[0x2400];
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x0FFF) + 0x1C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
break;
case 0x5000:
case 0x6000:
if (addr <= 0x5014)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x0014) + 0x2C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x1FFF) + 0x2C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
break;
case 0x7000:
if (addr == 0x7000)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (confuses EXEC boot sequence) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[0x04C00];
}
else if (addr <= 0x77FF)
{
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x07FF) + 0x4C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x79FF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x09FF) + 0x4C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x7BFF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x0BFF) + 0x4C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x7DFF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x0DFF) + 0x4C00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
core = Cartridge[(addr & 0x0FFF) + 0x4C00];
}
break;
case 0x8000:
if (addr <= 0x803F)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (true)
{
// TODO: OK only during VBlank Period 1.
if (addr == 0x8021)
// TODO: Switch into Color Stack mode.
core = STIC_Registers[0x0021];
else
throw new ArgumentException(WRITE_ONLY_STIC);
}
else
core = Cartridge[(addr & 0x003F) + 0x5C00];
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0x5C00];
}
break;
case 0x9000:
case 0xA000:
case 0xB000:
if (addr <= 0xB7FF)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x27FF) + 0x6C00];
}
else if (addr <= 0xB9FF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x29FF) + 0x6C00];
}
else if (addr <= 0xBBFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x2BFF) + 0x6C00];
}
else if (addr <= 0xBDFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x2DFF) + 0x6C00];
}
else
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x2FFF) + 0x6C00];
}
break;
case 0xC000:
if (addr <= 0xC03F)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (true)
{
// TODO: OK only during VBlank Period 1.
if (addr == 0xC021)
// TODO: Switch into Color Stack mode.
core = STIC_Registers[0x0021];
else
throw new ArgumentException(WRITE_ONLY_STIC);
}
else
core = Cartridge[(addr & 0x003F) + 0x9C00];
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0x9C00];
}
break;
case 0xD000:
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0xAC00];
break;
case 0xE000:
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0xBC00];
break;
case 0xF000:
if (addr <= 0xF7FF)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x07FF) + 0xCC00];
}
else if (addr <= 0xF9FF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x09FF) + 0xCC00];
}
else if (addr <= 0xFBFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0BFF) + 0xCC00];
}
else if (addr <= 0xFDFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0DFF) + 0xCC00];
}
else
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_READ);
else
core = Cartridge[(addr & 0x0FFF) + 0xCC00];
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
break;
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
default:
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
throw new ArgumentException(INVALID);
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
-Made MVI@ and ADD@ follow the stack and immediate mode rules for incrementing / decrementing the SP / PC. -Disabled Intellicart hook for ReadMemory, which seemed to be interfering. -Implemented MVO@. -Several instructions are now executed in succession until it hits the unimplemented "XORR R5, R5". I should probably refactor Disassemble and Execute to label registers as source / destination to avoid further confusion at some point. My disassembly might have the source / destination registers flipped as well.
2012-07-20 07:22:41 +00:00
/*
TODO: Fix Intellicart hook.
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
if (cart != null)
return (ushort)cart;
-Made MVI@ and ADD@ follow the stack and immediate mode rules for incrementing / decrementing the SP / PC. -Disabled Intellicart hook for ReadMemory, which seemed to be interfering. -Implemented MVO@. -Several instructions are now executed in succession until it hits the unimplemented "XORR R5, R5". I should probably refactor Disassemble and Execute to label registers as source / destination to avoid further confusion at some point. My disassembly might have the source / destination registers flipped as well.
2012-07-20 07:22:41 +00:00
*/
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
return core;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
-Made the memory map use ushort arrays because the Intellivision is 16-bit. -Fixed JMP disassembly; I need to return on an invalid opcode because I was breaking out of the inner switch statement, not both that and the outer one.
2012-07-09 23:19:57 +00:00
public void WriteMemory(ushort addr, ushort value)
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
{
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
WriteCart(addr, value);
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
switch (addr & 0xF000)
{
case 0x0000:
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
if (addr <= 0x003F)
STIC_Registers[addr] = value;
else if (addr <= 0x007F)
throw new ArgumentException(READ_ONLY_STIC);
else if (addr <= 0x00FF)
throw new ArgumentException(UNOCCUPIED);
else if (addr <= 0x01EF)
-Made Executive ROM and Graphics ROM read-only. I still haven't made the memory map accessibility limited by the VBlank Period, but I'm assuming that should come way later. -Initialized the memory devices with a tentative size that ignores the unofficial ranges. -Masked addresses to match those sizes (That's my understanding of what the memory map needs to do based on other examples). -Added the ICart interface. -Started the Intellicart parser; got far enough to know that the files I'm working with are not Intellicarts. ^_^
2012-07-15 08:38:50 +00:00
Scratchpad_RAM[addr & 0x00EF] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x01FF)
PSG_Registers[addr & 0x000F] = value;
else if (addr <= 0x035F)
System_RAM[addr & 0x015F] = value;
else if (addr <= 0x03FF)
// TODO: Intellivision II support?
throw new ArgumentException(GARBAGE);
else if (addr <= 0x04FF)
// TODO: Actually map cartridge (on all but Intellivision II) RAM / ROM to decide which path to take.
if (false)
// TODO: Intellivision II support?
throw new ArgumentException(INTV2_EXEC);
else
Cartridge[addr & 0x00FF] = value;
else if (addr <= 0x06FF)
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[addr & 0x02FF] = value;
else if (addr <= 0x0CFF)
// TODO: Actually map cartridge (only if no Intellivoice) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[addr & 0x08FF] = value;
else
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[addr & 0x0BFF] = value;
break;
case 0x1000:
throw new ArgumentException(READ_ONLY_EXEC);
case 0x2000:
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x0FFF) + 0x0C00] = value;
break;
case 0x3000:
if (addr <= 0x37FF)
throw new ArgumentException(READ_ONLY_GROM);
else if (addr <= 0x39FF)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else if (addr <= 0x3BFF)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else if (addr <= 0x3DFF)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
break;
case 0x4000:
if (addr <= 0x403F)
{
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (true)
// TODO: OK only during VBlank Period 1.
STIC_Registers[addr & 0x003F] = value;
else
Cartridge[(addr & 0x003F) + 0x1C00] = value;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr <= 0x47FF)
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
{
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x07FF) + 0x1C00] = value;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
else if (addr == 0x4800)
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
{
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
// TODO: Actually map cartridge (only if boot ROM at $7000) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[0x2400] = value;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
else
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
{
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x0FFF) + 0x1C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
break;
case 0x5000:
case 0x6000:
if (addr <= 0x5014)
{
/*
TODO: Actually map (only if boot ROM at $4800 or $7000) cartridge RAM / ROM to decide which path to
take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x0014) + 0x2C00] = value;
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
else
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
{
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x1FFF) + 0x2C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
break;
case 0x7000:
if (addr == 0x7000)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (confuses EXEC boot sequence) / ROM to decide
which path to take.
*/
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[0x04C00] = value;
}
else if (addr <= 0x77FF)
{
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x07FF) + 0x4C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x79FF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (true)
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
// TODO: OK only during VBlank Period 2.
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
Graphics_RAM[addr & 0x01FF] = value;
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x09FF) + 0x4C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x7BFF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (true)
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
// TODO: OK only during VBlank Period 2.
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
Graphics_RAM[addr & 0x01FF] = value;
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x0BFF) + 0x4C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else if (addr <= 0x7DFF)
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (true)
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
// TODO: OK only during VBlank Period 2.
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
Graphics_RAM[addr & 0x01FF] = value;
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x0DFF) + 0x4C00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
else
{
/*
TODO: Actually map cartridge (only if no ECS) RAM (Do not because of GRAM alias) / ROM to decide
which path to take.
*/
if (true)
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x0FFF) + 0x4C00] = value;
}
break;
case 0x8000:
if (addr <= 0x803F)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (true)
// TODO: OK only during VBlank Period 1.
STIC_Registers[addr & 0x003F] = value;
else
Cartridge[(addr & 0x003F) + 0x5C00] = value;
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x0FFF) + 0x5C00] = value;
}
break;
case 0x9000:
case 0xA000:
case 0xB000:
if (addr <= 0xB7FF)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x27FF) + 0x6C00] = value;
}
else if (addr <= 0xB9FF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x29FF) + 0x6C00] = value;
}
else if (addr <= 0xBBFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x2BFF) + 0x6C00] = value;
}
else if (addr <= 0xBDFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x2DFF) + 0x6C00] = value;
}
else
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x2FFF) + 0x6C00] = value;
}
break;
case 0xC000:
if (addr <= 0x803F)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (true)
// TODO: OK only during VBlank Period 1.
STIC_Registers[addr & 0x003F] = value;
else
Cartridge[(addr & 0x003F) + 0x9C00] = value;
}
else
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x0FFF) + 0x9C00] = value;
}
break;
case 0xD000:
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x0FFF) + 0xAC00] = value;
break;
case 0xE000:
// TODO: Actually map cartridge (only if no ECS) RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x0FFF) + 0xBC00] = value;
break;
case 0xF000:
if (addr <= 0xF7FF)
{
// TODO: Actually map cartridge RAM / ROM to decide which path to take.
if (false)
throw new ArgumentException(UNOCCUPIED_CART_WRITE);
else
Cartridge[(addr & 0x07FF) + 0xCC00] = value;
}
else if (addr <= 0xF9FF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x09FF) + 0xCC00] = value;
}
else if (addr <= 0xFBFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x0BFF) + 0xCC00] = value;
}
else if (addr <= 0xFDFF)
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Graphics_RAM[addr & 0x01FF] = value;
else
Cartridge[(addr & 0x0DFF) + 0xCC00] = value;
}
else
{
/*
TODO: Actually map cartridge RAM (Do not because of GRAM alias) / ROM to decide which path to take.
*/
if (true)
// TODO: OK only during VBlank Period 2.
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
Graphics_RAM[addr & 0x01FF] = value;
else
Finished the Memory Map. I think the cartridge logic needs to be separated.
2012-07-31 01:39:47 +00:00
Cartridge[(addr & 0x0FFF) + 0xCC00] = value;
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
}
break;
-Refactored ReadMemory so that both the core and cart addresses are read. --Afterwards, the data is reconciled, right now by chucking out the core value if the cart responded. -WriteMemory now writes to both the core and the cart unconditionally. --Each case now breaks out of the switch statement in case we want to do more complex things at the end of the function later on. -All default paths in both functions now throw an exception.
2012-07-18 06:19:03 +00:00
default:
Started filling the gaps in the Memory Map, getting up to 0x7FFF. Once complete, a lot of TODOs remain, the most important being the actual mapping of the cartridge.
2012-07-30 22:25:00 +00:00
throw new ArgumentException(INVALID);
Checked in memory map...I need to stop programming and start sleeping.
2012-07-09 19:41:49 +00:00
}
}
}
}