ShuriZma
/
fbneo
mirror of https://github.com/finalburnneo/FBNeo.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Phase 2. Remove xxx_RAM, xxx_ROM, etc. Now use MAP_RAM, MAP_ROM, etc.

This commit is contained in:
iq_132 2015-02-10 04:47:38 +00:00
parent 04e1d44a1c
commit f3ba4fe0c1
250 changed files with 4111 additions and 4214 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/burn/burn.h
View File

@ -194,7 +194,8 @@ struct BurnDIPInfo {
#define MAP_WRITE 2
#define MAP_FETCHOP 4
#define MAP_FETCHARG 8
#define MAP_ROM (MAP_READ|MAP_FETCHOP|MAP_FETCHARG)
#define MAP_FETCH (MAP_FETCHOP|MAP_FETCHARG)
#define MAP_ROM (MAP_READ|MAP_FETCH)
#define MAP_RAM (MAP_ROM|MAP_WRITE)

4
src/burn/devices/nmk004.cpp
View File

@ -143,8 +143,8 @@ void NMK004_init()
tlcs90Init(0, 8000000);
tlcs90Open(0);
tlcs90MapMemory(NMK004PROGROM, 0x0000, 0xefff, TLCS90_ROM);
tlcs90MapMemory(ram, 0xf000, 0xf7ff, TLCS90_RAM);
tlcs90MapMemory(NMK004PROGROM, 0x0000, 0xefff, MAP_ROM);
tlcs90MapMemory(ram, 0xf000, 0xf7ff, MAP_RAM);
tlcs90SetReadHandler(nmk004_tlcs90_read);
tlcs90SetWriteHandler(nmk004_tlcs90_write);
tlcs90SetWritePortHandler(nmk004_tlcs90_write_port);

46
src/burn/drv/capcom/cps_mem.cpp
View File

@ -87,15 +87,15 @@ void CpsMapObjectBanks(INT32 nBank)
nCpsObjectBank = nBank;
if (nCpsObjectBank) {
SekMapMemory(CpsRam708 + 0x8000, 0x708000, 0x709FFF, SM_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70A000, 0x70BFFF, SM_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70C000, 0x70DFFF, SM_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70E000, 0x70FFFF, SM_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x708000, 0x709FFF, MAP_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70A000, 0x70BFFF, MAP_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70C000, 0x70DFFF, MAP_RAM);
SekMapMemory(CpsRam708 + 0x8000, 0x70E000, 0x70FFFF, MAP_RAM);
} else {
SekMapMemory(CpsRam708, 0x708000, 0x709FFF, SM_RAM);
SekMapMemory(CpsRam708, 0x70A000, 0x70BFFF, SM_RAM);
SekMapMemory(CpsRam708, 0x70C000, 0x70DFFF, SM_RAM);
SekMapMemory(CpsRam708, 0x70E000, 0x70FFFF, SM_RAM);
SekMapMemory(CpsRam708, 0x708000, 0x709FFF, MAP_RAM);
SekMapMemory(CpsRam708, 0x70A000, 0x70BFFF, MAP_RAM);
SekMapMemory(CpsRam708, 0x70C000, 0x70DFFF, MAP_RAM);
SekMapMemory(CpsRam708, 0x70E000, 0x70FFFF, MAP_RAM);
}
}
}
@ -252,16 +252,16 @@ INT32 CpsMemInit()
// Map in memory:
// 68000 Rom (as seen as is, through read)
SekMapMemory(CpsRom, 0, nCpsRomLen - 1, SM_READ);
SekMapMemory(CpsRom, 0, nCpsRomLen - 1, MAP_READ);
// 68000 Rom (as seen decrypted, through fetch)
if (nCpsCodeLen > 0) {
// Decoded part (up to nCpsCodeLen)
SekMapMemory(CpsCode, 0, nCpsCodeLen - 1, SM_FETCH);
SekMapMemory(CpsCode, 0, nCpsCodeLen - 1, MAP_FETCH);
}
if (nCpsRomLen > nCpsCodeLen) {
// The rest (up to nCpsRomLen)
SekMapMemory(CpsRom + nCpsCodeLen, nCpsCodeLen, nCpsRomLen - 1, SM_FETCH);
SekMapMemory(CpsRom + nCpsCodeLen, nCpsCodeLen, nCpsRomLen - 1, MAP_FETCH);
}
if (Cps == 2) {
@ -269,24 +269,24 @@ INT32 CpsMemInit()
CpsMapObjectBanks(0);
#if 0
SekMapHandler(3, 0x660000, 0x663FFF, SM_RAM);
SekMapHandler(3, 0x660000, 0x663FFF, MAP_RAM);
SekSetReadByteHandler(3, CPSExtraNVRAMReadByte);
SekSetWriteByteHandler(3, CPSExtraNVRAMWriteByte);
#else
SekMapMemory(CpsRam660, 0x660000, 0x663FFF, SM_RAM);
SekMapMemory(CpsRam660, 0x660000, 0x663FFF, MAP_RAM);
#endif
// SekMapHandler(4, 0x708000, 0x709FFF, SM_WRITE);
// SekMapHandler(4, 0x70A000, 0x70BFFF, SM_WRITE);
// SekMapHandler(4, 0x70C000, 0x70DFFF, SM_WRITE);
// SekMapHandler(4, 0x70E000, 0x70FFFF, SM_WRITE);
// SekMapHandler(4, 0x708000, 0x709FFF, MAP_WRITE);
// SekMapHandler(4, 0x70A000, 0x70BFFF, MAP_WRITE);
// SekMapHandler(4, 0x70C000, 0x70DFFF, MAP_WRITE);
// SekMapHandler(4, 0x70E000, 0x70FFFF, MAP_WRITE);
// SekSetWriteByteHandler(4, CpsWriteSpriteByte);
// SekSetWriteWordHandler(4, CpsWriteSpriteWord);
}
SekMapMemory(CpsRam90, 0x900000, 0x92FFFF, SM_RAM); // Gfx Ram
SekMapMemory(CpsRamFF, 0xFF0000, 0xFFFFFF, SM_RAM); // Work Ram
SekMapMemory(CpsRam90, 0x900000, 0x92FFFF, MAP_RAM); // Gfx Ram
SekMapMemory(CpsRamFF, 0xFF0000, 0xFFFFFF, MAP_RAM); // Work Ram
SekSetReadByteHandler(0, CpsReadByte);
SekSetWriteByteHandler(0, CpsWriteByte);
@ -295,7 +295,7 @@ INT32 CpsMemInit()
// QSound
if ((Cps == 2) && !Cps2DisableQSnd) {
SekMapHandler(1, 0x618000, 0x619FFF, SM_RAM);
SekMapHandler(1, 0x618000, 0x619FFF, MAP_RAM);
SekSetReadByteHandler(1, CPSQSoundC0ReadByte);
SekSetWriteByteHandler(1, CPSQSoundC0WriteByte);
@ -307,11 +307,11 @@ INT32 CpsMemInit()
CpsEncZRom[(i << 1) + 0] = CpsEncZRom[i];
CpsEncZRom[(i << 1) + 1] = 0xFF;
}
SekMapMemory(CpsEncZRom, 0xF00000, 0xF0FFFF, SM_ROM);
SekMapMemory(CpsEncZRom, 0xF00000, 0xF0FFFF, MAP_ROM);
// QSound shared RAM
SekMapHandler(1, 0xF18000, 0xF19FFF, SM_RAM);
SekMapHandler(2, 0xF1E000, 0xF1FFFF, SM_RAM);
SekMapHandler(1, 0xF18000, 0xF19FFF, MAP_RAM);
SekMapHandler(2, 0xF1E000, 0xF1FFFF, MAP_RAM);
SekSetReadByteHandler(1, CPSQSoundC0ReadByte);
SekSetWriteByteHandler(1, CPSQSoundC0WriteByte);

172
src/burn/drv/capcom/d_cps1.cpp
View File

@ -13204,7 +13204,7 @@ static INT32 CawingblInit()
nRet = DrvInit();
SekOpen(0);
SekMapHandler(1, 0x882000, 0x882fff, SM_READ | SM_WRITE);
SekMapHandler(1, 0x882000, 0x882fff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, CawingblInputReadByte);
SekSetReadWordHandler(1, CawingblInputReadWord);
SekSetWriteByteHandler(1, CawingblInputWriteByte);
@ -13240,7 +13240,7 @@ static INT32 Cawingb2Init()
nRet = DrvInit();
SekOpen(0);
SekMapHandler(1, 0x882000, 0x882fff, SM_READ | SM_WRITE);
SekMapHandler(1, 0x882000, 0x882fff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, CawingblInputReadByte);
SekSetReadWordHandler(1, CawingblInputReadWord);
SekSetWriteByteHandler(1, CawingblInputWriteByte);
@ -13331,10 +13331,10 @@ static INT32 DinopicInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x98000f, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x98000f, MAP_WRITE);
SekSetWriteWordHandler(1, DinopicScrollWrite);
SekMapHandler(2, 0x800200, 0x8002ff, SM_WRITE);
SekMapHandler(2, 0x800200, 0x8002ff, MAP_WRITE);
SekSetWriteWordHandler(2, DinopicLayerWrite);
SekClose();
@ -13355,7 +13355,7 @@ static INT32 DinohInit()
nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, DinohuntQSharedRamRead);
SekClose();
@ -13374,7 +13374,7 @@ static INT32 Dinopic4Init()
nRet = TwelveMhzInit();
/* SekOpen(0);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, DinohuntQSharedRamRead);
SekClose();*/
@ -13406,7 +13406,7 @@ static INT32 DinotInit()
nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, DinohuntQSharedRamRead);
SekClose();
@ -13429,10 +13429,10 @@ static INT32 DinotpicInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x98000f, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x98000f, MAP_WRITE);
SekSetWriteWordHandler(1, DinopicScrollWrite);
SekMapHandler(2, 0x800200, 0x8002ff, SM_WRITE);
SekMapHandler(2, 0x800200, 0x8002ff, MAP_WRITE);
SekSetWriteWordHandler(2, DinopicLayerWrite);
SekClose();
@ -13449,7 +13449,7 @@ static INT32 DinohuntInit()
nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, DinohuntQSharedRamRead);
SekClose();
@ -13551,7 +13551,7 @@ static INT32 FfightblInit()
INT32 nRet = DrvInit();
SekOpen(0);
SekMapHandler(1, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(1, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, FcrashInputReadByte);
SekSetReadWordHandler(1, FcrashInputReadWord);
SekSetWriteByteHandler(1, FcrashInputWriteByte);
@ -13589,7 +13589,7 @@ static INT32 FcrashInit()
INT32 nRet = DrvInit();
SekOpen(0);
SekMapHandler(1, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(1, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, FcrashInputReadByte);
SekSetReadWordHandler(1, FcrashInputReadWord);
SekSetWriteByteHandler(1, FcrashInputWriteByte);
@ -13698,7 +13698,7 @@ static INT32 GanbareInit()
INT32 nRet = DrvInit();
SekOpen(0);
SekMapHandler(1, 0xff0000, 0xffffff, SM_RAM);
SekMapHandler(1, 0xff0000, 0xffffff, MAP_RAM);
SekSetReadByteHandler(1, GanbareTimeKeeperReadByte);
SekSetReadWordHandler(1, GanbareTimeKeeperReadWord);
SekSetWriteByteHandler(1, GanbareTimeKeeperWriteByte);
@ -13880,12 +13880,12 @@ static INT32 DaimakaibInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, SM_RAM);
SekMapHandler(1, 0x880000, 0x88ffff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x991fff, MAP_RAM);
SekMapHandler(1, 0x880000, 0x88ffff, MAP_WRITE);
SekSetWriteWordHandler(1, Daimakaib88WriteWord);
SekMapHandler(2, 0x980000, 0x98ffff, SM_WRITE);
SekMapHandler(2, 0x980000, 0x98ffff, MAP_WRITE);
SekSetWriteWordHandler(2, Daimakaib98WriteWord);
SekMapHandler(3, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(3, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(3, DaimakaibFFWriteByte);
SekSetWriteWordHandler(3, DaimakaibFFWriteWord);
SekClose();
@ -14037,8 +14037,8 @@ static INT32 KnightsbInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x98ffff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x98ffff, MAP_WRITE);
SekSetWriteWordHandler(1, Knightsb98WriteWord);
SekClose();
@ -14179,12 +14179,12 @@ static INT32 KodbInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x900000, 0x903fff, SM_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x904000, 0x907fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x99ffff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x900000, 0x903fff, MAP_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x904000, 0x907fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x99ffff, MAP_WRITE);
SekSetWriteByteHandler(1, Kodb98WriteByte);
SekSetWriteWordHandler(1, Kodb98WriteWord);
SekMapHandler(2, 0x992000, 0x992009, SM_READ);
SekMapHandler(2, 0x992000, 0x992009, MAP_READ);
SekSetReadByteHandler(2, KodbInputReadByte);
SekClose();
@ -14452,12 +14452,12 @@ static INT32 PunipicInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, PunipicF18Read);
SekMapHandler(2, 0x980000, 0x980fff, SM_WRITE);
SekMapHandler(2, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(2, Punipic98WriteWord);
SekMapHandler(3, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(3, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(3, PunipicFFWriteByte);
SekSetWriteWordHandler(3, PunipicFFWriteWord);
SekClose();
@ -14488,12 +14488,12 @@ static INT32 Punipic2Init()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, PunipicF18Read);
SekMapHandler(2, 0x980000, 0x980fff, SM_WRITE);
SekMapHandler(2, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(2, Punipic98WriteWord);
SekMapHandler(3, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(3, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(3, PunipicFFWriteByte);
SekSetWriteWordHandler(3, PunipicFFWriteWord);
SekClose();
@ -14517,12 +14517,12 @@ static INT32 Punipic3Init()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, PunipicF18Read);
SekMapHandler(2, 0x980000, 0x980fff, SM_WRITE);
SekMapHandler(2, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(2, Punipic98WriteWord);
SekMapHandler(3, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(3, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(3, PunipicFFWriteByte);
SekSetWriteWordHandler(3, PunipicFFWriteWord);
SekClose();
@ -14780,9 +14780,9 @@ static INT32 Sf2bInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, SM_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, SM_RAM); // mirror?
SekMapHandler(1, 0x708000, 0x7fffff, SM_READ | SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, MAP_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, MAP_RAM); // mirror?
SekMapHandler(1, 0x708000, 0x7fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, Sf2bReadByte);
SekSetReadWordHandler(1, Sf2bReadWord);
SekSetWriteByteHandler(1, Sf2bWriteByte);
@ -14830,8 +14830,8 @@ static INT32 Sf2dkot2Init()
nRet = Sf2ceInit();
SekOpen(0);
SekMapMemory(CpsRom + 0x000000, 0x280000, 0x2fffff, SM_ROM);
SekMapMemory(CpsRom + 0x080000, 0x200000, 0x27ffff, SM_ROM);
SekMapMemory(CpsRom + 0x000000, 0x280000, 0x2fffff, MAP_ROM);
SekMapMemory(CpsRom + 0x080000, 0x200000, 0x27ffff, MAP_ROM);
SekClose();
return nRet;
@ -14879,7 +14879,7 @@ static INT32 Sf2rbInit()
INT32 nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x200000, 0x2fffff, SM_READ);
SekMapHandler(1, 0x200000, 0x2fffff, MAP_READ);
SekSetReadByteHandler(1, Sf2rbProtReadByte);
SekSetReadWordHandler(1, Sf2rbProtReadWord);
SekClose();
@ -14922,7 +14922,7 @@ static INT32 Sf2rb2Init()
INT32 nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x200000, 0x2fffff, SM_READ);
SekMapHandler(1, 0x200000, 0x2fffff, MAP_READ);
SekSetReadByteHandler(1, Sf2rb2ProtReadByte);
SekSetReadWordHandler(1, Sf2rb2ProtReadWord);
SekClose();
@ -15226,9 +15226,9 @@ static INT32 Sf2mdtInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, SM_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, SM_RAM); // mirror? can use either of this - seems to make no difference
SekMapHandler(1, 0x708000, 0x7fffff, SM_READ | SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, MAP_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, MAP_RAM); // mirror? can use either of this - seems to make no difference
SekMapHandler(1, 0x708000, 0x7fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, Sf2mdtReadByte);
SekSetReadWordHandler(1, Sf2mdtReadWord);
SekSetWriteByteHandler(1, Sf2mdtWriteByte);
@ -15261,10 +15261,10 @@ static INT32 Sf2mdtaInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, SM_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, SM_RAM); // mirror? can use either of this - seems to make no difference
SekMapMemory(CpsRamFF, 0xfc0000, 0xfcffff, SM_RAM);
SekMapHandler(1, 0x708000, 0x7fffff, SM_READ | SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, MAP_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, MAP_RAM); // mirror? can use either of this - seems to make no difference
SekMapMemory(CpsRamFF, 0xfc0000, 0xfcffff, MAP_RAM);
SekMapHandler(1, 0x708000, 0x7fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, Sf2mdtReadByte);
SekSetReadWordHandler(1, Sf2mdtReadWord);
SekSetWriteByteHandler(1, Sf2mdtWriteByte);
@ -15297,10 +15297,10 @@ static INT32 Sf2mdtbInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, SM_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, SM_RAM); // mirror? can use either of this - seems to make no difference
SekMapMemory(CpsRamFF, 0xfc0000, 0xfcffff, SM_RAM);
SekMapHandler(1, 0x708000, 0x7fffff, SM_READ | SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x700000, 0x703fff, MAP_RAM);
SekMapMemory(CpsBootlegSpriteRam, 0x704000, 0x707fff, MAP_RAM); // mirror? can use either of this - seems to make no difference
SekMapMemory(CpsRamFF, 0xfc0000, 0xfcffff, MAP_RAM);
SekMapHandler(1, 0x708000, 0x7fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(1, Sf2mdtReadByte);
SekSetReadWordHandler(1, Sf2mdtReadWord);
SekSetWriteByteHandler(1, Sf2mdtWriteByte);
@ -15438,8 +15438,8 @@ static INT32 Sf2ceeab2Init()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x980fff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(1, Sf2ceeablScrollWrite);
SekClose();
@ -15665,7 +15665,7 @@ static INT32 Sf2ceuablInit()
nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x800000, 0x800200, SM_RAM);
SekMapHandler(1, 0x800000, 0x800200, MAP_RAM);
SekSetReadByteHandler(1, Sf2ceuablReadByte);
SekSetWriteByteHandler(1, Sf2ceuablWriteByte);
SekSetWriteWordHandler(1, Sf2ceuablWriteWord);
@ -15746,7 +15746,7 @@ static INT32 Sf2ceuab7Init()
INT32 nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x570000, 0x57ffff, SM_READ | SM_WRITE);
SekMapHandler(1, 0x570000, 0x57ffff, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(1, Sf2ceuab7ProtReadWord);
SekSetWriteWordHandler(1, Sf2ceuab7ProtWriteWord);
SekClose();
@ -15803,7 +15803,7 @@ static INT32 Sf2dongbInit()
INT32 nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x180000, 0x1fffff, SM_READ);
SekMapHandler(1, 0x180000, 0x1fffff, MAP_READ);
SekSetReadByteHandler(1, Sf2dongbProtReadByte);
SekSetReadWordHandler(1, Sf2dongbProtReadWord);
SekClose();
@ -15863,7 +15863,7 @@ static INT32 Sf2hfjbInit()
INT32 nRet = Sf2ceInit();
SekOpen(0);
SekMapHandler(1, 0x800000, 0x807fff, SM_WRITE);
SekMapHandler(1, 0x800000, 0x807fff, MAP_WRITE);
SekSetWriteByteHandler(1, Sf2hfjbWriteByte);
SekSetWriteWordHandler(1, Sf2hfjbWriteWord);
SekClose();
@ -15988,15 +15988,15 @@ static INT32 SlampicInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsZRom, 0xf00000, 0xf0ffff, SM_ROM);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, SM_READ);
SekMapMemory(CpsZRom, 0xf00000, 0xf0ffff, MAP_ROM);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0xf18000, 0xf19fff, MAP_READ);
SekSetReadByteHandler(1, SlampicF18Read);
SekMapHandler(2, 0xf1e000, 0xf1ffff, SM_READ);
SekMapHandler(2, 0xf1e000, 0xf1ffff, MAP_READ);
SekSetReadByteHandler(2, SlampicF18Read);
SekMapHandler(3, 0x980000, 0x980fff, SM_WRITE);
SekMapHandler(3, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(3, SlampicScrollWrite);
SekMapHandler(4, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(4, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(4, SlampicFFWriteByte);
SekSetWriteWordHandler(4, SlampicFFWriteWord);
SekClose();
@ -16120,10 +16120,10 @@ static INT32 VarthbInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x980fff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x980fff, MAP_WRITE);
SekSetWriteWordHandler(1, VarthbScrollWriteWord);
SekMapHandler(2, 0x800000, 0x807fff, SM_WRITE);
SekMapHandler(2, 0x800000, 0x807fff, MAP_WRITE);
SekSetWriteByteHandler(2, VarthbRegWriteByte);
SekSetWriteWordHandler(2, VarthbRegWriteWord);
SekClose();
@ -16281,15 +16281,15 @@ static INT32 WofhInit()
nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(3, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(3, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(3, WofhInputReadByte);
SekSetReadWordHandler(3, WofhInputReadWord);
SekSetWriteByteHandler(3, WofhInputWriteByte);
SekSetWriteWordHandler(3, WofhInputWriteWord);
SekMapHandler(4, 0x135000, 0x135fff, SM_READ);
SekMapHandler(4, 0x135000, 0x135fff, MAP_READ);
SekSetReadByteHandler(4, Wofh135ReadByte);
SekSetReadWordHandler(4, Wofh135ReadWord);
SekMapHandler(5, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(5, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(5, WofbFFWriteByte);
SekSetWriteWordHandler(5, WofbFFWriteWord);
SekClose();
@ -16342,18 +16342,18 @@ static INT32 SgyxzInit()
nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(3, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(3, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(3, WofhInputReadByte);
SekSetReadWordHandler(3, WofhInputReadWord);
SekSetWriteByteHandler(3, WofhInputWriteByte);
SekSetWriteWordHandler(3, WofhInputWriteWord);
SekMapHandler(4, 0x135000, 0x135fff, SM_READ);
SekMapHandler(4, 0x135000, 0x135fff, MAP_READ);
SekSetReadByteHandler(4, Wofh135ReadByte);
SekSetReadWordHandler(4, Wofh135ReadWord);
SekMapHandler(5, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(5, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(5, WofbFFWriteByte);
SekSetWriteWordHandler(5, WofbFFWriteWord);
SekMapHandler(6, 0x900000, 0x9007FF, SM_WRITE);
SekMapHandler(6, 0x900000, 0x9007FF, MAP_WRITE);
SekSetWriteLongHandler(6, SgyxzSpriteRamWriteLong);
SekClose();
@ -16390,12 +16390,12 @@ static INT32 Wof3jsaInit()
INT32 nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(3, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(3, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(3, WofhInputReadByte);
SekSetReadWordHandler(3, WofhInputReadWord);
SekSetWriteByteHandler(3, WofhInputWriteByte);
SekSetWriteWordHandler(3, WofhInputWriteWord);
SekMapHandler(4, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(4, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(4, WofbFFWriteByte);
SekSetWriteWordHandler(4, WofbFFWriteWord);
SekClose();
@ -16500,12 +16500,12 @@ static INT32 Wof3sjInit()
INT32 nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(3, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(3, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(3, Wof3sjInputReadByte);
SekSetReadWordHandler(3, Wof3sjInputReadWord);
SekSetWriteByteHandler(3, Wof3sjInputWriteByte);
SekSetWriteWordHandler(3, Wof3sjInputWriteWord);
SekMapHandler(4, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(4, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(4, WofbFFWriteByte);
SekSetWriteWordHandler(4, WofbFFWriteWord);
SekClose();
@ -16526,12 +16526,12 @@ static INT32 WofsjInit()
INT32 nRet = TwelveMhzInit();
SekOpen(0);
SekMapHandler(3, 0x880000, 0x89ffff, SM_READ | SM_WRITE);
SekMapHandler(3, 0x880000, 0x89ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(3, Wof3sjInputReadByte);
SekSetReadWordHandler(3, Wof3sjInputReadWord);
SekSetWriteByteHandler(3, Wof3sjInputWriteByte);
SekSetWriteWordHandler(3, Wof3sjInputWriteWord);
SekMapHandler(4, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(4, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(4, WofbFFWriteByte);
SekSetWriteWordHandler(4, WofbFFWriteWord);
SekClose();
@ -16661,10 +16661,10 @@ static INT32 WofbInit()
CpsBootlegSpriteRam = (UINT8*)BurnMalloc(0x4000);
SekOpen(0);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, SM_RAM);
SekMapHandler(1, 0x980000, 0x98ffff, SM_WRITE);
SekMapMemory(CpsBootlegSpriteRam, 0x990000, 0x993fff, MAP_RAM);
SekMapHandler(1, 0x980000, 0x98ffff, MAP_WRITE);
SekSetWriteWordHandler(1, Wofb98WriteWord);
SekMapHandler(2, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(2, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(2, WofbFFWriteByte);
SekSetWriteWordHandler(2, WofbFFWriteWord);
SekClose();

6
src/burn/drv/capcom/d_cps2.cpp
View File

@ -11416,10 +11416,10 @@ static INT32 PhoenixInit()
nCpsNumScanlines = 262; // phoenix sets seem to be sensitive to timing??
SekOpen(0);
SekMapHandler(3, 0xff0000, 0xffffff, SM_WRITE);
SekMapHandler(3, 0xff0000, 0xffffff, MAP_WRITE);
SekSetWriteByteHandler(3, PhoenixOutputWriteByte);
SekSetWriteWordHandler(3, PhoenixOutputWriteWord);
SekMapHandler(4, 0x700000, 0x701fff, SM_WRITE);
SekMapHandler(4, 0x700000, 0x701fff, MAP_WRITE);
SekSetWriteByteHandler(4, PhoenixSpriteWriteByte);
SekSetWriteWordHandler(4, PhoenixSpriteWriteWord);
SekClose();
@ -12061,7 +12061,7 @@ static INT32 Gigaman2Init()
nRet = CpsRunInit();
SekOpen(0);
SekMapMemory(Gigaman2DummyQsndRam, 0x618000, 0x619fff, SM_RAM);
SekMapMemory(Gigaman2DummyQsndRam, 0x618000, 0x619fff, MAP_RAM);
SekClose();
// nCpsNumScanlines = 262; // phoenix sets seem to be sensitive to timing??

22
src/burn/drv/cave/d_dodonpachi.cpp
View File

@ -535,18 +535,18 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x700000, 0x703FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x704000, 0x707FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x708000, 0x70BFFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x70C000, 0x70FFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x700000, 0x703FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x704000, 0x707FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x708000, 0x70BFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x70C000, 0x70FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, MAP_WRITE); //
SekSetReadWordHandler(0, ddonpachReadWord);
SekSetReadByteHandler(0, ddonpachReadByte);

16
src/burn/drv/cave/d_donpachi.cpp
View File

@ -594,14 +594,14 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x200000, 0x207FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x300000, 0x307FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x400000, 0x403FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x404000, 0x407FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x500000, 0x50FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0xA08000, 0xA08FFF, SM_RAM); // Palette RAM
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x200000, 0x207FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x300000, 0x307FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x400000, 0x403FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2] + 0x4000, 0x404000, 0x407FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x500000, 0x50FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xA08000, 0xA08FFF, MAP_RAM); // Palette RAM
SekSetReadWordHandler(0, donpachiReadWord);
SekSetReadByteHandler(0, donpachiReadByte);

16
src/burn/drv/cave/d_esprade.cpp
View File

@ -567,15 +567,15 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x707FFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x707FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, MAP_WRITE); //
SekSetReadWordHandler(0, espradeReadWord);
SekSetReadByteHandler(0, espradeReadByte);

16
src/burn/drv/cave/d_feversos.cpp
View File

@ -521,14 +521,14 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x708000, 0x708FFF, SM_RAM); // Palette RAM
SekMapMemory(Ram02, 0x710000, 0x710BFF, SM_ROM);
SekMapMemory(Ram02, 0x710C00, 0x710FFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x708000, 0x708FFF, MAP_RAM); // Palette RAM
SekMapMemory(Ram02, 0x710000, 0x710BFF, MAP_ROM);
SekMapMemory(Ram02, 0x710C00, 0x710FFF, MAP_RAM);
SekSetReadWordHandler(0, feversosReadWord);
SekSetReadByteHandler(0, feversosReadByte);

16
src/burn/drv/cave/d_gaia.cpp
View File

@ -781,15 +781,15 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x50FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x60FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x70FFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x50FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x60FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x70FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, MAP_WRITE); //
SekSetReadWordHandler(0, gaiaReadWord);
SekSetReadByteHandler(0, gaiaReadByte);

16
src/burn/drv/cave/d_guwange.cpp
View File

@ -579,15 +579,15 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x200000, 0x20FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x707FFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x200000, 0x20FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x600000, 0x607FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x700000, 0x707FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0xC00000, 0xC0FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC00000, 0xC0FFFF, MAP_WRITE); //
SekSetReadWordHandler(0, guwangeReadWord);
SekSetReadByteHandler(0, guwangeReadByte);

14
src/burn/drv/cave/d_hotdogst.cpp
View File

@ -661,13 +661,13 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x300000, 0x30FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x408000, 0x408FFF, SM_RAM); // Palette RAM
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x980000, 0x987FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0xf00000, 0xf0fFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x300000, 0x30FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x408000, 0x408FFF, MAP_RAM); // Palette RAM
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x980000, 0x987FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0xf00000, 0xf0fFFF, MAP_RAM);
SekSetReadByteHandler(0, hotdogstReadByte);
SekSetWriteByteHandler(0, hotdogstWriteByte);

20
src/burn/drv/cave/d_korokoro.cpp
View File

@ -566,11 +566,11 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(CaveTileRAM[0], 0x100000, 0x107FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x180000, 0x187FFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x200000, 0x207FFF, SM_RAM);
SekMapMemory(Ram01, 0x300000, 0x30FFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(CaveTileRAM[0], 0x100000, 0x107FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x180000, 0x187FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x200000, 0x207FFF, MAP_RAM);
SekMapMemory(Ram01, 0x300000, 0x30FFFF, MAP_RAM);
SekSetReadWordHandler(0, korokoroReadWord);
SekSetReadByteHandler(0, korokoroReadByte);
@ -646,11 +646,11 @@ static INT32 crushermInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(CaveTileRAM[0], 0x100000, 0x107FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x180000, 0x187FFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x200000, 0x207FFF, SM_RAM);
SekMapMemory(Ram01, 0x340000, 0x34FFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(CaveTileRAM[0], 0x100000, 0x107FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x180000, 0x187FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x200000, 0x207FFF, MAP_RAM);
SekMapMemory(Ram01, 0x340000, 0x34FFFF, MAP_RAM);
SekSetReadWordHandler(0, korokoroReadWord);
SekSetReadByteHandler(0, korokoroReadByte);

22
src/burn/drv/cave/d_mazinger.cpp
View File

@ -704,18 +704,18 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x200000, 0x20FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[1] + 0x4000, 0x400000, 0x403FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1] + 0x4000, 0x404000, 0x407FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0] + 0x4000, 0x500000, 0x503FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0] + 0x4000, 0x504000, 0x507FFF, SM_RAM);
SekMapMemory(CavePalSrc, 0xC08000, 0xc087FF, SM_RAM); // Palette RAM
SekMapMemory(CavePalSrc + 0x8800, 0xC08800, 0xC0FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC08800, 0xC0FFFF, SM_WRITE); //
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x200000, 0x20FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1] + 0x4000, 0x400000, 0x403FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1] + 0x4000, 0x404000, 0x407FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0] + 0x4000, 0x500000, 0x503FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0] + 0x4000, 0x504000, 0x507FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xC08000, 0xc087FF, MAP_RAM); // Palette RAM
SekMapMemory(CavePalSrc + 0x8800, 0xC08800, 0xC0FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0xC08800, 0xC0FFFF, MAP_WRITE); //
SekMapMemory(Rom01 + 0x80000, 0xD00000, 0xD7FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Rom01 + 0x80000, 0xD00000, 0xD7FFFF, MAP_ROM); // CPU 0 ROM
SekSetReadByteHandler(0, mazingerReadByte);
SekSetWriteByteHandler(0, mazingerWriteByte);

22
src/burn/drv/cave/d_metmqstr.cpp
View File

@ -724,17 +724,17 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Rom01 + 0x080000, 0x100000, 0x17FFFF, SM_ROM);
SekMapMemory(Rom01 + 0x100000, 0x200000, 0x27FFFF, SM_ROM);
SekMapMemory(CaveTileRAM[2], 0x880000, 0x887FFF, SM_RAM);
SekMapMemory(Ram01 + 0x00000, 0x888000, 0x88FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, SM_RAM);
SekMapMemory(Ram01 + 0x08000, 0x908000, 0x90FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x980000, 0x987FFF, SM_RAM);
SekMapMemory(Ram01 + 0x10000, 0x988000, 0x98FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x408000, 0x408FFF, SM_RAM); // Palette RAM
SekMapMemory(CaveSpriteRAM, 0xF00000, 0xF0FFFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Rom01 + 0x080000, 0x100000, 0x17FFFF, MAP_ROM);
SekMapMemory(Rom01 + 0x100000, 0x200000, 0x27FFFF, MAP_ROM);
SekMapMemory(CaveTileRAM[2], 0x880000, 0x887FFF, MAP_RAM);
SekMapMemory(Ram01 + 0x00000, 0x888000, 0x88FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, MAP_RAM);
SekMapMemory(Ram01 + 0x08000, 0x908000, 0x90FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x980000, 0x987FFF, MAP_RAM);
SekMapMemory(Ram01 + 0x10000, 0x988000, 0x98FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x408000, 0x408FFF, MAP_RAM); // Palette RAM
SekMapMemory(CaveSpriteRAM, 0xF00000, 0xF0FFFF, MAP_RAM);
SekSetReadByteHandler(0, metmqstrReadByte);
SekSetWriteByteHandler(0, metmqstrWriteByte);
SekSetReadWordHandler(0, metmqstrReadWord);

42
src/burn/drv/cave/d_pwrinst2.cpp
View File

@ -891,16 +891,16 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x800000, 0x807FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, SM_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x980000, 0x983FFF, SM_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x984000, 0x987FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0xa00000, 0xa07FFF, SM_RAM);
SekMapMemory(Ram01 + 0x10000, 0xa08000, 0xa1FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0xf00000, 0xf04FFF, SM_RAM); // Palette RAM
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x800000, 0x807FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x980000, 0x983FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x984000, 0x987FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0xa00000, 0xa07FFF, MAP_RAM);
SekMapMemory(Ram01 + 0x10000, 0xa08000, 0xa1FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xf00000, 0xf04FFF, MAP_RAM); // Palette RAM
SekSetReadWordHandler(0, pwrinst2ReadWord);
SekSetWriteWordHandler(0, pwrinst2WriteWord);
SekSetReadByteHandler(0, pwrinst2ReadByte);
@ -973,17 +973,17 @@ static INT32 PlegendsInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(Rom01 + 0x200000, 0x600000, 0x6FFFFF, SM_ROM);
SekMapMemory(CaveTileRAM[2], 0x800000, 0x807FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, SM_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x980000, 0x983FFF, SM_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x984000, 0x987FFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0xa00000, 0xa07FFF, SM_RAM);
SekMapMemory(Ram01 + 0x10000, 0xa08000, 0xa1FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0xf00000, 0xf04FFF, SM_RAM); // Palette RAM
SekMapMemory(Rom01, 0x000000, 0x1FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(Rom01 + 0x200000, 0x600000, 0x6FFFFF, MAP_ROM);
SekMapMemory(CaveTileRAM[2], 0x800000, 0x807FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x880000, 0x887FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x900000, 0x907FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x980000, 0x983FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[3] + 0x4000, 0x984000, 0x987FFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0xa00000, 0xa07FFF, MAP_RAM);
SekMapMemory(Ram01 + 0x10000, 0xa08000, 0xa1FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0xf00000, 0xf04FFF, MAP_RAM); // Palette RAM
SekSetReadWordHandler(0, pwrinst2ReadWord);
SekSetWriteWordHandler(0, pwrinst2WriteWord);
SekSetReadByteHandler(0, pwrinst2ReadByte);

24
src/burn/drv/cave/d_sailormn.cpp
View File

@ -899,19 +899,19 @@ static INT32 gameInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x110001, SM_RAM); // ram (Air Gallet tests too far)
SekMapMemory(Rom02, 0x200000, 0x3FFFFF, SM_ROM);
SekMapMemory(Ram02, 0x400000, 0x407FFF, SM_RAM);
SekMapMemory(Ram03, 0x40C000, 0x410001, SM_RAM); // RAM (Air Gallet tests too far)
SekMapMemory(CaveSpriteRAM, 0x500000, 0x510001, SM_RAM); // Sprite RAM (Air Gallet tests too far)
SekMapMemory(CaveTileRAM[0], 0x800000, 0x807FFF, SM_RAM);
SekMapMemory(CaveTileRAM[1], 0x880000, 0x887FFF, SM_RAM);
SekMapMemory(CaveTileRAM[2], 0x900000, 0x908001, SM_RAM); // Air Gallet tests too far
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x110001, MAP_RAM); // ram (Air Gallet tests too far)
SekMapMemory(Rom02, 0x200000, 0x3FFFFF, MAP_ROM);
SekMapMemory(Ram02, 0x400000, 0x407FFF, MAP_RAM);
SekMapMemory(Ram03, 0x40C000, 0x410001, MAP_RAM); // RAM (Air Gallet tests too far)
SekMapMemory(CaveSpriteRAM, 0x500000, 0x510001, MAP_RAM); // Sprite RAM (Air Gallet tests too far)
SekMapMemory(CaveTileRAM[0], 0x800000, 0x807FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[1], 0x880000, 0x887FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[2], 0x900000, 0x908001, MAP_RAM); // Air Gallet tests too far
SekMapMemory(CavePalSrc, 0x408000, 0x4087FF, SM_RAM); // Palette RAM
SekMapMemory(CavePalSrc + 0x8800, 0x408800, 0x40BFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0x408800, 0x40BFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0x408000, 0x4087FF, MAP_RAM); // Palette RAM
SekMapMemory(CavePalSrc + 0x8800, 0x408800, 0x40BFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0x408800, 0x40BFFF, MAP_WRITE); //
SekSetReadWordHandler(0, sailormnReadWord);
SekSetReadByteHandler(0, sailormnReadByte);

14
src/burn/drv/cave/d_tjumpman.cpp
View File

@ -519,18 +519,18 @@ static INT32 DrvInit()
{
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, SM_ROM);
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x300000, 0x303FFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x304000, 0x307FFF, SM_RAM); // mirror
SekMapMemory(CaveSpriteRAM, 0x200000, 0x20FFFF, SM_RAM);
SekMapMemory(CavePalSrc, 0x500000, 0x50FFFF, SM_ROM);
SekMapMemory(Rom01, 0x000000, 0x07FFFF, MAP_ROM);
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x300000, 0x303FFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x304000, 0x307FFF, MAP_RAM); // mirror
SekMapMemory(CaveSpriteRAM, 0x200000, 0x20FFFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x500000, 0x50FFFF, MAP_ROM);
SekSetReadWordHandler(0, tjumpmanReadWord);
SekSetReadByteHandler(0, tjumpmanReadByte);
SekSetWriteWordHandler(0, tjumpmanWriteWord);
SekSetWriteByteHandler(0, tjumpmanWriteByte);
SekMapHandler(1, 0x500000, 0x50FFFF, SM_WRITE);
SekMapHandler(1, 0x500000, 0x50FFFF, MAP_WRITE);
SekSetWriteWordHandler(1, tjumpmanWriteWordPalette);
SekSetWriteByteHandler(1, tjumpmanWriteBytePalette);
SekClose();

12
src/burn/drv/cave/d_uopoko.cpp
View File

@ -512,13 +512,13 @@ static INT32 DrvInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, SM_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, SM_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, SM_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, SM_RAM);
SekMapMemory(Rom01, 0x000000, 0x0FFFFF, MAP_ROM); // CPU 0 ROM
SekMapMemory(Ram01, 0x100000, 0x10FFFF, MAP_RAM);
SekMapMemory(CaveSpriteRAM, 0x400000, 0x40FFFF, MAP_RAM);
SekMapMemory(CaveTileRAM[0], 0x500000, 0x507FFF, MAP_RAM);
SekMapMemory(CavePalSrc, 0x800000, 0x80FFFF, SM_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0x800000, 0x80FFFF, SM_WRITE); //
SekMapMemory(CavePalSrc, 0x800000, 0x80FFFF, MAP_ROM); // Palette RAM (write goes through handler)
SekMapHandler(1, 0x800000, 0x80FFFF, MAP_WRITE); //
SekSetReadWordHandler(0, uopokoReadWord);
SekSetReadByteHandler(0, uopokoReadByte);

32
src/burn/drv/dataeast/d_actfancr.cpp
View File

@ -502,8 +502,8 @@ static void Dec0SoundInit()
{
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(Drv6502RAM, 0x0000, 0x07ff, M6502_RAM);
M6502MapMemory(Drv6502ROM + 0x4000, 0x4000, 0xffff, M6502_ROM);
M6502MapMemory(Drv6502RAM, 0x0000, 0x07ff, MAP_RAM);
M6502MapMemory(Drv6502ROM + 0x4000, 0x4000, 0xffff, MAP_ROM);
M6502SetWriteHandler(Dec0_sound_write);
M6502SetReadHandler(Dec0_sound_read);
M6502Close();
@ -563,12 +563,12 @@ static INT32 ActfanInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(Drv6280ROM, 0x000000, 0x03ffff, H6280_ROM);
h6280MapMemory(DrvPf1RAM, 0x062000, 0x063fff, H6280_RAM);
h6280MapMemory(DrvPf2RAM, 0x072000, 0x073fff, H6280_RAM);
h6280MapMemory(DrvSprRAM, 0x100000, 0x1007ff, H6280_RAM);
h6280MapMemory(DrvPalRAM, 0x120000, 0x1205ff, H6280_ROM);
h6280MapMemory(Drv6280RAM, 0x1f0000, 0x1f3fff, H6280_RAM);
h6280MapMemory(Drv6280ROM, 0x000000, 0x03ffff, MAP_ROM);
h6280MapMemory(DrvPf1RAM, 0x062000, 0x063fff, MAP_RAM);
h6280MapMemory(DrvPf2RAM, 0x072000, 0x073fff, MAP_RAM);
h6280MapMemory(DrvSprRAM, 0x100000, 0x1007ff, MAP_RAM);
h6280MapMemory(DrvPalRAM, 0x120000, 0x1205ff, MAP_ROM);
h6280MapMemory(Drv6280RAM, 0x1f0000, 0x1f3fff, MAP_RAM);
h6280SetWriteHandler(actfan_main_write);
h6280SetReadHandler(actfan_main_read);
h6280Close();
@ -627,14 +627,14 @@ static INT32 TriothepInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(Drv6280ROM, 0x000000, 0x03ffff, H6280_ROM);
h6280MapMemory(DrvPf2RAM, 0x044000, 0x045fff, H6280_RAM);
h6280MapMemory(DrvPf2Scr, 0x046000, 0x0467ff, H6280_RAM);
h6280MapMemory(DrvPf1RAM, 0x064000, 0x0647ff, H6280_RAM);
h6280MapMemory(DrvPf1Scr, 0x066000, 0x0667ff, H6280_RAM);
h6280MapMemory(DrvSprRAM, 0x120000, 0x1207ff, H6280_RAM);
h6280MapMemory(DrvPalRAM, 0x130000, 0x1305ff, H6280_ROM);
h6280MapMemory(Drv6280RAM, 0x1f0000, 0x1f3fff, H6280_RAM);
h6280MapMemory(Drv6280ROM, 0x000000, 0x03ffff, MAP_ROM);
h6280MapMemory(DrvPf2RAM, 0x044000, 0x045fff, MAP_RAM);
h6280MapMemory(DrvPf2Scr, 0x046000, 0x0467ff, MAP_RAM);
h6280MapMemory(DrvPf1RAM, 0x064000, 0x0647ff, MAP_RAM);
h6280MapMemory(DrvPf1Scr, 0x066000, 0x0667ff, MAP_RAM);
h6280MapMemory(DrvSprRAM, 0x120000, 0x1207ff, MAP_RAM);
h6280MapMemory(DrvPalRAM, 0x130000, 0x1305ff, MAP_ROM);
h6280MapMemory(Drv6280RAM, 0x1f0000, 0x1f3fff, MAP_RAM);
h6280SetWriteHandler(triothep_main_write);
h6280SetReadHandler(triothep_main_read);
h6280Close();

28
src/burn/drv/dataeast/d_boogwing.cpp
View File

@ -432,20 +432,20 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x0fffff, SM_FETCH);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x242000, 0x2427ff, SM_RAM);
SekMapMemory(DrvSprRAM1, 0x246000, 0x2467ff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x264000, 0x265fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x266000, 0x267fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x268000, 0x268fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x26a000, 0x26afff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x274000, 0x275fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x276000, 0x277fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x278000, 0x278fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x27a000, 0x27afff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x284000, 0x285fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x0fffff, MAP_FETCH);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x242000, 0x2427ff, MAP_RAM);
SekMapMemory(DrvSprRAM1, 0x246000, 0x2467ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x264000, 0x265fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x266000, 0x267fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x268000, 0x268fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x26a000, 0x26afff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x274000, 0x275fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x276000, 0x277fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x278000, 0x278fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x27a000, 0x27afff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x284000, 0x285fff, MAP_RAM);
SekSetWriteWordHandler(0, boogwing_main_write_word);
SekSetWriteByteHandler(0, boogwing_main_write_byte);
SekSetReadWordHandler(0, boogwing_main_read_word);

26
src/burn/drv/dataeast/d_cbuster.cpp
View File

@ -427,19 +427,19 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x083fff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x0a0000, 0x0a1fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x0a2000, 0x0a2fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x0a4000, 0x0a47ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x0a6000, 0x0a67ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x0a8000, 0x0a8fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x0aa000, 0x0abfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x0ac000, 0x0ac7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x0ae000, 0x0ae7ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x0b0000, 0x0b07ff, SM_RAM);
SekMapMemory(DrvPalRAM0, 0x0b8000, 0x0b8fff, SM_RAM);
SekMapMemory(DrvPalRAM1, 0x0b9000, 0x0b9fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x083fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x0a0000, 0x0a1fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x0a2000, 0x0a2fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x0a4000, 0x0a47ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x0a6000, 0x0a67ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x0a8000, 0x0a8fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x0aa000, 0x0abfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x0ac000, 0x0ac7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x0ae000, 0x0ae7ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x0b0000, 0x0b07ff, MAP_RAM);
SekMapMemory(DrvPalRAM0, 0x0b8000, 0x0b8fff, MAP_RAM);
SekMapMemory(DrvPalRAM1, 0x0b9000, 0x0b9fff, MAP_RAM);
SekSetWriteWordHandler(0, cbuster_main_write_word);
SekSetWriteByteHandler(0, cbuster_main_write_byte);
SekSetReadWordHandler(0, cbuster_main_read_word);

146
src/burn/drv/dataeast/d_cninja.cpp
View File

@ -1175,18 +1175,18 @@ static INT32 CninjaInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x184000, 0x187fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x1a4000, 0x1a47ff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x184000, 0x187fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x1a4000, 0x1a47ff, MAP_RAM);
SekSetWriteWordHandler(0, cninja_main_write_word);
SekSetWriteByteHandler(0, cninja_main_write_byte);
SekSetReadWordHandler(0, cninja_main_read_word);
@ -1275,18 +1275,18 @@ static INT32 EdrandyInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x188000, 0x189fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x194000, 0x197fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x1bc000, 0x1bc7ff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x188000, 0x189fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x194000, 0x197fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x1bc000, 0x1bc7ff, MAP_RAM);
SekSetWriteWordHandler(0, cninja_main_write_word);
SekSetWriteByteHandler(0, cninja_main_write_byte);
SekSetReadWordHandler(0, cninja_main_read_word);
@ -1385,19 +1385,19 @@ static INT32 MutantfInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvSprRAM1, 0x140000, 0x1407ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x160000, 0x161fff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x304000, 0x305fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x306000, 0x307fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x308000, 0x3087ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x30a000, 0x30a7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x314000, 0x315fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x316000, 0x317fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x318000, 0x3187ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x31a000, 0x31a7ff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvSprRAM1, 0x140000, 0x1407ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x160000, 0x161fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x304000, 0x305fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x306000, 0x307fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x308000, 0x3087ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x30a000, 0x30a7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x314000, 0x315fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x316000, 0x317fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x318000, 0x3187ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x31a000, 0x31a7ff, MAP_RAM);
SekSetWriteWordHandler(0, mutantf_main_write_word);
SekSetWriteByteHandler(0, mutantf_main_write_byte);
SekSetReadWordHandler(0, mutantf_main_read_word);
@ -1471,18 +1471,18 @@ static INT32 CninjablInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, SM_ROM);
SekMapMemory(DrvSprRAM, 0x138000, 0x1387ff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x180000, 0x187fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, MAP_ROM);
SekMapMemory(DrvSprRAM, 0x138000, 0x1387ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x180000, 0x187fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, MAP_RAM);
SekSetWriteWordHandler(0, cninja_main_write_word);
SekSetWriteByteHandler(0, cninja_main_write_byte);
SekSetReadWordHandler(0, cninja_main_read_word);
@ -1585,18 +1585,18 @@ static INT32 StoneageInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x184000, 0x187fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x1a4000, 0x1a47ff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0bffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x184000, 0x187fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x19c000, 0x19dfff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x1a4000, 0x1a47ff, MAP_RAM);
SekSetWriteWordHandler(0, cninja_main_write_word);
SekSetWriteByteHandler(0, cninja_main_write_byte);
SekSetReadWordHandler(0, cninja_main_read_word);
@ -1712,18 +1712,18 @@ static INT32 Robocop2Init()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x1807ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x1a8000, 0x1a9fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x1b8000, 0x1bbfff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x144000, 0x144fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x146000, 0x146fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x14c000, 0x14c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x14e000, 0x14e7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x154000, 0x154fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x156000, 0x156fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x15c000, 0x15c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x15e000, 0x15e7ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x1807ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x1a8000, 0x1a9fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x1b8000, 0x1bbfff, MAP_RAM);
SekSetWriteWordHandler(0, robocop2_main_write_word);
SekSetWriteByteHandler(0, robocop2_main_write_byte);
SekSetReadWordHandler(0, robocop2_main_read_word);

20
src/burn/drv/dataeast/d_darkseal.cpp
View File

@ -378,16 +378,16 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x141fff, SM_RAM); // split ram
SekMapMemory(DrvPf3RAM + 0x001000, 0x200000, 0x200fff, SM_RAM); // mirror
SekMapMemory(DrvPf3RAM, 0x202000, 0x203fff, SM_RAM);
SekMapMemory(DrvPf12RowRAM, 0x220000, 0x220fff, SM_RAM);
SekMapMemory(DrvPf34RowRAM, 0x222000, 0x222fff, SM_RAM);
SekMapMemory(DrvPf2RAM, 0x260000, 0x261fff, SM_RAM);
SekMapMemory(DrvPf1RAM, 0x262000, 0x263fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x141fff, MAP_RAM); // split ram
SekMapMemory(DrvPf3RAM + 0x001000, 0x200000, 0x200fff, MAP_RAM); // mirror
SekMapMemory(DrvPf3RAM, 0x202000, 0x203fff, MAP_RAM);
SekMapMemory(DrvPf12RowRAM, 0x220000, 0x220fff, MAP_RAM);
SekMapMemory(DrvPf34RowRAM, 0x222000, 0x222fff, MAP_RAM);
SekMapMemory(DrvPf2RAM, 0x260000, 0x261fff, MAP_RAM);
SekMapMemory(DrvPf1RAM, 0x262000, 0x263fff, MAP_RAM);
SekSetWriteWordHandler(0, darkseal_write_word);
SekSetWriteByteHandler(0, darkseal_write_byte);
SekSetReadWordHandler(0, darkseal_read_word);

34
src/burn/drv/dataeast/d_dassault.cpp
View File

@ -628,24 +628,24 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM0, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x100000, 0x103fff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x201fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x203fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x212000, 0x212fff, SM_WRITE);
SekMapMemory(deco16_pf_ram[2], 0x240000, 0x240fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x242000, 0x242fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x252000, 0x252fff, SM_WRITE);
SekMapMemory(Drv68KRAM0, 0x3f8000, 0x3fbfff, SM_RAM);
SekMapMemory(DrvSprRAM1, 0x3fc000, 0x3fcfff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x3fe000, 0x3fefff, SM_FETCH);
SekMapMemory(Drv68KROM0, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x201fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x203fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x212000, 0x212fff, MAP_WRITE);
SekMapMemory(deco16_pf_ram[2], 0x240000, 0x240fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x242000, 0x242fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x252000, 0x252fff, MAP_WRITE);
SekMapMemory(Drv68KRAM0, 0x3f8000, 0x3fbfff, MAP_RAM);
SekMapMemory(DrvSprRAM1, 0x3fc000, 0x3fcfff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x3fe000, 0x3fefff, MAP_FETCH);
SekSetWriteWordHandler(0, dassault_main_write_word);
SekSetWriteByteHandler(0, dassault_main_write_byte);
SekSetReadWordHandler(0, dassault_main_read_word);
SekSetReadByteHandler(0, dassault_main_read_byte);
SekMapHandler(1, 0x3fe000, 0x3fefff, SM_WRITE | SM_READ);
SekMapHandler(1, 0x3fe000, 0x3fefff, MAP_WRITE | MAP_READ);
SekSetWriteWordHandler(1, dassault_irq_write_word);
SekSetWriteByteHandler(1, dassault_irq_write_byte);
SekSetReadWordHandler(1, dassault_irq_read_word);
@ -654,17 +654,17 @@ static INT32 DrvInit()
SekInit(1, 0x68000);
SekOpen(1);
SekMapMemory(Drv68KROM1, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM1, 0x3f8000, 0x3fbfff, SM_RAM);
SekMapMemory(DrvSprRAM0, 0x3fc000, 0x3fcfff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x3fe000, 0x3fefff, SM_FETCH);
SekMapMemory(Drv68KROM1, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM1, 0x3f8000, 0x3fbfff, MAP_RAM);
SekMapMemory(DrvSprRAM0, 0x3fc000, 0x3fcfff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x3fe000, 0x3fefff, MAP_FETCH);
SekSetWriteWordHandler(0, dassault_sub_write_word);
SekSetWriteByteHandler(0, dassault_sub_write_byte);
SekSetReadWordHandler(0, dassault_sub_read_word);
SekSetReadByteHandler(0, dassault_sub_read_byte);
SekMapHandler(1, 0x3fe000, 0x3fefff, SM_WRITE | SM_READ);
SekMapHandler(1, 0x3fe000, 0x3fefff, MAP_WRITE | MAP_READ);
SekSetWriteWordHandler(1, dassault_irq_write_word);
SekSetWriteByteHandler(1, dassault_irq_write_byte);

114
src/burn/drv/dataeast/d_dec0.cpp
View File

@ -3032,37 +3032,37 @@ static void SlyspySetProtectionMap(UINT8 Type)
// so far I've not seen evidence that the game activates the alt RAM banks and this implementation is much
// cleaner and quicker
SekMapHandler(8, 0x240000, 0x24ffff, SM_WRITE);
SekMapHandler(8, 0x240000, 0x24ffff, MAP_WRITE);
SekSetWriteByteHandler(8, SlyspyProt68KWriteByte);
SekSetWriteWordHandler(8, SlyspyProt68KWriteWord);
switch (Type) {
case 0: {
SekMapMemory(DrvVideo1ColScrollRam , 0x242000, 0x24207f, SM_WRITE);
SekMapMemory(DrvVideo1RowScrollRam , 0x242400, 0x2427ff, SM_WRITE);
SekMapMemory(DrvVideo1Ram , 0x246000, 0x247fff, SM_WRITE);
SekMapMemory(DrvCharColScrollRam , 0x24c000, 0x24c07f, SM_WRITE);
SekMapMemory(DrvCharRowScrollRam , 0x24c400, 0x24c7ff, SM_WRITE);
SekMapMemory(DrvCharRam , 0x24e000, 0x24ffff, SM_WRITE);
SekMapMemory(DrvVideo1ColScrollRam , 0x242000, 0x24207f, MAP_WRITE);
SekMapMemory(DrvVideo1RowScrollRam , 0x242400, 0x2427ff, MAP_WRITE);
SekMapMemory(DrvVideo1Ram , 0x246000, 0x247fff, MAP_WRITE);
SekMapMemory(DrvCharColScrollRam , 0x24c000, 0x24c07f, MAP_WRITE);
SekMapMemory(DrvCharRowScrollRam , 0x24c400, 0x24c7ff, MAP_WRITE);
SekMapMemory(DrvCharRam , 0x24e000, 0x24ffff, MAP_WRITE);
break;
}
case 1: {
SekMapMemory(DrvCharRam , 0x248000, 0x249fff, SM_WRITE);
SekMapMemory(DrvVideo1Ram , 0x24c000, 0x24dfff, SM_WRITE);
SekMapMemory(DrvCharRam , 0x248000, 0x249fff, MAP_WRITE);
SekMapMemory(DrvVideo1Ram , 0x24c000, 0x24dfff, MAP_WRITE);
break;
}
case 2: {
SekMapMemory(DrvVideo1Ram , 0x240000, 0x241fff, SM_WRITE);
SekMapMemory(DrvCharRam , 0x242000, 0x243fff, SM_WRITE);
SekMapMemory(DrvCharRam , 0x24e000, 0x24ffff, SM_WRITE);
SekMapMemory(DrvVideo1Ram , 0x240000, 0x241fff, MAP_WRITE);
SekMapMemory(DrvCharRam , 0x242000, 0x243fff, MAP_WRITE);
SekMapMemory(DrvCharRam , 0x24e000, 0x24ffff, MAP_WRITE);
break;
}
case 3: {
SekMapMemory(DrvCharRam , 0x240000, 0x241fff, SM_WRITE);
SekMapMemory(DrvVideo1Ram , 0x248000, 0x249fff, SM_WRITE);
SekMapMemory(DrvCharRam , 0x240000, 0x241fff, MAP_WRITE);
SekMapMemory(DrvVideo1Ram , 0x248000, 0x249fff, MAP_WRITE);
break;
}
}
@ -3521,18 +3521,18 @@ static INT32 Dec0MachineInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(DrvCharColScrollRam , 0x242000, 0x24207f, SM_RAM);
SekMapMemory(DrvCharRowScrollRam , 0x242400, 0x2427ff, SM_RAM);
SekMapMemory(Drv68KRam + 0x4000 , 0x242800, 0x243fff, SM_RAM);
SekMapMemory(DrvVideo1ColScrollRam , 0x248000, 0x24807f, SM_RAM);
SekMapMemory(DrvVideo1RowScrollRam , 0x248400, 0x2487ff, SM_RAM);
SekMapMemory(DrvVideo2ColScrollRam , 0x24c800, 0x24c87f, SM_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x24cc00, 0x24cfff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x310000, 0x3107ff, SM_RAM);
SekMapMemory(DrvPalette2Ram , 0x314000, 0x3147ff, SM_RAM);
SekMapMemory(Drv68KRam , 0xff8000, 0xffbfff, SM_RAM);
SekMapMemory(DrvSpriteRam , 0xffc000, 0xffc7ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(DrvCharColScrollRam , 0x242000, 0x24207f, MAP_RAM);
SekMapMemory(DrvCharRowScrollRam , 0x242400, 0x2427ff, MAP_RAM);
SekMapMemory(Drv68KRam + 0x4000 , 0x242800, 0x243fff, MAP_RAM);
SekMapMemory(DrvVideo1ColScrollRam , 0x248000, 0x24807f, MAP_RAM);
SekMapMemory(DrvVideo1RowScrollRam , 0x248400, 0x2487ff, MAP_RAM);
SekMapMemory(DrvVideo2ColScrollRam , 0x24c800, 0x24c87f, MAP_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x24cc00, 0x24cfff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x310000, 0x3107ff, MAP_RAM);
SekMapMemory(DrvPalette2Ram , 0x314000, 0x3147ff, MAP_RAM);
SekMapMemory(Drv68KRam , 0xff8000, 0xffbfff, MAP_RAM);
SekMapMemory(DrvSpriteRam , 0xffc000, 0xffc7ff, MAP_RAM);
SekSetReadByteHandler(0, Dec068KReadByte);
SekSetWriteByteHandler(0, Dec068KWriteByte);
SekSetReadWordHandler(0, Dec068KReadWord);
@ -3541,8 +3541,8 @@ static INT32 Dec0MachineInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502Rom , 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502Rom , 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(Dec0SoundReadByte);
M6502SetWriteHandler(Dec0SoundWriteByte);
M6502Close();
@ -3852,7 +3852,7 @@ static INT32 HippodrmInit()
Dec0DrawFunction = HippodrmDraw;
SekOpen(0);
SekMapHandler(1, 0x180000, 0x180fff, SM_RAM);
SekMapHandler(1, 0x180000, 0x180fff, MAP_RAM);
SekSetReadByteHandler(1, HippodrmShared68KReadByte);
SekSetWriteByteHandler(1, HippodrmShared68KWriteByte);
SekSetReadWordHandler(1, HippodrmShared68KReadWord);
@ -3861,9 +3861,9 @@ static INT32 HippodrmInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, H6280_ROM);
h6280MapMemory(DrvSharedRam, 0x180000, 0x1800ff, H6280_RAM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, H6280_RAM);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, MAP_ROM);
h6280MapMemory(DrvSharedRam, 0x180000, 0x1800ff, MAP_RAM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, MAP_RAM);
h6280SetReadHandler(HippodrmH6280ReadProg);
h6280SetWriteHandler(HippodrmH6280WriteProg);
h6280Close();
@ -3924,7 +3924,7 @@ static INT32 RobocopInit()
Dec0DrawFunction = RobocopDraw;
SekOpen(0);
SekMapHandler(1, 0x180000, 0x180fff, SM_RAM);
SekMapHandler(1, 0x180000, 0x180fff, MAP_RAM);
SekSetReadByteHandler(1, RobocopShared68KReadByte);
SekSetWriteByteHandler(1, RobocopShared68KWriteByte);
SekSetReadWordHandler(1, RobocopShared68KReadWord);
@ -3933,9 +3933,9 @@ static INT32 RobocopInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, H6280_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, H6280_RAM);
h6280MapMemory(DrvSharedRam, 0x1f2000, 0x1f3fff, H6280_RAM);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, MAP_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, MAP_RAM);
h6280MapMemory(DrvSharedRam, 0x1f2000, 0x1f3fff, MAP_RAM);
h6280SetReadHandler(RobocopH6280ReadProg);
h6280SetWriteHandler(RobocopH6280WriteProg);
h6280Close();
@ -4021,13 +4021,13 @@ static INT32 SlyspyDrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(DrvVideo2ColScrollRam , 0x300800, 0x30087f, SM_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x300c00, 0x300fff, SM_RAM);
SekMapMemory(DrvVideo2Ram , 0x301000, 0x3017ff, SM_RAM);
SekMapMemory(Drv68KRam , 0x304000, 0x307fff, SM_RAM);
SekMapMemory(DrvSpriteRam , 0x308000, 0x3087ff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x310000, 0x3107ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(DrvVideo2ColScrollRam , 0x300800, 0x30087f, MAP_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x300c00, 0x300fff, MAP_RAM);
SekMapMemory(DrvVideo2Ram , 0x301000, 0x3017ff, MAP_RAM);
SekMapMemory(Drv68KRam , 0x304000, 0x307fff, MAP_RAM);
SekMapMemory(DrvSpriteRam , 0x308000, 0x3087ff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x310000, 0x3107ff, MAP_RAM);
SekSetReadByteHandler(0, Slyspy68KReadByte);
SekSetWriteByteHandler(0, Slyspy68KWriteByte);
SekSetReadWordHandler(0, Slyspy68KReadWord);
@ -4036,8 +4036,8 @@ static INT32 SlyspyDrvInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, H6280_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, H6280_RAM);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, MAP_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, MAP_RAM);
h6280SetReadHandler(SlyspyH6280ReadProg);
h6280SetWriteHandler(SlyspyH6280WriteProg);
h6280Close();
@ -4227,16 +4227,16 @@ static INT32 MidresInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvSpriteRam , 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x1407ff, SM_RAM);
SekMapMemory(DrvVideo1ColScrollRam , 0x240000, 0x24007f, SM_RAM);
SekMapMemory(DrvVideo1RowScrollRam , 0x240400, 0x2407ff, SM_RAM);
SekMapMemory(DrvVideo2ColScrollRam , 0x2c0000, 0x2c007f, SM_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x2c0400, 0x2c07ff, SM_RAM);
SekMapMemory(DrvCharColScrollRam , 0x340000, 0x34007f, SM_RAM);
SekMapMemory(DrvCharRowScrollRam , 0x340400, 0x3407ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvSpriteRam , 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x1407ff, MAP_RAM);
SekMapMemory(DrvVideo1ColScrollRam , 0x240000, 0x24007f, MAP_RAM);
SekMapMemory(DrvVideo1RowScrollRam , 0x240400, 0x2407ff, MAP_RAM);
SekMapMemory(DrvVideo2ColScrollRam , 0x2c0000, 0x2c007f, MAP_RAM);
SekMapMemory(DrvVideo2RowScrollRam , 0x2c0400, 0x2c07ff, MAP_RAM);
SekMapMemory(DrvCharColScrollRam , 0x340000, 0x34007f, MAP_RAM);
SekMapMemory(DrvCharRowScrollRam , 0x340400, 0x3407ff, MAP_RAM);
SekSetReadByteHandler(0, Midres68KReadByte);
SekSetWriteByteHandler(0, Midres68KWriteByte);
SekSetReadWordHandler(0, Midres68KReadWord);
@ -4245,8 +4245,8 @@ static INT32 MidresInit()
h6280Init(0);
h6280Open(0);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, H6280_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, H6280_RAM);
h6280MapMemory(DrvH6280Rom , 0x000000, 0x00ffff, MAP_ROM);
h6280MapMemory(DrvH6280Ram , 0x1f0000, 0x1f1fff, MAP_RAM);
h6280SetReadHandler(MidresH6280ReadProg);
h6280SetWriteHandler(MidresH6280WriteProg);
h6280Close();

202
src/burn/drv/dataeast/d_dec8.cpp
View File

@ -957,7 +957,7 @@ static void bankswitch(INT32 data)
{
RomBank = (data & 0x0f) * 0x4000;
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, HD6309_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM); // bank
}
void ghostb_main_write(UINT16 address, UINT8 data)
@ -1320,22 +1320,22 @@ static INT32 DrvInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x17ff, HD6309_RAM);
HD6309MapMemory(DrvVidRAM, 0x1800, 0x1fff, HD6309_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2000, 0x2bff, HD6309_RAM);// 0 - 27ff
HD6309MapMemory(DrvRowRAM, 0x2c00, 0x2fff, HD6309_RAM);// c00-dff
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, HD6309_RAM);
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, HD6309_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x17ff, MAP_RAM);
HD6309MapMemory(DrvVidRAM, 0x1800, 0x1fff, MAP_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2000, 0x2bff, MAP_RAM);// 0 - 27ff
HD6309MapMemory(DrvRowRAM, 0x2c00, 0x2fff, MAP_RAM);// c00-dff
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(ghostb_main_write);
HD6309SetReadHandler(ghostb_main_read);
HD6309Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, M6502_FETCH);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, MAP_FETCH);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(ghostb_sound_write);
M6502Close();
@ -1767,7 +1767,7 @@ static INT32 GhostbScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
HD6309Open(0);
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM);
HD6309Close();
}
}
@ -1934,7 +1934,7 @@ static void m6809_bankswitch(INT32 data)
{
RomBank = (data & 0x0f) * 0x4000;
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, M6809_ROM); // bank
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM); // bank
}
@ -2144,24 +2144,24 @@ static INT32 CobraInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvMainRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x0800, 0x0fff, M6809_RAM);
M6809MapMemory(DrvPf1RAM, 0x1000, 0x1fff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvMainRAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x0800, 0x0fff, MAP_RAM);
M6809MapMemory(DrvPf1RAM, 0x1000, 0x1fff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(cobra_main_write);
M6809SetReadHandler(cobra_main_read);
M6809Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
// m6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_READ);
// m6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, M6502_FETCH);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
// m6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_READ);
// m6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, MAP_FETCH);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(ghostb_sound_write);
M6502Close();
@ -2415,7 +2415,7 @@ static INT32 CobraScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
M6809Open(0);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM);
M6809Close();
}
}
@ -2779,24 +2779,24 @@ static INT32 SrdarwinInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvMainRAM, 0x0000, 0x05ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x0600, 0x07ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x1000, 0x13ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x1400, 0x17ff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x2800, 0x28ff, M6809_RAM);
M6809MapMemory(DrvPalRAM + 0x100, 0x3000, 0x30ff, M6809_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvMainRAM, 0x0000, 0x05ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x0600, 0x07ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, MAP_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x1000, 0x13ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x1400, 0x17ff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x2800, 0x28ff, MAP_RAM);
M6809MapMemory(DrvPalRAM + 0x100, 0x3000, 0x30ff, MAP_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(srdarwin_main_write);
M6809SetReadHandler(srdarwin_main_read);
M6809Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, M6502_FETCH);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, MAP_FETCH);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(ghostb_sound_write);
M6502Close();
@ -3465,13 +3465,13 @@ static INT32 GondoInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x17ff, HD6309_RAM);
HD6309MapMemory(DrvVidRAM, 0x1800, 0x1fff, HD6309_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2000, 0x27ff, HD6309_RAM);
HD6309MapMemory(DrvPalRAM, 0x2800, 0x2fff, HD6309_RAM);//xxxxBBBBGGGGRRRR_split
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, HD6309_RAM);
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, HD6309_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x17ff, MAP_RAM);
HD6309MapMemory(DrvVidRAM, 0x1800, 0x1fff, MAP_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2000, 0x27ff, MAP_RAM);
HD6309MapMemory(DrvPalRAM, 0x2800, 0x2fff, MAP_RAM);//xxxxBBBBGGGGRRRR_split
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(gondo_main_write);
if (!strcmp(BurnDrvGetTextA(DRV_NAME), "garyoret")) {
HD6309SetReadHandler(garyoret_main_read);
@ -3482,8 +3482,8 @@ static INT32 GondoInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(gondo_sound_write);
M6502Close();
@ -3709,7 +3709,7 @@ static INT32 GondoScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
HD6309Open(0);
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM);
HD6309Close();
}
}
@ -4070,31 +4070,31 @@ static INT32 OscarInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x1fff, HD6309_RAM); // all shared?
HD6309MapMemory(DrvVidRAM, 0x2000, 0x28ff, HD6309_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2800, 0x2fff, HD6309_RAM);
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, HD6309_RAM);
HD6309MapMemory(DrvPalRAM, 0x3800, 0x3bff, HD6309_RAM); // xxxxBBBBGGGGRRRR_be_w
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, HD6309_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x1fff, MAP_RAM); // all shared?
HD6309MapMemory(DrvVidRAM, 0x2000, 0x28ff, MAP_RAM);
HD6309MapMemory(DrvPf0RAM, 0x2800, 0x2fff, MAP_RAM);
HD6309MapMemory(DrvSprRAM, 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvPalRAM, 0x3800, 0x3bff, MAP_RAM); // xxxxBBBBGGGGRRRR_be_w
HD6309MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM); // bank
HD6309MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(oscar_main_write);
HD6309SetReadHandler(oscar_main_read);
HD6309Close();
HD6309Init(1);
HD6309Open(1);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x0eff, HD6309_RAM); // all shared? AM_RANGE(0x0f00, 0x0fff) AM_RAM not?
HD6309MapMemory(DrvPalRAM + 0x400, 0x0f00, 0x0fff, HD6309_RAM); // not really pal...
HD6309MapMemory(DrvMainRAM + 0x1000, 0x1000, 0x1fff, HD6309_RAM); // all shared? AM_RANGE(0x0f00, 0x0fff) AM_RAM not?
HD6309MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvMainRAM, 0x0000, 0x0eff, MAP_RAM); // all shared? AM_RANGE(0x0f00, 0x0fff) AM_RAM not?
HD6309MapMemory(DrvPalRAM + 0x400, 0x0f00, 0x0fff, MAP_RAM); // not really pal...
HD6309MapMemory(DrvMainRAM + 0x1000, 0x1000, 0x1fff, MAP_RAM); // all shared? AM_RANGE(0x0f00, 0x0fff) AM_RAM not?
HD6309MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(oscar_sub_write); // 0x3e80, 0x3e83 used...
HD6309Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, M6502_FETCH);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_READ);
M6502MapMemory(DrvM6502OPS + 0x8000, 0x8000, 0xffff, MAP_FETCH);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(gondo_sound_write);
M6502Close();
@ -4720,34 +4720,34 @@ static INT32 LastmissInit()
M6809Init(2);
M6809Open(0);
M6809MapMemory(DrvMainRAM, 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvMainRAM, 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(lastmiss_main_write);
M6809SetReadHandler(lastmiss_main_read);
M6809Close();
M6809Open(1);
M6809MapMemory(DrvMainRAM, 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, M6809_ROM);
M6809MapMemory(DrvMainRAM, 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvMainRAM + 0x1000, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, MAP_ROM);
M6809SetWriteHandler(lastmiss_main_write);
M6809SetReadHandler(lastmiss_main_read);
M6809Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(ghostb_sound_read);
M6502SetWriteHandler(gondo_sound_write);
M6502Close();
@ -4978,7 +4978,7 @@ static INT32 LastmissScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
M6809Open(0);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM);
M6809Close();
}
}
@ -5337,7 +5337,7 @@ static void csilver_sound_bank(INT32 data)
{
SndRomBank = (data & 8) >> 3;
M6502MapMemory(DrvM6502ROM + 0x10000 + SndRomBank * 0x4000, 0x4000, 0x7fff, M6502_ROM);
M6502MapMemory(DrvM6502ROM + 0x10000 + SndRomBank * 0x4000, 0x4000, 0x7fff, MAP_ROM);
}
void csilver_sound_write(UINT16 address, UINT8 data)
@ -5434,35 +5434,35 @@ static INT32 CsilverInit()
M6809Init(2);
M6809Open(0);
M6809MapMemory(DrvMainRAM + 0x00000, 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, M6809_RAM); // xxxxbbbbggggrrrr
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x01000, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, M6809_RAM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x00000, 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, MAP_RAM); // xxxxbbbbggggrrrr
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvMainRAM + 0x01000, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvMainROM + 0x10000, 0x4000, 0x7fff, MAP_RAM);
M6809MapMemory(DrvMainROM + 0x08000, 0x8000, 0xffff, MAP_RAM);
M6809SetWriteHandler(csilver_main_write);
M6809SetReadHandler(csilver_main_read);
M6809Close();
M6809Open(1);
M6809MapMemory(DrvMainRAM + 0x00000, 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, M6809_RAM); // xxxxbbbbggggrrrr
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x01000, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, M6809_RAM);
M6809MapMemory(DrvMainRAM + 0x00000, 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvPalRAM, 0x1000, 0x17ff, MAP_RAM); // xxxxbbbbggggrrrr
M6809MapMemory(DrvVidRAM, 0x2000, 0x27ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvMainRAM + 0x01000, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvPf0RAM, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvSubROM + 0x04000, 0x4000, 0xffff, MAP_RAM);
M6809SetWriteHandler(csilver_main_write);
M6809SetReadHandler(csilver_main_read);
M6809Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x07ff, M6502_RAM);
M6502MapMemory(DrvM6502ROM + 0x4000, 0x4000, 0x7fff, M6502_ROM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502RAM, 0x0000, 0x07ff, MAP_RAM);
M6502MapMemory(DrvM6502ROM + 0x4000, 0x4000, 0x7fff, MAP_ROM);
M6502MapMemory(DrvM6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(csilver_sound_read);
M6502SetWriteHandler(csilver_sound_write);
M6502Close();
@ -5580,11 +5580,11 @@ static INT32 CsilverScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
M6809Open(0);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvMainROM + 0x10000 + RomBank, 0x4000, 0x7fff, MAP_ROM);
M6809Close();
M6502Open(0);
M6502MapMemory(DrvM6502ROM + 0x10000 + SndRomBank * 0x4000, 0x4000, 0x7fff, M6502_ROM);
M6502MapMemory(DrvM6502ROM + 0x10000 + SndRomBank * 0x4000, 0x4000, 0x7fff, MAP_ROM);
M6502Close();
}
}

18
src/burn/drv/dataeast/d_dietgogo.cpp
View File

@ -275,15 +275,15 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x07ffff, SM_FETCH);
SekMapMemory(deco16_pf_ram[0], 0x210000, 0x211fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x212000, 0x213fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x220000, 0x2207ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x222000, 0x2227ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x280000, 0x2807ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x300000, 0x300bff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x380000, 0x38ffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x07ffff, MAP_FETCH);
SekMapMemory(deco16_pf_ram[0], 0x210000, 0x211fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x212000, 0x213fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x220000, 0x2207ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x222000, 0x2227ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x280000, 0x2807ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x300000, 0x300bff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x380000, 0x38ffff, MAP_RAM);
SekSetWriteWordHandler(0, dietgogo_main_write_word);
SekSetWriteByteHandler(0, dietgogo_main_write_byte);
SekSetReadWordHandler(0, dietgogo_main_read_word);

16
src/burn/drv/dataeast/d_funkyjet.cpp
View File

@ -392,14 +392,14 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x140000, 0x143fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x160000, 0x1607ff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x140000, 0x143fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x160000, 0x1607ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, MAP_RAM);
SekSetWriteWordHandler(0, funkyjet_main_write_word);
SekSetWriteByteHandler(0, funkyjet_main_write_byte);
SekSetReadWordHandler(0, funkyjet_main_read_word);

16
src/burn/drv/dataeast/d_karnov.cpp
View File

@ -882,12 +882,12 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x060000, 0x063fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x080000, 0x080fff, SM_RAM);
SekMapMemory(DrvVidRAM, 0x0a0000, 0x0a07ff, SM_RAM);
SekMapMemory(DrvVidRAM, 0x0a0800, 0x0a0fff, SM_RAM);
SekMapMemory(DrvPfRAM, 0x0a1000, 0x0a17ff, SM_WRITE);
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x060000, 0x063fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x080000, 0x080fff, MAP_RAM);
SekMapMemory(DrvVidRAM, 0x0a0000, 0x0a07ff, MAP_RAM);
SekMapMemory(DrvVidRAM, 0x0a0800, 0x0a0fff, MAP_RAM);
SekMapMemory(DrvPfRAM, 0x0a1000, 0x0a17ff, MAP_WRITE);
SekSetWriteWordHandler(0, karnov_main_write_word);
SekSetWriteByteHandler(0, karnov_main_write_byte);
SekSetReadWordHandler(0, karnov_main_read_word);
@ -896,8 +896,8 @@ static INT32 DrvInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(Drv6502RAM, 0x0000, 0x05ff, M6502_RAM);
M6502MapMemory(Drv6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(Drv6502RAM, 0x0000, 0x05ff, MAP_RAM);
M6502MapMemory(Drv6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(karnov_sound_read);
M6502SetWriteHandler(karnov_sound_write);
M6502Close();

20
src/burn/drv/dataeast/d_lemmings.cpp
View File

@ -433,14 +433,14 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x10ffff, SM_RAM);
SekMapMemory(DrvSprRAM0, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvSprRAM1, 0x140000, 0x1407ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x160000, 0x160fff, SM_ROM);
SekMapMemory(DrvVidRAM, 0x200000, 0x202fff, SM_RAM);
SekMapMemory(DrvPxlRAM0, 0x300000, 0x37ffff, SM_ROM);
SekMapMemory(DrvPxlRAM1, 0x380000, 0x39ffff, SM_ROM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x10ffff, MAP_RAM);
SekMapMemory(DrvSprRAM0, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvSprRAM1, 0x140000, 0x1407ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x160000, 0x160fff, MAP_ROM);
SekMapMemory(DrvVidRAM, 0x200000, 0x202fff, MAP_RAM);
SekMapMemory(DrvPxlRAM0, 0x300000, 0x37ffff, MAP_ROM);
SekMapMemory(DrvPxlRAM1, 0x380000, 0x39ffff, MAP_ROM);
SekSetWriteWordHandler(0, lemmings_main_write_word);
SekSetWriteByteHandler(0, lemmings_main_write_byte);
SekSetReadWordHandler(0, lemmings_main_read_word);
@ -449,8 +449,8 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x8000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(lemmings_sound_write);
M6809SetReadHandler(lemmings_sound_read);
M6809Close();

20
src/burn/drv/dataeast/d_pktgaldx.cpp
View File

@ -335,16 +335,16 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x07ffff, SM_FETCH);
SekMapMemory(deco16_pf_ram[0], 0x100000, 0x100fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x102000, 0x102fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x110000, 0x1107ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x112000, 0x1127ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x130000, 0x130fff, SM_RAM);
SekMapMemory(DrvProtRAM, 0x167800, 0x167fff, SM_WRITE);
SekMapMemory(Drv68KRAM, 0x170000, 0x17ffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_READ);
SekMapMemory(Drv68KCode, 0x000000, 0x07ffff, MAP_FETCH);
SekMapMemory(deco16_pf_ram[0], 0x100000, 0x100fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x102000, 0x102fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x110000, 0x1107ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x112000, 0x1127ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x130000, 0x130fff, MAP_RAM);
SekMapMemory(DrvProtRAM, 0x167800, 0x167fff, MAP_WRITE);
SekMapMemory(Drv68KRAM, 0x170000, 0x17ffff, MAP_RAM);
SekSetWriteWordHandler(0, pktgaldx_write_word);
SekSetWriteByteHandler(0, pktgaldx_write_byte);
SekSetReadWordHandler(0, pktgaldx_read_word);

126
src/burn/drv/dataeast/d_rohga.cpp
View File

@ -791,22 +791,22 @@ static INT32 RohgaInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x3c0000, 0x3c1fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x3c2000, 0x3c2fff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x3c4000, 0x3c4fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x3c6000, 0x3c6fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c8000, 0x3c8fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c9000, 0x3c9fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3ca000, 0x3cafff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3cb000, 0x3cbfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cc000, 0x3ccfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cd000, 0x3cdfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3ce000, 0x3cefff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3cf000, 0x3cffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x3d0000, 0x3d07ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x3e0000, 0x3e1fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x3f0000, 0x3f3fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x3c0000, 0x3c1fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x3c2000, 0x3c2fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x3c4000, 0x3c4fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x3c6000, 0x3c6fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c8000, 0x3c8fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c9000, 0x3c9fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3ca000, 0x3cafff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3cb000, 0x3cbfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cc000, 0x3ccfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cd000, 0x3cdfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3ce000, 0x3cefff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3cf000, 0x3cffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x3d0000, 0x3d07ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x3e0000, 0x3e1fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x3f0000, 0x3f3fff, MAP_RAM);
SekSetWriteWordHandler(0, rohga_main_write_word);
SekSetWriteByteHandler(0, rohga_main_write_byte);
SekSetReadWordHandler(0, rohga_main_read_word);
@ -889,18 +889,18 @@ static INT32 WizdfireInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x200fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x202fff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208000, 0x208fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a000, 0x20afff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x20c000, 0x20c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x20e000, 0x20e7ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x340000, 0x3407ff, SM_RAM);
SekMapMemory(DrvSprRAM2, 0x360000, 0x3607ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x380000, 0x381fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0xfdc000, 0xfe3fff, SM_RAM);
SekMapMemory(Drv68KRAM + 0x8000, 0xfe4800, 0xffffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x200fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x202fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208000, 0x208fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a000, 0x20afff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x20c000, 0x20c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x20e000, 0x20e7ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x340000, 0x3407ff, MAP_RAM);
SekMapMemory(DrvSprRAM2, 0x360000, 0x3607ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x380000, 0x381fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0xfdc000, 0xfe3fff, MAP_RAM);
SekMapMemory(Drv68KRAM + 0x8000, 0xfe4800, 0xffffff, MAP_RAM);
SekSetWriteWordHandler(0, wizdfire_main_write_word);
SekSetWriteByteHandler(0, wizdfire_main_write_byte);
SekSetReadWordHandler(0, wizdfire_main_read_word);
@ -973,23 +973,23 @@ static INT32 SchmeisrInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x3c0000, 0x3c1fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x3c2000, 0x3c2fff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x3c4000, 0x3c4fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x3c6000, 0x3c6fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c8000, 0x3c8fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c9000, 0x3c9fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3ca000, 0x3cafff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3cb000, 0x3cbfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cc000, 0x3ccfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cd000, 0x3cdfff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3ce000, 0x3cefff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3cf000, 0x3cffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x3d0000, 0x3d07ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x3e0000, 0x3e1fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x3e2000, 0x3e3fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0xff0000, 0xff7fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x3c0000, 0x3c1fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x3c2000, 0x3c2fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x3c4000, 0x3c4fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x3c6000, 0x3c6fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c8000, 0x3c8fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x3c9000, 0x3c9fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3ca000, 0x3cafff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x3cb000, 0x3cbfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cc000, 0x3ccfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x3cd000, 0x3cdfff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3ce000, 0x3cefff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x3cf000, 0x3cffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x3d0000, 0x3d07ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x3e0000, 0x3e1fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x3e2000, 0x3e3fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0xff0000, 0xff7fff, MAP_RAM);
SekSetWriteWordHandler(0, rohga_main_write_word);
SekSetWriteByteHandler(0, rohga_main_write_byte);
SekSetReadWordHandler(0, rohga_main_read_word);
@ -1076,24 +1076,24 @@ static INT32 NitrobalInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x200fff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x201000, 0x201fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x2027ff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202800, 0x202fff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208000, 0x2087ff, SM_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208800, 0x208fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a000, 0x20a7ff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a800, 0x20afff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x204000, 0x2047ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x206000, 0x2067ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x20c000, 0x20c7ff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x20e000, 0x20e7ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x340000, 0x3407ff, SM_RAM);
SekMapMemory(DrvSprRAM2, 0x360000, 0x3607ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x380000, 0x381fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0xfec000, 0xff3fff, SM_RAM);
SekMapMemory(Drv68KRAM + 0x8000, 0xff8000, 0xffffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[0], 0x200000, 0x200fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x201000, 0x201fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202000, 0x2027ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x202800, 0x202fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208000, 0x2087ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[2], 0x208800, 0x208fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a000, 0x20a7ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x20a800, 0x20afff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x204000, 0x2047ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x206000, 0x2067ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[2], 0x20c000, 0x20c7ff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[3], 0x20e000, 0x20e7ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x340000, 0x3407ff, MAP_RAM);
SekMapMemory(DrvSprRAM2, 0x360000, 0x3607ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x380000, 0x381fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0xfec000, 0xff3fff, MAP_RAM);
SekMapMemory(Drv68KRAM + 0x8000, 0xff8000, 0xffffff, MAP_RAM);
SekSetWriteWordHandler(0, wizdfire_main_write_word);
SekSetWriteByteHandler(0, wizdfire_main_write_byte);
SekSetReadWordHandler(0, wizdfire_main_read_word);

20
src/burn/drv/dataeast/d_sidepckt.cpp
View File

@ -663,22 +663,22 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809Ram + 0x0000, 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvVideoRam , 0x1000, 0x13ff, M6809_RAM);
M6809MapMemory(DrvM6809Ram + 0x1000, 0x1400, 0x17ff, M6809_RAM);
M6809MapMemory(DrvColourRam , 0x1800, 0x1bff, M6809_RAM);
M6809MapMemory(DrvM6809Ram + 0x1400, 0x1c00, 0x1fff, M6809_RAM);
M6809MapMemory(DrvSpriteRam , 0x2000, 0x20ff, M6809_RAM);
M6809MapMemory(DrvM6809Ram + 0x1800, 0x2100, 0x24ff, M6809_RAM);
M6809MapMemory(DrvM6809Rom + 0x4000, 0x4000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809Ram + 0x0000, 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvVideoRam , 0x1000, 0x13ff, MAP_RAM);
M6809MapMemory(DrvM6809Ram + 0x1000, 0x1400, 0x17ff, MAP_RAM);
M6809MapMemory(DrvColourRam , 0x1800, 0x1bff, MAP_RAM);
M6809MapMemory(DrvM6809Ram + 0x1400, 0x1c00, 0x1fff, MAP_RAM);
M6809MapMemory(DrvSpriteRam , 0x2000, 0x20ff, MAP_RAM);
M6809MapMemory(DrvM6809Ram + 0x1800, 0x2100, 0x24ff, MAP_RAM);
M6809MapMemory(DrvM6809Rom + 0x4000, 0x4000, 0xffff, MAP_ROM);
M6809SetReadHandler(SidepcktM6809ReadByte);
M6809SetWriteHandler(SidepcktM6809WriteByte);
M6809Close();
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, M6502_RAM);
M6502MapMemory(DrvM6502Rom , 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, MAP_RAM);
M6502MapMemory(DrvM6502Rom , 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(SidepcktSoundReadByte);
M6502SetWriteHandler(SidepcktSoundWriteByte);
M6502Close();

18
src/burn/drv/dataeast/d_supbtime.cpp
View File

@ -313,18 +313,18 @@ static INT32 DrvInit(INT32 game)
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
if (game) {
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, SM_RAM); // super burger time
SekMapMemory(Drv68KRAM, 0x100000, 0x103fff, MAP_RAM); // super burger time
} else {
SekMapMemory(Drv68KRAM, 0x1a0000, 0x1a3fff, SM_RAM); // china town
SekMapMemory(Drv68KRAM, 0x1a0000, 0x1a3fff, MAP_RAM); // china town
}
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x1407ff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x120000, 0x1207ff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x1407ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, MAP_RAM);
SekSetWriteWordHandler(0, supbtime_main_write_word);
SekSetWriteByteHandler(0, supbtime_main_write_byte);
SekSetReadWordHandler(0, supbtime_main_read_word);

16
src/burn/drv/dataeast/d_tumblep.cpp
View File

@ -267,14 +267,14 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x120000, 0x123fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x1407ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x1a0000, 0x1a07ff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, SM_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x120000, 0x123fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x140000, 0x1407ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x1a0000, 0x1a07ff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x320000, 0x321fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x322000, 0x323fff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[0], 0x340000, 0x340bff, MAP_RAM);
SekMapMemory(deco16_pf_rowscroll[1], 0x342000, 0x342bff, MAP_RAM);
SekSetWriteWordHandler(0, tumblep_main_write_word);
SekSetWriteByteHandler(0, tumblep_main_write_byte);
SekSetReadWordHandler(0, tumblep_main_read_word);

18
src/burn/drv/dataeast/d_vaportra.cpp
View File

@ -373,15 +373,15 @@ static INT32 DrvInit(INT32 type)
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(deco16_pf_ram[2], 0x200000, 0x201fff, SM_RAM);
SekMapMemory(deco16_pf_ram[3], 0x202000, 0x203fff, SM_RAM);
SekMapMemory(deco16_pf_ram[0], 0x280000, 0x281fff, SM_RAM);
SekMapMemory(deco16_pf_ram[1], 0x282000, 0x283fff, SM_RAM);
SekMapMemory(DrvPalRAM0, 0x300000, 0x3009ff, SM_RAM);
SekMapMemory(DrvPalRAM1, 0x304000, 0x3049ff, SM_RAM);
SekMapMemory(DrvSprRAM, 0xff8000, 0xff87ff, SM_RAM);
SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(deco16_pf_ram[2], 0x200000, 0x201fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[3], 0x202000, 0x203fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[0], 0x280000, 0x281fff, MAP_RAM);
SekMapMemory(deco16_pf_ram[1], 0x282000, 0x283fff, MAP_RAM);
SekMapMemory(DrvPalRAM0, 0x300000, 0x3009ff, MAP_RAM);
SekMapMemory(DrvPalRAM1, 0x304000, 0x3049ff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0xff8000, 0xff87ff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0xffc000, 0xffffff, MAP_RAM);
SekSetWriteWordHandler(0, vaportra_main_write_word);
SekSetWriteByteHandler(0, vaportra_main_write_byte);
SekSetReadWordHandler(0, vaportra_main_read_word);

4
src/burn/drv/dataeast/deco16ic.cpp
View File

@ -869,8 +869,8 @@ void deco16SoundInit(UINT8 *rom, UINT8 *ram, INT32 huc_clock, INT32 ym2203, void
#ifdef ENABLE_HUC6280
h6280Init(0);
h6280Open(0);
h6280MapMemory(rom, 0x000000, 0x00ffff, H6280_ROM);
h6280MapMemory(ram, 0x1f0000, 0x1f1fff, H6280_RAM);
h6280MapMemory(rom, 0x000000, 0x00ffff, MAP_ROM);
h6280MapMemory(ram, 0x1f0000, 0x1f1fff, MAP_RAM);
h6280SetWriteHandler(deco16_sound_write);
h6280SetReadHandler(deco16_sound_read);
h6280Close();

64
src/burn/drv/galaxian/d_galaxian.cpp
View File

@ -22456,22 +22456,22 @@ static void S2650PostLoad()
{
s2650Init(1);
s2650Open(0);
s2650MapMemory(GalS2650Rom1 + 0x0000, 0x0000, 0x0fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x1480, 0x14ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x1800, 0x1bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x1c00, 0x1fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x1000, 0x2000, 0x2fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x3480, 0x34ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x3800, 0x3bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x3c00, 0x3fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x2000, 0x4000, 0x4fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x5480, 0x54ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x5800, 0x5bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x5c00, 0x5fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x3000, 0x6000, 0x6fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x7480, 0x74ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x7800, 0x7bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x7c00, 0x7fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x0000, 0x0000, 0x0fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x1480, 0x14ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x1800, 0x1bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x1c00, 0x1fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x1000, 0x2000, 0x2fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x3480, 0x34ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x3800, 0x3bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x3c00, 0x3fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x2000, 0x4000, 0x4fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x5480, 0x54ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x5800, 0x5bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x5c00, 0x5fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x3000, 0x6000, 0x6fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x7480, 0x74ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x7800, 0x7bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x7c00, 0x7fff, MAP_RAM);
s2650SetReadHandler(HunchbkgS2650Read);
s2650SetWriteHandler(HunchbkgS2650Write);
s2650SetInHandler(HunchbkgS2650PortRead);
@ -22569,22 +22569,22 @@ static void RacknrolPostLoad()
{
s2650Init(1);
s2650Open(0);
s2650MapMemory(GalS2650Rom1 + 0x0000, 0x0000, 0x0fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x1400, 0x14ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x1800, 0x1bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x1c00, 0x1fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x1000, 0x2000, 0x2fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x3400, 0x34ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x3800, 0x3bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x3c00, 0x3fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x2000, 0x4000, 0x4fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x5400, 0x54ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x5800, 0x5bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x5c00, 0x5fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x3000, 0x6000, 0x6fff, S2650_ROM);
s2650MapMemory(GalSpriteRam, 0x7400, 0x74ff, S2650_READ);
s2650MapMemory(GalVideoRam, 0x7800, 0x7bff, S2650_RAM);
s2650MapMemory(GalZ80Ram1, 0x7c00, 0x7fff, S2650_RAM);
s2650MapMemory(GalS2650Rom1 + 0x0000, 0x0000, 0x0fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x1400, 0x14ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x1800, 0x1bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x1c00, 0x1fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x1000, 0x2000, 0x2fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x3400, 0x34ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x3800, 0x3bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x3c00, 0x3fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x2000, 0x4000, 0x4fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x5400, 0x54ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x5800, 0x5bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x5c00, 0x5fff, MAP_RAM);
s2650MapMemory(GalS2650Rom1 + 0x3000, 0x6000, 0x6fff, MAP_ROM);
s2650MapMemory(GalSpriteRam, 0x7400, 0x74ff, MAP_READ);
s2650MapMemory(GalVideoRam, 0x7800, 0x7bff, MAP_RAM);
s2650MapMemory(GalZ80Ram1, 0x7c00, 0x7fff, MAP_RAM);
s2650SetReadHandler(RacknrolS2650Read);
s2650SetWriteHandler(RacknrolS2650Write);
s2650SetInHandler(RacknrolS2650PortRead);

2
src/burn/drv/irem/d_m62.cpp
View File

@ -3383,7 +3383,7 @@ static void M62MachineInit()
ZetClose();
M6803Init(1);
M6803MapMemory(M62M6803Rom, 0x4000, 0xffff, M6803_ROM);
M6803MapMemory(M62M6803Rom, 0x4000, 0xffff, MAP_ROM);
M6803SetReadHandler(M62M6803ReadByte);
M6803SetWriteHandler(M62M6803WriteByte);
M6803SetReadPortHandler(M62M6803ReadPort);

20
src/burn/drv/konami/d_ajax.cpp
View File

@ -167,7 +167,7 @@ static void ajax_main_bankswitch(INT32 data)
ajax_priority = data & 0x08;
konamiMapMemory(DrvKonROM + nBank, 0x6000, 0x7fff, KON_ROM);
konamiMapMemory(DrvKonROM + nBank, 0x6000, 0x7fff, MAP_ROM);
}
void ajax_main_write(UINT16 address, UINT8 data)
@ -261,7 +261,7 @@ static void ajax_sub_bankswitch(UINT8 data)
firq_enable = data & 0x10;
INT32 nBank = ((data & 0x0f) << 13) + 0x10000;
M6809MapMemory(DrvM6809ROM + nBank, 0x8000, 0x9fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + nBank, 0x8000, 0x9fff, MAP_ROM);
}
void ajax_sub_write(UINT16 address, UINT8 data)
@ -547,20 +547,20 @@ static INT32 DrvInit(INT32 type)
konamiInit(0);
konamiOpen(0);
konamiMapMemory(DrvPalRAM, 0x1000, 0x1fff, KON_RAM);
konamiMapMemory(DrvShareRAM, 0x2000, 0x3fff, KON_RAM);
konamiMapMemory(DrvKonRAM, 0x4000, 0x5fff, KON_RAM);
konamiMapMemory(DrvKonROM + 0x10000, 0x6000, 0x7fff, KON_ROM);
konamiMapMemory(DrvKonROM + 0x08000, 0x8000, 0xffff, KON_ROM);
konamiMapMemory(DrvPalRAM, 0x1000, 0x1fff, MAP_RAM);
konamiMapMemory(DrvShareRAM, 0x2000, 0x3fff, MAP_RAM);
konamiMapMemory(DrvKonRAM, 0x4000, 0x5fff, MAP_RAM);
konamiMapMemory(DrvKonROM + 0x10000, 0x6000, 0x7fff, MAP_ROM);
konamiMapMemory(DrvKonROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
konamiSetWriteHandler(ajax_main_write);
konamiSetReadHandler(ajax_main_read);
konamiClose();
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvShareRAM, 0x2000, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x8000, 0x9fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + 0x0a000, 0xa000, 0xffff, M6809_ROM);
M6809MapMemory(DrvShareRAM, 0x2000, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x8000, 0x9fff, MAP_ROM);
M6809MapMemory(DrvM6809ROM + 0x0a000, 0xa000, 0xffff, MAP_ROM);
M6809SetWriteHandler(ajax_sub_write);
M6809SetReadHandler(ajax_sub_read);
M6809Close();

14
src/burn/drv/konami/d_aliens.cpp
View File

@ -139,9 +139,9 @@ static void set_ram_bank(INT32 data)
nDrvRamBank[0] = data;
if (data & 0x20) {
konamiMapMemory(DrvPalRAM, 0x0000, 0x03ff, KON_RAM);
konamiMapMemory(DrvPalRAM, 0x0000, 0x03ff, MAP_RAM);
} else {
konamiMapMemory(DrvBankRAM, 0x0000, 0x03ff, KON_RAM);
konamiMapMemory(DrvBankRAM, 0x0000, 0x03ff, MAP_RAM);
}
}
@ -257,7 +257,7 @@ static void aliens_set_lines(INT32 lines)
INT32 nBank = (lines & 0x1f) * 0x2000;
konamiMapMemory(DrvKonROM + 0x10000 + nBank, 0x2000, 0x3fff, KON_ROM);
konamiMapMemory(DrvKonROM + 0x10000 + nBank, 0x2000, 0x3fff, MAP_ROM);
}
static void K052109Callback(INT32 layer, INT32 bank, INT32 *code, INT32 *color, INT32 *, INT32 *)
@ -379,10 +379,10 @@ static INT32 DrvInit()
konamiInit(0);
konamiOpen(0);
konamiMapMemory(DrvBankRAM, 0x0000, 0x03ff, KON_RAM);
konamiMapMemory(DrvKonRAM, 0x0400, 0x1fff, KON_RAM);
konamiMapMemory(DrvKonROM + 0x10000, 0x2000, 0x3fff, KON_ROM);
konamiMapMemory(DrvKonROM + 0x08000, 0x8000, 0xffff, KON_ROM);
konamiMapMemory(DrvBankRAM, 0x0000, 0x03ff, MAP_RAM);
konamiMapMemory(DrvKonRAM, 0x0400, 0x1fff, MAP_RAM);
konamiMapMemory(DrvKonROM + 0x10000, 0x2000, 0x3fff, MAP_ROM);
konamiMapMemory(DrvKonROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
konamiSetWriteHandler(aliens_main_write);
konamiSetReadHandler(aliens_main_read);
konamiSetlinesCallback(aliens_set_lines);

14
src/burn/drv/konami/d_asterix.cpp
View File

@ -494,11 +494,11 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x100000, 0x107fff, SM_RAM);
SekMapMemory(K053245Ram[0], 0x180000, 0x1807ff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x180800, 0x180fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x280000, 0x280fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x100000, 0x107fff, MAP_RAM);
SekMapMemory(K053245Ram[0], 0x180000, 0x1807ff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x180800, 0x180fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x280000, 0x280fff, MAP_RAM);
SekSetWriteWordHandler(0, asterix_main_write_word);
SekSetWriteByteHandler(0, asterix_main_write_byte);
SekSetReadWordHandler(0, asterix_main_read_word);
@ -507,8 +507,8 @@ static INT32 DrvInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, MAP_RAM);
ZetSetWriteHandler(asterix_sound_write);
ZetSetReadHandler(asterix_sound_read);
ZetClose();

16
src/burn/drv/konami/d_battlnts.cpp
View File

@ -242,7 +242,7 @@ STDDIPINFO(Rackemup)
static void bankswitch(INT32 bank)
{
HD6309Bank = bank;
HD6309MapMemory(DrvHD6309ROM + 0x10000 + ((bank >> 6) * 0x4000), 0x4000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + 0x10000 + ((bank >> 6) * 0x4000), 0x4000, 0x7fff, MAP_ROM);
}
static void battlnts_main_write(UINT16 address, UINT8 data)
@ -438,19 +438,19 @@ static INT32 DrvInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, HD6309_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, HD6309_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, HD6309_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, HD6309_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, MAP_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, MAP_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, MAP_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, MAP_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(battlnts_main_write);
HD6309SetReadHandler(battlnts_main_read);
HD6309Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, MAP_RAM);
ZetSetWriteHandler(battlnts_sound_write);
ZetSetReadHandler(battlnts_sound_read);
ZetClose();

8
src/burn/drv/konami/d_bishi.cpp
View File

@ -480,10 +480,10 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x400000, 0x407fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0xb00000, 0xb03fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0xb04000, 0xb047ff, SM_ROM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x400000, 0x407fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0xb00000, 0xb03fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0xb04000, 0xb047ff, MAP_ROM);
SekSetWriteWordHandler(0, bishi_write_word);
SekSetWriteByteHandler(0, bishi_write_byte);
SekSetReadWordHandler(0, bishi_read_word);

18
src/burn/drv/konami/d_bladestl.cpp
View File

@ -166,7 +166,7 @@ STDDIPINFO(Bladestl)
static void bankswitch(INT32 bank)
{
HD6309Bank = bank;
HD6309MapMemory(DrvHD6309ROM + (((bank & 0x60) >> 5) * 0x2000), 0x6000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + (((bank & 0x60) >> 5) * 0x2000), 0x6000, 0x7fff, MAP_ROM);
}
static void bladestl_main_write(UINT16 address, UINT8 data)
@ -419,20 +419,20 @@ static INT32 DrvInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, HD6309_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, HD6309_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, HD6309_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, HD6309_RAM);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, HD6309_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, MAP_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, MAP_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, MAP_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, MAP_RAM);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, MAP_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(bladestl_main_write);
HD6309SetReadHandler(bladestl_main_read);
HD6309Close();
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(bladestl_sound_write);
M6809SetReadHandler(bladestl_sound_read);
M6809Close();

8
src/burn/drv/konami/d_bottom9.cpp
View File

@ -239,7 +239,7 @@ static void bankswitch(INT32 data)
INT32 offs = 0x10000 + (data & 0x1e) * 0x1000;
M6809MapMemory(DrvM6809ROM + offs, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + offs, 0x6000, 0x7fff, MAP_ROM);
}
void bottom9_main_write(UINT16 address, UINT8 data)
@ -542,9 +542,9 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x4000, 0x5fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x4000, 0x5fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x6000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(bottom9_main_write);
M6809SetReadHandler(bottom9_main_read);
M6809Close();

18
src/burn/drv/konami/d_circusc.cpp
View File

@ -358,22 +358,22 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x2000, 0x2fff, M6809_RAM);
M6809MapMemory(DrvColRAM, 0x3000, 0x33ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x3400, 0x37ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x3800, 0x39ff, M6809_RAM);
M6809MapMemory(DrvM6809RAM + 0x1a00, 0x3a00, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x6000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809ROMDec, 0x6000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvM6809RAM, 0x2000, 0x2fff, MAP_RAM);
M6809MapMemory(DrvColRAM, 0x3000, 0x33ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x3400, 0x37ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x3800, 0x39ff, MAP_RAM);
M6809MapMemory(DrvM6809RAM + 0x1a00, 0x3a00, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x6000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809ROMDec, 0x6000, 0xffff, MAP_FETCH);
M6809SetWriteHandler(circusc_main_write);
M6809SetReadHandler(circusc_main_read);
M6809Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, ZET_ROM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, MAP_ROM);
for (INT32 i = 0; i < 0x2000; i+=0x400) {
ZetMapMemory(DrvZ80RAM, 0x4000+i, 0x43ff+i, ZET_RAM);
ZetMapMemory(DrvZ80RAM, 0x4000+i, 0x43ff+i, MAP_RAM);
}
ZetSetWriteHandler(circusc_sound_write);
ZetSetReadHandler(circusc_sound_read);

30
src/burn/drv/konami/d_contra.cpp
View File

@ -210,7 +210,7 @@ void contra_bankswitch_w(INT32 data)
INT32 bankaddress = 0x10000 + nBankData * 0x2000;
if (bankaddress < 0x28000)
M6809MapMemory(DrvM6809ROM0 + bankaddress, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM0 + bankaddress, 0x6000, 0x7fff, MAP_ROM);
}
UINT8 DrvContraM6809ReadByte(UINT16 address)
@ -485,25 +485,25 @@ static INT32 DrvInit()
M6809Init(2);
M6809Open(0);
M6809MapMemory(DrvPalRAM, 0x0c00, 0x0cff, M6809_ROM);
M6809MapMemory(DrvM6809RAM0, 0x1000, 0x1fff, M6809_RAM);
M6809MapMemory(DrvFgCRAM, 0x2000, 0x23ff, M6809_RAM);
M6809MapMemory(DrvFgVRAM, 0x2400, 0x27ff, M6809_RAM);
M6809MapMemory(DrvTxCRAM, 0x2800, 0x2bff, M6809_RAM);
M6809MapMemory(DrvTxVRAM, 0x2c00, 0x2fff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x3000, 0x3fff, M6809_RAM);
M6809MapMemory(DrvBgCRAM, 0x4000, 0x43ff, M6809_RAM);
M6809MapMemory(DrvBgVRAM, 0x4400, 0x47ff, M6809_RAM);
M6809MapMemory(DrvM6809RAM1, 0x4800, 0x5fff, M6809_RAM);
// M6809MapMemory(DrvM6809ROM0 + 0x10000, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM0 + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvPalRAM, 0x0c00, 0x0cff, MAP_ROM);
M6809MapMemory(DrvM6809RAM0, 0x1000, 0x1fff, MAP_RAM);
M6809MapMemory(DrvFgCRAM, 0x2000, 0x23ff, MAP_RAM);
M6809MapMemory(DrvFgVRAM, 0x2400, 0x27ff, MAP_RAM);
M6809MapMemory(DrvTxCRAM, 0x2800, 0x2bff, MAP_RAM);
M6809MapMemory(DrvTxVRAM, 0x2c00, 0x2fff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x3000, 0x3fff, MAP_RAM);
M6809MapMemory(DrvBgCRAM, 0x4000, 0x43ff, MAP_RAM);
M6809MapMemory(DrvBgVRAM, 0x4400, 0x47ff, MAP_RAM);
M6809MapMemory(DrvM6809RAM1, 0x4800, 0x5fff, MAP_RAM);
// M6809MapMemory(DrvM6809ROM0 + 0x10000, 0x6000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvM6809ROM0 + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetReadHandler(DrvContraM6809ReadByte);
M6809SetWriteHandler(DrvContraM6809WriteByte);
M6809Close();
M6809Open(1);
M6809MapMemory(DrvM6809RAM2, 0x6000, 0x67ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM1 + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM2, 0x6000, 0x67ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM1 + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetReadHandler(DrvContraM6809SoundReadByte);
M6809SetWriteHandler(DrvContraM6809SoundWriteByte);
M6809Close();

26
src/burn/drv/konami/d_dbz.cpp
View File

@ -731,17 +731,17 @@ static INT32 DrvInit(INT32 nGame)
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x480000, 0x48ffff, SM_RAM);
SekMapMemory(K053247Ram, 0x4a0000, 0x4a0fff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x4a1000, 0x4a3fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x4a8000, 0x4abfff, SM_RAM);
SekMapMemory(DrvK053936Ctrl1, 0x4d0000, 0x4d03ff, SM_RAM);
SekMapMemory(DrvK053936Ctrl2, 0x4d4000, 0x4d43ff, SM_RAM);
SekMapMemory(DrvBg2RAM, 0x500000, 0x501fff, SM_RAM);
SekMapMemory(DrvBg1RAM, 0x508000, 0x509fff, SM_RAM);
SekMapMemory(Drvk053936RAM1, 0x510000, 0x513fff, SM_RAM);
SekMapMemory(Drvk053936RAM2, 0x518000, 0x51bfff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x480000, 0x48ffff, MAP_RAM);
SekMapMemory(K053247Ram, 0x4a0000, 0x4a0fff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x4a1000, 0x4a3fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x4a8000, 0x4abfff, MAP_RAM);
SekMapMemory(DrvK053936Ctrl1, 0x4d0000, 0x4d03ff, MAP_RAM);
SekMapMemory(DrvK053936Ctrl2, 0x4d4000, 0x4d43ff, MAP_RAM);
SekMapMemory(DrvBg2RAM, 0x500000, 0x501fff, MAP_RAM);
SekMapMemory(DrvBg1RAM, 0x508000, 0x509fff, MAP_RAM);
SekMapMemory(Drvk053936RAM1, 0x510000, 0x513fff, MAP_RAM);
SekMapMemory(Drvk053936RAM2, 0x518000, 0x51bfff, MAP_RAM);
SekSetWriteWordHandler(0, dbz_main_write_word);
SekSetWriteByteHandler(0, dbz_main_write_byte);
SekSetReadWordHandler(0, dbz_main_read_word);
@ -750,8 +750,8 @@ static INT32 DrvInit(INT32 nGame)
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0xbfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0xbfff, MAP_RAM);
ZetSetWriteHandler(dbz_sound_write);
ZetSetReadHandler(dbz_sound_read);
ZetClose();

16
src/burn/drv/konami/d_finalzr.cpp
View File

@ -438,14 +438,14 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvColRAM0, 0x2000, 0x23ff, M6809_RAM);
M6809MapMemory(DrvVidRAM0, 0x2400, 0x27ff, M6809_RAM);
M6809MapMemory(DrvColRAM1, 0x2800, 0x2bff, M6809_RAM);
M6809MapMemory(DrvVidRAM1, 0x2c00, 0x2fff, M6809_RAM);
M6809MapMemory(DrvSprRAM0, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvSprRAM1, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809DecROM, 0x4000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvColRAM0, 0x2000, 0x23ff, MAP_RAM);
M6809MapMemory(DrvVidRAM0, 0x2400, 0x27ff, MAP_RAM);
M6809MapMemory(DrvColRAM1, 0x2800, 0x2bff, MAP_RAM);
M6809MapMemory(DrvVidRAM1, 0x2c00, 0x2fff, MAP_RAM);
M6809MapMemory(DrvSprRAM0, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvSprRAM1, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809DecROM, 0x4000, 0xffff, MAP_FETCH);
M6809SetWriteHandler(finalizr_main_write);
M6809SetReadHandler(finalizr_main_read);
M6809Close();

12
src/burn/drv/konami/d_gijoe.cpp
View File

@ -518,10 +518,10 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(DrvSprRAM, 0x100000, 0x100fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x180000, 0x18ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x190000, 0x190fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(DrvSprRAM, 0x100000, 0x100fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x180000, 0x18ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x190000, 0x190fff, MAP_RAM);
SekSetWriteWordHandler(0, gijoe_main_write_word);
SekSetWriteByteHandler(0, gijoe_main_write_byte);
SekSetReadWordHandler(0, gijoe_main_read_word);
@ -530,8 +530,8 @@ static INT32 DrvInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, MAP_RAM);
ZetSetWriteHandler(gijoe_sound_write);
ZetSetReadHandler(gijoe_sound_read);
ZetClose();

20
src/burn/drv/konami/d_gradius3.cpp
View File

@ -596,11 +596,11 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x040000, 0x043fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x080000, 0x080fff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvShareRAM2, 0x180000, 0x19ffff, SM_ROM);
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x040000, 0x043fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x080000, 0x080fff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvShareRAM2, 0x180000, 0x19ffff, MAP_ROM);
SekSetWriteWordHandler(0, gradius3_main_write_word);
SekSetWriteByteHandler(0, gradius3_main_write_byte);
SekSetReadWordHandler(0, gradius3_main_read_word);
@ -609,11 +609,11 @@ static INT32 DrvInit()
SekInit(1, 0x68000);
SekOpen(1);
SekMapMemory(Drv68KROM1, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM1, 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x200000, 0x203fff, SM_RAM);
SekMapMemory(DrvShareRAM2, 0x280000, 0x29ffff, SM_ROM);
SekMapMemory(DrvGfxROM1, 0x400000, 0x5fffff, SM_ROM);
SekMapMemory(Drv68KROM1, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM1, 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x200000, 0x203fff, MAP_RAM);
SekMapMemory(DrvShareRAM2, 0x280000, 0x29ffff, MAP_ROM);
SekMapMemory(DrvGfxROM1, 0x400000, 0x5fffff, MAP_ROM);
SekSetWriteWordHandler(0, gradius3_sub_write_word);
SekSetWriteByteHandler(0, gradius3_sub_write_byte);
SekSetReadWordHandler(0, gradius3_sub_read_word);

22
src/burn/drv/konami/d_gyruss.cpp
View File

@ -706,11 +706,11 @@ static INT32 DrvInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM0, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvColRAM, 0x8000, 0x83ff, ZET_RAM);
ZetMapMemory(DrvVidRAM, 0x8400, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80RAM0, 0x9000, 0x9fff, ZET_RAM);
ZetMapMemory(DrvShareRAM, 0xa000, 0xa7ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM0, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvColRAM, 0x8000, 0x83ff, MAP_RAM);
ZetMapMemory(DrvVidRAM, 0x8400, 0x87ff, MAP_RAM);
ZetMapMemory(DrvZ80RAM0, 0x9000, 0x9fff, MAP_RAM);
ZetMapMemory(DrvShareRAM, 0xa000, 0xa7ff, MAP_RAM);
ZetSetReadHandler(gyruss_main_read);
ZetSetWriteHandler(gyruss_main_write);
@ -718,18 +718,18 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x4000, 0x47ff, M6809_RAM);
M6809MapMemory(DrvShareRAM, 0x6000, 0x67ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0xe000, 0xe000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809DecROM + 0xe000, 0xe000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvM6809RAM, 0x4000, 0x47ff, MAP_RAM);
M6809MapMemory(DrvShareRAM, 0x6000, 0x67ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0xe000, 0xe000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809DecROM + 0xe000, 0xe000, 0xffff, MAP_FETCH);
M6809SetReadHandler(gyruss_sub_read);
M6809SetWriteHandler(gyruss_sub_write);
M6809Close();
ZetInit(1);
ZetOpen(1);
ZetMapMemory(DrvZ80ROM1, 0x0000, 0x5fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM1, 0x6000, 0x63ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM1, 0x0000, 0x5fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM1, 0x6000, 0x63ff, MAP_RAM);
ZetSetReadHandler(gyruss_sound0_read);
ZetSetOutHandler(gyruss_sound0_out);
ZetSetInHandler(gyruss_sound0_in);

18
src/burn/drv/konami/d_ironhors.cpp
View File

@ -415,21 +415,21 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM0, 0x0000, 0x00ff, M6809_RAM);
M6809MapMemory(DrvColRAM, 0x2000, 0x23ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x2400, 0x27ff, M6809_RAM);
M6809MapMemory(DrvM6809RAM1, 0x2800, 0x2fff, M6809_RAM);
M6809MapMemory(DrvSprRAM1, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvSprRAM0, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, M6809_RAM);
M6809MapMemory(DrvM6809RAM0, 0x0000, 0x00ff, MAP_RAM);
M6809MapMemory(DrvColRAM, 0x2000, 0x23ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x2400, 0x27ff, MAP_RAM);
M6809MapMemory(DrvM6809RAM1, 0x2800, 0x2fff, MAP_RAM);
M6809MapMemory(DrvSprRAM1, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvSprRAM0, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, MAP_RAM);
M6809SetWriteHandler(ironhors_main_write);
M6809SetReadHandler(ironhors_main_read);
M6809Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x43ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x43ff, MAP_RAM);
ZetSetReadHandler(ironhors_sound_read);
ZetSetOutHandler(ironhors_sound_write_port);
ZetSetInHandler(ironhors_sound_read_port);

14
src/burn/drv/konami/d_jailbrek.cpp
View File

@ -375,13 +375,13 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvColRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x1000, 0x10ff, M6809_RAM);
M6809MapMemory(DrvM6809RAM0, 0x1100, 0x1fff, M6809_RAM);
M6809MapMemory(DrvM6809RAM1, 0x3000, 0x30ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x8000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809DecROM, 0x8000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvColRAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x1000, 0x10ff, MAP_RAM);
M6809MapMemory(DrvM6809RAM0, 0x1100, 0x1fff, MAP_RAM);
M6809MapMemory(DrvM6809RAM1, 0x3000, 0x30ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x8000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809DecROM, 0x8000, 0xffff, MAP_FETCH);
M6809SetWriteHandler(jailbrek_write);
M6809SetReadHandler(jailbrek_read);
M6809Close();

14
src/burn/drv/konami/d_labyrunr.cpp
View File

@ -165,7 +165,7 @@ static void bankswitch(INT32 data)
{
if (data != HD6309Bank) {
HD6309Bank = data;
HD6309MapMemory(DrvHD6309ROM + 0x10000 + ((HD6309Bank & 7) * 0x4000), 0x4000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + 0x10000 + ((HD6309Bank & 7) * 0x4000), 0x4000, 0x7fff, MAP_ROM);
}
}
@ -413,12 +413,12 @@ static INT32 CommonInit(INT32 nLoadType)
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvPalRAM, 0x1000, 0x10ff, HD6309_ROM);
HD6309MapMemory(DrvHD6309RAM, 0x1800, 0x1fff, HD6309_RAM);
HD6309MapMemory(DrvSprRAM, 0x2000, 0x2fff, HD6309_RAM);
HD6309MapMemory(DrvVidRAM0, 0x3000, 0x37ff, HD6309_RAM);
HD6309MapMemory(DrvVidRAM1, 0x3800, 0x3fff, HD6309_RAM);
HD6309MapMemory(DrvHD6309ROM, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvPalRAM, 0x1000, 0x10ff, MAP_ROM);
HD6309MapMemory(DrvHD6309RAM, 0x1800, 0x1fff, MAP_RAM);
HD6309MapMemory(DrvSprRAM, 0x2000, 0x2fff, MAP_RAM);
HD6309MapMemory(DrvVidRAM0, 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvVidRAM1, 0x3800, 0x3fff, MAP_RAM);
HD6309MapMemory(DrvHD6309ROM, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(labyrunr_write);
HD6309SetReadHandler(labyrunr_read);
HD6309Close();

12
src/burn/drv/konami/d_lethal.cpp
View File

@ -147,7 +147,7 @@ static void bankswitch(INT32 bank)
{
bank = (bank & 0x1f) * 0x2000;
HD6309MapMemory(DrvMainROM + bank, 0x0000, 0x1fff, HD6309_ROM);
HD6309MapMemory(DrvMainROM + bank, 0x0000, 0x1fff, MAP_ROM);
}
static void lethal_main_write(UINT16 address, UINT8 data)
@ -502,17 +502,17 @@ static INT32 DrvInit(INT32 flipy)
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvMainROM + 0x00000, 0x0000, 0x1fff, HD6309_ROM);
HD6309MapMemory(DrvMainRAM, 0x2000, 0x3fff, HD6309_RAM);
HD6309MapMemory(DrvMainROM + 0x38000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvMainROM + 0x00000, 0x0000, 0x1fff, MAP_ROM);
HD6309MapMemory(DrvMainRAM, 0x2000, 0x3fff, MAP_RAM);
HD6309MapMemory(DrvMainROM + 0x38000, 0x8000, 0xffff, MAP_ROM);
HD6309SetReadHandler(lethal_main_read);
HD6309SetWriteHandler(lethal_main_write);
HD6309Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0xefff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xf000, 0xf7ff, MAP_RAM);
ZetSetWriteHandler(lethal_sound_write);
ZetSetReadHandler(lethal_sound_read);
ZetClose();

8
src/burn/drv/konami/d_mainevt.cpp
View File

@ -427,7 +427,7 @@ static void bankswitch(INT32 data)
INT32 nBank = 0x10000 + nDrvBank[0] * 0x2000;
HD6309MapMemory(DrvHD6309ROM + nBank, 0x6000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + nBank, 0x6000, 0x7fff, MAP_ROM);
K052109RMRDLine = data & 0x40;
}
@ -713,9 +713,9 @@ static INT32 DrvInit(INT32 type)
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, HD6309_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x10000, 0x6000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, MAP_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x10000, 0x6000, 0x7fff, MAP_ROM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(mainevt_main_write);
HD6309SetReadHandler(mainevt_main_read);
HD6309Close();

20
src/burn/drv/konami/d_megazone.cpp
View File

@ -523,22 +523,22 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvVidRAM0, 0x2000, 0x23ff, M6809_RAM);
M6809MapMemory(DrvVidRAM1, 0x2400, 0x27ff, M6809_RAM);
M6809MapMemory(DrvColRAM0, 0x2800, 0x2bff, M6809_RAM);
M6809MapMemory(DrvColRAM1, 0x2c00, 0x2fff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x3000, 0x37ff, M6809_RAM);
M6809MapMemory(DrvShareRAM, 0x3800, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x4000, 0x4000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809DecROM + 0x4000, 0x4000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvVidRAM0, 0x2000, 0x23ff, MAP_RAM);
M6809MapMemory(DrvVidRAM1, 0x2400, 0x27ff, MAP_RAM);
M6809MapMemory(DrvColRAM0, 0x2800, 0x2bff, MAP_RAM);
M6809MapMemory(DrvColRAM1, 0x2c00, 0x2fff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x3000, 0x37ff, MAP_RAM);
M6809MapMemory(DrvShareRAM, 0x3800, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x4000, 0x4000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809DecROM + 0x4000, 0x4000, 0xffff, MAP_FETCH);
M6809SetWriteHandler(megazone_main_write);
// M6809SetReadHandler(megazone_main_read);
M6809Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, ZET_ROM);
ZetMapMemory(DrvShareRAM, 0xe000, 0xe7ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, MAP_ROM);
ZetMapMemory(DrvShareRAM, 0xe000, 0xe7ff, MAP_RAM);
ZetSetWriteHandler(megazone_sound_write);
ZetSetReadHandler(megazone_sound_read);
ZetSetOutHandler(megazone_sound_write_port);

14
src/burn/drv/konami/d_mikie.cpp
View File

@ -398,19 +398,19 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x00ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x37ff, M6809_RAM);
M6809MapMemory(DrvColRAM, 0x3800, 0x3bff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x3c00, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x6000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x0000, 0x00ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x2800, 0x37ff, MAP_RAM);
M6809MapMemory(DrvColRAM, 0x3800, 0x3bff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x3c00, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x6000, 0xffff, MAP_ROM);
M6809SetWriteHandler(mikie_main_write);
M6809SetReadHandler(mikie_main_read);
M6809Close();
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x43ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x43ff, MAP_RAM);
ZetSetWriteHandler(mikie_sound_write);
ZetSetReadHandler(mikie_sound_read);
ZetClose();

34
src/burn/drv/konami/d_moo.cpp
View File

@ -679,7 +679,7 @@ static UINT8 __fastcall bucky_main_read_byte(UINT32 address)
static void bankswitch(INT32 data)
{
z80_bank = data;
ZetMapMemory(DrvZ80ROM + ((data & 0x0f) * 0x4000), 0x8000, 0xbfff, ZET_ROM);
ZetMapMemory(DrvZ80ROM + ((data & 0x0f) * 0x4000), 0x8000, 0xbfff, MAP_ROM);
}
static void __fastcall moo_sound_write(UINT16 address, UINT8 data)
@ -892,11 +892,11 @@ static INT32 MooInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KROM + 0x080000, 0x100000, 0x17ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x180000, 0x18ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x190000, 0x19ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x1c0000, 0x1c1fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KROM + 0x080000, 0x100000, 0x17ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x180000, 0x18ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x190000, 0x19ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x1c0000, 0x1c1fff, MAP_RAM);
SekSetWriteWordHandler(0, moo_main_write_word);
SekSetWriteByteHandler(0, moo_main_write_byte);
SekSetReadWordHandler(0, moo_main_read_word);
@ -905,8 +905,8 @@ static INT32 MooInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(moo_sound_write);
ZetSetReadHandler(moo_sound_read);
ZetClose();
@ -982,13 +982,13 @@ static INT32 BuckyInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KROM + 0x080000, 0x200000, 0x23ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x090000, 0x09ffff, SM_RAM);
SekMapMemory(Drv68KRAM2, 0x0a0000, 0x0affff, SM_RAM);
SekMapMemory(Drv68KRAM3, 0x184000, 0x187fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x1b0000, 0x1b3fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KROM + 0x080000, 0x200000, 0x23ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x090000, 0x09ffff, MAP_RAM);
SekMapMemory(Drv68KRAM2, 0x0a0000, 0x0affff, MAP_RAM);
SekMapMemory(Drv68KRAM3, 0x184000, 0x187fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x1b0000, 0x1b3fff, MAP_RAM);
SekSetWriteWordHandler(0, bucky_main_write_word);
SekSetWriteByteHandler(0, bucky_main_write_byte);
SekSetReadWordHandler(0, bucky_main_read_word);
@ -997,8 +997,8 @@ static INT32 BuckyInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(moo_sound_write);
ZetSetReadHandler(moo_sound_read);
ZetClose();

88
src/burn/drv/konami/d_mystwarr.cpp
View File

@ -1616,7 +1616,7 @@ static UINT8 __fastcall dadandrn_main_read_byte(UINT32 address)
static void bankswitch(INT32 data)
{
z80_bank = data;
ZetMapMemory(DrvZ80ROM + ((data & 0x0f) * 0x4000), 0x8000, 0xbfff, ZET_ROM);
ZetMapMemory(DrvZ80ROM + ((data & 0x0f) * 0x4000), 0x8000, 0xbfff, MAP_ROM);
}
static void __fastcall mystwarr_sound_write(UINT16 address, UINT8 data)
@ -1986,10 +1986,10 @@ static INT32 MystwarrInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, SM_RAM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x700000, 0x701fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x700000, 0x701fff, MAP_RAM);
SekSetWriteWordHandler(0, mystwarr_main_write_word);
SekSetWriteByteHandler(0, mystwarr_main_write_byte);
SekSetReadWordHandler(0, mystwarr_main_read_word);
@ -1998,8 +1998,8 @@ static INT32 MystwarrInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();
@ -2096,11 +2096,11 @@ static INT32 MetamrphInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, SM_RAM);
SekMapMemory(DrvSpriteRam, 0x211000, 0x21ffff, SM_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x24c000, 0x24ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x330000, 0x331fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
SekMapMemory(DrvSpriteRam, 0x211000, 0x21ffff, MAP_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x24c000, 0x24ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x330000, 0x331fff, MAP_RAM);
SekSetWriteWordHandler(0, metamrph_main_write_word);
SekSetWriteByteHandler(0, metamrph_main_write_byte);
SekSetReadWordHandler(0, metamrph_main_read_word);
@ -2109,8 +2109,8 @@ static INT32 MetamrphInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();
@ -2202,11 +2202,11 @@ static INT32 ViostormInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, SM_RAM);
SekMapMemory(DrvSpriteRam, 0x211000, 0x21ffff, SM_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x24c000, 0x24ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x330000, 0x331fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x200000, 0x20ffff, MAP_RAM);
SekMapMemory(DrvSpriteRam, 0x211000, 0x21ffff, MAP_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x24c000, 0x24ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x330000, 0x331fff, MAP_RAM);
SekSetWriteWordHandler(0, metamrph_main_write_word);
SekSetWriteByteHandler(0, metamrph_main_write_byte);
SekSetReadWordHandler(0, metamrph_main_read_word);
@ -2215,8 +2215,8 @@ static INT32 ViostormInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();
@ -2304,11 +2304,11 @@ static INT32 MartchmpInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM + 0x000000, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x10ffff, SM_RAM);
SekMapMemory(Drv68KROM + 0x100000, 0x300000, 0x3fffff, SM_ROM);
SekMapMemory(DrvSpriteRam, 0x480000, 0x483fff, SM_ROM); // should be written through handler
SekMapMemory(DrvPalRAM, 0x600000, 0x601fff, SM_RAM);
SekMapMemory(Drv68KROM + 0x000000, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x100000, 0x10ffff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x100000, 0x300000, 0x3fffff, MAP_ROM);
SekMapMemory(DrvSpriteRam, 0x480000, 0x483fff, MAP_ROM); // should be written through handler
SekMapMemory(DrvPalRAM, 0x600000, 0x601fff, MAP_RAM);
SekSetWriteWordHandler(0, martchmp_main_write_word);
SekSetWriteByteHandler(0, martchmp_main_write_byte);
SekSetReadWordHandler(0, martchmp_main_read_word);
@ -2317,8 +2317,8 @@ static INT32 MartchmpInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();
@ -2458,12 +2458,12 @@ static INT32 GaiapolisInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x2fffff, SM_ROM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x420000, 0x421fff, SM_RAM);
SekMapMemory(DrvK053936Ctrl, 0x460000, 0x46001f, SM_RAM);
SekMapMemory(DrvK053936RAM, 0x470000, 0x470fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x600000, 0x60ffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x2fffff, MAP_ROM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x420000, 0x421fff, MAP_RAM);
SekMapMemory(DrvK053936Ctrl, 0x460000, 0x46001f, MAP_RAM);
SekMapMemory(DrvK053936RAM, 0x470000, 0x470fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x600000, 0x60ffff, MAP_RAM);
SekSetWriteWordHandler(0, dadandrn_main_write_word);
SekSetWriteByteHandler(0, dadandrn_main_write_byte);
SekSetReadWordHandler(0, dadandrn_main_read_word);
@ -2472,8 +2472,8 @@ static INT32 GaiapolisInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();
@ -2616,12 +2616,12 @@ static INT32 DadandrnInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, SM_ROM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x420000, 0x421fff, SM_RAM);
SekMapMemory(DrvK053936Ctrl, 0x460000, 0x46001f, SM_RAM);
SekMapMemory(DrvK053936RAM, 0x470000, 0x470fff, SM_RAM);
SekMapMemory(Drv68KRAM, 0x600000, 0x60ffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x1fffff, MAP_ROM);
SekMapMemory(DrvSpriteRam, 0x400000, 0x40ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x420000, 0x421fff, MAP_RAM);
SekMapMemory(DrvK053936Ctrl, 0x460000, 0x46001f, MAP_RAM);
SekMapMemory(DrvK053936RAM, 0x470000, 0x470fff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0x600000, 0x60ffff, MAP_RAM);
SekSetWriteWordHandler(0, dadandrn_main_write_word);
SekSetWriteByteHandler(0, dadandrn_main_write_byte);
SekSetReadWordHandler(0, dadandrn_main_read_word);
@ -2630,8 +2630,8 @@ static INT32 DadandrnInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(mystwarr_sound_write);
ZetSetReadHandler(mystwarr_sound_read);
ZetClose();

254
src/burn/drv/konami/d_nemesis.cpp
View File

@ -2142,8 +2142,8 @@ static void NemesisSoundInit(INT32 konamigtmode)
{
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x47ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x3fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x4000, 0x47ff, MAP_RAM);
ZetSetWriteHandler(nemesis_sound_write);
ZetSetReadHandler(nemesis_sound_read);
ZetClose();
@ -2164,9 +2164,9 @@ static void Gx400SoundInit(INT32 rf2mode)
{
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, ZET_ROM);
ZetMapMemory(DrvShareRAM, 0x4000, 0x7fff, ZET_RAM);
ZetMapMemory(DrvVLMROM, 0x8000, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, MAP_ROM);
ZetMapMemory(DrvShareRAM, 0x4000, 0x7fff, MAP_RAM);
ZetMapMemory(DrvVLMROM, 0x8000, 0x87ff, MAP_RAM);
ZetSetWriteHandler(nemesis_sound_write);
ZetSetReadHandler(nemesis_sound_read);
ZetClose();
@ -2191,9 +2191,9 @@ static void TwinbeeGx400SoundInit()
{
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, ZET_ROM);
ZetMapMemory(DrvShareRAM, 0x4000, 0x7fff, ZET_RAM);
ZetMapMemory(DrvVLMROM, 0x8000, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x1fff, MAP_ROM);
ZetMapMemory(DrvShareRAM, 0x4000, 0x7fff, MAP_RAM);
ZetMapMemory(DrvVLMROM, 0x8000, 0x87ff, MAP_RAM);
ZetSetWriteHandler(nemesis_sound_write);
ZetSetReadHandler(nemesis_sound_read);
ZetClose();
@ -2218,8 +2218,8 @@ static void SalamandSoundInit()
{
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, MAP_RAM);
ZetSetWriteHandler(salamand_sound_write);
ZetSetReadHandler(salamand_sound_read);
ZetClose();
@ -2244,8 +2244,8 @@ static void CitybombSoundInit()
{
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0x8000, 0x87ff, MAP_RAM);
ZetSetWriteHandler(citybomb_sound_write);
ZetSetReadHandler(citybomb_sound_read);
ZetClose();
@ -2293,28 +2293,28 @@ static INT32 NemesisInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvCharRAM, 0x040000, 0x04ffff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvCharRAM, 0x040000, 0x04ffff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x067fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x067fff, MAP_RAM);
SekSetWriteWordHandler(0, nemesis_main_write_word);
SekSetWriteByteHandler(0, nemesis_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, nemesis_main_read_byte);
SekMapHandler(1, 0x040000, 0x04ffff, SM_WRITE);
SekMapHandler(1, 0x040000, 0x04ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x05a000, 0x05afff, SM_WRITE);
SekMapHandler(2, 0x05a000, 0x05afff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2357,28 +2357,28 @@ static INT32 KonamigtInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvCharRAM, 0x040000, 0x04ffff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvCharRAM, 0x040000, 0x04ffff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x067fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x067fff, MAP_RAM);
SekSetWriteWordHandler(0, nemesis_main_write_word);
SekSetWriteByteHandler(0, konamigt_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, nemesis_main_read_byte);
SekMapHandler(1, 0x040000, 0x04ffff, SM_WRITE);
SekMapHandler(1, 0x040000, 0x04ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x05a000, 0x05afff, SM_WRITE);
SekMapHandler(2, 0x05a000, 0x05afff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2418,16 +2418,16 @@ static INT32 SalamandInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x090000, 0x091fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x100000, 0x100fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x101000, 0x101fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x102000, 0x102fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x103000, 0x103fff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x180fff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x190000, 0x191fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x090000, 0x091fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x100000, 0x100fff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0x101000, 0x101fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x102000, 0x102fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x103000, 0x103fff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x180fff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x190000, 0x191fff, MAP_RAM);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f00);
@ -2436,10 +2436,10 @@ static INT32 SalamandInit()
SekSetWriteByteHandler(0, salamand_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, salamand_main_read_byte);
SekMapHandler(1, 0x120000, 0x12ffff, SM_WRITE);
SekMapHandler(1, 0x120000, 0x12ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x090000, 0x091fff, SM_WRITE);
SekMapHandler(2, 0x090000, 0x091fff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2477,28 +2477,28 @@ static INT32 BlkpnthrInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x080000, 0x081fff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x090000, 0x097fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x100000, 0x100fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x101000, 0x101fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x102000, 0x102fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x103000, 0x103fff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x180000, 0x181fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x080000, 0x081fff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x090000, 0x097fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x100000, 0x100fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x101000, 0x101fff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0x102000, 0x102fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x103000, 0x103fff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x180000, 0x181fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvSprRAM, 0x190000, 0x190fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x190000, 0x190fff, MAP_RAM);
SekSetWriteWordHandler(0, salamand_main_write_word);
SekSetWriteByteHandler(0, salamand_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, salamand_main_read_byte);
SekMapHandler(1, 0x120000, 0x12ffff, SM_WRITE);
SekMapHandler(1, 0x120000, 0x12ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x080000, 0x081fff, SM_WRITE);
SekMapHandler(2, 0x080000, 0x081fff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2539,16 +2539,16 @@ static INT32 HcrashInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x090000, 0x091fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x100000, 0x100fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x101000, 0x101fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x102000, 0x102fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x103000, 0x103fff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x180fff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x190000, 0x191fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x090000, 0x091fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x100000, 0x100fff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0x101000, 0x101fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x102000, 0x102fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x103000, 0x103fff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x120000, 0x12ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x180000, 0x180fff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x190000, 0x191fff, MAP_RAM);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f00);
@ -2557,10 +2557,10 @@ static INT32 HcrashInit()
SekSetWriteByteHandler(0, hcrash_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, hcrash_main_read_byte);
SekMapHandler(1, 0x120000, 0x12ffff, SM_WRITE);
SekMapHandler(1, 0x120000, 0x12ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x090000, 0x091fff, SM_WRITE);
SekMapHandler(2, 0x090000, 0x091fff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2600,31 +2600,31 @@ static INT32 Gx400Init()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x00ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x010000, 0x01ffff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x030000, 0x03ffff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x00ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x010000, 0x01ffff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x030000, 0x03ffff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, SM_RAM);
SekMapMemory(Drv68KRAM2, 0x057000, 0x057fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x07ffff, SM_RAM);
SekMapMemory(Drv68KROM + 0x10000, 0x080000, 0x0bffff, SM_ROM);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, MAP_RAM);
SekMapMemory(Drv68KRAM2, 0x057000, 0x057fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x07ffff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x10000, 0x080000, 0x0bffff, MAP_ROM);
SekSetWriteWordHandler(0, nemesis_main_write_word);
SekSetWriteByteHandler(0, gx400_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, gx400_main_read_byte);
SekMapHandler(1, 0x030000, 0x03ffff, SM_WRITE);
SekMapHandler(1, 0x030000, 0x03ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x05a000, 0x05afff, SM_WRITE);
SekMapHandler(2, 0x05a000, 0x05afff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2670,30 +2670,30 @@ static INT32 Rf2_gx400Init()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x00ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x010000, 0x01ffff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x030000, 0x03ffff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x00ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x010000, 0x01ffff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x030000, 0x03ffff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x050000, 0x051fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x067fff, SM_RAM);
SekMapMemory(Drv68KROM + 0x10000, 0x080000, 0x0bffff, SM_ROM);
SekMapMemory(DrvVidRAM0, 0x052000, 0x052fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x053000, 0x053fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x054000, 0x054fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x055000, 0x055fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x056000, 0x056fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x05a000, 0x05afff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x067fff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x10000, 0x080000, 0x0bffff, MAP_ROM);
SekSetWriteWordHandler(0, nemesis_main_write_word);
SekSetWriteByteHandler(0, gx400_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, gx400_main_read_byte);
SekMapHandler(1, 0x030000, 0x03ffff, SM_WRITE);
SekMapHandler(1, 0x030000, 0x03ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekMapHandler(2, 0x05a000, 0x05afff, SM_WRITE);
SekMapHandler(2, 0x05a000, 0x05afff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekClose();
@ -2735,29 +2735,29 @@ static INT32 CitybombInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x0e0000, 0x0e1fff, SM_RAM);
SekMapMemory(Drv68KROM + 0x40000, 0x100000, 0x1bffff, SM_ROM);
SekMapMemory(DrvCharRAM, 0x200000, 0x20ffff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x210000, 0x210fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x211000, 0x211fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x212000, 0x212fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x213000, 0x213fff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x300000, 0x301fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x0e0000, 0x0e1fff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x40000, 0x100000, 0x1bffff, MAP_ROM);
SekMapMemory(DrvCharRAM, 0x200000, 0x20ffff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0x210000, 0x210fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x211000, 0x211fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x212000, 0x212fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x213000, 0x213fff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x300000, 0x301fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
yscroll1 = (UINT16*)(DrvScrollRAM + 0x00f80);
SekMapMemory(DrvSprRAM, 0x310000, 0x310fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x310000, 0x310fff, MAP_RAM);
SekSetWriteWordHandler(0, citybomb_main_write_word);
SekSetWriteByteHandler(0, citybomb_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, citybomb_main_read_byte);
SekMapHandler(2, 0x0e0000, 0x0e1fff, SM_WRITE);
SekMapHandler(2, 0x0e0000, 0x0e1fff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekMapHandler(1, 0x200000, 0x20ffff, SM_WRITE);
SekMapHandler(1, 0x200000, 0x20ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekClose();
@ -2795,17 +2795,17 @@ static INT32 NyanpaniInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x040000, 0x047fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x060000, 0x061fff, SM_RAM);
SekMapMemory(Drv68KROM + 0x40000, 0x100000, 0x13ffff, SM_ROM);
SekMapMemory(DrvVidRAM0, 0x200000, 0x200fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x201000, 0x201fff, SM_RAM);
SekMapMemory(DrvColRAM0, 0x202000, 0x202fff, SM_RAM);
SekMapMemory(DrvColRAM1, 0x203000, 0x203fff, SM_RAM);
SekMapMemory(DrvCharRAM, 0x210000, 0x21ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x300000, 0x300fff, SM_RAM);
SekMapMemory(DrvScrollRAM, 0x310000, 0x311fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x040000, 0x047fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x060000, 0x061fff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x40000, 0x100000, 0x13ffff, MAP_ROM);
SekMapMemory(DrvVidRAM0, 0x200000, 0x200fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x201000, 0x201fff, MAP_RAM);
SekMapMemory(DrvColRAM0, 0x202000, 0x202fff, MAP_RAM);
SekMapMemory(DrvColRAM1, 0x203000, 0x203fff, MAP_RAM);
SekMapMemory(DrvCharRAM, 0x210000, 0x21ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x300000, 0x300fff, MAP_RAM);
SekMapMemory(DrvScrollRAM, 0x310000, 0x311fff, MAP_RAM);
xscroll1 = (UINT16*)(DrvScrollRAM + 0x00000);
xscroll2 = (UINT16*)(DrvScrollRAM + 0x00400);
yscroll2 = (UINT16*)(DrvScrollRAM + 0x00f00);
@ -2814,10 +2814,10 @@ static INT32 NyanpaniInit()
SekSetWriteByteHandler(0, citybomb_main_write_byte);
SekSetReadWordHandler(0, nemesis_main_read_word);
SekSetReadByteHandler(0, citybomb_main_read_byte);
SekMapHandler(2, 0x060000, 0x061fff, SM_WRITE);
SekMapHandler(2, 0x060000, 0x061fff, MAP_WRITE);
SekSetWriteWordHandler(2, nemesis_palette_write_word);
SekSetWriteByteHandler(2, nemesis_palette_write_byte);
SekMapHandler(1, 0x210000, 0x21ffff, SM_WRITE);
SekMapHandler(1, 0x210000, 0x21ffff, MAP_WRITE);
SekSetWriteWordHandler(1, nemesis_charram_write_word);
SekSetWriteByteHandler(1, nemesis_charram_write_byte);
SekClose();

18
src/burn/drv/konami/d_rockrage.cpp
View File

@ -147,7 +147,7 @@ STDDIPINFO(Rockrage)
static void bankswitch(INT32 bank)
{
HD6309Bank = bank;
HD6309MapMemory(DrvHD6309ROM + 0x10000 + (((bank & 0x70) >> 4) * 0x2000), 0x6000, 0x7fff, HD6309_ROM);
HD6309MapMemory(DrvHD6309ROM + 0x10000 + (((bank & 0x70) >> 4) * 0x2000), 0x6000, 0x7fff, MAP_ROM);
}
static void rockrage_main_write(UINT16 address, UINT8 data)
@ -381,20 +381,20 @@ static INT32 DrvInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, HD6309_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, HD6309_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, HD6309_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, HD6309_RAM);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, HD6309_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, HD6309_ROM);
HD6309MapMemory(K007342VidRAM[0], 0x0000, 0x1fff, MAP_RAM);
HD6309MapMemory(K007420RAM[0], 0x2000, 0x21ff, MAP_RAM);
HD6309MapMemory(K007342ScrRAM[0], 0x2200, 0x23ff, MAP_RAM);
HD6309MapMemory(DrvPalRAM, 0x2400, 0x24ff, MAP_RAM);
HD6309MapMemory(DrvHD6309RAM, 0x4000, 0x5fff, MAP_RAM);
HD6309MapMemory(DrvHD6309ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
HD6309SetWriteHandler(rockrage_main_write);
HD6309SetReadHandler(rockrage_main_read);
HD6309Close();
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x7000, 0x77ff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x7000, 0x77ff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(rockrage_sound_write);
M6809SetReadHandler(rockrage_sound_read);
M6809Close();

12
src/burn/drv/konami/d_rocnrope.cpp
View File

@ -369,12 +369,12 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvSprRAM, 0x4000, 0x47ff, M6809_RAM);
M6809MapMemory(DrvColRAM, 0x4800, 0x4bff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x4c00, 0x4fff, M6809_RAM);
M6809MapMemory(DrvM6809RAM, 0x5000, 0x5fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x6000, 0x6000, 0xffff, M6809_READ);
M6809MapMemory(DrvM6809ROMDec + 0x6000, 0x6000, 0xffff, M6809_FETCH);
M6809MapMemory(DrvSprRAM, 0x4000, 0x47ff, MAP_RAM);
M6809MapMemory(DrvColRAM, 0x4800, 0x4bff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x4c00, 0x4fff, MAP_RAM);
M6809MapMemory(DrvM6809RAM, 0x5000, 0x5fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x6000, 0x6000, 0xffff, MAP_READ);
M6809MapMemory(DrvM6809ROMDec + 0x6000, 0x6000, 0xffff, MAP_FETCH);
M6809SetWriteHandler(rocnrope_write);
M6809SetReadHandler(rocnrope_read);
M6809Close();

10
src/burn/drv/konami/d_rollerg.cpp
View File

@ -278,7 +278,7 @@ static void rollerg_set_lines(INT32 lines)
INT32 offs = 0x10000 + ((lines & 0x07) * 0x4000);
konamiMapMemory(DrvKonROM + offs, 0x4000, 0x7fff, KON_ROM);
konamiMapMemory(DrvKonROM + offs, 0x4000, 0x7fff, MAP_ROM);
}
static void K053245Callback(INT32 *, INT32 *color, INT32 *priority)
@ -384,10 +384,10 @@ static INT32 DrvInit()
konamiInit(0);
konamiOpen(0);
konamiMapMemory(DrvPalRAM, 0x1800, 0x1fff, KON_RAM);
konamiMapMemory(DrvKonRAM, 0x2000, 0x3aff, KON_RAM);
konamiMapMemory(DrvKonROM + 0x4000, 0x4000, 0x7fff, KON_ROM);
konamiMapMemory(DrvKonROM + 0x8000, 0x8000, 0xffff, KON_ROM);
konamiMapMemory(DrvPalRAM, 0x1800, 0x1fff, MAP_RAM);
konamiMapMemory(DrvKonRAM, 0x2000, 0x3aff, MAP_RAM);
konamiMapMemory(DrvKonROM + 0x4000, 0x4000, 0x7fff, MAP_ROM);
konamiMapMemory(DrvKonROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
konamiSetWriteHandler(rollerg_main_write);
konamiSetReadHandler(rollerg_main_read);
konamiSetlinesCallback(rollerg_set_lines);

8
src/burn/drv/konami/d_scotrsht.cpp
View File

@ -373,10 +373,10 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvColRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x1000, 0x1fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x04000, 0x4000, 0xffff, M6809_ROM);
M6809MapMemory(DrvColRAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x0800, 0x0fff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x1000, 0x1fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x04000, 0x4000, 0xffff, MAP_ROM);
M6809SetWriteHandler(scotrsht_main_write);
M6809SetReadHandler(scotrsht_main_read);
M6809Close();

10
src/burn/drv/konami/d_shaolins.cpp
View File

@ -350,12 +350,12 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x2800, 0x30ff, M6809_RAM);
M6809MapMemory(DrvSprRAM, 0x3100, 0x33ff, M6809_RAM);
M6809MapMemory(DrvColRAM, 0x3800, 0x3bff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x3c00, 0x3fff, M6809_RAM);
M6809MapMemory(DrvM6809RAM, 0x2800, 0x30ff, MAP_RAM);
M6809MapMemory(DrvSprRAM, 0x3100, 0x33ff, MAP_RAM);
M6809MapMemory(DrvColRAM, 0x3800, 0x3bff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x3c00, 0x3fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809ROM, 0x4000, 0xffff, MAP_ROM);
M6809SetWriteHandler(shaolins_write);
M6809SetReadHandler(shaolins_read);
M6809Close();

18
src/burn/drv/konami/d_spy.cpp
View File

@ -160,17 +160,17 @@ static void DrvSetRAMBank(UINT8 bank, UINT8 data)
nDrvRomBank[2] = data;
if (data & 0x10) {
M6809MapMemory(DrvPalRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvPalRAM, 0x0000, 0x07ff, MAP_RAM);
} else if (data & 0x20) {
if (bank & 0x80) {
M6809MapMemory(DrvPMCRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvPMCRAM, 0x0000, 0x07ff, MAP_RAM);
} else {
// unmap
M6809MapMemory(DrvM6809ROM + 0x800, 0x0000, 0x07ff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + 0x000, 0x0000, 0x07ff, M6809_WRITE);
M6809MapMemory(DrvM6809ROM + 0x800, 0x0000, 0x07ff, MAP_ROM);
M6809MapMemory(DrvM6809ROM + 0x000, 0x0000, 0x07ff, MAP_WRITE);
}
} else {
M6809MapMemory(DrvBankRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvBankRAM, 0x0000, 0x07ff, MAP_RAM);
}
}
@ -276,7 +276,7 @@ static void bankswitch(INT32 data)
nBank = 0x10000 + (data & 0x0e) * 0x1000;
}
M6809MapMemory(DrvM6809ROM + nBank, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + nBank, 0x6000, 0x7fff, MAP_ROM);
}
void spy_main_write(UINT16 address, UINT8 data)
@ -536,9 +536,9 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x0800, 0x1aff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x6000, 0x7fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x0800, 0x1aff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x10000, 0x6000, 0x7fff, MAP_ROM);
M6809MapMemory(DrvM6809ROM + 0x08000, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(spy_main_write);
M6809SetReadHandler(spy_main_read);
M6809Close();

66
src/burn/drv/konami/d_tmnt.cpp
View File

@ -4471,9 +4471,9 @@ static INT32 TmntInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x060000, 0x063fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x060000, 0x063fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, MAP_RAM);
SekSetReadWordHandler(0, Tmnt68KReadWord);
SekSetWriteWordHandler(0, Tmnt68KWriteWord);
SekSetReadByteHandler(0, Tmnt68KReadByte);
@ -4570,10 +4570,10 @@ static INT32 MiaInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRam + 0x0000 , 0x040000, 0x043fff, SM_RAM);
SekMapMemory(Drv68KRam + 0x4000 , 0x060000, 0x063fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRam + 0x0000 , 0x040000, 0x043fff, MAP_RAM);
SekMapMemory(Drv68KRam + 0x4000 , 0x060000, 0x063fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, MAP_RAM);
SekSetReadWordHandler(0, Mia68KReadWord);
SekSetWriteWordHandler(0, Mia68KWriteWord);
SekSetReadByteHandler(0, Mia68KReadByte);
@ -4654,9 +4654,9 @@ static INT32 CuebrickInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(Drv68KRam + 0x0000 , 0x040000, 0x043fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(Drv68KRam + 0x0000 , 0x040000, 0x043fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, MAP_RAM);
SekSetReadWordHandler(0, Cuebrick68KReadWord);
SekSetWriteWordHandler(0, Cuebrick68KWriteWord);
SekSetReadByteHandler(0, Cuebrick68KReadByte);
@ -4729,9 +4729,9 @@ static INT32 BlswhstlInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x204000, 0x207fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x400000, 0x400fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x204000, 0x207fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x400000, 0x400fff, MAP_RAM);
SekSetReadWordHandler(0, Blswhstl68KReadWord);
SekSetWriteWordHandler(0, Blswhstl68KWriteWord);
SekSetReadByteHandler(0, Blswhstl68KReadByte);
@ -4816,9 +4816,9 @@ static INT32 SsridersInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x0bffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x0bffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, MAP_RAM);
SekSetReadWordHandler(0, Ssriders68KReadWord);
SekSetWriteWordHandler(0, Ssriders68KWriteWord);
SekSetReadByteHandler(0, Ssriders68KReadByte);
@ -4901,9 +4901,9 @@ static INT32 Thndrx2Init()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x100000, 0x103fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x200000, 0x200fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x100000, 0x103fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x200000, 0x200fff, MAP_RAM);
SekSetWriteWordHandler(0, Thndrx268KWriteWord);
SekSetReadByteHandler(0, Thndrx268KReadByte);
SekSetWriteByteHandler(0, Thndrx268KWriteByte);
@ -4985,9 +4985,9 @@ static INT32 LgtnfghtInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, SM_RAM);
SekMapMemory(Drv68KRam , 0x090000, 0x093fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvPaletteRam , 0x080000, 0x080fff, MAP_RAM);
SekMapMemory(Drv68KRam , 0x090000, 0x093fff, MAP_RAM);
SekSetReadWordHandler(0, Lgtnfght68KReadWord);
SekSetWriteWordHandler(0, Lgtnfght68KWriteWord);
SekSetReadByteHandler(0, Lgtnfght68KReadByte);
@ -5074,15 +5074,15 @@ static INT32 Tmnt2Init()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, MAP_RAM);
SekSetReadWordHandler(0, Ssriders68KReadWord);
SekSetWriteWordHandler(0, Ssriders68KWriteWord);
SekSetReadByteHandler(0, Ssriders68KReadByte);
SekSetWriteByteHandler(0, Ssriders68KWriteByte);
SekMapHandler(1, 0x1c0800, 0x1c081f, SM_WRITE);
SekMapHandler(1, 0x1c0800, 0x1c081f, MAP_WRITE);
SekSetWriteWordHandler(1, Tmnt268KProtWord);
SekSetWriteByteHandler(1, Tmnt268KProtByte);
SekClose();
@ -5165,15 +5165,15 @@ static INT32 QgakumonInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x104000, 0x107fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x140000, 0x140fff, MAP_RAM);
SekSetReadWordHandler(0, Ssriders68KReadWord);
SekSetWriteWordHandler(0, Ssriders68KWriteWord);
SekSetReadByteHandler(0, Ssriders68KReadByte);
SekSetWriteByteHandler(0, Ssriders68KWriteByte);
SekMapHandler(1, 0x1c0800, 0x1c081f, SM_WRITE);
SekMapHandler(1, 0x1c0800, 0x1c081f, MAP_WRITE);
SekSetWriteWordHandler(1, Tmnt268KProtWord);
SekSetWriteByteHandler(1, Tmnt268KProtByte);
SekClose();
@ -5254,9 +5254,9 @@ static INT32 PunkshotInit()
// Setup the 68000 emulation
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRam , 0x080000, 0x083fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x090000, 0x090fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRam , 0x080000, 0x083fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x090000, 0x090fff, MAP_RAM);
SekSetReadWordHandler(0, Punkshot68KReadWord);
SekSetWriteWordHandler(0, Punkshot68KWriteWord);
SekSetReadByteHandler(0, Punkshot68KReadByte);

8
src/burn/drv/konami/d_tutankhm.cpp
View File

@ -145,7 +145,7 @@ static void bankswitch(INT32 data)
INT32 bank = 0x10000 + (data & 0x0f) * 0x1000;
M6809MapMemory(DrvM6809ROM + bank, 0x9000, 0x9fff, M6809_ROM);
M6809MapMemory(DrvM6809ROM + bank, 0x9000, 0x9fff, MAP_ROM);
}
static void tutankhm_write(UINT16 address, UINT8 data)
@ -316,9 +316,9 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvVidRAM, 0x0000, 0x7fff, M6809_RAM);
M6809MapMemory(DrvM6809RAM, 0x8800, 0x8fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0xa000, 0xa000, 0xffff, M6809_ROM);
M6809MapMemory(DrvVidRAM, 0x0000, 0x7fff, MAP_RAM);
M6809MapMemory(DrvM6809RAM, 0x8800, 0x8fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0xa000, 0xa000, 0xffff, MAP_ROM);
M6809SetWriteHandler(tutankhm_write);
M6809SetReadHandler(tutankhm_read);
M6809Close();

46
src/burn/drv/konami/d_twin16.cpp
View File

@ -608,7 +608,7 @@ static void twin16_CPUB_register_w(INT32 data)
}
INT32 offset = (twin16_CPUB_register & 4) << 17;
SekMapMemory(DrvGfxROM1 + 0x100000 + offset, 0x700000, 0x77ffff, SM_ROM);
SekMapMemory(DrvGfxROM1 + 0x100000 + offset, 0x700000, 0x77ffff, MAP_ROM);
}
}
@ -659,7 +659,7 @@ void __fastcall twin16_main_write_byte(UINT32 address, UINT8 data)
{
*DrvNvRAMBank = data & 0x1f;
int offset = data & 0x1f;
SekMapMemory(DrvNvRAM + offset * 0x400, 0x0b0000, 0x0b03ff, SM_RAM);
SekMapMemory(DrvNvRAM + offset * 0x400, 0x0b0000, 0x0b03ff, MAP_RAM);
}
return;
@ -975,15 +975,15 @@ static INT32 DrvInit(INT32 (pLoadCallback)())
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvShareRAM, 0x040000, 0x04ffff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x063fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x080000, 0x080fff, SM_RAM);
SekMapMemory(DrvNvRAM, 0x0b0000, 0x0b03ff, SM_RAM);
SekMapMemory(DrvVidRAM2, 0x100000, 0x105fff, SM_RAM);
SekMapMemory(DrvVidRAM, 0x120000, 0x123fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x140000, 0x143fff, SM_RAM);
SekMapMemory(DrvGfxROM1, 0x500000, 0x6fffff, SM_ROM);
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvShareRAM, 0x040000, 0x04ffff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x060000, 0x063fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x080000, 0x080fff, MAP_RAM);
SekMapMemory(DrvNvRAM, 0x0b0000, 0x0b03ff, MAP_RAM);
SekMapMemory(DrvVidRAM2, 0x100000, 0x105fff, MAP_RAM);
SekMapMemory(DrvVidRAM, 0x120000, 0x123fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x140000, 0x143fff, MAP_RAM);
SekMapMemory(DrvGfxROM1, 0x500000, 0x6fffff, MAP_ROM);
SekSetWriteWordHandler(0, twin16_main_write_word);
SekSetWriteByteHandler(0, twin16_main_write_byte);
SekSetReadWordHandler(0, twin16_main_read_word);
@ -992,16 +992,16 @@ static INT32 DrvInit(INT32 (pLoadCallback)())
SekInit(1, 0x68000);
SekOpen(1);
SekMapMemory(Drv68KROM1, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvShareRAM, 0x040000, 0x04ffff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x063fff, SM_RAM);
SekMapMemory(DrvGfxROM2, 0x080000, 0x09ffff, SM_ROM);
SekMapMemory(DrvSprRAM, 0x400000, 0x403fff, SM_RAM);
SekMapMemory(DrvVidRAM, 0x480000, 0x483fff, SM_RAM);
SekMapMemory(DrvTileRAM, 0x500000, 0x53ffff, SM_ROM);
SekMapMemory(DrvGfxROM1, 0x600000, 0x6fffff, SM_ROM);
SekMapMemory(DrvGfxROM1 + 0x100000, 0x700000, 0x77ffff, SM_ROM);
SekMapMemory(DrvSprGfxRAM, 0x780000, 0x79ffff, SM_RAM);
SekMapMemory(Drv68KROM1, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvShareRAM, 0x040000, 0x04ffff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x060000, 0x063fff, MAP_RAM);
SekMapMemory(DrvGfxROM2, 0x080000, 0x09ffff, MAP_ROM);
SekMapMemory(DrvSprRAM, 0x400000, 0x403fff, MAP_RAM);
SekMapMemory(DrvVidRAM, 0x480000, 0x483fff, MAP_RAM);
SekMapMemory(DrvTileRAM, 0x500000, 0x53ffff, MAP_ROM);
SekMapMemory(DrvGfxROM1, 0x600000, 0x6fffff, MAP_ROM);
SekMapMemory(DrvGfxROM1 + 0x100000, 0x700000, 0x77ffff, MAP_ROM);
SekMapMemory(DrvSprGfxRAM, 0x780000, 0x79ffff, MAP_RAM);
SekSetWriteWordHandler(0, twin16_sub_write_word);
SekSetWriteByteHandler(0, twin16_sub_write_byte);
SekClose();
@ -1516,12 +1516,12 @@ static INT32 DrvScan(INT32 nAction,INT32 *pnMin)
}
SekOpen(0);
SekMapMemory(DrvNvRAM + (*DrvNvRAMBank * 0x400), 0x0b0000, 0x0b03ff, SM_RAM);
SekMapMemory(DrvNvRAM + (*DrvNvRAMBank * 0x400), 0x0b0000, 0x0b03ff, MAP_RAM);
SekClose();
SekOpen(1);
INT32 offset = (twin16_CPUB_register & 4) << 17;
SekMapMemory(DrvGfxROM1 + 0x100000 + offset, 0x700000, 0x77ffff, SM_ROM);
SekMapMemory(DrvGfxROM1 + 0x100000 + offset, 0x700000, 0x77ffff, MAP_ROM);
SekClose();
}

6
src/burn/drv/konami/d_ultraman.cpp
View File

@ -446,9 +446,9 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x180000, 0x183fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x180000, 0x183fff, MAP_RAM);
SekSetWriteByteHandler(0, ultraman_write_byte);
SekSetReadByteHandler(0, ultraman_read_byte);
SekClose();

20
src/burn/drv/konami/d_xexex.cpp
View File

@ -339,7 +339,7 @@ static UINT8 _fastcall xexex_main_read_byte(UINT32 address)
static void bankswitch(INT32 data)
{
z80_bank = data;
ZetMapMemory(DrvZ80ROM + ((data & 0x07) * 0x4000), 0x8000, 0xbfff, ZET_ROM);
ZetMapMemory(DrvZ80ROM + ((data & 0x07) * 0x4000), 0x8000, 0xbfff, MAP_ROM);
}
static void __fastcall xexex_sound_write(UINT16 address, UINT8 data)
@ -556,13 +556,13 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x090000, 0x097fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x098000, 0x09ffff, SM_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x0c6000, 0x0c7fff, SM_RAM);
SekMapMemory(Drv68KROM + 0x080000, 0x100000, 0x17ffff, SM_ROM);
SekMapMemory(DrvPalRAM, 0x1b0000, 0x1b1fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(Drv68KRAM, 0x080000, 0x08ffff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x090000, 0x097fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x098000, 0x09ffff, MAP_RAM);
SekMapMemory((UINT8*)K053250Ram, 0x0c6000, 0x0c7fff, MAP_RAM);
SekMapMemory(Drv68KROM + 0x080000, 0x100000, 0x17ffff, MAP_ROM);
SekMapMemory(DrvPalRAM, 0x1b0000, 0x1b1fff, MAP_RAM);
SekSetWriteWordHandler(0, xexex_main_write_word);
SekSetWriteByteHandler(0, xexex_main_write_byte);
SekSetReadWordHandler(0, xexex_main_read_word);
@ -571,8 +571,8 @@ static INT32 DrvInit()
ZetInit(0);
ZetOpen(0);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, ZET_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, ZET_RAM);
ZetMapMemory(DrvZ80ROM, 0x0000, 0x7fff, MAP_ROM);
ZetMapMemory(DrvZ80RAM, 0xc000, 0xdfff, MAP_RAM);
ZetSetWriteHandler(xexex_sound_write);
ZetSetReadHandler(xexex_sound_read);
ZetClose();

8
src/burn/drv/konami/d_xmen.cpp
View File

@ -428,10 +428,10 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, SM_ROM);
SekMapMemory(Drv68KRAM + 0x00000, 0x101000, 0x101fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x104000, 0x104fff, SM_RAM);
SekMapMemory(Drv68KRAM + 0x01000, 0x110000, 0x113fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x0fffff, MAP_ROM);
SekMapMemory(Drv68KRAM + 0x00000, 0x101000, 0x101fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x104000, 0x104fff, MAP_RAM);
SekMapMemory(Drv68KRAM + 0x01000, 0x110000, 0x113fff, MAP_RAM);
SekSetWriteByteHandler(0, xmen_main_write_byte);
SekSetWriteWordHandler(0, xmen_main_write_word);
SekSetReadByteHandler(0, xmen_main_read_byte);

6
src/burn/drv/konami/d_yiear.cpp
View File

@ -333,9 +333,9 @@ static INT32 DrvInit()
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvM6809RAM, 0x5000, 0x57ff, M6809_RAM);
M6809MapMemory(DrvVidRAM, 0x5800, 0x5fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvM6809RAM, 0x5000, 0x57ff, MAP_RAM);
M6809MapMemory(DrvVidRAM, 0x5800, 0x5fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(yiear_write);
M6809SetReadHandler(yiear_read);
M6809Close();

96
src/burn/drv/megadrive/megadrive.cpp
View File

@ -2183,7 +2183,7 @@ static void SetupCustomCartridgeMappers()
{
if (((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_CM_JCART) || ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_CM_JCART_SEPROM)) {
SekOpen(0);
SekMapHandler(7, 0x38fffe, 0x38ffff, SM_READ | SM_WRITE);
SekMapHandler(7, 0x38fffe, 0x38ffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(7, JCartCtrlReadByte);
SekSetReadWordHandler(7, JCartCtrlReadWord);
SekSetWriteByteHandler(7, JCartCtrlWriteByte);
@ -2200,7 +2200,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x000000, OriginalRom + 0x000000, 0x400000);
SekOpen(0);
SekMapHandler(7, 0xa130f0, 0xa130ff, SM_WRITE);
SekMapHandler(7, 0xa130f0, 0xa130ff, MAP_WRITE);
SekSetWriteByteHandler(7, Ssf2BankWriteByte);
SekClose();
}
@ -2219,12 +2219,12 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x200000, OriginalRom + 0x000000, 0x200000);
SekOpen(0);
SekMapHandler(7, 0x600000, 0x6fffff, SM_READ | SM_WRITE);
SekMapHandler(7, 0x600000, 0x6fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(7, LK3AltProtReadByte);
SekSetReadWordHandler(7, LK3AltProtReadWord);
SekSetWriteByteHandler(7, LK3AltProtWriteByte);
SekSetWriteWordHandler(7, LK3AltProtWriteWord);
SekMapHandler(8, 0x700000, 0x7fffff, SM_WRITE);
SekMapHandler(8, 0x700000, 0x7fffff, MAP_WRITE);
SekSetWriteByteHandler(8, LK3AltBankWriteByte);
SekSetWriteWordHandler(8, LK3AltBankWriteWord);
SekClose();
@ -2241,12 +2241,12 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x300000, OriginalRom + 0x000000, 0x100000);
SekOpen(0);
SekMapHandler(7, 0x600000, 0x6fffff, SM_READ | SM_WRITE);
SekMapHandler(7, 0x600000, 0x6fffff, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(7, LK3AltProtReadByte);
SekSetReadWordHandler(7, LK3AltProtReadWord);
SekSetWriteByteHandler(7, LK3AltProtWriteByte);
SekSetWriteWordHandler(7, LK3AltProtWriteWord);
SekMapHandler(8, 0x700000, 0x7fffff, SM_WRITE);
SekMapHandler(8, 0x700000, 0x7fffff, MAP_WRITE);
SekSetWriteByteHandler(8, LK3AltBankWriteByte);
SekSetWriteWordHandler(8, LK3AltBankWriteWord);
SekClose();
@ -2262,10 +2262,10 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x000000, OriginalRom + 0x000004, 0x200000);
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400001, SM_READ);
SekMapHandler(7, 0x400000, 0x400001, MAP_READ);
SekSetReadByteHandler(7, RedclifProt2ReadByte);
SekSetReadWordHandler(7, RedclifProt2ReadWord);
SekMapHandler(8, 0x400004, 0x400005, SM_READ);
SekMapHandler(8, 0x400004, 0x400005, MAP_READ);
SekSetReadByteHandler(8, RedclifProtReadByte);
SekSetReadWordHandler(8, RedclifProtReadWord);
SekClose();
@ -2280,7 +2280,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x800000, OriginalRom + 0x000000, 0x400000);
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa1307f, SM_READ);
SekMapHandler(7, 0xa13000, 0xa1307f, MAP_READ);
SekSetReadByteHandler(7, RadicaBankSelectReadByte);
SekSetReadWordHandler(7, RadicaBankSelectReadWord);
SekClose();
@ -2289,7 +2289,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_KOF99 ||
(BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_POKEMON) {
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa1303f, SM_READ);
SekMapHandler(7, 0xa13000, 0xa1303f, MAP_READ);
SekSetReadByteHandler(7, Kof99A13000ReadByte);
SekSetReadWordHandler(7, Kof99A13000ReadWord);
SekClose();
@ -2297,7 +2297,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SOULBLAD) {
SekOpen(0);
SekMapHandler(7, 0x400002, 0x400007, SM_READ);
SekMapHandler(7, 0x400002, 0x400007, MAP_READ);
SekSetReadByteHandler(7, SoulbladReadByte);
SekSetReadWordHandler(7, SoulbladReadWord);
SekClose();
@ -2305,10 +2305,10 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_MJLOVER) {
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400001, SM_READ);
SekMapHandler(7, 0x400000, 0x400001, MAP_READ);
SekSetReadByteHandler(7, MjloverProt1ReadByte);
SekSetReadWordHandler(7, MjloverProt1ReadWord);
SekMapHandler(8, 0x401000, 0x401001, SM_READ);
SekMapHandler(8, 0x401000, 0x401001, MAP_READ);
SekSetReadByteHandler(8, MjloverProt2ReadByte);
SekSetReadWordHandler(8, MjloverProt2ReadWord);
SekClose();
@ -2316,7 +2316,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SQUIRRELK) {
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400007, SM_READ | SM_WRITE);
SekMapHandler(7, 0x400000, 0x400007, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(7, SquirrelKingExtraReadByte);
SekSetReadWordHandler(7, SquirrelKingExtraReadWord);
SekSetWriteByteHandler(7, SquirrelKingExtraWriteByte);
@ -2326,7 +2326,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SMOUSE) {
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400007, SM_READ);
SekMapHandler(7, 0x400000, 0x400007, MAP_READ);
SekSetReadByteHandler(7, SmouseProtReadByte);
SekSetReadWordHandler(7, SmouseProtReadWord);
SekClose();
@ -2334,7 +2334,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SMB) {
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13001, SM_READ);
SekMapHandler(7, 0xa13000, 0xa13001, MAP_READ);
SekSetReadByteHandler(7, SmbProtReadByte);
SekSetReadWordHandler(7, SmbProtReadWord);
SekClose();
@ -2342,7 +2342,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SMB2) {
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13001, SM_READ);
SekMapHandler(7, 0xa13000, 0xa13001, MAP_READ);
SekSetReadByteHandler(7, Smb2ProtReadByte);
SekSetReadWordHandler(7, Smb2ProtReadWord);
SekClose();
@ -2357,7 +2357,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x000000, OriginalRom, 0x200000);
SekOpen(0);
SekMapHandler(7, 0x700000, 0x7fffff, SM_WRITE);
SekMapHandler(7, 0x700000, 0x7fffff, MAP_WRITE);
SekSetWriteByteHandler(7, KaijuBankWriteByte);
SekSetWriteWordHandler(7, KaijuBankWriteWord);
SekClose();
@ -2372,10 +2372,10 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x000000, OriginalRom + 0x000000, 0x200000);
SekOpen(0);
SekMapHandler(7, 0x400000, 0x4fffff, SM_READ);
SekMapHandler(7, 0x400000, 0x4fffff, MAP_READ);
SekSetReadByteHandler(7, Chinfi3ProtReadByte);
SekSetReadWordHandler(7, Chinfi3ProtReadWord);
SekMapHandler(8, 0x600000, 0x6fffff, SM_WRITE);
SekMapHandler(8, 0x600000, 0x6fffff, MAP_WRITE);
SekSetWriteByteHandler(8, Chinfi3BankWriteByte);
SekSetWriteWordHandler(8, Chinfi3BankWriteWord);
SekClose();
@ -2386,7 +2386,7 @@ static void SetupCustomCartridgeMappers()
RamMisc->Lionk2ProtData2 = 0;
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400007, SM_READ | SM_WRITE);
SekMapHandler(7, 0x400000, 0x400007, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(7, Lionk2ProtReadByte);
SekSetReadWordHandler(7, Lionk2ProtReadWord);
SekSetWriteByteHandler(7, Lionk2ProtWriteByte);
@ -2396,7 +2396,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_BUGSLIFE) {
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13001, SM_READ);
SekMapHandler(7, 0xa13000, 0xa13001, MAP_READ);
SekSetReadByteHandler(7, BuglExtraReadByte);
SekSetReadWordHandler(7, BuglExtraReadWord);
SekClose();
@ -2404,7 +2404,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_ELFWOR) {
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400007, SM_READ);
SekMapHandler(7, 0x400000, 0x400007, MAP_READ);
SekSetReadByteHandler(7, Elfwor400000ReadByte);
SekSetReadWordHandler(7, Elfwor400000ReadWord);
SekClose();
@ -2412,7 +2412,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_ROCKMANX3) {
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13001, SM_READ);
SekMapHandler(7, 0xa13000, 0xa13001, MAP_READ);
SekSetReadByteHandler(7, RockmanX3ExtraReadByte);
SekSetReadWordHandler(7, RockmanX3ExtraReadWord);
SekClose();
@ -2420,7 +2420,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SBUBBOB) {
SekOpen(0);
SekMapHandler(7, 0x400000, 0x400003, SM_READ);
SekMapHandler(7, 0x400000, 0x400003, MAP_READ);
SekSetReadByteHandler(7, SbubExtraReadByte);
SekSetReadWordHandler(7, SbubExtraReadWord);
SekClose();
@ -2428,7 +2428,7 @@ static void SetupCustomCartridgeMappers()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_KOF98) {
SekOpen(0);
SekMapHandler(7, 0x480000, 0x4fffff, SM_READ);
SekMapHandler(7, 0x480000, 0x4fffff, MAP_READ);
SekSetReadByteHandler(7, Kof98ReadByte);
SekSetReadWordHandler(7, Kof98ReadWord);
SekClose();
@ -2448,7 +2448,7 @@ static void SetupCustomCartridgeMappers()
}
SekOpen(0);
SekMapHandler(7, 0x400000, 0x40400f, SM_WRITE);
SekMapHandler(7, 0x400000, 0x40400f, MAP_WRITE);
SekSetWriteByteHandler(7, RealtecWriteByte);
SekSetWriteWordHandler(7, RealtecWriteWord);
SekClose();
@ -2461,7 +2461,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x400000, OriginalRom + 0x000000, 0x400000);
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13039, SM_WRITE);
SekMapHandler(7, 0xa13000, 0xa13039, MAP_WRITE);
SekSetWriteByteHandler(7, Sup19in1BankWriteByte);
SekSetWriteWordHandler(7, Sup19in1BankWriteWord);
SekClose();
@ -2474,7 +2474,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x400000, OriginalRom + 0x000000, 0x200000);
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa13039, SM_WRITE);
SekMapHandler(7, 0xa13000, 0xa13039, MAP_WRITE);
SekSetWriteByteHandler(7, Sup19in1BankWriteByte);
SekSetWriteWordHandler(7, Sup19in1BankWriteWord);
SekClose();
@ -2487,7 +2487,7 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x000000, OriginalRom + 0x000000, 0x200000);
SekOpen(0);
SekMapHandler(7, 0xa13000, 0xa1303f, SM_WRITE);
SekMapHandler(7, 0xa13000, 0xa1303f, MAP_WRITE);
SekSetWriteByteHandler(7, Mc12in1BankWriteByte);
SekSetWriteWordHandler(7, Mc12in1BankWriteWord);
SekClose();
@ -2503,10 +2503,10 @@ static void SetupCustomCartridgeMappers()
memcpy(RomMain + 0x600000, OriginalRom + 0x000000, 0x200000);
SekOpen(0);
SekMapHandler(7, 0x600000, 0x6fffff, SM_READ);
SekMapHandler(7, 0x600000, 0x6fffff, MAP_READ);
SekSetReadByteHandler(7, TopfigReadByte);
SekSetReadWordHandler(7, TopfigReadWord);
SekMapHandler(8, 0x700000, 0x7fffff, SM_WRITE);
SekMapHandler(8, 0x700000, 0x7fffff, MAP_WRITE);
SekSetWriteByteHandler(8, TopfigWriteByte);
SekSetWriteWordHandler(8, TopfigWriteWord);
SekClose();
@ -2564,7 +2564,7 @@ static void InstallSRAMHandlers(bool MaskAddr)
memcpy((UINT8*)MegadriveBackupRam, SRam, RamMisc->SRamEnd - RamMisc->SRamStart + 1);
SekOpen(0);
SekMapHandler(6, RamMisc->SRamStart & Mask, RamMisc->SRamEnd & Mask, SM_READ | SM_WRITE);
SekMapHandler(6, RamMisc->SRamStart & Mask, RamMisc->SRamEnd & Mask, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(6, MegadriveSRAMReadByte);
SekSetReadWordHandler(6, MegadriveSRAMReadWord);
SekSetWriteByteHandler(6, MegadriveSRAMWriteByte);
@ -2792,7 +2792,7 @@ static void MegadriveSetupSRAM()
MegadriveBackupRam = (UINT16*)RomMain + RamMisc->SRamStart;
SekOpen(0);
SekMapHandler(5, 0xa130f0, 0xa130f1, SM_WRITE);
SekMapHandler(5, 0xa130f0, 0xa130f1, MAP_WRITE);
SekSetWriteByteHandler(5, MegadriveSRAMToggleWriteByte);
SekSetWriteWordHandler(5, MegadriveSRAMToggleWriteWord);
SekClose();
@ -2822,7 +2822,7 @@ static void MegadriveSetupSRAM()
MegadriveBackupRam = (UINT16*)RomMain + RamMisc->SRamStart;
SekOpen(0);
SekMapHandler(5, 0xa130f0, 0xa130f1, SM_READ | SM_WRITE);
SekMapHandler(5, 0xa130f0, 0xa130f1, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(5, Megadrive6658ARegReadByte);
SekSetReadWordHandler(5, Megadrive6658ARegReadWord);
SekSetWriteByteHandler(5, Megadrive6658ARegWriteByte);
@ -2835,7 +2835,7 @@ static void MegadriveSetupSRAM()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_SEGA_EEPROM) {
RamMisc->SRamHasSerialEEPROM = 1;
SekOpen(0);
SekMapHandler(5, 0x200000, 0x200001, SM_READ | SM_WRITE);
SekMapHandler(5, 0x200000, 0x200001, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(5, WboyVEEPROMReadByte);
SekSetReadWordHandler(5, WboyVEEPROMReadWord);
SekSetWriteByteHandler(5, WboyVEEPROMWriteByte);
@ -2846,7 +2846,7 @@ static void MegadriveSetupSRAM()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_NBA_JAM) {
RamMisc->SRamHasSerialEEPROM = 1;
SekOpen(0);
SekMapHandler(5, 0x200000, 0x200001, SM_READ | SM_WRITE);
SekMapHandler(5, 0x200000, 0x200001, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(5, NbajamEEPROMReadByte);
SekSetReadWordHandler(5, NbajamEEPROMReadWord);
SekSetWriteByteHandler(5, NbajamEEPROMWriteByte);
@ -2857,7 +2857,7 @@ static void MegadriveSetupSRAM()
if (((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_NBA_JAM_TE) || ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_NFL_QB_96) || ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_C_SLAM)) {
RamMisc->SRamHasSerialEEPROM = 1;
SekOpen(0);
SekMapHandler(5, 0x200000, 0x200001, SM_READ | SM_WRITE);
SekMapHandler(5, 0x200000, 0x200001, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(5, NbajamteEEPROMReadByte);
SekSetReadWordHandler(5, NbajamteEEPROMReadWord);
SekSetWriteByteHandler(5, NbajamteEEPROMWriteByte);
@ -2868,7 +2868,7 @@ static void MegadriveSetupSRAM()
if ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_EA_NHLPA) {
RamMisc->SRamHasSerialEEPROM = 1;
SekOpen(0);
SekMapHandler(5, 0x200000, 0x200001, SM_READ | SM_WRITE);
SekMapHandler(5, 0x200000, 0x200001, MAP_READ | MAP_WRITE);
SekSetReadByteHandler(5, EANhlpaEEPROMReadByte);
SekSetReadWordHandler(5, EANhlpaEEPROMReadWord);
SekSetWriteByteHandler(5, EANhlpaEEPROMWriteByte);
@ -2879,10 +2879,10 @@ static void MegadriveSetupSRAM()
if (((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_CODE_MASTERS) || ((BurnDrvGetHardwareCode() & 0xff) == HARDWARE_SEGA_MEGADRIVE_PCB_CM_JCART_SEPROM)) {
RamMisc->SRamHasSerialEEPROM = 1;
SekOpen(0);
SekMapHandler(5, 0x300000, 0x300001, SM_WRITE);
SekMapHandler(5, 0x300000, 0x300001, MAP_WRITE);
SekSetWriteByteHandler(5, CodemastersEEPROMWriteByte);
SekSetWriteWordHandler(5, CodemastersEEPROMWriteWord);
SekMapHandler(6, 0x380000, 0x380001, SM_READ);
SekMapHandler(6, 0x380000, 0x380001, MAP_READ);
SekSetReadByteHandler(6, CodemastersEEPROMReadByte);
SekSetReadWordHandler(6, CodemastersEEPROMReadWord);
SekClose();
@ -2934,7 +2934,7 @@ static void MegadriveSetupSRAM()
}
SekOpen(0);
SekMapHandler(5, 0xa130f0, 0xa130f1, SM_WRITE);
SekMapHandler(5, 0xa130f0, 0xa130f1, MAP_WRITE);
SekSetWriteByteHandler(5, MegadriveSRAMToggleWriteByte);
SekSetWriteWordHandler(5, MegadriveSRAMToggleWriteWord);
SekClose();
@ -2967,13 +2967,13 @@ INT32 MegadriveInit()
SekOpen(0);
// Map 68000 memory:
SekMapMemory(RomMain, 0x000000, 0x3FFFFF, SM_ROM); // 68000 ROM
SekMapMemory(Ram68K, 0xFF0000, 0xFFFFFF, SM_RAM); // 68000 RAM
SekMapMemory(RomMain, 0x000000, 0x3FFFFF, MAP_ROM); // 68000 ROM
SekMapMemory(Ram68K, 0xFF0000, 0xFFFFFF, MAP_RAM); // 68000 RAM
SekMapHandler(1, 0xC00000, 0xC0001F, SM_RAM); // Video Port
SekMapHandler(2, 0xA00000, 0xA01FFF, SM_RAM); // Z80 Ram
SekMapHandler(3, 0xA02000, 0xA03FFF, SM_RAM); // Z80 Ram
SekMapHandler(4, 0xA10000, 0xA1001F, SM_RAM); // I/O
SekMapHandler(1, 0xC00000, 0xC0001F, MAP_RAM); // Video Port
SekMapHandler(2, 0xA00000, 0xA01FFF, MAP_RAM); // Z80 Ram
SekMapHandler(3, 0xA02000, 0xA03FFF, MAP_RAM); // Z80 Ram
SekMapHandler(4, 0xA10000, 0xA1001F, MAP_RAM); // I/O
SekSetReadByteHandler (0, MegadriveReadByte);
SekSetReadWordHandler (0, MegadriveReadWord);

82
src/burn/drv/neogeo/d_neogeo.cpp
View File

@ -1201,11 +1201,11 @@ static pSekWriteWordHandler pSMABankswitchHandler[MAX_SLOT] = { NULL, };
// Bank in an area of memory
void NeoSMABankswitch()
{
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
if (nNeoSMARNGAddress[0] > 0 || nNeoSMARNGAddress[1] > 0) {
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, MAP_ROM);
} else {
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFFFF, MAP_ROM);
}
}
@ -1299,17 +1299,17 @@ static void NeoSMAInstallHanders()
{
// bprintf(PRINT_NORMAL, _T(" Installing handlers for slot %i\n"), nNeoActiveSlot);
SekMapHandler(8, 0x2FFC00, 0x2FFFFF, SM_WRITE); // Bankswitch
SekMapHandler(8, 0x2FFC00, 0x2FFFFF, MAP_WRITE); // Bankswitch
SekSetWriteWordHandler(8, pSMABankswitchHandler[nNeoActiveSlot]);
SekMapHandler(6, 0x2FE400, 0x2FE7FF, SM_ROM); // Protection
SekMapHandler(6, 0x2FE400, 0x2FE7FF, MAP_ROM); // Protection
SekSetReadWordHandler(6, neogeoReadWordSMA9A37);
SekSetReadByteHandler(6, neogeoReadByteSMA9A37);
if (nNeoSMARNGAddress[nNeoActiveSlot][0] > 0 || nNeoSMARNGAddress[nNeoActiveSlot][1] > 0) {
SekMapHandler(7, 0x2FFC00, 0x2FFFFF, SM_ROM); // Randum number generator
SekMapHandler(7, 0x2FFC00, 0x2FFFFF, MAP_ROM); // Randum number generator
SekSetReadWordHandler(7, neogeoReadWordSMARNG);
SekSetReadByteHandler(7, neogeoReadByteSMARNG);
@ -1450,7 +1450,7 @@ void NeoPVCBankswitch()
if (nNeo68KROMBank != nBank)
{
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
PVCRAM[0x1ff0] = 0xa0;
@ -1476,7 +1476,7 @@ void __fastcall PVCWriteWordBankSwitch(UINT32 sekAddress, UINT16 wordValue)
static void NeoPVCMapBank()
{
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
static INT32 NeoPVCScan(INT32 nAction, INT32*)
@ -1497,9 +1497,9 @@ static INT32 NeoPVCScan(INT32 nAction, INT32*)
static void NeoPVCInstallHandlers()
{
// Install cart PVC protections
SekMapMemory(PVCRAM, 0x2fe000, 0x2fffff, SM_READ);
SekMapMemory(PVCRAM, 0x2fe000, 0x2fffff, MAP_READ);
SekMapHandler(6, 0x2fe000, 0x2fffff, SM_WRITE);
SekMapHandler(6, 0x2fe000, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(6, PVCWriteWordBankSwitch);
SekSetWriteByteHandler(6, PVCWriteByteBankSwitch);
}
@ -3471,8 +3471,8 @@ INT32 fatfury2Scan(INT32 nAction, INT32* /*pnMin*/)
static void fatfury2InstallHanders()
{
// Install protection handler
SekMapHandler(6, 0x200000, 0x2FFFFF, SM_WRITE);
SekMapHandler(6, 0x200000, 0x2FFFFF, SM_READ);
SekMapHandler(6, 0x200000, 0x2FFFFF, MAP_WRITE);
SekMapHandler(6, 0x200000, 0x2FFFFF, MAP_READ);
SekSetWriteWordHandler(6, fatfury2WriteWordProtection);
SekSetWriteByteHandler(6, fatfury2WriteByteProtection);
SekSetReadWordHandler(6, fatfury2ReadWordProtection);
@ -4934,7 +4934,7 @@ static void kogCallback()
static void kogInstallHandlers()
{
// Install jumper that controls title screen language
SekMapHandler(6, 0x0FFFFE, 0x0FFFFF, SM_READ);
SekMapHandler(6, 0x0FFFFE, 0x0FFFFF, MAP_READ);
SekSetReadWordHandler(6, KogReadWord);
}
@ -5401,7 +5401,7 @@ void __fastcall kof98WriteWordProtection(UINT32 sekAddress, UINT16 wordValue)
static void kof98InstallHandler()
{
SekMapHandler(6, 0x200000, 0x2FFBFF, SM_WRITE);
SekMapHandler(6, 0x200000, 0x2FFBFF, MAP_WRITE);
SekSetWriteWordHandler(6, kof98WriteWordProtection);
SekSetWriteByteHandler(6, kof98WriteByteProtection);
@ -5724,7 +5724,7 @@ static UINT16 __fastcall mslugx_protection_read()
static void mslugxMapBank()
{
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2ffbff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2ffbff, MAP_ROM);
}
static void mslugxBankswitch(UINT32 nBank)
@ -5771,7 +5771,7 @@ static void __fastcall mslugx_write_protection_byte(UINT32 SekAddress, UINT8 byt
static void mslugxInstallBankSwitchHandler()
{
SekMapHandler(6, 0x2ffc00, 0x2fffff, SM_WRITE | SM_READ | SM_FETCH);
SekMapHandler(6, 0x2ffc00, 0x2fffff, MAP_WRITE | MAP_READ | MAP_FETCH);
SekSetReadWordHandler(6, mslugx_read_protection_word);
SekSetReadByteHandler(6, mslugx_read_protection_byte);
SekSetWriteWordHandler(6, mslugx_write_protection_word);
@ -5883,8 +5883,8 @@ void __fastcall kof99WriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (bankoffset[nBank] != nNeo68KROMBank) {
nNeo68KROMBank = bankoffset[nBank];
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, MAP_ROM);
}
}
}
@ -6144,8 +6144,8 @@ void __fastcall garouWriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (bankoffset[nBank] != nNeo68KROMBank) {
nNeo68KROMBank = bankoffset[nBank];
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, MAP_ROM);
}
}
}
@ -6246,8 +6246,8 @@ void __fastcall garouhWriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (bankoffset[nBank] != nNeo68KROMBank) {
nNeo68KROMBank = bankoffset[nBank];
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, MAP_ROM);
}
}
}
@ -6442,8 +6442,8 @@ void __fastcall mslug3WriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (bankoffset[nBank] != nNeo68KROMBank) {
nNeo68KROMBank = bankoffset[nBank];
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFFFF, MAP_ROM);
}
}
}
@ -6634,8 +6634,8 @@ void __fastcall kof2000WriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (bankoffset[nBank] != nNeo68KROMBank) {
nNeo68KROMBank = bankoffset[nBank];
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FE3FF, MAP_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank + 0x0FE800, 0x2FE800, 0x2FFBFF, MAP_ROM);
}
}
}
@ -6893,7 +6893,7 @@ static void cthd2003Bankswitch(UINT32 nBank)
if (nBank != nNeo68KROMBank) {
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fffff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fffff, MAP_ROM);
}
}
@ -6966,7 +6966,7 @@ static void cthd2003Callback()
static void cthd2003InstallBankSwitchHandler()
{
SekMapHandler(6, 0x200000, 0x2fffff, SM_WRITE);
SekMapHandler(6, 0x200000, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(6, cthd2003WriteWordBankswitch);
SekSetWriteByteHandler(6, cthd2003WriteByteBankswitch);
@ -7044,7 +7044,7 @@ static void ct2k3spCallback()
static void ct2kspInstallBankSwitchHandler()
{
SekMapHandler(6, 0x200000, 0x2fffff, SM_WRITE);
SekMapHandler(6, 0x200000, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(6, cthd2003WriteWordBankswitch);
SekSetWriteByteHandler(6, cthd2003WriteByteBankswitch);
@ -7504,7 +7504,7 @@ static void kof10thBankswitch(UINT32 nBank)
if (nBank != nNeo68KROMBank) {
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
}
@ -7533,7 +7533,7 @@ void __fastcall kof10thWriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (sekAddress == 0x2ffff0)
kof10thBankswitch(wordValue);
else if (sekAddress == 0x2ffff8 && *(UINT16*)(kof10thExtraRAMB + 0x1ff8) != BURN_ENDIAN_SWAP_INT16(wordValue))
SekMapMemory(Neo68KROMActive + ((wordValue & 1) ? 0x710000 : 0x010000) , 0x010000, 0x0dffff, SM_ROM);
SekMapMemory(Neo68KROMActive + ((wordValue & 1) ? 0x710000 : 0x010000) , 0x010000, 0x0dffff, MAP_ROM);
*(UINT16*)(kof10thExtraRAMB + (sekAddress & 0x01ffe)) = wordValue;
}
@ -7570,7 +7570,7 @@ static void kof10thCallback()
static void kof10thMapBank()
{
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
static INT32 kof10thScan(INT32 nAction, INT32* pnMin)
@ -7600,15 +7600,15 @@ static INT32 kof10thScan(INT32 nAction, INT32* pnMin)
static void kof10thInstallHandlers()
{
// Install RAM handlers
SekMapMemory(kof10thExtraRAMA, 0x0e0000, 0x0fffff, SM_ROM); // Text RAM on range 0x0e0000 - 0x0fffff
SekMapMemory(kof10thExtraRAMB, 0x2fe000, 0x2fffff, SM_ROM); // Extra 68K RAM
SekMapMemory(kof10thExtraRAMA, 0x0e0000, 0x0fffff, MAP_ROM); // Text RAM on range 0x0e0000 - 0x0fffff
SekMapMemory(kof10thExtraRAMB, 0x2fe000, 0x2fffff, MAP_ROM); // Extra 68K RAM
// Install bankswitch and text handlers
SekMapHandler(6, 0x2fe000, 0x2fffff, SM_WRITE);
SekMapHandler(6, 0x2fe000, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(6, kof10thWriteWordBankswitch);
SekSetWriteByteHandler(6, kof10thWriteByteBankswitch);
SekMapHandler(7, 0x200000, 0x23ffff, SM_WRITE);
SekMapHandler(7, 0x200000, 0x23ffff, MAP_WRITE);
SekSetWriteWordHandler(7, kof10thWriteWordCustom);
// Set bank
@ -8060,14 +8060,14 @@ void __fastcall ms5plusWriteWordBankSwitch(UINT32 sekAddress, UINT16 wordValue)
if (nNeo68KROMBank != nBank)
{
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
};
}
static void ms5plusInstallHandlers()
{
SekMapHandler(6, 0x2fe000, 0x2fffff, SM_WRITE);
SekMapHandler(6, 0x2fe000, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(6, ms5plusWriteWordBankSwitch);
}
@ -9149,7 +9149,7 @@ static void kf2k3blInstallHandlers()
{
NeoPVCInstallHandlers();
SekMapHandler(7, 0x058196, 0x058197, SM_READ);
SekMapHandler(7, 0x058196, 0x058197, MAP_READ);
SekSetReadByteHandler(7, kf2k3blReadByteProtection);
}
@ -9247,7 +9247,7 @@ void __fastcall kf2k3blaWriteWordBankswitch(UINT32 sekAddress, UINT16 wordValue)
if (nBank != nNeo68KROMBank)
{
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2fdfff, MAP_ROM);
}
}
}
@ -9256,7 +9256,7 @@ static void kf2k3blaInstallHandlers()
{
NeoPVCInstallHandlers();
SekMapHandler(7, 0x2ffff0, 0x2fffff, SM_WRITE);
SekMapHandler(7, 0x2ffff0, 0x2fffff, MAP_WRITE);
SekSetWriteWordHandler(7, kf2k3blaWriteWordBankswitch);
}

84
src/burn/drv/neogeo/neo_run.cpp
View File

@ -861,9 +861,9 @@ static void NeoZ80MapROM(bool bMapBoardROM)
static void MapVectorTable(bool bMapBoardROM)
{
if (!bMapBoardROM && Neo68KROMActive) {
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0003FF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0003FF, MAP_ROM);
} else {
SekMapMemory(NeoVectorActive, 0x000000, 0x0003FF, SM_ROM);
SekMapMemory(NeoVectorActive, 0x000000, 0x0003FF, MAP_ROM);
}
}
@ -871,7 +871,7 @@ inline static void MapPalette(INT32 nBank)
{
if (nNeoPaletteBank != nBank) {
nNeoPaletteBank = nBank;
SekMapMemory(NeoPalSrc[nBank], 0x400000, 0x401FFF, SM_ROM);
SekMapMemory(NeoPalSrc[nBank], 0x400000, 0x401FFF, MAP_ROM);
NeoSetPalette();
}
@ -887,20 +887,20 @@ static void Bankswitch(UINT32 nBank)
if (nBank != nNeo68KROMBank) {
// bprintf(PRINT_NORMAL, "Bankswitched main ROM, new address is 0x%08X.\n", nBank);
nNeo68KROMBank = nBank;
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, MAP_ROM);
}
}
void NeoMapBank()
{
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, MAP_ROM);
}
void NeoMap68KFix()
{
if ((nNeoSystemType & NEO_SYS_CART) && (nCodeSize[nNeoActiveSlot] > 0x100000)) {
SekMapMemory(Neo68KFix[nNeoActiveSlot] + 0x0400, 0x000400, 0x0FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot] + 0x0400, 0x000400, 0x0FFFFF, MAP_ROM);
if (Neo68KROM[nNeoActiveSlot]) {
memcpy(NeoVector[nNeoActiveSlot] + 0x80, Neo68KFix[nNeoActiveSlot] + 0x80, 0x0380);
@ -1090,8 +1090,8 @@ static void NeoMapActiveCartridge()
Neo68KROMActive = NULL;
SekMapHandler(0, 0x000000, 0x0FFFFF, SM_RAM);
SekMapHandler(0, 0x200000, 0x2FFFFF, SM_RAM);
SekMapHandler(0, 0x000000, 0x0FFFFF, MAP_RAM);
SekMapHandler(0, 0x200000, 0x2FFFFF, MAP_RAM);
b68KBoardROMBankedIn = true;
MapVectorTable(b68KBoardROMBankedIn);
@ -1119,24 +1119,24 @@ static void NeoMapActiveCartridge()
SekSetReadByteHandler(7, NULL);
SekSetWriteByteHandler(7, NULL);
SekMapHandler(0, 0x000000, 0x0FFFFF, SM_WRITE);
SekMapHandler(0, 0x000000, 0x0FFFFF, MAP_WRITE);
if (nCodeSize[nNeoActiveSlot] <= 0x080000) {
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x07FFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x080000, 0x0FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x200000, 0x27FFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x280000, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x07FFFF, MAP_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x080000, 0x0FFFFF, MAP_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x200000, 0x27FFFF, MAP_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x280000, 0x2FFFFF, MAP_ROM);
}
if (nCodeSize[nNeoActiveSlot] <= 0x100000) {
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x200000, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0FFFFF, MAP_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x200000, 0x2FFFFF, MAP_ROM);
}
if (nCodeSize[nNeoActiveSlot] > 0x100000) {
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0FFFFF, SM_ROM);
SekMapMemory(Neo68KFix[nNeoActiveSlot], 0x000000, 0x0FFFFF, MAP_ROM);
SekMapHandler(4, 0x200000, 0x2FFFFF, SM_WRITE);
SekMapHandler(4, 0x200000, 0x2FFFFF, MAP_WRITE);
SekSetWriteWordHandler(4, neogeoWriteWordBankswitch);
SekSetWriteByteHandler(4, neogeoWriteByteBankswitch);
@ -1159,14 +1159,14 @@ static void NeoMapActiveCartridge()
}
if ((BurnDrvGetHardwareCode() & HARDWARE_SNK_CONTROLMASK) == HARDWARE_SNK_GAMBLING) {
SekMapMemory(NeoNVRAM2, 0x200000, 0x201FFF, SM_RAM); // 68K RAM
SekMapMemory(NeoNVRAM2, 0x200000, 0x201FFF, MAP_RAM); // 68K RAM
SekMapHandler(6, 0x202000, 0x2FFFFF, SM_READ);
SekMapHandler(6, 0x202000, 0x2FFFFF, MAP_READ);
SekSetReadByteHandler(6, neogeoReadByteGambling);
SekSetReadWordHandler(6, neogeoReadWordGambling);
if (!strcmp(BurnDrvGetTextA(DRV_NAME), "vliner") || !strcmp(BurnDrvGetTextA(DRV_NAME), "vlinero")) {
SekMapHandler(7, 0x320000, 0x320001, SM_READ);
SekMapHandler(7, 0x320000, 0x320001, MAP_READ);
SekSetReadByteHandler(7, vliner_timing);
}
}
@ -1490,7 +1490,7 @@ INT32 NeoScan(INT32 nAction, INT32* pnMin)
} else {
if ((BurnDrvGetHardwareCode() & HARDWARE_SNK_CONTROLMASK) != HARDWARE_SNK_GAMBLING) {
SekOpen(0);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, SM_ROM);
SekMapMemory(Neo68KROMActive + nNeo68KROMBank, 0x200000, 0x2FFFFF, MAP_ROM);
SekClose();
}
}
@ -3630,11 +3630,11 @@ static INT32 neogeoReset()
if (nNeoSystemType & NEO_SYS_MVS) {
for (INT32 a = 0xD00000; a < 0xE00000; a += 0x010000) {
SekMapMemory(NeoNVRAM, a, a + 0xFFFF, SM_RAM); // 68K RAM
SekMapMemory(NeoNVRAM, a, a + 0xFFFF, MAP_RAM); // 68K RAM
}
SekMapHandler(1, 0xD00000, 0xDFFFFF, SM_WRITE); //
SekMapHandler(1, 0xD00000, 0xDFFFFF, MAP_WRITE); //
} else {
SekMapHandler(0, 0xD00000, 0xDFFFFF, SM_RAM); // AES/NeoCD don't have the SRAM
SekMapHandler(0, 0xD00000, 0xDFFFFF, MAP_RAM); // AES/NeoCD don't have the SRAM
}
if (nNeoSystemType & NEO_SYS_CART) {
@ -3643,18 +3643,18 @@ static INT32 neogeoReset()
if (nNeoSystemType & NEO_SYS_PCB) {
if (BurnDrvGetHardwareCode() & HARDWARE_SNK_KOF2K3) {
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, SM_ROM);
SekMapMemory(Neo68KBIOS, 0xC80000, 0xCFFFFF, SM_ROM);
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, MAP_ROM);
SekMapMemory(Neo68KBIOS, 0xC80000, 0xCFFFFF, MAP_ROM);
} else {
for (INT32 a = 0xC00000; a < 0xD00000; a += 0x020000) {
SekMapMemory(Neo68KBIOS + (NeoSystem & 0x03) * 0x020000, a, a + 0x01FFFF, SM_ROM);
SekMapMemory(Neo68KBIOS + (NeoSystem & 0x03) * 0x020000, a, a + 0x01FFFF, MAP_ROM);
}
}
}
// Set by a switch on the PCB
if (!strcmp(BurnDrvGetTextA(DRV_NAME), "svcpcb") || !strcmp(BurnDrvGetTextA(DRV_NAME), "svcpcba") || !strcmp(BurnDrvGetTextA(DRV_NAME), "svcpcbnd") || !strcmp(BurnDrvGetTextA(DRV_NAME), "ms5pcb") || !strcmp(BurnDrvGetTextA(DRV_NAME), "ms5pcbnd")) {
SekMapMemory(Neo68KBIOS + 0x20000 * (~NeoSystem & 1), 0xc00000, 0xc1ffff, SM_ROM);
SekMapMemory(Neo68KBIOS + 0x20000 * (~NeoSystem & 1), 0xc00000, 0xc1ffff, MAP_ROM);
}
MapVectorTable(true);
@ -3764,20 +3764,20 @@ static INT32 NeoInitCommon()
if (nNeoSystemType & NEO_SYS_CART) {
for (INT32 a = 0x100000; a < 0x200000; a += 0x010000) {
SekMapMemory(Neo68KRAM, a, a + 0xFFFF, SM_RAM); // 68K RAM
SekMapMemory(Neo68KRAM, a, a + 0xFFFF, MAP_RAM); // 68K RAM
}
if (!(nNeoSystemType & NEO_SYS_PCB)) {
// for (INT32 a = 0xC00000; a < 0xD00000; a += 0x020000) {
// SekMapMemory(Neo68KBIOS, a, a + 0x01FFFF, SM_ROM); // MVS/AES BIOS ROM
// SekMapMemory(Neo68KBIOS, a, a + 0x01FFFF, MAP_ROM); // MVS/AES BIOS ROM
// }
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, SM_ROM); // BIOS ROM
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, MAP_ROM); // BIOS ROM
}
} else {
SekMapMemory(Neo68KFix[0], 0x000000, 0x1FFFFF, SM_RAM); // Main 68K RAM
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, SM_ROM); // NeoCD BIOS ROM
SekMapMemory(Neo68KBIOS, 0xC80000, 0xCFFFFF, SM_ROM); //
SekMapMemory(Neo68KFix[0], 0x000000, 0x1FFFFF, MAP_RAM); // Main 68K RAM
SekMapMemory(Neo68KBIOS, 0xC00000, 0xC7FFFF, MAP_ROM); // NeoCD BIOS ROM
SekMapMemory(Neo68KBIOS, 0xC80000, 0xCFFFFF, MAP_ROM); //
}
SekSetReadWordHandler(0, neogeoReadWord);
@ -3789,43 +3789,43 @@ static INT32 NeoInitCommon()
SekSetWriteByteHandler(1, neogeoWriteByteSRAM);
if (!(nNeoSystemType & NEO_SYS_PCB)) {
SekMapHandler(2, 0x800000, 0xBFFFFF, SM_ROM); // Memory card
SekMapHandler(2, 0x800000, 0xBFFFFF, SM_WRITE); //
SekMapHandler(2, 0x800000, 0xBFFFFF, MAP_ROM); // Memory card
SekMapHandler(2, 0x800000, 0xBFFFFF, MAP_WRITE); //
SekSetReadByteHandler(2, neogeoReadByteMemoryCard);
SekSetWriteByteHandler(2, neogeoWriteByteMemoryCard);
}
SekMapHandler(3, 0x400000, 0x7FFFFF, SM_WRITE); // Palette
SekMapHandler(3, 0x400000, 0x7FFFFF, MAP_WRITE); // Palette
SekSetWriteWordHandler(3, NeoPalWriteWord);
SekSetWriteByteHandler(3, NeoPalWriteByte);
// Set up mirrors
for (INT32 a = 0x420000; a < 0x800000; a += 0x2000) {
SekMapMemory(NeoPalSrc[0], a, a + 0x1FFF, SM_ROM);
SekMapMemory(NeoPalSrc[0], a, a + 0x1FFF, MAP_ROM);
}
SekMapHandler(5, 0x3C0000, 0x3DFFFF, SM_RAM); // Read Video Controller
SekMapHandler(5, 0x3C0000, 0x3DFFFF, MAP_RAM); // Read Video Controller
SekSetReadWordHandler(5, neogeoReadWordVideo);
SekSetReadByteHandler(5, neogeoReadByteVideo);
SekSetWriteWordHandler(5, neogeoWriteWordVideo);
SekSetWriteByteHandler(5, neogeoWriteByteVideo);
if (nNeoSystemType & NEO_SYS_CD) {
SekMapHandler(4, 0x000000, 0x0003FF, SM_WRITE);
SekMapHandler(4, 0x000000, 0x0003FF, MAP_WRITE);
SekSetWriteWordHandler(4, neogeoWriteWord68KProgram);
SekSetWriteByteHandler(4, neogeoWriteByte68KProgram);
SekMapHandler(6, 0xE00000, 0xEFFFFF, SM_RAM);
SekMapHandler(6, 0xE00000, 0xEFFFFF, MAP_RAM);
SekSetReadWordHandler(6, neogeoReadWordTransfer);
SekSetReadByteHandler(6, neogeoReadByteTransfer);
SekSetWriteWordHandler(6, neogeoWriteWordTransfer);
SekSetWriteByteHandler(6, neogeoWriteByteTransfer);
SekMapHandler(7, 0xF00000, 0xFFFFFF, SM_RAM);
SekMapHandler(7, 0xF00000, 0xFFFFFF, MAP_RAM);
SekSetReadWordHandler(7, neogeoReadWordCDROM);
SekSetReadByteHandler(7, neogeoReadByteCDROM);

18
src/burn/drv/pce/pce.cpp
View File

@ -156,7 +156,7 @@ static void sf2_bankswitch(UINT8 offset)
{
pce_sf2_bank = offset;
h6280MapMemory(PCECartROM + (offset * 0x80000) + 0x080000, 0x080000, 0x0fffff, H6280_ROM);
h6280MapMemory(PCECartROM + (offset * 0x80000) + 0x080000, 0x080000, 0x0fffff, MAP_ROM);
}
static void pce_write(UINT32 address, UINT8 data)
@ -480,11 +480,11 @@ static INT32 CommonInit(int type)
{
h6280Init(0);
h6280Open(0);
h6280MapMemory(PCECartROM + 0x000000, 0x000000, 0x0fffff, H6280_ROM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f0000, 0x1f1fff, H6280_RAM); // mirrored
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f2000, 0x1f3fff, H6280_RAM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f4000, 0x1f5fff, H6280_RAM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f6000, 0x1f7fff, H6280_RAM);
h6280MapMemory(PCECartROM + 0x000000, 0x000000, 0x0fffff, MAP_ROM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f0000, 0x1f1fff, MAP_RAM); // mirrored
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f2000, 0x1f3fff, MAP_RAM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f4000, 0x1f5fff, MAP_RAM);
h6280MapMemory(PCEUserRAM + 0x000000, 0x1f6000, 0x1f7fff, MAP_RAM);
h6280SetWritePortHandler(pce_write_port);
h6280SetWriteHandler(pce_write);
h6280SetReadHandler(pce_read);
@ -502,8 +502,8 @@ static INT32 CommonInit(int type)
{
h6280Init(0);
h6280Open(0);
h6280MapMemory(PCECartROM, 0x000000, 0x0fffff, H6280_ROM);
h6280MapMemory(PCEUserRAM, 0x1f0000, 0x1f7fff, H6280_RAM);
h6280MapMemory(PCECartROM, 0x000000, 0x0fffff, MAP_ROM);
h6280MapMemory(PCEUserRAM, 0x1f0000, 0x1f7fff, MAP_RAM);
h6280SetWritePortHandler(sgx_write_port);
h6280SetWriteHandler(sgx_write);
h6280SetReadHandler(sgx_read);
@ -553,7 +553,7 @@ INT32 populousInit()
if (nRet == 0) {
h6280Open(0);
h6280MapMemory(PCECartRAM, 0x080000, 0x087fff, H6280_RAM);
h6280MapMemory(PCECartRAM, 0x080000, 0x087fff, MAP_RAM);
h6280Close();
}

14
src/burn/drv/pgm/pgm_asic25.cpp
View File

@ -907,8 +907,8 @@ void install_protection_asic25_asic22_killbld()
sharedprotram = (UINT16*)PGMUSER0;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x300000, 0x303fff, SM_RAM);
SekMapHandler(4, 0xd40000, 0xd40003, SM_READ | SM_WRITE);
SekMapMemory(PGMUSER0, 0x300000, 0x303fff, MAP_RAM);
SekMapHandler(4, 0xd40000, 0xd40003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, igs025_prot_read);
SekSetWriteWordHandler(4, killbld_igs025_prot_write);
SekClose();
@ -924,8 +924,8 @@ void install_protection_asic25_asic22_drgw3()
sharedprotram = (UINT16*)PGMUSER0;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x300000, 0x303fff, SM_RAM);
SekMapHandler(4, 0xda5610, 0xda5613, SM_READ | SM_WRITE);
SekMapMemory(PGMUSER0, 0x300000, 0x303fff, MAP_RAM);
SekMapHandler(4, 0xda5610, 0xda5613, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, igs025_prot_read);
SekSetWriteWordHandler(4, killbld_igs025_prot_write);
SekClose();
@ -937,7 +937,7 @@ void install_protection_asic25_asic12_dw2()
pPgmResetCallback = drgw2_reset;
SekOpen(0);
SekMapHandler(4, 0xd80000, 0xd80003, SM_READ | SM_WRITE);
SekMapHandler(4, 0xd80000, 0xd80003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, igs025_prot_read);
SekSetWriteWordHandler(4, drgw2_igs025_prot_write);
SekClose();
@ -951,8 +951,8 @@ void install_protection_asic25_asic28_olds()
sharedprotram = (UINT16*)PGMUSER0;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x400000, 0x403fff, SM_RAM);
SekMapHandler(4, 0xdcb400, 0xdcb403, SM_READ | SM_WRITE);
SekMapMemory(PGMUSER0, 0x400000, 0x403fff, MAP_RAM);
SekMapHandler(4, 0xdcb400, 0xdcb403, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, igs025_prot_read);
SekSetWriteWordHandler(4, olds_igs025_prot_write);
SekClose();

44
src/burn/drv/pgm/pgm_asic27a_type1.cpp
View File

@ -171,18 +171,18 @@ void install_protection_asic27a_kovsh()
pPgmResetCallback = reset_kovsh_asic27a;
SekOpen(0);
SekMapMemory(PGMARMShareRAM, 0x4f0000, 0x4f003f, SM_RAM);
SekMapMemory(PGMARMShareRAM, 0x4f0000, 0x4f003f, MAP_RAM);
SekMapHandler(4, 0x500000, 0x600005, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x600005, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, kovsh_asic27a_read_word);
SekSetWriteWordHandler(4, kovsh_asic27a_write_word);
SekClose();
Arm7Init(0);
Arm7Open(0);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, ARM7_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, ARM7_RAM);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, MAP_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, MAP_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, MAP_RAM);
Arm7SetWriteWordHandler(kovsh_asic27a_arm7_write_word);
Arm7SetWriteLongHandler(kovsh_asic27a_arm7_write_long);
Arm7SetReadLongHandler(kovsh_asic27a_arm7_read_long);
@ -255,18 +255,18 @@ void install_protection_asic27a_kovshp()
pPgmScanCallback = kovsh_asic27aScan;
SekOpen(0);
SekMapMemory(PGMARMShareRAM, 0x4f0000, 0x4f003f, SM_RAM);
SekMapMemory(PGMARMShareRAM, 0x4f0000, 0x4f003f, MAP_RAM);
SekMapHandler(4, 0x500000, 0x600005, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x600005, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, kovsh_asic27a_read_word);
SekSetWriteWordHandler(4, kovshp_asic27a_write_word);
SekClose();
Arm7Init(0);
Arm7Open(0);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, ARM7_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, ARM7_RAM);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, MAP_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, MAP_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, MAP_RAM);
Arm7SetWriteWordHandler(kovsh_asic27a_arm7_write_word);
Arm7SetWriteLongHandler(kovsh_asic27a_arm7_write_long);
Arm7SetReadLongHandler(kovsh_asic27a_arm7_read_long);
@ -427,7 +427,7 @@ void install_protection_asic27a_ketsui()
asic27a_sim_command = ddp3_asic27a_sim_command;
SekOpen(0);
SekMapHandler(4, 0x400000, 0x400005, SM_READ | SM_WRITE);
SekMapHandler(4, 0x400000, 0x400005, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -440,7 +440,7 @@ void install_protection_asic27a_ddp3()
asic27a_sim_command = ddp3_asic27a_sim_command;
SekOpen(0);
SekMapHandler(4, 0x500000, 0x500005, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500005, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -675,9 +675,9 @@ void install_protection_asic27a_oldsplus()
asic27a_sim_command = oldsplus_asic27a_sim_command;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, SM_READ); // ram
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, MAP_READ); // ram
SekMapHandler(4, 0x500000, 0x500003, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -825,9 +825,9 @@ void install_protection_asic27_kov()
asic27a_sim_command = kov_asic27a_sim_command;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, SM_READ);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, MAP_READ);
SekMapHandler(4, 0x500000, 0x500003, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -1155,9 +1155,9 @@ void install_protection_asic27a_puzzli2()
asic27a_sim_command = puzzli2_asic27a_sim_command;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, SM_READ);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, MAP_READ);
SekMapHandler(4, 0x500000, 0x500003, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -1240,9 +1240,9 @@ void install_protection_asic27a_py2k2()
asic27a_sim_command = py2k2_asic27a_sim_command;
SekOpen(0);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, SM_READ);
SekMapMemory(PGMUSER0, 0x4f0000, 0x4f003f | 0x3ff, MAP_READ);
SekMapHandler(4, 0x500000, 0x500003, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekClose();
@ -1439,11 +1439,11 @@ void install_protection_asic27a_puzlstar()
asic27a_sim_command = puzlstar_asic27a_sim_command;
SekOpen(0);
SekMapHandler(4, 0x500000, 0x500003, SM_READ | SM_WRITE);
SekMapHandler(4, 0x500000, 0x500003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_sim_read);
SekSetWriteWordHandler(4, asic27a_sim_write);
SekMapHandler(5, 0x4f0000, 0x4f03ff, SM_READ);
SekMapHandler(5, 0x4f0000, 0x4f03ff, MAP_READ);
SekSetReadWordHandler(5, puzlstar_protram_read_word);
SekSetReadByteHandler(5, puzlstar_protram_read_byte);
SekClose();

16
src/burn/drv/pgm/pgm_asic27a_type2.cpp
View File

@ -133,9 +133,9 @@ void install_protection_asic27a_martmast()
SekOpen(0);
SekMapMemory(PGMARMShareRAM, 0xd00000, 0xd0ffff, SM_RAM);
SekMapMemory(PGMARMShareRAM, 0xd00000, 0xd0ffff, MAP_RAM);
SekMapHandler(4, 0xd10000, 0xd10003, SM_READ | SM_WRITE);
SekMapHandler(4, 0xd10000, 0xd10003, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic27a_read_word);
SekSetReadByteHandler(4, asic27a_read_byte);
SekSetWriteWordHandler(4, asic27a_write_word);
@ -144,12 +144,12 @@ void install_protection_asic27a_martmast()
Arm7Init(0);
Arm7Open(0);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, ARM7_ROM);
Arm7MapMemory(PGMUSER0, 0x08000000, 0x08000000+(nPGMExternalARMLen-1), ARM7_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM1, 0x18000000, 0x1800ffff, ARM7_RAM);
Arm7MapMemory(PGMARMShareRAM, 0x48000000, 0x4800ffff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, ARM7_RAM);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, MAP_ROM);
Arm7MapMemory(PGMUSER0, 0x08000000, 0x08000000+(nPGMExternalARMLen-1), MAP_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, MAP_RAM);
Arm7MapMemory(PGMARMRAM1, 0x18000000, 0x1800ffff, MAP_RAM);
Arm7MapMemory(PGMARMShareRAM, 0x48000000, 0x4800ffff, MAP_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, MAP_RAM);
Arm7SetWriteByteHandler(asic27a_arm7_write_byte);
Arm7SetReadByteHandler(asic27a_arm7_read_byte);
Arm7Close();

18
src/burn/drv/pgm/pgm_asic27a_type3.cpp
View File

@ -28,8 +28,8 @@ static inline void pgm_cpu_sync()
static void svg_set_ram_bank(INT32 data)
{
svg_ram_sel = data & 1;
Arm7MapMemory(svg_ram[svg_ram_sel], 0x38000000, 0x3800ffff, ARM7_RAM);
SekMapMemory(svg_ram[svg_ram_sel^1], 0x500000, 0x50ffff, SM_RAM);
Arm7MapMemory(svg_ram[svg_ram_sel], 0x38000000, 0x3800ffff, MAP_RAM);
SekMapMemory(svg_ram[svg_ram_sel^1], 0x500000, 0x50ffff, MAP_RAM);
}
static void __fastcall svg_write_byte(UINT32 address, UINT8 data)
@ -155,7 +155,7 @@ void install_protection_asic27a_svg()
svg_ram[1] = PGMARMShareRAM2;
SekOpen(0);
SekMapHandler(5, 0x500000, 0x5fffff, SM_RAM);
SekMapHandler(5, 0x500000, 0x5fffff, MAP_RAM);
SekSetReadWordHandler(5, svg_read_word);
SekSetWriteWordHandler(5, svg_write_word);
SekSetWriteByteHandler(5, svg_write_byte);
@ -163,12 +163,12 @@ void install_protection_asic27a_svg()
Arm7Init(0);
Arm7Open(0);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, ARM7_ROM);
Arm7MapMemory(PGMUSER0, 0x08000000, 0x08000000 | (nPGMExternalARMLen-1), ARM7_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM1, 0x18000000, 0x1803ffff, ARM7_RAM);
Arm7MapMemory(svg_ram[1], 0x38000000, 0x3800ffff, ARM7_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, ARM7_RAM);
Arm7MapMemory(PGMARMROM, 0x00000000, 0x00003fff, MAP_ROM);
Arm7MapMemory(PGMUSER0, 0x08000000, 0x08000000 | (nPGMExternalARMLen-1), MAP_ROM);
Arm7MapMemory(PGMARMRAM0, 0x10000000, 0x100003ff, MAP_RAM);
Arm7MapMemory(PGMARMRAM1, 0x18000000, 0x1803ffff, MAP_RAM);
Arm7MapMemory(svg_ram[1], 0x38000000, 0x3800ffff, MAP_RAM);
Arm7MapMemory(PGMARMRAM2, 0x50000000, 0x500003ff, MAP_RAM);
Arm7SetWriteByteHandler(svg_arm7_write_byte);
Arm7SetReadByteHandler(svg_arm7_read_byte);
Arm7Close();

2
src/burn/drv/pgm/pgm_asic3.cpp
View File

@ -165,7 +165,7 @@ void install_protection_asic3_orlegend()
pPgmResetCallback = reset_asic3;
SekOpen(0);
SekMapHandler(4, 0xc04000, 0xc0400f, SM_READ | SM_WRITE);
SekMapHandler(4, 0xc04000, 0xc0400f, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(4, asic3_read_word);
SekSetWriteWordHandler(4, asic3_write_word);
SekClose();

30
src/burn/drv/pgm/pgm_run.cpp
View File

@ -645,36 +645,36 @@ INT32 pgmInit()
// ketsui and espgaluda
if (BurnDrvGetHardwareCode() & HARDWARE_IGS_JAMMAPCB)
{
SekMapMemory(PGM68KROM, 0x000000, (nPGM68KROMLen-1), SM_ROM); // 68000 ROM (no bios)
SekMapMemory(PGM68KROM, 0x000000, (nPGM68KROMLen-1), MAP_ROM); // 68000 ROM (no bios)
}
else
{
SekMapMemory(PGM68KBIOS, 0x000000, 0x07ffff, SM_ROM); // 68000 BIOS
SekMapMemory(PGM68KROM, 0x100000, (nPGM68KROMLen-1)+0x100000, SM_ROM); // 68000 ROM
SekMapMemory(PGM68KBIOS, 0x000000, 0x07ffff, MAP_ROM); // 68000 BIOS
SekMapMemory(PGM68KROM, 0x100000, (nPGM68KROMLen-1)+0x100000, MAP_ROM); // 68000 ROM
}
for (INT32 i = 0; i < 0x100000; i+=0x20000) { // Main Ram + Mirrors...
SekMapMemory(PGM68KRAM, 0x800000 | i, 0x81ffff | i, SM_RAM);
SekMapMemory(PGM68KRAM, 0x800000 | i, 0x81ffff | i, MAP_RAM);
}
// Ripped from FBA Shuffle.
for (INT32 i = 0; i < 0x100000; i+=0x08000) { // Video Ram + Mirrors...
SekMapMemory((UINT8 *)PGMBgRAM, 0x900000 | i, 0x900fff | i, SM_RAM);
SekMapMemory((UINT8 *)PGMBgRAM, 0x901000 | i, 0x901fff | i, SM_RAM); // mirror
SekMapMemory((UINT8 *)PGMBgRAM, 0x902000 | i, 0x902fff | i, SM_RAM); // mirror
SekMapMemory((UINT8 *)PGMBgRAM, 0x903000 | i, 0x904fff | i, SM_RAM); // mirror
SekMapMemory((UINT8 *)PGMBgRAM, 0x900000 | i, 0x900fff | i, MAP_RAM);
SekMapMemory((UINT8 *)PGMBgRAM, 0x901000 | i, 0x901fff | i, MAP_RAM); // mirror
SekMapMemory((UINT8 *)PGMBgRAM, 0x902000 | i, 0x902fff | i, MAP_RAM); // mirror
SekMapMemory((UINT8 *)PGMBgRAM, 0x903000 | i, 0x904fff | i, MAP_RAM); // mirror
SekMapMemory((UINT8 *)PGMTxtRAM, 0x904000 | i, 0x905fff | i, SM_RAM);
SekMapMemory((UINT8 *)PGMTxtRAM, 0x906000 | i, 0x906fff | i, SM_RAM); // mirror
SekMapMemory((UINT8 *)PGMTxtRAM, 0x904000 | i, 0x905fff | i, MAP_RAM);
SekMapMemory((UINT8 *)PGMTxtRAM, 0x906000 | i, 0x906fff | i, MAP_RAM); // mirror
SekMapMemory((UINT8 *)PGMRowRAM, 0x907000 | i, 0x907fff | i, SM_RAM);
SekMapMemory((UINT8 *)PGMRowRAM, 0x907000 | i, 0x907fff | i, MAP_RAM);
}
SekMapMemory((UINT8 *)PGMPalRAM, 0xa00000, 0xa013ff, SM_ROM); // palette
SekMapMemory((UINT8 *)PGMVidReg, 0xb00000, 0xb0ffff, SM_RAM); // should be mirrored?
SekMapMemory((UINT8 *)PGMPalRAM, 0xa00000, 0xa013ff, MAP_ROM); // palette
SekMapMemory((UINT8 *)PGMVidReg, 0xb00000, 0xb0ffff, MAP_RAM); // should be mirrored?
SekMapHandler(1, 0xa00000, 0xa013ff, SM_WRITE);
SekMapHandler(2, 0xc10000, 0xc1ffff, SM_READ | SM_WRITE);
SekMapHandler(1, 0xa00000, 0xa013ff, MAP_WRITE);
SekMapHandler(2, 0xc10000, 0xc1ffff, MAP_READ | MAP_WRITE);
SekSetReadWordHandler(0, PgmReadWord);
SekSetReadByteHandler(0, PgmReadByte);

8
src/burn/drv/pre90s/d_alinvade.cpp
View File

@ -161,11 +161,11 @@ static INT32 DrvInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(Drv6502RAM, 0x0000, 0x01ff, M6502_RAM);
M6502MapMemory(DrvVidRAM, 0x0400, 0x0fff, M6502_RAM);
M6502MapMemory(Drv6502RAM, 0x0000, 0x01ff, MAP_RAM);
M6502MapMemory(DrvVidRAM, 0x0400, 0x0fff, MAP_RAM);
for (INT32 i = 0; i < 0x1000; i+=0x100)
M6502MapMemory(DrvProtPROM, 0xc000+i, 0xc0ff+i, M6502_ROM); // mirrored
M6502MapMemory(Drv6502ROM, 0xe000, 0xffff, M6502_ROM);
M6502MapMemory(DrvProtPROM, 0xc000+i, 0xc0ff+i, MAP_ROM); // mirrored
M6502MapMemory(Drv6502ROM, 0xe000, 0xffff, MAP_ROM);
M6502SetWriteHandler(alinvade_write);
M6502SetReadHandler(alinvade_read);
M6502Close();

12
src/burn/drv/pre90s/d_alpha68k.cpp
View File

@ -725,9 +725,9 @@ static INT32 SstingryInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(DrvSharedRam , 0x020000, 0x020fff, SM_RAM);
SekMapMemory(DrvSpriteRam , 0x040000, 0x041fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(DrvSharedRam , 0x020000, 0x020fff, MAP_RAM);
SekMapMemory(DrvSpriteRam , 0x040000, 0x041fff, MAP_RAM);
SekSetReadByteHandler(0, Kyros68KReadByte);
SekSetWriteByteHandler(0, Kyros68KWriteByte);
SekSetReadWordHandler(0, Kyros68KReadWord);
@ -839,9 +839,9 @@ static INT32 KyrosInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(DrvSharedRam , 0x020000, 0x020fff, SM_RAM);
SekMapMemory(DrvSpriteRam , 0x040000, 0x041fff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(DrvSharedRam , 0x020000, 0x020fff, MAP_RAM);
SekMapMemory(DrvSpriteRam , 0x040000, 0x041fff, MAP_RAM);
SekSetReadByteHandler(0, Kyros68KReadByte);
SekSetWriteByteHandler(0, Kyros68KWriteByte);
SekSetReadWordHandler(0, Kyros68KReadWord);

36
src/burn/drv/pre90s/d_armedf.cpp
View File

@ -785,29 +785,29 @@ static INT32 DrvGfxDecode()
static void Armedf68KInit()
{
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(DrvSprRAM, 0x060000, 0x060fff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x061000, 0x065fff, SM_RAM);
SekMapMemory(DrvBgRAM, 0x066000, 0x066fff, SM_RAM);
SekMapMemory(DrvFgRAM, 0x067000, 0x067fff, SM_RAM);
SekMapMemory(DrvTxRAM, 0x068000, 0x069fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x06a000, 0x06afff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x06b000, 0x06bfff, SM_RAM);
SekMapMemory(Drv68KRAM2, 0x06c000, 0x06c7ff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(DrvSprRAM, 0x060000, 0x060fff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x061000, 0x065fff, MAP_RAM);
SekMapMemory(DrvBgRAM, 0x066000, 0x066fff, MAP_RAM);
SekMapMemory(DrvFgRAM, 0x067000, 0x067fff, MAP_RAM);
SekMapMemory(DrvTxRAM, 0x068000, 0x069fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x06a000, 0x06afff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x06b000, 0x06bfff, MAP_RAM);
SekMapMemory(Drv68KRAM2, 0x06c000, 0x06c7ff, MAP_RAM);
SekSetWriteWordHandler(0, armedf_write_word);
}
static void Cclimbr268KInit()
{
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, SM_ROM);
SekMapMemory(DrvSprRAM, 0x060000, 0x060fff, SM_RAM);
SekMapMemory(Drv68KRAM0, 0x061000, 0x063fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x064000, 0x064fff, SM_RAM);
SekMapMemory(DrvTxRAM, 0x068000, 0x069fff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x06a000, 0x06a9ff, SM_RAM);
SekMapMemory(Drv68KRAM2, 0x06c000, 0x06c9ff, SM_RAM);
SekMapMemory(DrvFgRAM, 0x070000, 0x070fff, SM_RAM);
SekMapMemory(DrvBgRAM, 0x074000, 0x074fff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x05ffff, MAP_ROM);
SekMapMemory(DrvSprRAM, 0x060000, 0x060fff, MAP_RAM);
SekMapMemory(Drv68KRAM0, 0x061000, 0x063fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x064000, 0x064fff, MAP_RAM);
SekMapMemory(DrvTxRAM, 0x068000, 0x069fff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x06a000, 0x06a9ff, MAP_RAM);
SekMapMemory(Drv68KRAM2, 0x06c000, 0x06c9ff, MAP_RAM);
SekMapMemory(DrvFgRAM, 0x070000, 0x070fff, MAP_RAM);
SekMapMemory(DrvBgRAM, 0x074000, 0x074fff, MAP_RAM);
SekSetWriteWordHandler(0, cclimbr2_write_word);
SekSetWriteByteHandler(0, cclimbr2_write_byte);
SekSetReadWordHandler(0, cclimbr2_read_word);

18
src/burn/drv/pre90s/d_atetris.cpp
View File

@ -290,15 +290,15 @@ static INT32 CommonInit(INT32 boot)
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(Drv6502RAM, 0x0000, 0x0fff, M6502_RAM);
M6502MapMemory(DrvVidRAM, 0x1000, 0x1fff, M6502_RAM);
M6502MapMemory(DrvPalRAM, 0x2000, 0x20ff, M6502_ROM);
M6502MapMemory(DrvPalRAM, 0x2100, 0x21ff, M6502_ROM);
M6502MapMemory(DrvPalRAM, 0x2200, 0x22ff, M6502_ROM);
M6502MapMemory(DrvPalRAM, 0x2300, 0x23ff, M6502_ROM);
M6502MapMemory(DrvNVRAM, 0x2400, 0x25ff, M6502_ROM);
M6502MapMemory(DrvNVRAM, 0x2600, 0x27ff, M6502_ROM);
M6502MapMemory(Drv6502ROM + 0x8000, 0x8000, 0xffff, M6502_ROM);
M6502MapMemory(Drv6502RAM, 0x0000, 0x0fff, MAP_RAM);
M6502MapMemory(DrvVidRAM, 0x1000, 0x1fff, MAP_RAM);
M6502MapMemory(DrvPalRAM, 0x2000, 0x20ff, MAP_ROM);
M6502MapMemory(DrvPalRAM, 0x2100, 0x21ff, MAP_ROM);
M6502MapMemory(DrvPalRAM, 0x2200, 0x22ff, MAP_ROM);
M6502MapMemory(DrvPalRAM, 0x2300, 0x23ff, MAP_ROM);
M6502MapMemory(DrvNVRAM, 0x2400, 0x25ff, MAP_ROM);
M6502MapMemory(DrvNVRAM, 0x2600, 0x27ff, MAP_ROM);
M6502MapMemory(Drv6502ROM + 0x8000, 0x8000, 0xffff, MAP_ROM);
M6502SetReadHandler(atetris_read);
M6502SetReadOpHandler(atetris_read);
M6502SetReadOpArgHandler(atetris_read);

8
src/burn/drv/pre90s/d_aztarac.cpp
View File

@ -380,10 +380,10 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekSetIrqCallback(aztarac_irq_callback);
SekMapMemory(Drv68KROM, 0x000000, 0x00bfff, SM_ROM);
SekMapMemory(DrvNVRAM, 0x022000, 0x0223ff, SM_ROM);
SekMapMemory(DrvVecRAM, 0xff8000, 0xffafff, SM_RAM);
SekMapMemory(Drv68KRAM, 0xffe000, 0xffffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x00bfff, MAP_ROM);
SekMapMemory(DrvNVRAM, 0x022000, 0x0223ff, MAP_ROM);
SekMapMemory(DrvVecRAM, 0xff8000, 0xffafff, MAP_RAM);
SekMapMemory(Drv68KRAM, 0xffe000, 0xffffff, MAP_RAM);
SekSetWriteWordHandler(0, aztarac_write_word);
SekSetWriteByteHandler(0, aztarac_write_byte);
SekSetReadWordHandler(0, aztarac_read_word);

16
src/burn/drv/pre90s/d_baraduke.cpp
View File

@ -488,20 +488,20 @@ static INT32 DrvInit(INT32 type)
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvSprRAM, 0x0000, 0x1fff, M6809_READ | M6809_FETCH);
M6809MapMemory(DrvSprRAM, 0x0000, 0x1eff, M6809_WRITE);
M6809MapMemory(DrvVidRAM, 0x2000, 0x3fff, M6809_RAM);
M6809MapMemory(DrvTxtRAM, 0x4800, 0x4fff, M6809_RAM);
M6809MapMemory(DrvM6809ROM + 0x06000, 0x6000, 0xffff, M6809_ROM);
M6809MapMemory(DrvSprRAM, 0x0000, 0x1fff, MAP_READ | MAP_FETCH);
M6809MapMemory(DrvSprRAM, 0x0000, 0x1eff, MAP_WRITE);
M6809MapMemory(DrvVidRAM, 0x2000, 0x3fff, MAP_RAM);
M6809MapMemory(DrvTxtRAM, 0x4800, 0x4fff, MAP_RAM);
M6809MapMemory(DrvM6809ROM + 0x06000, 0x6000, 0xffff, MAP_ROM);
M6809SetWriteHandler(baraduke_main_write);
M6809SetReadHandler(baraduke_main_read);
M6809Close();
HD63701Init(1);
// HD63701Open(0);
HD63701MapMemory(DrvHD63701ROM + 0x8000, 0x8000, 0xbfff, HD63701_ROM);
HD63701MapMemory(DrvHD63701RAM, 0xc000, 0xc7ff, HD63701_RAM);
HD63701MapMemory(DrvHD63701ROM + 0xf000, 0xf000, 0xffff, HD63701_ROM);
HD63701MapMemory(DrvHD63701ROM + 0x8000, 0x8000, 0xbfff, MAP_ROM);
HD63701MapMemory(DrvHD63701RAM, 0xc000, 0xc7ff, MAP_RAM);
HD63701MapMemory(DrvHD63701ROM + 0xf000, 0xf000, 0xffff, MAP_ROM);
HD63701SetReadHandler(baraduke_mcu_read);
HD63701SetWriteHandler(baraduke_mcu_write);
HD63701SetReadPortHandler(baraduke_mcu_read_port);

14
src/burn/drv/pre90s/d_bionicc.cpp
View File

@ -417,13 +417,13 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0xfe0000, 0xfe3fff, SM_RAM);
SekMapMemory(DrvTextRAM, 0xfec000, 0xfecfff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0xff0000, 0xff3fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0xff4000, 0xff7fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0xff8000, 0xff87ff, SM_ROM);
SekMapMemory(Drv68KRAM1, 0xffc000, 0xffffff, SM_RAM);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0xfe0000, 0xfe3fff, MAP_RAM);
SekMapMemory(DrvTextRAM, 0xfec000, 0xfecfff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0xff0000, 0xff3fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0xff4000, 0xff7fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0xff8000, 0xff87ff, MAP_ROM);
SekMapMemory(Drv68KRAM1, 0xffc000, 0xffffff, MAP_RAM);
SekSetReadByteHandler(0, bionicc_read_byte);
SekSetReadWordHandler(0, bionicc_read_word);
SekSetWriteByteHandler(0, bionicc_write_byte);

14
src/burn/drv/pre90s/d_blockout.cpp
View File

@ -430,13 +430,13 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(DrvVidRAM0, 0x180000, 0x1bffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x1d4000, 0x1dffff, SM_RAM);
SekMapMemory(Drv68KRAM1, 0x1f4000, 0x1fffff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x200000, 0x207fff, SM_RAM);
SekMapMemory(Drv68KRAM2, 0x208000, 0x21ffff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x280200, 0x2805ff, SM_ROM); // maps 280000 - 2707ff
SekMapMemory(Drv68KROM, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(DrvVidRAM0, 0x180000, 0x1bffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x1d4000, 0x1dffff, MAP_RAM);
SekMapMemory(Drv68KRAM1, 0x1f4000, 0x1fffff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x200000, 0x207fff, MAP_RAM);
SekMapMemory(Drv68KRAM2, 0x208000, 0x21ffff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x280200, 0x2805ff, MAP_ROM); // maps 280000 - 2707ff
SekSetWriteByteHandler(0, blockout_write_byte);
SekSetWriteWordHandler(0, blockout_write_word);
SekSetReadByteHandler(0, blockout_read_byte);

10
src/burn/drv/pre90s/d_capbowl.cpp
View File

@ -80,7 +80,7 @@ static void bankswitch(INT32 d)
int bank = 0x08000 + (((d & 0x0c) >> 1) | (d & 1)) * 0x4000;
M6809MapMemory(DrvMainROM + bank, 0x0000, 0x3fff, M6809_ROM);
M6809MapMemory(DrvMainROM + bank, 0x0000, 0x3fff, MAP_ROM);
}
static void main_write(UINT16 a, UINT8 d)
@ -363,15 +363,15 @@ static INT32 DrvInit(INT32 game)
M6809Init(2);
M6809Open(0);
M6809MapMemory(DrvNVRAM, 0x5000, 0x57ff, M6809_RAM);
M6809MapMemory(DrvMainROM, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvNVRAM, 0x5000, 0x57ff, MAP_RAM);
M6809MapMemory(DrvMainROM, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(main_write);
M6809SetReadHandler(main_read);
M6809Close();
M6809Open(1);
M6809MapMemory(DrvSoundRAM, 0x0000, 0x07ff, M6809_RAM);
M6809MapMemory(DrvSoundROM, 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvSoundRAM, 0x0000, 0x07ff, MAP_RAM);
M6809MapMemory(DrvSoundROM, 0x8000, 0xffff, MAP_ROM);
M6809SetWriteHandler(sound_write);
M6809SetReadHandler(sound_read);
M6809Close();

26
src/burn/drv/pre90s/d_cybertnk.cpp
View File

@ -548,15 +548,15 @@ static INT32 DrvInit()
SekInit(0, 0x68000);
SekOpen(0);
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, SM_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, SM_RAM);
SekMapMemory(DrvSprRAM, 0x0a0000, 0x0a0fff, SM_RAM);
SekMapMemory(DrvVidRAM0, 0x0c0000, 0x0c1fff, SM_RAM);
SekMapMemory(DrvVidRAM1, 0x0c4000, 0x0c5fff, SM_RAM);
SekMapMemory(DrvVidRAM2, 0x0c8000, 0x0c9fff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x0e0000, 0x0e0fff, SM_RAM);
SekMapMemory(DrvPalRAM, 0x100000, 0x103fff, SM_ROM);
SekMapMemory(DrvPalRAM + 0x4000,0x104000, 0x107fff, SM_RAM); // Copy of first half
SekMapMemory(Drv68KROM0, 0x000000, 0x03ffff, MAP_ROM);
SekMapMemory(Drv68KRAM0, 0x080000, 0x087fff, MAP_RAM);
SekMapMemory(DrvSprRAM, 0x0a0000, 0x0a0fff, MAP_RAM);
SekMapMemory(DrvVidRAM0, 0x0c0000, 0x0c1fff, MAP_RAM);
SekMapMemory(DrvVidRAM1, 0x0c4000, 0x0c5fff, MAP_RAM);
SekMapMemory(DrvVidRAM2, 0x0c8000, 0x0c9fff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x0e0000, 0x0e0fff, MAP_RAM);
SekMapMemory(DrvPalRAM, 0x100000, 0x103fff, MAP_ROM);
SekMapMemory(DrvPalRAM + 0x4000,0x104000, 0x107fff, MAP_RAM); // Copy of first half
SekSetWriteByteHandler(0, cybertnk_main_write_byte);
SekSetWriteWordHandler(0, cybertnk_main_write_word);
SekSetReadByteHandler(0, cybertnk_main_read_byte);
@ -565,10 +565,10 @@ static INT32 DrvInit()
SekInit(1, 0x68000);
SekOpen(1);
SekMapMemory(Drv68KROM1, 0x000000, 0x01ffff, SM_ROM);
SekMapMemory(Drv68KRAM1, 0x080000, 0x083fff, SM_RAM);
SekMapMemory(DrvRoadRAM, 0x0c0000, 0x0c0fff, SM_RAM);
SekMapMemory(DrvShareRAM, 0x100000, 0x100fff, SM_RAM);
SekMapMemory(Drv68KROM1, 0x000000, 0x01ffff, MAP_ROM);
SekMapMemory(Drv68KRAM1, 0x080000, 0x083fff, MAP_RAM);
SekMapMemory(DrvRoadRAM, 0x0c0000, 0x0c0fff, MAP_RAM);
SekMapMemory(DrvShareRAM, 0x100000, 0x100fff, MAP_RAM);
SekClose();
ZetInit(0);

54
src/burn/drv/pre90s/d_ddragon.cpp
View File

@ -1057,7 +1057,7 @@ void DrvDdragonHD6309WriteByte(UINT16 Address, UINT8 Data)
case 0x3808: {
UINT8 DrvOldRomBank = DrvRomBank;
DrvRomBank = (Data & 0xe0) >> 5;
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, M6809_ROM);
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, MAP_ROM);
DrvScrollXHi = (Data & 0x01) << 8;
DrvScrollYHi = (Data & 0x02) << 7;
@ -1092,10 +1092,10 @@ void DrvDdragonHD6309WriteByte(UINT16 Address, UINT8 Data)
if (DrvGameType == DD_GAME_DARKTOWR) {
if (DrvRomBank == 4 && DrvOldRomBank != 4) {
HD6309MemCallback(0x4000, 0x7fff, HD6309_RAM);
HD6309MemCallback(0x4000, 0x7fff, MAP_RAM);
} else {
if (DrvRomBank != 4 && DrvOldRomBank == 4) {
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, M6809_ROM);
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, MAP_ROM);
}
}
}
@ -1897,21 +1897,21 @@ static INT32 DrvMachineInit()
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvHD6309Ram , 0x0000, 0x0fff, M6809_RAM);
HD6309MapMemory(DrvPaletteRam1 , 0x1000, 0x11ff, M6809_RAM);
HD6309MapMemory(DrvPaletteRam2 , 0x1200, 0x13ff, M6809_RAM);
HD6309MapMemory(DrvFgVideoRam , 0x1800, 0x1fff, M6809_RAM);
HD6309MapMemory(DrvSpriteRam , 0x2000, 0x2fff, M6809_WRITE);
HD6309MapMemory(DrvBgVideoRam , 0x3000, 0x37ff, M6809_RAM);
HD6309MapMemory(DrvHD6309Rom + 0x8000, 0x4000, 0x7fff, M6809_ROM);
HD6309MapMemory(DrvHD6309Rom , 0x8000, 0xffff, M6809_ROM);
HD6309MapMemory(DrvHD6309Ram , 0x0000, 0x0fff, MAP_RAM);
HD6309MapMemory(DrvPaletteRam1 , 0x1000, 0x11ff, MAP_RAM);
HD6309MapMemory(DrvPaletteRam2 , 0x1200, 0x13ff, MAP_RAM);
HD6309MapMemory(DrvFgVideoRam , 0x1800, 0x1fff, MAP_RAM);
HD6309MapMemory(DrvSpriteRam , 0x2000, 0x2fff, MAP_WRITE);
HD6309MapMemory(DrvBgVideoRam , 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvHD6309Rom + 0x8000, 0x4000, 0x7fff, MAP_ROM);
HD6309MapMemory(DrvHD6309Rom , 0x8000, 0xffff, MAP_ROM);
HD6309SetReadHandler(DrvDdragonHD6309ReadByte);
HD6309SetWriteHandler(DrvDdragonHD6309WriteByte);
HD6309Close();
if (DrvSubCPUType == DD_CPU_TYPE_HD63701) {
HD63701Init(1);
HD63701MapMemory(DrvSubCPURom , 0xc000, 0xffff, HD63701_ROM);
HD63701MapMemory(DrvSubCPURom , 0xc000, 0xffff, MAP_ROM);
HD63701SetReadHandler(DrvDdragonHD63701ReadByte);
HD63701SetWriteHandler(DrvDdragonHD63701WriteByte);
}
@ -1919,7 +1919,7 @@ static INT32 DrvMachineInit()
if (DrvSubCPUType == DD_CPU_TYPE_HD6309) {
HD6309Init(1);
HD6309Open(1);
HD6309MapMemory(DrvSubCPURom , 0xc000, 0xffff, HD6309_ROM);
HD6309MapMemory(DrvSubCPURom , 0xc000, 0xffff, MAP_ROM);
HD6309SetReadHandler(DrvDdragonbSubHD6309ReadByte);
HD6309SetWriteHandler(DrvDdragonbSubHD6309WriteByte);
HD6309Close();
@ -1927,7 +1927,7 @@ static INT32 DrvMachineInit()
if (DrvSubCPUType == DD_CPU_TYPE_M6803) {
M6803Init(1);
M6803MapMemory(DrvSubCPURom , 0xc000, 0xffff, M6803_ROM);
M6803MapMemory(DrvSubCPURom , 0xc000, 0xffff, MAP_ROM);
M6803SetReadHandler(DrvDdragonbaM6803ReadByte);
M6803SetWriteHandler(DrvDdragonbaM6803WriteByte);
M6803SetWritePortHandler(DrvDdragonbaM6803WritePort);
@ -1936,8 +1936,8 @@ static INT32 DrvMachineInit()
if (DrvSoundCPUType == DD_CPU_TYPE_M6809) {
M6809Init(1);
M6809Open(0);
M6809MapMemory(DrvSoundCPURam , 0x0000, 0x0fff, M6809_RAM);
M6809MapMemory(DrvSoundCPURom , 0x8000, 0xffff, M6809_ROM);
M6809MapMemory(DrvSoundCPURam , 0x0000, 0x0fff, MAP_RAM);
M6809MapMemory(DrvSoundCPURom , 0x8000, 0xffff, MAP_ROM);
M6809SetReadHandler(DrvDdragonM6809ReadByte);
M6809SetWriteHandler(DrvDdragonM6809WriteByte);
M6809Close();
@ -1954,8 +1954,8 @@ static INT32 DrvMachineInit()
if (DrvGameType == DD_GAME_DARKTOWR) {
m6805Init(1, 0x800);
m6805MapMemory(DrvMCURom + 0x80, 0x080, 0x7ff, M6805_ROM);
m6805MapMemory(DrvMCURom, 0x008, 0x07f, M6805_RAM);
m6805MapMemory(DrvMCURom + 0x80, 0x080, 0x7ff, MAP_ROM);
m6805MapMemory(DrvMCURom, 0x008, 0x07f, MAP_RAM);
m6805SetReadHandler(DrvMCUReadByte);
m6805SetWriteHandler(DrvMCUWriteByte);
}
@ -1977,14 +1977,14 @@ static INT32 Drv2MachineInit()
// Setup the HD6309 emulation
HD6309Init(0);
HD6309Open(0);
HD6309MapMemory(DrvHD6309Ram , 0x0000, 0x17ff, M6809_RAM);
HD6309MapMemory(DrvFgVideoRam , 0x1800, 0x1fff, M6809_RAM);
HD6309MapMemory(DrvSpriteRam , 0x2000, 0x2fff, M6809_WRITE);
HD6309MapMemory(DrvBgVideoRam , 0x3000, 0x37ff, M6809_RAM);
HD6309MapMemory(DrvPaletteRam1 , 0x3c00, 0x3dff, M6809_RAM);
HD6309MapMemory(DrvPaletteRam2 , 0x3e00, 0x3fff, M6809_RAM);
HD6309MapMemory(DrvHD6309Rom + 0x8000, 0x4000, 0x7fff, M6809_ROM);
HD6309MapMemory(DrvHD6309Rom , 0x8000, 0xffff, M6809_ROM);
HD6309MapMemory(DrvHD6309Ram , 0x0000, 0x17ff, MAP_RAM);
HD6309MapMemory(DrvFgVideoRam , 0x1800, 0x1fff, MAP_RAM);
HD6309MapMemory(DrvSpriteRam , 0x2000, 0x2fff, MAP_WRITE);
HD6309MapMemory(DrvBgVideoRam , 0x3000, 0x37ff, MAP_RAM);
HD6309MapMemory(DrvPaletteRam1 , 0x3c00, 0x3dff, MAP_RAM);
HD6309MapMemory(DrvPaletteRam2 , 0x3e00, 0x3fff, MAP_RAM);
HD6309MapMemory(DrvHD6309Rom + 0x8000, 0x4000, 0x7fff, MAP_ROM);
HD6309MapMemory(DrvHD6309Rom , 0x8000, 0xffff, MAP_ROM);
HD6309SetReadHandler(DrvDdragonHD6309ReadByte);
HD6309SetWriteHandler(DrvDdragonHD6309WriteByte);
HD6309Close();
@ -2607,7 +2607,7 @@ static INT32 DrvScan(INT32 nAction, INT32 *pnMin)
if (nAction & ACB_WRITE) {
HD6309Open(0);
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, M6809_ROM);
HD6309MapMemory(DrvHD6309Rom + 0x8000 + (DrvRomBank * 0x4000), 0x4000, 0x7fff, MAP_ROM);
HD6309Close();
if (DrvSubCPUBusy == 0) {

24
src/burn/drv/pre90s/d_dkong.cpp
View File

@ -1537,16 +1537,16 @@ static INT32 Dkong3Init()
M6502Init(0, TYPE_N2A03);
M6502Open(0);
M6502MapMemory(DrvSndRAM0, 0x0000, 0x01ff, M6502_RAM);
M6502MapMemory(DrvSndROM0, 0xe000, 0xffff, M6502_ROM);
M6502MapMemory(DrvSndRAM0, 0x0000, 0x01ff, MAP_RAM);
M6502MapMemory(DrvSndROM0, 0xe000, 0xffff, MAP_ROM);
M6502SetWriteHandler(dkong3_sound0_write);
M6502SetReadHandler(dkong3_sound0_read);
M6502Close();
M6502Init(1, TYPE_N2A03);
M6502Open(1);
M6502MapMemory(DrvSndRAM1, 0x0000, 0x01ff, M6502_RAM);
M6502MapMemory(DrvSndROM1, 0xe000, 0xffff, M6502_ROM);
M6502MapMemory(DrvSndRAM1, 0x0000, 0x01ff, MAP_RAM);
M6502MapMemory(DrvSndROM1, 0xe000, 0xffff, MAP_ROM);
M6502SetWriteHandler(dkong3_sound1_write);
M6502SetReadHandler(dkong3_sound1_read);
M6502Close();
@ -1645,14 +1645,14 @@ static INT32 s2650DkongInit(INT32 (*pRomLoadCallback)())
s2650Init(1);
s2650Open(0);
s2650MapMemory(Drv2650ROM + 0x0000, 0x0000, 0x0fff, S2650_ROM);
s2650MapMemory(Drv2650RAM + 0x0000, 0x1000, 0x13ff, S2650_RAM); // sprite ram (after dma)
s2650MapMemory(DrvSprRAM + 0x0000, 0x1600, 0x17ff, S2650_RAM);
s2650MapMemory(DrvVidRAM + 0x0000, 0x1800, 0x1bff, S2650_RAM);
s2650MapMemory(DrvSprRAM + 0x0400, 0x1c00, 0x1eff, S2650_RAM);
s2650MapMemory(Drv2650ROM + 0x2000, 0x2000, 0x2fff, S2650_ROM);
s2650MapMemory(Drv2650ROM + 0x4000, 0x4000, 0x4fff, S2650_ROM);
s2650MapMemory(Drv2650ROM + 0x6000, 0x6000, 0x6fff, S2650_ROM);
s2650MapMemory(Drv2650ROM + 0x0000, 0x0000, 0x0fff, MAP_ROM);
s2650MapMemory(Drv2650RAM + 0x0000, 0x1000, 0x13ff, MAP_RAM); // sprite ram (after dma)
s2650MapMemory(DrvSprRAM + 0x0000, 0x1600, 0x17ff, MAP_RAM);
s2650MapMemory(DrvVidRAM + 0x0000, 0x1800, 0x1bff, MAP_RAM);
s2650MapMemory(DrvSprRAM + 0x0400, 0x1c00, 0x1eff, MAP_RAM);
s2650MapMemory(Drv2650ROM + 0x2000, 0x2000, 0x2fff, MAP_ROM);
s2650MapMemory(Drv2650ROM + 0x4000, 0x4000, 0x4fff, MAP_ROM);
s2650MapMemory(Drv2650ROM + 0x6000, 0x6000, 0x6fff, MAP_ROM);
s2650SetIrqCallback(s2650_irq_callback);
s2650SetWriteHandler(s2650_main_write);
s2650SetReadHandler(s2650_main_read);

56
src/burn/drv/pre90s/d_gauntlet.cpp
View File

@ -416,7 +416,7 @@ void atarigen_SlapsticInit(INT32 base, INT32 chipnum)
//atarigen_slapstic = install_mem_read_handler(cpunum, base, base + 0x7fff, atarigen_slapstic_r);
//atarigen_slapstic = install_mem_write_handler(cpunum, base, base + 0x7fff, atarigen_slapstic_w);
SekOpen(0);
SekMapHandler(1, base, base + 0x7fff, SM_RAM);
SekMapHandler(1, base, base + 0x7fff, MAP_RAM);
SekSetReadByteHandler(1, atarigen_slapstic_r);
SekSetReadWordHandler(1, atarigen_slapstic_r_word);
SekSetWriteByteHandler(1, atarigen_slapstic_w);
@ -2048,13 +2048,13 @@ static INT32 DrvInit()
// Setup the 68000 emulation
SekInit(0, 0x68010);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, SM_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, SM_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, SM_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, SM_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, MAP_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, MAP_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, MAP_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, MAP_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, MAP_RAM);
SekSetReadByteHandler(0, Gauntlet68KReadByte);
SekSetWriteByteHandler(0, Gauntlet68KWriteByte);
SekSetReadWordHandler(0, Gauntlet68KReadWord);
@ -2063,8 +2063,8 @@ static INT32 DrvInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, M6502_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, MAP_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, MAP_ROM);
M6502SetReadHandler(GauntletSoundRead);
M6502SetWriteHandler(GauntletSoundWrite);
M6502Close();
@ -2160,13 +2160,13 @@ static INT32 Gaunt2pInit()
// Setup the 68000 emulation
SekInit(0, 0x68010);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, SM_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, SM_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, SM_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, SM_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, MAP_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, MAP_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, MAP_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, MAP_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, MAP_RAM);
SekSetReadByteHandler(0, Gauntlet68KReadByte);
SekSetWriteByteHandler(0, Gauntlet68KWriteByte);
SekSetReadWordHandler(0, Gauntlet68KReadWord);
@ -2175,8 +2175,8 @@ static INT32 Gaunt2pInit()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, M6502_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, MAP_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, MAP_ROM);
M6502SetReadHandler(GauntletSoundRead);
M6502SetWriteHandler(GauntletSoundWrite);
M6502Close();
@ -2282,13 +2282,13 @@ static INT32 Gaunt2Init()
// Setup the 68000 emulation
SekInit(0, 0x68010);
SekOpen(0);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, SM_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, SM_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, SM_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, SM_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, SM_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, SM_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, SM_RAM);
SekMapMemory(Drv68KRom , 0x000000, 0x07ffff, MAP_ROM);
SekMapMemory(DrvPlayfieldRam , 0x900000, 0x901fff, MAP_RAM);
SekMapMemory(DrvMOSpriteRam , 0x902000, 0x903fff, MAP_RAM);
SekMapMemory(Drv68KRam + 0x2000 , 0x904000, 0x904fff, MAP_RAM);
SekMapMemory(DrvAlphaRam , 0x905000, 0x905f7f, MAP_RAM);
SekMapMemory(DrvMOSlipRam , 0x905f80, 0x905fff, MAP_RAM);
SekMapMemory(DrvPaletteRam , 0x910000, 0x9107ff, MAP_RAM);
SekSetReadByteHandler(0, Gauntlet68KReadByte);
SekSetWriteByteHandler(0, Gauntlet68KWriteByte);
SekSetReadWordHandler(0, Gauntlet68KReadWord);
@ -2297,8 +2297,8 @@ static INT32 Gaunt2Init()
M6502Init(0, TYPE_M6502);
M6502Open(0);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, M6502_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, M6502_ROM);
M6502MapMemory(DrvM6502Ram , 0x0000, 0x0fff, MAP_RAM);
M6502MapMemory(DrvM6502Rom , 0x4000, 0xffff, MAP_ROM);
M6502SetReadHandler(GauntletSoundRead);
M6502SetWriteHandler(GauntletSoundWrite);
M6502Close();

Some files were not shown because too many files have changed in this diff Show More