diff --git a/src/burn/drv/pgm/d_pgm.cpp b/src/burn/drv/pgm/d_pgm.cpp index 653d2bb8d..cc0226afe 100644 --- a/src/burn/drv/pgm/d_pgm.cpp +++ b/src/burn/drv/pgm/d_pgm.cpp @@ -886,6 +886,7 @@ STD_ROM_FN(drgw3) static INT32 drgw3Init() { pPgmInitCallback = pgm_decrypt_dw3; + pPgmProtCallback = install_protection_asic25_asic22_drgw3; return pgmInit(); } @@ -1026,7 +1027,7 @@ static struct BurnRomInfo oldsRomDesc[] = { { "sp_v101.u6", 0x010000, 0x097046bc, 0 | BRF_PRG | BRF_ESS }, // 19 Protection Rom - { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 20 ram dump +// { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 20 ram dump }; STDROMPICKEXT(olds, olds, pgm) @@ -1079,7 +1080,7 @@ static struct BurnRomInfo olds100RomDesc[] = { { "kd-u6.512", 0x010000, 0xe7613dda, 0 | BRF_PRG | BRF_ESS }, // 19 Protection Rom - { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 20 ram dump +// { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 20 ram dump }; STDROMPICKEXT(olds100, olds100, pgm) @@ -1119,13 +1120,9 @@ static struct BurnRomInfo olds100aRomDesc[] = { { "m0500.rom", 0x200000, 0x37928cdd, 5 | BRF_SND }, // 14 Samples -#if !defined (ROM_VERIFY) - { "protection_data.u6", 0x010000, 0x00000000, 0 | BRF_PRG | BRF_ESS | BRF_NODUMP }, // 15 Protection Rom -#else - { "", 0x000000, 0x00000000, 0 }, // 15 -#endif + { "kd-u6.512", 0x010000, 0xe7613dda, 0 | BRF_PRG | BRF_ESS }, // 15 Protection Rom - { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 16 ram dump +// { "ram_dump", 0x004000, 0x280cfb4e, 0 | BRF_PRG | BRF_ESS }, // 16 ram dump }; STDROMPICKEXT(olds100a, olds100a, pgm) @@ -1718,11 +1715,11 @@ static INT32 puzzli2Init() return pgmInit(); } -struct BurnDriverD BurnDrvPuzzli2 = { +struct BurnDriver BurnDrvPuzzli2 = { "puzzli2", NULL, "pgm", NULL, "1999", "Puzzli 2 (V100)\0", "Incomplete dump", "IGS", "PolyGameMaster", NULL, NULL, NULL, NULL, - 0, 4, HARDWARE_IGS_PGM/* | HARDWARE_IGS_USE_ARM_CPU*/, GBF_PUZZLE, 0, + BDF_GAME_WORKING, 4, HARDWARE_IGS_PGM/* | HARDWARE_IGS_USE_ARM_CPU*/, GBF_PUZZLE, 0, NULL, puzzli2RomInfo, puzzli2RomName, NULL, NULL, pgmInputInfo, puzzli2DIPInfo, puzzli2Init, pgmExit, pgmFrame, pgmDraw, pgmScan, &nPgmPalRecalc, 0x900, 448, 224, 4, 3 @@ -1749,11 +1746,11 @@ static struct BurnRomInfo puzzli2sRomDesc[] = { STDROMPICKEXT(puzzli2s, puzzli2s, pgm) STD_ROM_FN(puzzli2s) -struct BurnDriverD BurnDrvPuzzli2s = { +struct BurnDriver BurnDrvPuzzli2s = { "puzzli2s", "puzzli2", "pgm", NULL, "2001", "Puzzli 2 Super (V200)\0", "Incomplete dump", "IGS", "PolyGameMaster", NULL, NULL, NULL, NULL, - BDF_CLONE, 4, HARDWARE_IGS_PGM/* | HARDWARE_IGS_USE_ARM_CPU*/, GBF_PUZZLE, 0, + BDF_GAME_WORKING | BDF_CLONE, 4, HARDWARE_IGS_PGM/* | HARDWARE_IGS_USE_ARM_CPU*/, GBF_PUZZLE, 0, NULL, puzzli2sRomInfo, puzzli2sRomName, NULL, NULL, pgmInputInfo, puzzli2DIPInfo, puzzli2Init, pgmExit, pgmFrame, pgmDraw, pgmScan, &nPgmPalRecalc, 0x900, 448, 224, 4, 3 diff --git a/src/burn/drv/pgm/pgm.h b/src/burn/drv/pgm/pgm.h index 1397d254d..6d4226332 100644 --- a/src/burn/drv/pgm/pgm.h +++ b/src/burn/drv/pgm/pgm.h @@ -67,6 +67,7 @@ INT32 pgmDraw(); void install_protection_asic3_orlegend(); void install_protection_asic25_asic12_dw2(); void install_protection_asic25_asic22_killbld(); +void install_protection_asic25_asic22_drgw3(); void install_protection_asic25_asic28_olds(); void install_protection_asic27_kov(); void install_protection_asic27a_kovsh(); diff --git a/src/burn/drv/pgm/pgm_prot.cpp b/src/burn/drv/pgm/pgm_prot.cpp index c89863ea0..23345fa2d 100644 --- a/src/burn/drv/pgm/pgm_prot.cpp +++ b/src/burn/drv/pgm/pgm_prot.cpp @@ -2,6 +2,8 @@ #include "pgm.h" #include "bitswap.h" +static UINT16 *sharedprotram; // shared by several simulations + //------------------------------------------------------------------------------------------------------------------- // Proper emulation //------------------------------------------------------------------------------------------------------------------- @@ -831,227 +833,578 @@ void install_protection_asic3_orlegend() //-------------------- -// killblad +// killblade -static UINT16 kb_cmd; -static UINT16 kb_reg; -static UINT16 kb_ptr; -static UINT32 kb_regs[0x100]; -static UINT16 *sharedprotram; +static const UINT8 (*m_kb_source_data)[0xec]; +static INT32 m_kb_source_data_offset; +static UINT32 m_kb_game_id; +static UINT16 m_kb_prot_hold; +static UINT16 m_kb_prot_hilo; +static UINT16 m_kb_prot_hilo_select; +static int m_kb_cmd; +static int m_kb_reg; +static int m_kb_ptr; +static UINT8 m_kb_swap; +static UINT32 m_kb_regs[0x10]; + +// these were all xored by a table at $178B2A +static const UINT8 killbld_source_data[0x0c][0xec] = // offsets to these tables stored at $155ed0 +{ + { // region 16, $178772 + 0x5e, 0x09, 0xb3, 0x39, 0x60, 0x71, 0x71, 0x53, 0x11, 0xe5, 0x26, 0x34, 0x4c, 0x8c, 0x90, 0xee, + 0xed, 0xb5, 0x05, 0x95, 0x9e, 0x6b, 0xdd, 0x87, 0x0e, 0x7b, 0xed, 0x33, 0xaf, 0xc2, 0x62, 0x98, + 0xec, 0xc8, 0x2c, 0x2b, 0x57, 0x3d, 0x00, 0xbd, 0x12, 0xac, 0xba, 0x64, 0x81, 0x99, 0x16, 0x29, + 0xb4, 0x63, 0xa8, 0xd9, 0xc9, 0x5f, 0xfe, 0x21, 0xbb, 0xbf, 0x9b, 0xd1, 0x7b, 0x93, 0xc4, 0x82, + 0xef, 0x2b, 0xe8, 0xa6, 0xdc, 0x68, 0x3a, 0xd9, 0xc9, 0x23, 0xc7, 0x7b, 0x98, 0x5b, 0xe1, 0xc7, + 0xa3, 0xd4, 0x51, 0x0a, 0x86, 0x30, 0x20, 0x51, 0x6e, 0x04, 0x1c, 0xd4, 0xfb, 0xf5, 0x22, 0x8f, + 0x16, 0x6f, 0xb9, 0x59, 0x30, 0xcf, 0xab, 0x32, 0x1d, 0x6c, 0x84, 0xab, 0x23, 0x90, 0x94, 0xb1, + 0xe7, 0x4b, 0x6d, 0xc1, 0x84, 0xba, 0x32, 0x68, 0xa3, 0xf2, 0x47, 0x28, 0xe5, 0xcb, 0xbb, 0x47, + 0x14, 0x2c, 0xad, 0x4d, 0xa1, 0xd7, 0x18, 0x53, 0xf7, 0x6f, 0x05, 0x81, 0x8f, 0xbb, 0x29, 0xdc, + 0xbd, 0x17, 0x61, 0x92, 0x9b, 0x1d, 0x4e, 0x7a, 0x83, 0x14, 0x9f, 0x7b, 0x7a, 0x6a, 0xe1, 0x27, + 0x62, 0x52, 0x7e, 0x82, 0x45, 0xda, 0xed, 0xf1, 0x0a, 0x3b, 0x6c, 0x02, 0x5b, 0x6e, 0x45, 0x4e, + 0xf2, 0x65, 0x87, 0x1d, 0x80, 0xed, 0x6a, 0xc3, 0x77, 0xcb, 0xe8, 0x8d, 0x5a, 0xb8, 0xda, 0x89, + 0x88, 0x4b, 0x27, 0xd5, 0x57, 0x29, 0x91, 0x86, 0x12, 0xbb, 0xd3, 0x8c, 0xc7, 0x49, 0x84, 0x9c, + 0x96, 0x59, 0x30, 0x93, 0x92, 0xeb, 0x59, 0x2b, 0x93, 0x5b, 0x5f, 0xf9, 0x67, 0xac, 0x97, 0x8c, + 0x04, 0xda, 0x1b, 0x65, 0xd7, 0xef, 0x44, 0xca, 0xc4, 0x87, 0x18, 0x2b + }, + { // region 17, $178a36 + 0xd7, 0x49, 0xb3, 0x39, 0x60, 0x71, 0x70, 0x53, 0x11, 0x00, 0x27, 0xb2, 0x61, 0xd3, 0x8c, 0x8b, + 0xb2, 0xde, 0x6a, 0x78, 0x40, 0x5d, 0x4d, 0x88, 0xeb, 0x81, 0xd0, 0x2a, 0xbf, 0x8c, 0x22, 0x0d, + 0x89, 0x83, 0xc8, 0xef, 0x0d, 0x7a, 0xf6, 0xf0, 0x1d, 0x49, 0xa2, 0xd3, 0x1e, 0xef, 0x1c, 0xa2, + 0xce, 0x00, 0x5e, 0xa8, 0x7f, 0x4c, 0x41, 0x27, 0xa8, 0x6b, 0x92, 0x0a, 0xb8, 0x03, 0x2f, 0x7e, + 0xaf, 0x4a, 0xd0, 0x5c, 0xce, 0xeb, 0x0e, 0x8a, 0x4d, 0x0b, 0x73, 0xb3, 0xf3, 0x0c, 0x83, 0xaa, + 0xe5, 0xe4, 0x84, 0x06, 0xd7, 0xcc, 0xcb, 0x52, 0x8d, 0xbe, 0xa4, 0xdf, 0xd9, 0xab, 0x50, 0x59, + 0x53, 0x61, 0xa1, 0xc8, 0x6d, 0xbc, 0xde, 0xab, 0xaa, 0x5e, 0xc6, 0xf7, 0x83, 0xdc, 0x40, 0xcb, + 0x1b, 0xdd, 0x28, 0x3b, 0xee, 0xb1, 0x1f, 0x37, 0xdb, 0xe9, 0xbb, 0x74, 0x4b, 0xc2, 0x8a, 0xe8, + 0xec, 0x6e, 0x0e, 0x35, 0xe3, 0x2e, 0xbe, 0xef, 0xfd, 0x07, 0xbf, 0x8c, 0xfe, 0xf3, 0x5c, 0xbf, + 0x87, 0xe5, 0xbc, 0xcf, 0x60, 0xdc, 0x18, 0xf8, 0xfc, 0x51, 0x50, 0x86, 0xc6, 0x48, 0x3d, 0xb9, + 0x1d, 0x26, 0xf7, 0x7e, 0x87, 0x90, 0x12, 0xe8, 0x06, 0x0a, 0x45, 0xe9, 0xd9, 0xd8, 0x41, 0x68, + 0x21, 0x52, 0x92, 0x0f, 0xd6, 0xda, 0xa2, 0x97, 0xeb, 0x68, 0xd0, 0xb1, 0x15, 0x19, 0x8b, 0xd0, + 0x48, 0x1a, 0xeb, 0x90, 0x3f, 0x2a, 0x33, 0x1e, 0x5e, 0x30, 0x66, 0x01, 0x64, 0xef, 0x99, 0x52, + 0xba, 0x23, 0xbd, 0x53, 0xc0, 0x60, 0x87, 0x09, 0xcb, 0x4d, 0xd3, 0x87, 0x0e, 0x3a, 0x5c, 0x8d, + 0xc8, 0xb8, 0xb7, 0x34, 0x01, 0xeb, 0x72, 0x0d, 0xb1, 0x1f, 0x0f, 0xea + }, + { // region 18, $17dac4 + 0x6a, 0x13, 0xb3, 0x09, 0x60, 0x79, 0x61, 0x53, 0x11, 0x33, 0x41, 0x31, 0x76, 0x34, 0x88, 0x0f, + 0x77, 0x08, 0xb6, 0x74, 0xc8, 0x36, 0xbc, 0x70, 0xe2, 0x87, 0x9a, 0x21, 0xe8, 0x56, 0xe1, 0x9a, + 0x26, 0x57, 0x7e, 0x9b, 0xdb, 0xb7, 0xd4, 0x3d, 0x0f, 0xfe, 0x8a, 0x2a, 0xba, 0x2d, 0x22, 0x03, + 0xcf, 0x9c, 0xfa, 0x77, 0x35, 0x39, 0x6a, 0x14, 0xae, 0x30, 0x89, 0x42, 0xdc, 0x59, 0xb2, 0x93, + 0x6f, 0x82, 0xd1, 0x12, 0xd9, 0x88, 0xfa, 0x3b, 0xb7, 0x0c, 0x1f, 0x05, 0x68, 0xa3, 0x0c, 0xa6, + 0x0f, 0xf4, 0x9e, 0x1b, 0x29, 0x82, 0x77, 0x3a, 0xac, 0x92, 0x2d, 0x04, 0xd0, 0x61, 0x65, 0x0a, + 0x77, 0x6c, 0x89, 0x38, 0xaa, 0xa9, 0xf8, 0x0c, 0x1f, 0x37, 0x09, 0x2b, 0xca, 0x29, 0x05, 0xe5, + 0x4e, 0x57, 0xfb, 0xcd, 0x40, 0xa8, 0x0c, 0x06, 0x2d, 0xe0, 0x30, 0xd9, 0x97, 0xb9, 0x59, 0x8a, + 0xde, 0xc9, 0x87, 0x1d, 0x3f, 0x84, 0x4c, 0x73, 0x04, 0x85, 0x61, 0xb0, 0x6e, 0x2c, 0x8f, 0xa2, + 0x6a, 0xcd, 0x31, 0xf3, 0x25, 0x83, 0xe1, 0x5e, 0x5d, 0xa7, 0xe7, 0xaa, 0x13, 0x26, 0xb1, 0x33, + 0xf0, 0x13, 0x58, 0x7a, 0xb0, 0x46, 0x1d, 0xdf, 0x02, 0xbf, 0x1e, 0xd1, 0x71, 0x43, 0x56, 0x82, + 0x4f, 0x58, 0x9d, 0x01, 0x2d, 0xc7, 0xda, 0x6b, 0x47, 0x05, 0xd1, 0xd5, 0xe8, 0x92, 0x3c, 0x18, + 0x21, 0xcf, 0xc9, 0x32, 0x0e, 0x12, 0xed, 0xb5, 0xaa, 0xa4, 0x12, 0x75, 0x01, 0x7d, 0xc7, 0x21, + 0xde, 0xec, 0x32, 0x13, 0xee, 0xd4, 0x9c, 0xe6, 0x04, 0x3f, 0x48, 0xfb, 0xb4, 0xc7, 0x21, 0x8e, + 0x8d, 0x7d, 0x54, 0x03, 0x11, 0xe7, 0xb9, 0x4f, 0x85, 0xb6, 0x1f, 0xaa + }, + { // region 19, $178eee + 0xe3, 0x53, 0xb3, 0x09, 0x60, 0x79, 0x60, 0x53, 0x11, 0x66, 0x5b, 0xc8, 0x8b, 0x94, 0x84, 0xab, + 0x3c, 0x18, 0x03, 0x57, 0x6a, 0x0f, 0x45, 0x58, 0xc0, 0x74, 0x64, 0x18, 0xf8, 0x39, 0xa1, 0x0f, + 0xc2, 0x2b, 0x1b, 0x60, 0xaa, 0x0e, 0xb2, 0x89, 0x01, 0x9b, 0x72, 0x80, 0x57, 0x83, 0x28, 0x63, + 0xe9, 0x39, 0x97, 0x46, 0xea, 0x3f, 0x93, 0x01, 0x9b, 0xf4, 0x80, 0x93, 0x01, 0xaf, 0x1d, 0x8f, + 0x16, 0xa1, 0xb9, 0xc7, 0xe4, 0x0c, 0xe7, 0xd2, 0x3b, 0xf3, 0xca, 0x3d, 0xc3, 0x54, 0xad, 0x89, + 0x51, 0x1e, 0xd1, 0x17, 0x7a, 0x1f, 0x23, 0x22, 0xcb, 0x4d, 0xce, 0x0f, 0xae, 0x30, 0x93, 0xd3, + 0x9b, 0x77, 0x71, 0xa7, 0xe7, 0x96, 0x2c, 0x85, 0xac, 0x29, 0x4b, 0x5e, 0x2b, 0x75, 0xb0, 0x00, + 0x81, 0xe9, 0xb6, 0x47, 0xaa, 0x9f, 0xdf, 0xd4, 0x7e, 0xd7, 0xa4, 0x3f, 0xe3, 0xb0, 0x41, 0x2c, + 0xb7, 0x0c, 0xe7, 0xeb, 0x9a, 0xda, 0xd9, 0x10, 0x23, 0x1d, 0x1c, 0xd4, 0xdd, 0x7d, 0xc2, 0x6c, + 0x4d, 0x9c, 0xa5, 0x18, 0xd0, 0x43, 0xab, 0xdc, 0xbd, 0xe4, 0x7f, 0xb5, 0x5f, 0x04, 0x0d, 0xac, + 0xab, 0xe6, 0xb8, 0x76, 0xf2, 0x15, 0x41, 0xef, 0x17, 0x8e, 0xf6, 0xb9, 0xef, 0x94, 0x52, 0x83, + 0x96, 0x45, 0x8f, 0xf2, 0x9c, 0xb4, 0x13, 0x3f, 0xbb, 0xa1, 0xd2, 0xf9, 0xa3, 0xf2, 0x06, 0x78, + 0xe0, 0x9e, 0xa7, 0xd3, 0xdc, 0x13, 0x8f, 0x4d, 0xf6, 0x19, 0xbd, 0x03, 0x9d, 0x24, 0xdc, 0xd6, + 0xe9, 0xcf, 0xa6, 0xd2, 0x1d, 0x49, 0xca, 0xc4, 0x55, 0x18, 0xbc, 0x70, 0x5b, 0x55, 0xfe, 0x8f, + 0x6b, 0x42, 0xf0, 0xd1, 0x21, 0xe3, 0xe7, 0x91, 0x59, 0x4e, 0x16, 0x83 + }, + { 0, }, // unused region 1a + { 0, }, // unused region 1b + { 0, }, // unused region 1c + { 0, }, // unused region 1d + { 0, }, // unused region 1e + { 0, }, // unused region 1f + { // region 20, $17a322 + 0xb3, 0x10, 0xf3, 0x0b, 0xe0, 0x71, 0x60, 0x53, 0x11, 0x9a, 0x12, 0x70, 0x1f, 0x1e, 0x81, 0xda, + 0x9d, 0x1f, 0x4b, 0xd6, 0x71, 0x48, 0x83, 0xe1, 0x04, 0x6c, 0x1b, 0xf1, 0xcd, 0x09, 0xdf, 0x3e, + 0x0b, 0xaa, 0x95, 0xc1, 0x07, 0xec, 0x0f, 0x54, 0xd0, 0x16, 0xb0, 0xdc, 0x86, 0x7b, 0x52, 0x38, + 0x3c, 0x68, 0x2b, 0xed, 0xe2, 0xeb, 0xb3, 0xc6, 0x48, 0x24, 0x41, 0x36, 0x17, 0x25, 0x1f, 0xa5, + 0x22, 0xc6, 0x5c, 0xa6, 0x19, 0xef, 0x17, 0x5c, 0x56, 0x4b, 0x4a, 0x2b, 0x75, 0xab, 0xe6, 0x22, + 0xd5, 0xc0, 0xd3, 0x46, 0xcc, 0xe4, 0xd4, 0xc4, 0x8c, 0x9a, 0x8a, 0x75, 0x24, 0x73, 0xa4, 0x26, + 0xca, 0x79, 0xaf, 0xb3, 0x94, 0x2a, 0x15, 0xbe, 0x40, 0x7b, 0x4d, 0xf6, 0xb4, 0xa4, 0x7b, 0xcf, + 0xce, 0xa0, 0x1d, 0xcb, 0x2f, 0x60, 0x28, 0x63, 0x85, 0x98, 0xd3, 0xd2, 0x45, 0x3f, 0x02, 0x65, + 0xd7, 0xf4, 0xbc, 0x2a, 0xe7, 0x50, 0xd1, 0x3f, 0x7f, 0xf6, 0x05, 0xb8, 0xe9, 0x39, 0x10, 0x6e, + 0x68, 0xa8, 0x89, 0x60, 0x00, 0x68, 0xfd, 0x20, 0xc4, 0xdc, 0xef, 0x67, 0x75, 0xfb, 0xbe, 0xfe, + 0x2b, 0x16, 0xa6, 0x5a, 0x77, 0x0d, 0x0c, 0xe2, 0x2d, 0xd1, 0xe4, 0x11, 0xc9, 0x4b, 0x81, 0x3a, + 0x0c, 0x24, 0xaa, 0x77, 0x2b, 0x2f, 0x83, 0x23, 0xd1, 0xe9, 0xa7, 0x29, 0x0a, 0xf9, 0x26, 0x9d, + 0x51, 0xc8, 0x6d, 0x71, 0x9d, 0xce, 0x46, 0x72, 0x26, 0x48, 0x3d, 0x64, 0xe5, 0x67, 0xbb, 0x1a, + 0xb4, 0x6d, 0x21, 0x11, 0x79, 0x78, 0xc2, 0xd5, 0x11, 0x6a, 0xd2, 0xea, 0x03, 0x4d, 0x92, 0xaf, + 0x18, 0xd5, 0x07, 0x79, 0xaa, 0xf9, 0x44, 0x93, 0x6f, 0x41, 0x22, 0x0d + }, + { // region 21, $17b3b4 + 0x2d, 0x50, 0xf3, 0x0b, 0xe0, 0x71, 0x61, 0x53, 0x11, 0xb4, 0x2c, 0xee, 0x34, 0x7e, 0x7d, 0x5e, + 0x62, 0x48, 0x97, 0xd2, 0xf9, 0x3a, 0xf2, 0xc9, 0xfa, 0x59, 0xe4, 0xe8, 0xf6, 0xd2, 0x9f, 0xb2, + 0xa7, 0x7e, 0x32, 0x86, 0xbc, 0x43, 0xec, 0xa0, 0xc2, 0xcb, 0x98, 0x33, 0x23, 0xd1, 0x58, 0x98, + 0x56, 0x05, 0xc7, 0xbc, 0x98, 0xd8, 0xdc, 0xb3, 0x35, 0xe8, 0x51, 0x6e, 0x3b, 0x7b, 0x89, 0xba, + 0xe1, 0xe5, 0x44, 0x5c, 0x24, 0x73, 0x04, 0x0d, 0xd9, 0x33, 0xf5, 0x63, 0xe9, 0x5c, 0x88, 0x05, + 0x18, 0xd0, 0x07, 0x5b, 0x1e, 0x81, 0x80, 0xac, 0x92, 0x6e, 0x13, 0x80, 0x1b, 0x29, 0xd2, 0xef, + 0x08, 0x84, 0x97, 0x23, 0xd1, 0x17, 0x2f, 0x38, 0xb4, 0x6d, 0x8f, 0x2a, 0x15, 0xf0, 0x40, 0xe9, + 0x02, 0x33, 0xd7, 0x5e, 0x99, 0x57, 0x15, 0x32, 0xbd, 0x8f, 0x48, 0x38, 0x91, 0x36, 0xe9, 0x07, + 0xc9, 0x37, 0x1d, 0x12, 0x2a, 0xbf, 0x5f, 0xdb, 0x85, 0x75, 0xbf, 0xdc, 0x59, 0x8a, 0x43, 0x51, + 0x4b, 0x77, 0xfd, 0x84, 0xc4, 0x28, 0xc7, 0x85, 0x25, 0x1a, 0x87, 0x8b, 0xc1, 0xd9, 0x1a, 0x78, + 0xe5, 0x03, 0x20, 0x56, 0xa0, 0xc2, 0x17, 0xf2, 0x29, 0xa0, 0xbd, 0xf8, 0x61, 0x9c, 0x7d, 0x54, + 0x3a, 0x11, 0xb5, 0x69, 0x9a, 0x1c, 0xbb, 0xf6, 0x2d, 0x86, 0xa8, 0x4d, 0xdd, 0x5a, 0xd6, 0xe4, + 0x11, 0x7e, 0x4b, 0x13, 0x6c, 0xb6, 0x01, 0x0a, 0x72, 0xbc, 0xe8, 0xf1, 0x82, 0x0e, 0xd0, 0xcf, + 0xbf, 0x50, 0x95, 0xb7, 0xa7, 0xec, 0xd7, 0xb3, 0x49, 0x5c, 0x47, 0x5f, 0xa9, 0xda, 0x70, 0xb0, + 0xdc, 0x9a, 0xa3, 0x48, 0xd3, 0xf5, 0x72, 0xd5, 0x43, 0xd8, 0x19, 0xcc + } +}; + +// all tables xored with data from $149c4c +static const UINT8 dw3_source_data[0x07][0xec] = +{ + { // region 1, $14c21a + 0x67, 0x51, 0xf3, 0x19, 0xa0, 0x09, 0xb1, 0x21, 0xb0, 0xee, 0xe3, 0xf6, 0xbe, 0x81, 0x35, 0xe3, + 0xfb, 0xe6, 0xef, 0xdf, 0x61, 0x01, 0xfa, 0x22, 0x5d, 0x43, 0x01, 0xa5, 0x3b, 0x17, 0xd4, 0x74, + 0xf0, 0xf4, 0xf3, 0x43, 0xb5, 0x19, 0x04, 0xd5, 0x84, 0xce, 0x87, 0xfe, 0x35, 0x3e, 0xc4, 0x3c, + 0xc7, 0x85, 0x2a, 0x33, 0x00, 0x86, 0xd0, 0x4d, 0x65, 0x4b, 0xf9, 0xe9, 0xc0, 0xba, 0xaa, 0x77, + 0x9e, 0x66, 0xf6, 0x0f, 0x4f, 0x3a, 0xb6, 0xf1, 0x64, 0x9a, 0xe9, 0x25, 0x1a, 0x5f, 0x22, 0xa3, + 0xa2, 0xbf, 0x4b, 0x77, 0x3f, 0x34, 0xc9, 0x6e, 0xdb, 0x12, 0x5c, 0x33, 0xa5, 0x8b, 0x6c, 0xb1, + 0x74, 0xc8, 0x40, 0x4e, 0x2f, 0xe7, 0x46, 0xae, 0x99, 0xfc, 0xb0, 0x55, 0x54, 0xdf, 0xa7, 0xa1, + 0x0f, 0x5e, 0x49, 0xcf, 0x56, 0x3c, 0x90, 0x2b, 0xac, 0x65, 0x6e, 0xdb, 0x58, 0x3e, 0xc9, 0x00, + 0xae, 0x53, 0x4d, 0x92, 0xfa, 0x40, 0xb2, 0x6b, 0x65, 0x4b, 0x90, 0x8a, 0x0c, 0xe2, 0xa5, 0x9a, + 0xd0, 0x20, 0x29, 0x55, 0xa4, 0x44, 0xac, 0x51, 0x87, 0x54, 0x53, 0x34, 0x24, 0x4b, 0x81, 0x67, + 0x34, 0x4c, 0x5f, 0x31, 0x4e, 0xf2, 0xf1, 0x19, 0x18, 0x1c, 0x34, 0x38, 0xe1, 0x81, 0x17, 0xcf, + 0x24, 0xb9, 0x9a, 0xcb, 0x34, 0x51, 0x50, 0x59, 0x44, 0xb1, 0x0b, 0x50, 0x95, 0x6c, 0x48, 0x7e, + 0x14, 0xa4, 0xc6, 0xd9, 0xd3, 0xa5, 0xd6, 0xd0, 0xc5, 0x97, 0xf0, 0x45, 0xd0, 0x98, 0x51, 0x91, + 0x9f, 0xa3, 0x43, 0x51, 0x05, 0x90, 0xee, 0xca, 0x7e, 0x5f, 0x72, 0x53, 0xb1, 0xd3, 0xaf, 0x36, + 0x08, 0x75, 0xb0, 0x9b, 0xe0, 0x0d, 0x43, 0x88, 0xaa, 0x27, 0x44, 0x11 + }, + { // region 2, $14c126 + 0xf9, 0x19, 0xf3, 0x09, 0xa0, 0x09, 0xb0, 0x21, 0xb0, 0x22, 0xfd, 0x8e, 0xd3, 0xc8, 0x31, 0x67, + 0xc0, 0x10, 0x3c, 0xc2, 0x03, 0xf2, 0x6a, 0x0a, 0x54, 0x49, 0xca, 0xb5, 0x4b, 0xe0, 0x94, 0xe8, + 0x8d, 0xc8, 0x90, 0xee, 0x6b, 0x6f, 0xfa, 0x09, 0x76, 0x84, 0x6f, 0x55, 0xd1, 0x94, 0xca, 0x9c, + 0xe1, 0x22, 0xc6, 0x02, 0xb5, 0x8c, 0xf9, 0x3a, 0x52, 0x10, 0xf0, 0x22, 0xe4, 0x11, 0x15, 0x73, + 0x5e, 0x9e, 0xde, 0xc4, 0x5a, 0xbd, 0xa3, 0x89, 0xe7, 0x9b, 0x95, 0x5d, 0x75, 0xf6, 0xc3, 0x9f, + 0xe4, 0xcf, 0x65, 0x73, 0x90, 0xd0, 0x75, 0x56, 0xfa, 0xcc, 0xe4, 0x3e, 0x9c, 0x41, 0x81, 0x62, + 0xb1, 0xd3, 0x28, 0xbd, 0x6c, 0xed, 0x60, 0x28, 0x27, 0xee, 0xf2, 0xa1, 0xb4, 0x2c, 0x6c, 0xbb, + 0x42, 0xd7, 0x1d, 0x62, 0xc0, 0x33, 0x7d, 0xf9, 0xe4, 0x5c, 0xe2, 0x41, 0xa4, 0x1c, 0x98, 0xa1, + 0x87, 0x95, 0xad, 0x61, 0x56, 0x96, 0x40, 0x08, 0x6b, 0xe2, 0x4b, 0x95, 0x7b, 0x1b, 0xd8, 0x64, + 0xb3, 0xee, 0x9d, 0x79, 0x69, 0xea, 0x5d, 0xcf, 0x01, 0x91, 0xea, 0x3f, 0x70, 0x29, 0xdc, 0xe0, + 0x08, 0x20, 0xbf, 0x46, 0x90, 0xa8, 0xfc, 0x29, 0x14, 0xd1, 0x0d, 0x20, 0x79, 0xd2, 0x2c, 0xe9, + 0x52, 0xa6, 0x8c, 0xbd, 0xa3, 0x3e, 0x88, 0x2d, 0xb8, 0x4e, 0xf2, 0x74, 0x50, 0xcc, 0x12, 0xde, + 0xd3, 0x5a, 0xa4, 0x7b, 0xa2, 0x8d, 0x91, 0x68, 0x12, 0x0c, 0x9c, 0xb9, 0x6d, 0x26, 0x66, 0x60, + 0xc3, 0x6d, 0xd0, 0x11, 0x33, 0x05, 0x1d, 0xa8, 0xb6, 0x51, 0xe6, 0xe0, 0x58, 0x61, 0x74, 0x37, + 0xcc, 0x3a, 0x4d, 0x6a, 0x0a, 0x09, 0x71, 0xe3, 0x7e, 0xa5, 0x3b, 0xe9 + }, + { // region 3, $14E5BE + 0x73, 0x59, 0xf3, 0x09, 0xa0, 0x09, 0xb1, 0x21, 0xb0, 0x55, 0x18, 0x0d, 0xe8, 0x29, 0x2d, 0x04, + 0x85, 0x39, 0x88, 0xbe, 0x8b, 0xcb, 0xd9, 0x0b, 0x32, 0x36, 0x94, 0xac, 0x74, 0xc3, 0x3b, 0x5d, + 0x2a, 0x83, 0x46, 0xb3, 0x3a, 0xac, 0xd8, 0x55, 0x68, 0x21, 0x57, 0xab, 0x6e, 0xd1, 0xd0, 0xfc, + 0xe2, 0xbe, 0x63, 0xd0, 0x6b, 0x79, 0x23, 0x40, 0x58, 0xd4, 0xe7, 0x73, 0x22, 0x67, 0x7f, 0x88, + 0x05, 0xbd, 0xdf, 0x7a, 0x65, 0x41, 0x90, 0x3a, 0x52, 0x83, 0x28, 0xae, 0xe9, 0x8e, 0x65, 0x82, + 0x0e, 0xdf, 0x98, 0x88, 0xe1, 0x86, 0x21, 0x3e, 0x1a, 0x87, 0x6d, 0x62, 0x7a, 0xf6, 0xaf, 0x2c, + 0xd5, 0xc5, 0x10, 0x2d, 0xa9, 0xda, 0x93, 0xa1, 0x9b, 0xc7, 0x35, 0xd4, 0x15, 0x78, 0x18, 0xd5, + 0x75, 0x6a, 0xd7, 0xdb, 0x12, 0x2a, 0x6a, 0xc8, 0x36, 0x53, 0x57, 0xa6, 0xf0, 0x13, 0x67, 0x43, + 0x79, 0xf0, 0x0e, 0x49, 0xb1, 0xec, 0xcd, 0xa4, 0x8a, 0x61, 0x06, 0xb9, 0xea, 0x53, 0xf2, 0x47, + 0x7d, 0xd6, 0xf8, 0x9d, 0x2e, 0xaa, 0x27, 0x35, 0x61, 0xce, 0x9b, 0x63, 0xbc, 0x07, 0x51, 0x5a, + 0xc2, 0x0d, 0x39, 0x42, 0xd2, 0x5e, 0x21, 0x20, 0x10, 0xa0, 0xe5, 0x08, 0xf7, 0x3d, 0x28, 0x04, + 0x99, 0x93, 0x97, 0xaf, 0xf9, 0x12, 0xc0, 0x01, 0x2d, 0xea, 0xf3, 0x98, 0x0b, 0x46, 0xc2, 0x26, + 0x93, 0x10, 0x69, 0x1d, 0x71, 0x8e, 0x33, 0x00, 0x5e, 0x80, 0x2f, 0x47, 0x0a, 0xcc, 0x94, 0x16, + 0xe7, 0x37, 0x45, 0xd0, 0x61, 0x79, 0x32, 0x86, 0x08, 0x2a, 0x5b, 0x55, 0xfe, 0xee, 0x52, 0x38, + 0xaa, 0x18, 0xe9, 0x39, 0x1a, 0x1e, 0xb8, 0x26, 0x6b, 0x3d, 0x4b, 0xa9 + }, + { // region 4, $14d500 + 0x06, 0x01, 0xf3, 0x39, 0xa0, 0x09, 0xa0, 0x21, 0xb0, 0x6f, 0x32, 0x8b, 0xfd, 0x89, 0x29, 0xa0, + 0x4a, 0x62, 0xed, 0xa1, 0x2d, 0xa4, 0x49, 0xf2, 0x10, 0x3c, 0x77, 0xa3, 0x84, 0x8d, 0xfa, 0xd1, + 0xc6, 0x57, 0xe2, 0x78, 0xef, 0xe9, 0xb6, 0xa1, 0x5a, 0xbd, 0x3f, 0x02, 0x0b, 0x28, 0xd6, 0x76, + 0xfc, 0x5b, 0x19, 0x9f, 0x21, 0x66, 0x4c, 0x2d, 0x45, 0x99, 0xde, 0xab, 0x46, 0xbd, 0xe9, 0x84, + 0xc4, 0xdc, 0xc7, 0x30, 0x70, 0xdd, 0x64, 0xea, 0xbc, 0x6b, 0xd3, 0xe6, 0x45, 0x3f, 0x07, 0x7e, + 0x50, 0xef, 0xb2, 0x84, 0x33, 0x3c, 0xcc, 0x3f, 0x39, 0x5b, 0xf5, 0x6d, 0x71, 0xc5, 0xdd, 0xf5, + 0xf9, 0xd0, 0xf7, 0x9c, 0xe6, 0xc7, 0xad, 0x1b, 0x29, 0xb9, 0x90, 0x08, 0x75, 0xc4, 0xc3, 0xef, + 0xa8, 0xfc, 0xab, 0x55, 0x7c, 0x21, 0x57, 0x97, 0x87, 0x4a, 0xcb, 0x0c, 0x56, 0x0a, 0x4f, 0xcb, + 0x52, 0x33, 0x87, 0x31, 0xf3, 0x43, 0x5b, 0x41, 0x90, 0xf8, 0xc0, 0xdd, 0x5a, 0xa4, 0x26, 0x2a, + 0x60, 0xa5, 0x6d, 0xda, 0xf2, 0x6a, 0xf0, 0xb3, 0xda, 0x25, 0x33, 0x87, 0x22, 0xe4, 0xac, 0xd3, + 0x96, 0xe0, 0x99, 0x3e, 0xfb, 0x14, 0x45, 0x17, 0x25, 0x56, 0xbe, 0xef, 0x8f, 0x8e, 0x3d, 0x1e, + 0xc7, 0x99, 0xa2, 0xa1, 0x50, 0xfe, 0xdf, 0xd4, 0xa1, 0x87, 0xf4, 0xd5, 0xde, 0xa6, 0x8c, 0x6d, + 0x6c, 0xde, 0x47, 0xbe, 0x59, 0x8f, 0xd4, 0x97, 0xc3, 0xf4, 0xda, 0xbb, 0xa6, 0x73, 0xa9, 0xcb, + 0xf2, 0x01, 0xb9, 0x90, 0x8f, 0xed, 0x60, 0x64, 0x40, 0x1c, 0xb6, 0xc9, 0xa5, 0x7c, 0x17, 0x52, + 0x6f, 0xdc, 0x6d, 0x08, 0x2a, 0x1a, 0xe6, 0x68, 0x3f, 0xd4, 0x42, 0x69 + }, + { // region 5, $14bfb2 + 0x7f, 0x41, 0xf3, 0x39, 0xa0, 0x09, 0xa1, 0x21, 0xb0, 0xa2, 0x4c, 0x23, 0x13, 0xe9, 0x25, 0x3d, + 0x0f, 0x72, 0x3a, 0x9d, 0xb5, 0x96, 0xd1, 0xda, 0x07, 0x29, 0x41, 0x9a, 0xad, 0x70, 0xba, 0x46, + 0x63, 0x2b, 0x7f, 0x3d, 0xbe, 0x40, 0xad, 0xd4, 0x4c, 0x73, 0x27, 0x58, 0xa7, 0x65, 0xdc, 0xd6, + 0xfd, 0xde, 0xb5, 0x6e, 0xd6, 0x6c, 0x75, 0x1a, 0x32, 0x45, 0xd5, 0xe3, 0x6a, 0x14, 0x6d, 0x80, + 0x84, 0x15, 0xaf, 0xcc, 0x7b, 0x61, 0x51, 0x82, 0x40, 0x53, 0x7f, 0x38, 0xa0, 0xd6, 0x8f, 0x61, + 0x79, 0x19, 0xe5, 0x99, 0x84, 0xd8, 0x78, 0x27, 0x3f, 0x16, 0x97, 0x78, 0x4f, 0x7b, 0x0c, 0xa6, + 0x37, 0xdb, 0xc6, 0x0c, 0x24, 0xb4, 0xc7, 0x94, 0x9d, 0x92, 0xd2, 0x3b, 0xd5, 0x11, 0x6f, 0x0a, + 0xdb, 0x76, 0x66, 0xe7, 0xcd, 0x18, 0x2b, 0x66, 0xd8, 0x41, 0x40, 0x58, 0xa2, 0x01, 0x1e, 0x6d, + 0x44, 0x75, 0xe7, 0x19, 0x4f, 0xb2, 0xe8, 0xc4, 0x96, 0x77, 0x62, 0x02, 0xc9, 0xdc, 0x59, 0xf3, + 0x43, 0x8d, 0xc8, 0xfe, 0x9e, 0x2a, 0xba, 0x32, 0x3b, 0x62, 0xe3, 0x92, 0x6e, 0xc2, 0x08, 0x4d, + 0x51, 0xcd, 0xf9, 0x3a, 0x3e, 0xc9, 0x50, 0x27, 0x21, 0x25, 0x97, 0xd7, 0x0e, 0xf8, 0x39, 0x38, + 0xf5, 0x86, 0x94, 0x93, 0xbf, 0xeb, 0x18, 0xa8, 0xfc, 0x24, 0xf5, 0xf9, 0x99, 0x20, 0x3d, 0xcd, + 0x2c, 0x94, 0x25, 0x79, 0x28, 0x77, 0x8f, 0x2f, 0x10, 0x69, 0x86, 0x30, 0x43, 0x01, 0xd7, 0x9a, + 0x17, 0xe3, 0x47, 0x37, 0xbd, 0x62, 0x75, 0x42, 0x78, 0xf4, 0x2b, 0x57, 0x4c, 0x0a, 0xdb, 0x53, + 0x4d, 0xa1, 0x0a, 0xd6, 0x3a, 0x16, 0x15, 0xaa, 0x2c, 0x6c, 0x39, 0x42 + }, + { // region 6, $14cd82 + 0x12, 0x09, 0xf3, 0x29, 0xa0, 0x09, 0xa0, 0x21, 0xb0, 0xd5, 0x66, 0xa1, 0x28, 0x4a, 0x21, 0xc0, + 0xd3, 0x9b, 0x86, 0x80, 0x57, 0x6f, 0x41, 0xc2, 0xe4, 0x2f, 0x0b, 0x91, 0xbd, 0x3a, 0x7a, 0xba, + 0x00, 0xe5, 0x35, 0x02, 0x74, 0x7d, 0x8b, 0x21, 0x57, 0x10, 0x0f, 0xae, 0x44, 0xbb, 0xe2, 0x37, + 0x18, 0x7b, 0x52, 0x3d, 0x8c, 0x59, 0x9e, 0x20, 0x1f, 0x0a, 0xcc, 0x1c, 0x8e, 0x6a, 0xd7, 0x95, + 0x2b, 0x34, 0xb0, 0x82, 0x6d, 0xfd, 0x25, 0x33, 0xaa, 0x3b, 0x2b, 0x70, 0x15, 0x87, 0x31, 0x5d, + 0xbb, 0x29, 0x19, 0x95, 0xd5, 0x8e, 0x24, 0x28, 0x5e, 0xd0, 0x20, 0x83, 0x46, 0x4a, 0x21, 0x70, + 0x5b, 0xcd, 0xae, 0x7b, 0x61, 0xa1, 0xfa, 0xf4, 0x2b, 0x84, 0x15, 0x6e, 0x36, 0x5d, 0x1b, 0x24, + 0x0f, 0x09, 0x3a, 0x61, 0x38, 0x0f, 0x18, 0x35, 0x11, 0x38, 0xb4, 0xbd, 0xee, 0xf7, 0xec, 0x0f, + 0x1d, 0xb7, 0x48, 0x01, 0xaa, 0x09, 0x8f, 0x61, 0xb5, 0x0f, 0x1d, 0x26, 0x39, 0x2e, 0x8c, 0xd6, + 0x26, 0x5c, 0x3d, 0x23, 0x63, 0xe9, 0x6b, 0x97, 0xb4, 0x9f, 0x7b, 0xb6, 0xba, 0xa0, 0x7c, 0xc6, + 0x25, 0xa1, 0x73, 0x36, 0x67, 0x7f, 0x74, 0x1e, 0x1d, 0xda, 0x70, 0xbf, 0xa5, 0x63, 0x35, 0x39, + 0x24, 0x8c, 0x9f, 0x85, 0x16, 0xd8, 0x50, 0x95, 0x71, 0xc0, 0xf6, 0x1e, 0x6d, 0x80, 0xed, 0x15, + 0xeb, 0x63, 0xe9, 0x1b, 0xf6, 0x78, 0x31, 0xc6, 0x5c, 0xdd, 0x19, 0xbd, 0xdf, 0xa7, 0xec, 0x50, + 0x22, 0xad, 0xbb, 0xf6, 0xeb, 0xd6, 0xa3, 0x20, 0xc9, 0xe6, 0x9f, 0xcb, 0xf2, 0x97, 0xb9, 0x54, + 0x12, 0x66, 0xa6, 0xbe, 0x4a, 0x12, 0x43, 0xec, 0x00, 0xea, 0x49, 0x02 + }, + { // region 7, $14ce76 + 0xa4, 0x49, 0xf3, 0x29, 0xa0, 0x09, 0xa1, 0x21, 0xb0, 0xef, 0x80, 0x20, 0x3d, 0xaa, 0x36, 0x5d, + 0x98, 0xc4, 0xd2, 0x63, 0xdf, 0x61, 0xb0, 0xc3, 0xc2, 0x35, 0xd4, 0x88, 0xe6, 0x1d, 0x3a, 0x2f, + 0x9c, 0xb9, 0xd1, 0xc6, 0x43, 0xba, 0x69, 0x6d, 0x49, 0xac, 0xdd, 0x05, 0xe0, 0xf8, 0xe8, 0x97, + 0x19, 0x18, 0x08, 0x0c, 0x42, 0x46, 0xc7, 0x0d, 0x25, 0xce, 0xc3, 0x54, 0xb2, 0xd9, 0x42, 0x91, + 0xea, 0x53, 0x98, 0x38, 0x78, 0x81, 0x12, 0xca, 0x15, 0x23, 0xbd, 0xc1, 0x70, 0x1f, 0xd2, 0x40, + 0xfd, 0x39, 0x33, 0xaa, 0x27, 0x2b, 0xe8, 0x10, 0x7d, 0xa4, 0xa8, 0x8e, 0x3d, 0x00, 0x4f, 0x3a, + 0x7f, 0xd8, 0x96, 0xea, 0x9e, 0x8e, 0x15, 0x6e, 0x9f, 0x76, 0x57, 0xba, 0x7d, 0xc2, 0xdf, 0x57, + 0x42, 0x82, 0xf4, 0xda, 0x89, 0x06, 0x05, 0x04, 0x62, 0x2f, 0x29, 0x23, 0x54, 0xd5, 0xbb, 0x97, + 0xf5, 0xf9, 0xc1, 0xcf, 0xec, 0x5f, 0x1d, 0xfd, 0xbb, 0xa6, 0xd7, 0x4a, 0xa8, 0x66, 0xbf, 0xb9, + 0x09, 0x44, 0xb1, 0x60, 0x28, 0xa9, 0x35, 0x16, 0x15, 0xf5, 0x13, 0xc1, 0x07, 0x7e, 0xd7, 0x40, + 0xdf, 0x8e, 0xd3, 0x32, 0xa9, 0x35, 0x98, 0x15, 0x32, 0xa9, 0x49, 0xc0, 0x24, 0xb4, 0x4a, 0x53, + 0x6b, 0x79, 0xaa, 0x77, 0x6c, 0xc5, 0x88, 0x69, 0xe5, 0x5d, 0xde, 0x42, 0x28, 0xf9, 0xb7, 0x5c, + 0xab, 0x19, 0xc7, 0xbc, 0xc5, 0x60, 0xeb, 0x5e, 0xa8, 0x52, 0xc4, 0x32, 0x7c, 0x35, 0x02, 0x06, + 0x46, 0x77, 0x30, 0xb6, 0x33, 0x4b, 0xb8, 0xfd, 0x02, 0xd8, 0x14, 0x40, 0x99, 0x25, 0x7e, 0x55, + 0xd6, 0x44, 0x43, 0x8d, 0x73, 0x0e, 0x71, 0x48, 0xd3, 0x82, 0x40, 0xda + } +}; static void IGS022_do_dma(UINT16 src, UINT16 dst, UINT16 size, UINT16 mode) { - UINT16 param = mode >> 8; + UINT16 param; + + param = mode >> 8; + mode &=0xf; // what are the other bits? + + if ((mode == 0) || (mode == 1) || (mode == 2) || (mode == 3)) + { + int x; + UINT16 *PROTROM = (UINT16*)(PGMUSER0 + 0x10000); + + for (x = 0; x < size; x++) + { + UINT16 dat2 = PROTROM[src + x]; + + UINT8 extraoffset = param&0xff; + UINT8* dectable = (UINT8*)PROTROM; // the basic decryption table is at the start of the mcu data rom! at least in killbld + UINT8 taboff = ((x*2)+extraoffset) & 0xff; // must allow for overflow in instances of odd offsets + UINT16 extraxor = ((dectable[taboff+0]) << 8) | (dectable[taboff+1] << 0); + + dat2 = ((dat2 & 0x00ff)<<8) | ((dat2 & 0xff00)>>8); + + // mode==0 plain + if (mode==3) dat2 ^= extraxor; + if (mode==2) dat2 += extraxor; + if (mode==1) dat2 -= extraxor; + + sharedprotram[dst + x] = dat2; + } + + /* Killing Blade: hack, patches out some additional security checks... we need to emulate them instead! */ + // different region IGS025 devices supply different sequences - we currently only have the china sequence for Killing Blade + //if ((mode==3) && (param==0x54) && (src*2==0x2120) && (dst*2==0x2600)) sharedprotram[0x2600 / 2] = 0x4e75; + + } + if (mode == 4) + { + // not used by killing blade + /* looks almost like a fixed value xor, but isn't */ + } + else if (mode == 5) + { + /* mode 5 seems to be a straight copy */ + int x; + UINT16 *PROTROM = (UINT16*)(PGMUSER0 + 0x10000); + for (x = 0; x < size; x++) + { + UINT16 dat = PROTROM[src + x]; + + sharedprotram[dst + x] = dat; + } + } + else if (mode == 6) + { + /* mode 6 seems to swap bytes and nibbles */ + int x; + UINT16 *PROTROM = (UINT16*)(PGMUSER0 + 0x10000); + for (x = 0; x < size; x++) + { + UINT16 dat = PROTROM[src + x]; + + dat = ((dat & 0xf000) >> 12)| + ((dat & 0x0f00) >> 4)| + ((dat & 0x00f0) << 4)| + ((dat & 0x000f) << 12); + + sharedprotram[dst + x] = dat; + } + } + else if (mode == 7) + { + // not used by killing blade + /* weird mode, the params get left in memory? - maybe it's a NOP? */ + } + else + { + // not used by killing blade + /* invalid? */ + + } +} + +// the internal MCU boot code automatically does this DMA +// and puts the version # of the data rom in ram +static void IGS022_reset() +{ + int i; UINT16 *PROTROM = (UINT16*)(PGMUSER0 + 0x10000); + UINT16 tmp; - mode &= 0x0f; + // fill ram with A5 patern + for (i = 0; i < 0x4000/2; i++) + sharedprotram[i] = 0xa55a; - switch (mode) - { - case 0: - case 1: - case 2: - case 3: - { - for (INT32 x = 0; x < size; x++) - { - UINT16 dat2 = BURN_ENDIAN_SWAP_INT16(PROTROM[src + x]); + // the auto-dma + UINT16 src = PROTROM[0x100 / 2]; + UINT32 dst = PROTROM[0x102 / 2]; + UINT16 size = PROTROM[0x104/ 2]; + UINT16 mode = PROTROM[0x106 / 2]; - UINT8 extraoffset = param & 0xfe; - UINT8* dectable = (UINT8 *)PROTROM; - UINT16 extraxor = ((dectable[((x*2)+0+extraoffset)&0xff]) << 8) | (dectable[((x*2)+1+extraoffset)&0xff] << 0); + src = ((src & 0xff00) >> 8) | ((src & 0x00ff) << 8); + dst = ((dst & 0xff00) >> 8) | ((dst & 0x00ff) << 8); + size = ((size & 0xff00) >> 8) | ((size & 0x00ff) << 8); + mode &= 0xff; - dat2 = ((dat2 & 0x00ff)<<8) | ((dat2 & 0xff00)>>8); + src >>= 1; - // mode==0 plain - if (mode==3) dat2 ^= extraxor; - if (mode==2) dat2 += extraxor; - if (mode==1) dat2 -= extraxor; + IGS022_do_dma(src,dst,size,mode); - sharedprotram[dst + x] = BURN_ENDIAN_SWAP_INT16(dat2); - } - - if ((mode==3) && (param==0x54) && (src*2==0x2120) && (dst*2==0x2600)) sharedprotram[0x2600 / 2] = BURN_ENDIAN_SWAP_INT16(0x4e75); // hack - } - break; - - case 5: // copy - { - for (INT32 x = 0; x < size; x++) { - sharedprotram[dst + x] = PROTROM[src + x]; - } - } - break; - - case 6: // swap bytes and nibbles - { - for (INT32 x = 0; x < size; x++) - { - UINT16 dat = PROTROM[src + x]; - - dat = ((dat & 0xf000) >> 12) | ((dat & 0x0f00) >> 4) | ((dat & 0x00f0) << 4) | ((dat & 0x000f) << 12); - - sharedprotram[dst + x] = dat; - } - } - break; - - case 4: // fixed value xor? - case 7: // params left in memory? nop? - default: // ? - break; - } + // there is also a version ID? (or is it some kind of checksum) that is stored in the data rom, and gets copied.. + // Dragon World 3 checks it + tmp = PROTROM[0x114/2]; + tmp = ((tmp & 0xff00) >> 8) | ((tmp & 0x00ff) << 8); + sharedprotram[0x2a2/2] = tmp; } -static void IGS022_handle_command() +void IGS022_handle_command() { - UINT16 cmd = BURN_ENDIAN_SWAP_INT16(sharedprotram[0x200/2]); + UINT16 cmd = sharedprotram[0x200/2]; - if (cmd == 0x6d) // Store values to asic ram + if (cmd == 0x6d) // Store values to asic ram { - UINT32 p1 = BURN_ENDIAN_SWAP_INT16((sharedprotram[0x298/2] << 16)) | BURN_ENDIAN_SWAP_INT16(sharedprotram[0x29a/2]); - UINT32 p2 = BURN_ENDIAN_SWAP_INT16((sharedprotram[0x29c/2] << 16)) | BURN_ENDIAN_SWAP_INT16(sharedprotram[0x29e/2]); + UINT32 p1 = (sharedprotram[0x298/2] << 16) | sharedprotram[0x29a/2]; + UINT32 p2 = (sharedprotram[0x29c/2] << 16) | sharedprotram[0x29e/2]; - if ((p2 & 0xffff) == 0x9) // Set value + if ((p2 & 0xffff) == 0x9) // Set value { - INT32 reg = (p2 >> 16) & 0xffff; - if (reg & 0x200) kb_regs[reg & 0xff] = p1; + int reg = (p2 >> 16) & 0xffff; + + if (reg & 0x200) + m_kb_regs[reg & 0xff] = p1; } - if ((p2 & 0xffff) == 0x6) // Add value + + if ((p2 & 0xffff) == 0x6) // Add value { - INT32 src1 = (p1 >> 16) & 0x00ff; - INT32 src2 = (p1 >> 0) & 0x00ff; - INT32 dst = (p2 >> 16) & 0x00ff; - kb_regs[dst] = kb_regs[src2] - kb_regs[src1]; + int src1 = (p1 >> 16) & 0xff; + int src2 = (p1 >> 0) & 0xff; + int dst = (p2 >> 16) & 0xff; + + m_kb_regs[dst] = m_kb_regs[src2] - m_kb_regs[src1]; } - if ((p2 & 0xffff) == 0x1) // Add Imm? + + if ((p2 & 0xffff) == 0x1) // Add Imm? { - INT32 reg = (p2 >> 16) & 0x00ff; - INT32 imm = (p1 >> 0) & 0xffff; - kb_regs[reg] += imm; + int reg = (p2 >> 16) & 0xff; + int imm = (p1 >> 0) & 0xffff; + + m_kb_regs[reg] += imm; } - if ((p2 & 0xffff) == 0xa) // Get value + + if ((p2 & 0xffff) == 0xa) // Get value { - INT32 reg = (p1 >> 16) & 0x00ff; - sharedprotram[0x29c/2] = BURN_ENDIAN_SWAP_INT16((kb_regs[reg] >> 16) & 0xffff); - sharedprotram[0x29e/2] = BURN_ENDIAN_SWAP_INT16((kb_regs[reg] >> 0) & 0xffff); + int reg = (p1 >> 16) & 0xFF; + + sharedprotram[0x29c/2] = (m_kb_regs[reg] >> 16) & 0xffff; + sharedprotram[0x29e/2] = m_kb_regs[reg] & 0xffff; } } - if (cmd == 0x4f) // memcpy with encryption / scrambling + if(cmd == 0x4f) //memcpy with encryption / scrambling { - UINT16 src = BURN_ENDIAN_SWAP_INT16(sharedprotram[0x290 / 2]) >> 1; // ? - UINT16 dst = BURN_ENDIAN_SWAP_INT16(sharedprotram[0x292 / 2]); - UINT16 size = BURN_ENDIAN_SWAP_INT16(sharedprotram[0x294 / 2]); - UINT16 mode = BURN_ENDIAN_SWAP_INT16(sharedprotram[0x296 / 2]); + UINT16 src = sharedprotram[0x290 / 2] >> 1; // ? + UINT32 dst = sharedprotram[0x292 / 2]; + UINT16 size = sharedprotram[0x294 / 2]; + UINT16 mode = sharedprotram[0x296 / 2]; - IGS022_do_dma(src, dst, size, mode); + IGS022_do_dma(src,dst,size,mode); } } -static void killbld_igs025_prot_write(UINT32 offset, UINT16 data) +void killbld_protection_calculate_hold(int y, int z) +{ + unsigned short old = m_kb_prot_hold; + + m_kb_prot_hold = ((old << 1) | (old >> 15)); + + m_kb_prot_hold ^= 0x2bad; + m_kb_prot_hold ^= BIT(z, y); + m_kb_prot_hold ^= BIT( old, 7) << 0; + m_kb_prot_hold ^= BIT(~old, 13) << 4; + m_kb_prot_hold ^= BIT( old, 3) << 11; + + m_kb_prot_hold ^= (m_kb_prot_hilo & ~0x0408) << 1; +} + +void killbld_protection_calculate_hilo() +{ + UINT8 source; + + m_kb_prot_hilo_select++; + + if (m_kb_prot_hilo_select > 0xeb) { + m_kb_prot_hilo_select = 0; + } + + source = m_kb_source_data[(PgmInput[7] - m_kb_source_data_offset)][m_kb_prot_hilo_select]; + + if (m_kb_prot_hilo_select & 1) + { + m_kb_prot_hilo = (m_kb_prot_hilo & 0x00ff) | (source << 8); + } + else + { + m_kb_prot_hilo = (m_kb_prot_hilo & 0xff00) | (source << 0); + } +} + +static void __fastcall killbld_igs025_prot_w(UINT32 offset, UINT16 data) { offset &= 0xf; - if (offset == 0) { - kb_cmd = data; - return; - } - - switch (kb_cmd) + if (offset == 0) { - case 0: - kb_reg = data; - break; - - case 2: - if (data == 1) { - IGS022_handle_command(); - kb_reg++; - } - break; - - case 4: - kb_ptr = data; - break; - - case 0x20: - kb_ptr++; - break; - - default: + m_kb_cmd = data; + } + else + { + switch (m_kb_cmd) + { + case 0x00: + m_kb_reg = data; break; + + //case 0x01: // ?? + //break; + + case 0x02: + { + if (data == 0x0001) { // Execute cmd + IGS022_handle_command(); + m_kb_reg++; + } + } + break; + + case 0x03: + m_kb_swap = data; + break; + + case 0x04: + m_kb_ptr = data; + break; + + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + m_kb_ptr++; + killbld_protection_calculate_hold(m_kb_cmd & 0x0f, data & 0xff); + break; + } } } -static UINT16 killbld_igs025_prot_read(UINT32 offset) +static UINT16 __fastcall killbld_igs025_prot_r(UINT32 offset) { - offset &= 0xf; + offset &= 2; - if (offset == 1) + if (offset) { - if (kb_cmd == 1) + switch (m_kb_cmd) { - return (kb_reg & 0x7f); - } - else if (kb_cmd == 5) - { - UINT32 protvalue = 0x89911400 | PgmInput[7]; - return (protvalue >> (8 * (kb_ptr - 1))) & 0xff; + case 0x00: + return BITSWAP08((m_kb_swap+1)&0xff, 0,1,2,3,4,5,6,7); // dw3 + + case 0x01: + return m_kb_reg & 0x7f; + + case 0x05: + { + switch (m_kb_ptr) + { + case 1: + return 0x3f00 | PgmInput[7]; + + case 2: + return 0x3f00 | ((m_kb_game_id >> 8) & 0xff); + + case 3: + return 0x3f00 | ((m_kb_game_id >> 16) & 0xff); + + case 4: + return 0x3f00 | ((m_kb_game_id >> 24) & 0xff); + + case 5: + default: // >= 5 + return 0x3f00 | BITSWAP08(m_kb_prot_hold, 5,2,9,7,10,13,12,15); + } + + return 0; + } + + case 0x40: + killbld_protection_calculate_hilo(); + return 0; // is this used? } } return 0; } -static void __fastcall killbld_write_word(UINT32 address, UINT16 data) +static void killbld_reset() { - killbld_igs025_prot_write(address / 2, data); -} + /* fill the protection ram with a5 + auto dma */ + IGS022_reset(); -static UINT16 __fastcall killbld_read_word(UINT32 address) -{ - return killbld_igs025_prot_read(address / 2); -} + // Reset IGS025 stuff + m_kb_prot_hold = 0; + m_kb_prot_hilo = 0; + m_kb_prot_hilo_select = 0; + m_kb_cmd = 0; + m_kb_reg = 0; + m_kb_ptr = 0; + m_kb_swap = 0; -static void IGS022Reset() -{ - sharedprotram = (UINT16*)PGMUSER0; - UINT8 *USER1 = PGMUSER0 + 0x10000; - - if (strcmp(BurnDrvGetTextA(DRV_NAME), "killbld") == 0) { - BurnLoadRom(USER1, 11, 1); // load protection data - } else { - BurnLoadRom(USER1, 14, 1); // load protection data - } - - BurnByteswap(USER1, 0x10000); - - UINT16 *PROTROM = (UINT16*)USER1; - - for (INT32 i = 0; i < 0x4000/2; i++) - sharedprotram[i] = 0xa55a; - - UINT16 src = PROTROM[0x100 / 2]; - UINT16 dst = PROTROM[0x102 / 2]; - UINT16 size = PROTROM[0x104 / 2]; - UINT16 mode = PROTROM[0x106 / 2]; - UINT16 tmp = PROTROM[0x114 / 2]; - - src = (( src & 0xff00) >> 8) | (( src & 0x00ff) << 8); - dst = (( dst & 0xff00) >> 8) | (( dst & 0x00ff) << 8); - size = ((size & 0xff00) >> 8) | ((size & 0x00ff) << 8); - tmp = (( tmp & 0xff00) >> 8) | (( tmp & 0x00ff) << 8); - mode &= 0xff; - - src >>= 1; - - IGS022_do_dma(src, dst, size, mode); - - sharedprotram[0x2a2/2] = tmp; // crc check? - - kb_cmd = kb_reg = kb_ptr = 0; - memset (kb_regs, 0, 0x100 * sizeof(INT32)); + memset(m_kb_regs, 0, 0x10 * sizeof(UINT32)); } static INT32 killbldScan(INT32 nAction, INT32 *) @@ -1065,7 +1418,7 @@ static INT32 killbldScan(INT32 nAction, INT32 *) ba.szName = "ProtRAM"; BurnAcb(&ba); - ba.Data = (UINT8*)kb_regs; + ba.Data = (UINT8*)m_kb_regs; ba.nLen = 0x00100 * sizeof(INT32); ba.nAddress = 0xfffffc00; ba.szName = "Protection Registers"; @@ -1073,29 +1426,124 @@ static INT32 killbldScan(INT32 nAction, INT32 *) } if (nAction & ACB_DRIVER_DATA) { - SCAN_VAR(kb_cmd); - SCAN_VAR(kb_reg); - SCAN_VAR(kb_ptr); + SCAN_VAR(m_kb_prot_hold); + SCAN_VAR(m_kb_prot_hilo); + SCAN_VAR(m_kb_prot_hilo_select); + SCAN_VAR(m_kb_cmd); + SCAN_VAR(m_kb_reg); + SCAN_VAR(m_kb_ptr); + SCAN_VAR(m_kb_swap); } return 0; } + void install_protection_asic25_asic22_killbld() { + if (strcmp(BurnDrvGetTextA(DRV_NAME), "killbld") == 0) { + BurnLoadRom(PGMUSER0 + 0x10000, 11, 1); + } else { + BurnLoadRom(PGMUSER0 + 0x10000, 14, 1); // killbld104 + } + + BurnByteswap(PGMUSER0 + 0x10000, 0x10000); + pPgmScanCallback = killbldScan; - pPgmResetCallback = IGS022Reset; + pPgmResetCallback = killbld_reset; sharedprotram = (UINT16*)PGMUSER0; + m_kb_source_data = killbld_source_data; + m_kb_source_data_offset = 0x16; + m_kb_game_id = 0x89911400; + SekOpen(0); SekMapMemory(PGMUSER0, 0x300000, 0x303fff, SM_RAM); SekMapHandler(4, 0xd40000, 0xd40003, SM_READ | SM_WRITE); - SekSetReadWordHandler(4, killbld_read_word); - SekSetWriteWordHandler(4, killbld_write_word); + SekSetReadWordHandler(4, killbld_igs025_prot_r); + SekSetWriteWordHandler(4, killbld_igs025_prot_w); SekClose(); } + +static void drgw3_reset() +{ + /* fill the protection ram with a5 + auto dma */ + IGS022_reset(); + + /* game won't boot unless various values are in protection RAM + - these should almost certainly end up there as the result of executing the protection + commands are startup, but which, and how? */ + + sharedprotram[0x200/2] = 0x006d; + sharedprotram[0x202/2] = 0x007c; // it cares about this, operation status flag? + + sharedprotram[0x20c/2] = 0x0000; + sharedprotram[0x20e/2] = 0x0007; + sharedprotram[0x210/2] = 0x0000; + sharedprotram[0x212/2] = 0x0004; + sharedprotram[0x214/2] = 0x0000; + sharedprotram[0x216/2] = 0x0007; + sharedprotram[0x218/2] = 0x0000; + sharedprotram[0x21a/2] = 0x0004; + + sharedprotram[0x288/2] = 0x0000; + sharedprotram[0x28a/2] = 0x00c2; + sharedprotram[0x28c/2] = 0x0000; + sharedprotram[0x28e/2] = 0x00c2; + sharedprotram[0x290/2] = 0x0500; + sharedprotram[0x292/2] = 0x1000; + sharedprotram[0x294/2] = 0x00c3; + sharedprotram[0x296/2] = 0x7104; + sharedprotram[0x298/2] = 0x0000; + sharedprotram[0x29a/2] = 0x0003; + sharedprotram[0x29c/2] = 0x0108; + sharedprotram[0x29e/2] = 0x0009; + + sharedprotram[0x2a2/2] = 0x84f6; // it cares about this, it's the version number of the data rom, copied automatically! + + sharedprotram[0x2ac/2] = 0x006d; + sharedprotram[0x2ae/2] = 0x0000; + + sharedprotram[0x2b0/2] = 0xaf56; + + // Reset IGS025 stuff + m_kb_prot_hold = 0; + m_kb_prot_hilo = 0; + m_kb_prot_hilo_select = 0; + m_kb_cmd = 0; + m_kb_reg = 0; + m_kb_ptr = 0; + m_kb_swap = 0; + memset(m_kb_regs, 0, 0x10 * sizeof(UINT32)); + +} + +void install_protection_asic25_asic22_drgw3() +{ + BurnLoadRom(PGMUSER0 + 0x10000, 7, 1); + BurnByteswap(PGMUSER0 + 0x10000, 0x10000); + + pPgmScanCallback = killbldScan; + pPgmResetCallback = drgw3_reset; + + sharedprotram = (UINT16*)PGMUSER0; + + m_kb_source_data = dw3_source_data; + m_kb_source_data_offset = 1; + m_kb_game_id = 0x00060000; + + SekOpen(0); + SekMapMemory(PGMUSER0, 0x300000, 0x303fff, SM_RAM); + SekMapHandler(4, 0xd40000, 0xd40003, SM_READ | SM_WRITE); + SekSetReadWordHandler(4, killbld_igs025_prot_r); + SekSetWriteWordHandler(4, killbld_igs025_prot_w); + SekClose(); +} + + + //------------------------------------------ // Common asic27a simulation functions @@ -1232,7 +1680,7 @@ static void ddp3_asic27a_sim_command(UINT8 command) case 0x99: // Reset? asic27a_sim_key = 0; - asic27a_sim_response = 0x880000; + asic27a_sim_response = 0x880000 | (PgmInput[7] << 8); break; default: @@ -1344,7 +1792,7 @@ static void oldsplus_asic27a_sim_command(UINT8 command) { case 0x88: // Reset? asic27a_sim_key = 0; - asic27a_sim_response = 0x990000; + asic27a_sim_response = 0x990000 | (PgmInput[7] << 8); break; case 0xa0: @@ -1538,7 +1986,7 @@ static void kov_asic27a_sim_command(UINT8 command) case 0x99: // Reset asic27a_sim_key = 0; - asic27a_sim_response = 0x880000; + asic27a_sim_response = 0x880000 | (PgmInput[7] << 8); break; case 0x9d: // Sprite palette offset @@ -1744,7 +2192,7 @@ static void puzlstar_asic27a_sim_command(UINT8 command) { case 0x99: // Reset? asic27a_sim_key = 0; - asic27a_sim_response = 0x890000; + asic27a_sim_response = 0x890000 | (PgmInput[7] << 8); break; case 0xb1: @@ -1861,77 +2309,317 @@ void install_protection_asic27a_puzlstar() //-------------------- // puzzli2 +static int stage; +static int tableoffs; +static int tableoffs2; +static int entries_left; +static int currentcolumn; +static int currentrow; +static int num_entries; +static int full_entry; +static int prev_tablloc; +static int numbercolumns; +static int depth; +static UINT16 m_row_bitmask; +static int hackcount; +static int hackcount2; +static int hack_47_value; +static int hack_31_table_offset; +static int p2_31_retcounter; +static int command_31_write_type; +static UINT16 level_structure[8][10]; + +static const UINT8 puzzli2_level_decode[256] = { + 0x32, 0x3e, 0xb2, 0x37, 0x31, 0x22, 0xd6, 0x0d, 0x35, 0x5c, 0x8d, 0x3c, 0x7a, 0x5f, 0xd7, 0xac, // 0x0 + 0x53, 0xff, 0xeb, 0x44, 0xe8, 0x11, 0x69, 0x77, 0xd9, 0x34, 0x36, 0x45, 0xa6, 0xe9, 0x1c, 0xc6, // 0x1 + 0x3b, 0xbd, 0xad, 0x2e, 0x18, 0xdf, 0xa1, 0xab, 0xdd, 0x52, 0x57, 0xc2, 0xe5, 0x0a, 0x00, 0x6d, // 0x2 + 0x67, 0x64, 0x15, 0x70, 0xb6, 0x39, 0x27, 0x78, 0x82, 0xd2, 0x71, 0xb9, 0x13, 0xf5, 0x93, 0x92, // 0x3 + 0xfa, 0xe7, 0x5e, 0xb0, 0xf6, 0xaf, 0x95, 0x8a, 0x7c, 0x73, 0xf9, 0x63, 0x86, 0xcb, 0x1a, 0x56, // 0x4 + 0xf1, 0x3a, 0xae, 0x61, 0x01, 0x29, 0x97, 0x23, 0x8e, 0x5d, 0x9a, 0x65, 0x74, 0x21, 0x20, 0x40, // 0x5 + 0xd3, 0x05, 0xa2, 0xe1, 0xbc, 0x9e, 0x1e, 0x10, 0x14, 0x0c, 0x88, 0x9c, 0xec, 0x38, 0xb5, 0x9d, // 0x6 + 0x2d, 0xf7, 0x17, 0x0e, 0x84, 0xc7, 0x7d, 0xce, 0x94, 0x16, 0x48, 0xa8, 0x81, 0x6e, 0x7b, 0xd8, // 0x7 + 0xa7, 0x7f, 0x42, 0xe6, 0xa0, 0x2a, 0xef, 0xee, 0x24, 0xba, 0xb8, 0x7e, 0xc9, 0x2b, 0x90, 0xcc, // 0x8 + 0x5b, 0xd1, 0xf3, 0xe2, 0x6f, 0xed, 0x9f, 0xf0, 0x4b, 0x54, 0x8c, 0x08, 0xf8, 0x51, 0x68, 0xc8, // 0x9 + 0x03, 0x0b, 0xbb, 0xc1, 0xe3, 0x4d, 0x04, 0xc5, 0x8f, 0x09, 0x0f, 0xbf, 0x62, 0x49, 0x76, 0x59, // 0xa + 0x1d, 0x80, 0xde, 0x60, 0x07, 0xe0, 0x1b, 0x66, 0xa5, 0xbe, 0xcd, 0x87, 0xdc, 0xc3, 0x6b, 0x4e, // 0xb + 0xd0, 0xfd, 0xd4, 0x3f, 0x98, 0x96, 0x2f, 0x4c, 0xb3, 0xea, 0x2c, 0x75, 0xe4, 0xc0, 0x6c, 0x6a, // 0xc + 0x9b, 0xb7, 0x43, 0x8b, 0x41, 0x47, 0x02, 0xdb, 0x99, 0x3d, 0xa3, 0x79, 0x50, 0x4f, 0xb4, 0x55, // 0xd + 0x5a, 0x25, 0xf4, 0xca, 0x58, 0x30, 0xc4, 0x12, 0xa9, 0x46, 0xda, 0x91, 0xa4, 0xaa, 0xfc, 0x85, // 0xe + 0xfb, 0x89, 0x06, 0xcf, 0xfe, 0x33, 0xd5, 0x28, 0x1f, 0x19, 0x4a, 0xb1, 0x83, 0xf2, 0x72, 0x26, // 0xf +}; + +static int get_position_of_bit(UINT16 value, int bit_wanted) +{ + int count = 0; + for (int i=0;i<16;i++) + { + int bit = (value >> i) & 1; + + if (bit) count++; + + if (count==(bit_wanted+1)) + return i; + } + + return -1; +} + +static int puzzli2_take_leveldata_value(UINT8 datvalue) +{ + if (stage==-1) + { + tableoffs = 0; + tableoffs2 = 0; + entries_left = 0; + currentcolumn = 0; + currentrow = 0; + num_entries = 0; + full_entry = 0; + prev_tablloc = 0; + numbercolumns = 0; + depth = 0; + m_row_bitmask = 0; + + tableoffs = datvalue; + tableoffs2 = 0; + stage = 0; + } + else + { + UINT8 rawvalue = datvalue; + UINT8 tableloc = (tableoffs+tableoffs2)&0xff; + rawvalue ^= puzzli2_level_decode[tableloc]; + + tableoffs2++; + tableoffs2&=0xf; + + if (stage==0) + { + stage = 1; + depth = (rawvalue & 0xf0); + numbercolumns = (rawvalue & 0x0f); + numbercolumns++; + } + else if (stage==1) + { + stage = 2; + entries_left = (rawvalue >> 4); + m_row_bitmask = (rawvalue & 0x0f)<<8; + full_entry = rawvalue; + prev_tablloc = tableloc; + num_entries = entries_left; + } + else if (stage==2) + { + stage = 3; + m_row_bitmask |= rawvalue; + + if (entries_left == 0) + { + stage = 1; + currentcolumn++; + currentrow = 0; + m_row_bitmask = 0; + + if (currentcolumn==numbercolumns) + { + return 1; + } + } + else + { + int num = (1 << ((num > 8) ? 8 : num)) - 1; + } + } + else if (stage==3) + { + UINT16 object_value; + + if (rawvalue<=0x10) object_value = 0x0100 + rawvalue; + else if (rawvalue<=0x21) object_value = 0x0120 + (rawvalue - 0x11); + else if (rawvalue<=0x32) object_value = 0x0140 + (rawvalue - 0x22); + else if (rawvalue<=0x43) object_value = 0x0180 + (rawvalue - 0x33); + else if (rawvalue==0xd0) object_value = 0x0200; + else if (rawvalue==0xe0) object_value = 0x8000; + else if (rawvalue==0xe1) object_value = 0x8020; // solid slant top down + else if (rawvalue==0xe2) object_value = 0x8040; // solid slant top up + else if (rawvalue==0xe3) object_value = 0x8060; + else if (rawvalue==0xe4) object_value = 0x8080; // sold slant bottom up + else object_value = 0x0110; + + int realrow = get_position_of_bit(m_row_bitmask, currentrow); + + if (realrow != -1) + level_structure[currentcolumn][realrow] = object_value; + + currentrow++; + + entries_left--; + if (entries_left == 0) + { + stage = 1; + currentcolumn++; + currentrow = 0; + m_row_bitmask = 0; + + if (currentcolumn==numbercolumns) + { + return 1; + } + } + } + } + + return 0; +} + static void puzzli2_asic27a_sim_command(UINT8 command) { switch (command) { - case 0x13: // ASIC status? - asic27a_sim_response = 0x74<<16; // 2d or 74! (based on?) - break; - case 0x31: { - // how is this selected? command 54? + if (command_31_write_type==2) + { + if (hackcount2==0) + { + puzzli2_take_leveldata_value(asic27a_sim_value&0xff); - // just a wild guess - if (asic27a_sim_regs[0x54]) { - // pc == 1387de - asic27a_sim_response = 0x63<<16; // ? - } else { - // pc == 14cf58 - asic27a_sim_response = 0xd2<<16; + hack_31_table_offset = asic27a_sim_value & 0xff; + hackcount2++; + asic27a_sim_response = 0x00d20000; + } + else + { + int end = puzzli2_take_leveldata_value(asic27a_sim_value&0xff); + + if (!end) + { + asic27a_sim_response = 0x00d20000; + hackcount2++; + } + else + { + hackcount2=0; + asic27a_sim_response = 0x00630000 | numbercolumns; + } + } + } + else + { + asic27a_sim_response = 0x00d20000 | p2_31_retcounter; + p2_31_retcounter++; + } + } + break; + + case 0x13: + { + UINT16* leveldata = &level_structure[0][0]; + if (hackcount==0) + { + asic27a_sim_response = 0x002d0000 | ((depth>>4)+1); + } + else if (hackcount<((10*numbercolumns)+1)) + { + asic27a_sim_response = 0x002d0000 | leveldata[hackcount-1]; + } + else + { + hackcount=0; + asic27a_sim_response = 0x00740054; } - asic27a_sim_regs[0x54] = 0; + hackcount++; } break; case 0x38: // Reset - asic27a_sim_response = 0x78<<16; - asic27a_sim_key = 0; - asic27a_sim_regs[0x54] = 0; - break; - - case 0x41: // ASIC status? - asic27a_sim_response = 0x74<<16; - break; - - case 0x47: // ASIC status? - asic27a_sim_response = 0x74<<16; - break; - - case 0x52: // ASIC status? { - // how is this selected? + asic27a_sim_response = 0x780000 | (PgmInput[7] << 8); + asic27a_sim_key = 0x100; + } + break; - //if (kov_value == 6) { - asic27a_sim_response = (0x74<<16)|1; // |1? - //} else { - // asic27a_sim_response = 0x74<<16; - //} + case 0x47: + hack_47_value = asic27a_sim_value; + asic27a_sim_response = 0x00740047; + break; + + case 0x52: + { + int val = ((hack_47_value & 0x0f00)>>8) * 0x19; + if (asic27a_sim_value!=0x0000) + { + val +=((hack_47_value & 0x000f)>>0) * 0x05; + } + val += asic27a_sim_value & 0x000f; + asic27a_sim_response = 0x00740000 | (val & 0xffff); } break; + case 0x61: + command_31_write_type = 1; + asic27a_sim_response = 0x360000; + p2_31_retcounter = 0xc; + break; + + case 0x41: // ASIC status? + command_31_write_type = 0; + asic27a_sim_response = 0x740061; + break; + case 0x54: // ?? - asic27a_sim_regs[0x54] = 1; - asic27a_sim_response = 0x36<<16; + { + command_31_write_type = 2; + stage = -1; + hackcount2 = 0; + hackcount = 0; + asic27a_sim_response = 0x360000; + + // clear the return structure + for (int columns=0;columns<8;columns++) + for (int rows=0;rows<10;rows++) + level_structure[columns][rows] = 0x0000; + } break; - case 0x61: // ?? - asic27a_sim_response = 0x36<<16; + case 0x63: + { + UINT32 z80table[2][8] = { + { 0x1694a8, 0x16cfae, 0x16ebf2, 0x16faa8, 0x174416, 0x600000, 0x600000, 0x600000 }, // puzzli2 + { 0x19027a, 0x193D80, 0x1959c4, 0x19687a, 0x19b1e8, 0x600000, 0x600000, 0x600000 } // puzzli2s + }; + + if (!strcmp(BurnDrvGetTextA(DRV_NAME),"puzzli2")) + { + asic27a_sim_response = z80table[0][asic27a_sim_value & 7]; + } + else {// puzzli2 super + asic27a_sim_response = z80table[1][asic27a_sim_value & 7]; + } + } break; - case 0x63: // probably read from a data table? - asic27a_sim_response = 0; // wrong... - break; + case 0x67: + { + UINT32 z80table[2][8] = { + { 0x166178, 0x166178, 0x166178, 0x166178, 0x166e72, 0x600000, 0x600000, 0x600000 }, // puzzli2 + { 0x18cf4a, 0x18cf4a, 0x18cf4a, 0x18cf4a, 0x18dc44, 0x600000, 0x600000, 0x600000 } // puzzli2s + }; - case 0x67: // probably read from a data table? - asic27a_sim_response = 0; + if (!strcmp(BurnDrvGetTextA(DRV_NAME),"puzzli2")) + { + asic27a_sim_response = z80table[0][asic27a_sim_value & 7]; + } + else {// puzzli2 super + asic27a_sim_response = z80table[1][asic27a_sim_value & 7]; + } + } break; default: - // bprintf (0, _T("ASIC Command %2.2x unknown!\n"), (data ^ asic27a_sim_key) & 0xff); - asic27a_sim_response = 0x74<<16; + asic27a_sim_response = 0x740000; break; } } @@ -1961,7 +2649,7 @@ static void py2k2_asic27a_sim_command(UINT8 command) { case 0x99: // Reset? asic27a_sim_key = 0x100; - asic27a_sim_response = 0x880000; + asic27a_sim_response = 0x880000 | (PgmInput[7] << 8); break; case 0x38: // ? @@ -2032,36 +2720,206 @@ void install_protection_asic27a_py2k2() //-------------------------- // drgw2 -#define DW2BITSWAP(s,d,bs,bd) d=((d&(~(1<>bs)&1)<>8)|(d<<8); - DW2BITSWAP(d,d2,7 ,0); - DW2BITSWAP(d,d2,4 ,1); - DW2BITSWAP(d,d2,5 ,2); - DW2BITSWAP(d,d2,2 ,3); - DW2BITSWAP(d,d2,15,4); - DW2BITSWAP(d,d2,1 ,5); - DW2BITSWAP(d,d2,10,6); - DW2BITSWAP(d,d2,13,7); +static void drgw2_protection_calculate_hold(int y, int z) +{ + unsigned short old = m_drgw2_prot_hold; - // ... missing bitswaps here (8-15) there is not enough data to know them - // the code only checks the lowest 8 bits + m_drgw2_prot_hold = ((old << 1) | (old >> 15)); - return d2; + m_drgw2_prot_hold ^= 0x2bad; + m_drgw2_prot_hold ^= BIT(z, y); + m_drgw2_prot_hold ^= BIT( old, 7) << 0; + m_drgw2_prot_hold ^= BIT(~old, 13) << 4; + m_drgw2_prot_hold ^= BIT( old, 3) << 11; + + m_drgw2_prot_hold ^= (m_drgw2_prot_hilo & ~0x0408) << 1; +} + +static void drgw2_protection_calculate_hilo() +{ + UINT8 source; + + m_drgw2_prot_hilo_select++; + if (m_drgw2_prot_hilo_select > 0xeb) { + m_drgw2_prot_hilo_select = 0; + } + + source = drgw2_source_data[m_drgw2_protection_region][m_drgw2_prot_hilo_select]; + + if (m_drgw2_prot_hilo_select & 1) + { + m_drgw2_prot_hilo = (m_drgw2_prot_hilo & 0x00ff) | (source << 8); + } + else + { + m_drgw2_prot_hilo = (m_drgw2_prot_hilo & 0xff00) | (source << 0); + } +} + +static UINT16 __fastcall drgw2_d80000_protection_r(UINT32 ) +{ + switch (m_drgw2_cmd) + { + case 0x05: + { + switch (m_drgw2_ptr) + { + case 1: return 0x3f00 | ((m_drgw2_protection_region >> 0) & 0xff); + + case 2: + return 0x3f00 | ((m_drgw2_protection_region >> 8) & 0xff); + + case 3: + return 0x3f00 | ((m_drgw2_protection_region >> 16) & 0xff); + + case 4: + return 0x3f00 | ((m_drgw2_protection_region >> 24) & 0xff); + + case 5: + default: + return 0x3f00 | BITSWAP08(m_drgw2_prot_hold, 5,2,9,7,10,13,12,15); + } + + return 0x3f00; + } + + case 0x40: + drgw2_protection_calculate_hilo(); + return 0; + } + + return 0; +} + +static void __fastcall drgw2_d80000_protection_w(UINT32 offset, UINT16 data) +{ + offset &= 2; + + if (offset == 0) + { + m_drgw2_cmd = data; + return; + } + + switch (m_drgw2_cmd) + { + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + m_drgw2_ptr++; + drgw2_protection_calculate_hold(m_drgw2_cmd & 0x0f, data & 0xff); + break; + } +} + +static INT32 dw2Scan(INT32 nAction, INT32 *) +{ + if (nAction & ACB_DRIVER_DATA) { + SCAN_VAR(m_drgw2_prot_hold); + SCAN_VAR(m_drgw2_prot_hilo); + SCAN_VAR(m_drgw2_prot_hilo_select); + SCAN_VAR(m_drgw2_ptr); + SCAN_VAR(m_drgw2_cmd); + } + + return 0; +} + +static void reset_asic25_asic12_dw2() +{ + m_drgw2_prot_hold = 0; + m_drgw2_prot_hilo = 0; + m_drgw2_prot_hilo_select = 0; + m_drgw2_ptr = 0; + m_drgw2_cmd = 0; } void install_protection_asic25_asic12_dw2() { + if (strcmp(BurnDrvGetTextA(DRV_NAME), "drgw2") == 0) m_drgw2_protection_region = 6; + if (strcmp(BurnDrvGetTextA(DRV_NAME), "dw2v100x") == 0) m_drgw2_protection_region = 6; + if (strcmp(BurnDrvGetTextA(DRV_NAME), "drgw2c") == 0) m_drgw2_protection_region = 5; + if (strcmp(BurnDrvGetTextA(DRV_NAME), "drgw2j") == 0) m_drgw2_protection_region = 1; + + pPgmScanCallback = dw2Scan; + pPgmResetCallback = reset_asic25_asic12_dw2; + SekOpen(0); - SekMapHandler(4, 0xd80000, 0xd80003, SM_READ); - SekSetReadWordHandler(4, dw2_read_word); + SekMapHandler(4, 0xd80000, 0xd80003, SM_READ | SM_WRITE); + SekSetReadWordHandler(4, drgw2_d80000_protection_r); + SekSetWriteWordHandler(4, drgw2_d80000_protection_w); SekClose(); } @@ -2069,57 +2927,156 @@ void install_protection_asic25_asic12_dw2() //------------------------- // olds -static INT32 rego; -static UINT16 olds_bs,olds_cmd3; +static int m_olds_cmd; +static int m_olds_reg; +static int m_olds_ptr; +static UINT16 m_olds_bs; +static UINT16 m_olds_cmd3; +static UINT16 m_olds_prot_hold; +static UINT16 m_olds_prot_hilo; +static UINT16 m_olds_prot_hilo_select; -static UINT32 olds_prot_addr( UINT16 addr ) +static const UINT8 olds_source_data[7][0xec] = // table addresses $2951CA { - UINT32 mode = addr & 0xff; - UINT32 offset = addr >> 8; - UINT32 realaddr; + { // region 1, $1A669A + 0x67, 0x51, 0xf3, 0x19, 0xa0, 0x11, 0xe1, 0x11, 0x10, 0xee, 0xe3, 0xf6, 0xbe, 0x81, 0x35, 0xe3, + 0xfb, 0xe6, 0xef, 0xdf, 0x61, 0x01, 0xfa, 0x22, 0x5d, 0x43, 0x01, 0xa5, 0x3b, 0x17, 0xd4, 0x74, + 0xf0, 0xf4, 0xf3, 0x43, 0xb5, 0x19, 0x04, 0xd5, 0x84, 0xce, 0x87, 0xfe, 0x35, 0x3e, 0xc4, 0x3c, + 0xc7, 0x85, 0x2a, 0x33, 0x00, 0x86, 0xd0, 0x4d, 0x65, 0x4b, 0xf9, 0xe9, 0xc0, 0xba, 0xaa, 0x77, + 0x9e, 0x66, 0xf6, 0x0f, 0x4f, 0x3a, 0xb6, 0xf1, 0x64, 0x9a, 0xe9, 0x25, 0x1a, 0x5f, 0x22, 0xa3, + 0xa2, 0xbf, 0x4b, 0x77, 0x3f, 0x34, 0xc9, 0x6e, 0xdb, 0x12, 0x5c, 0x33, 0xa5, 0x8b, 0x6c, 0xb1, + 0x74, 0xc8, 0x40, 0x4e, 0x2f, 0xe7, 0x46, 0xae, 0x99, 0xfc, 0xb0, 0x55, 0x54, 0xdf, 0xa7, 0xa1, + 0x0f, 0x5e, 0x49, 0xcf, 0x56, 0x3c, 0x90, 0x2b, 0xac, 0x65, 0x6e, 0xdb, 0x58, 0x3e, 0xc9, 0x00, + 0xae, 0x53, 0x4d, 0x92, 0xfa, 0x40, 0xb2, 0x6b, 0x65, 0x4b, 0x90, 0x8a, 0x0c, 0xe2, 0xa5, 0x9a, + 0xd0, 0x20, 0x29, 0x55, 0xa4, 0x44, 0xac, 0x51, 0x87, 0x54, 0x53, 0x34, 0x24, 0x4b, 0x81, 0x67, + 0x34, 0x4c, 0x5f, 0x31, 0x4e, 0xf2, 0xf1, 0x19, 0x18, 0x1c, 0x34, 0x38, 0xe1, 0x81, 0x17, 0xcf, + 0x24, 0xb9, 0x9a, 0xcb, 0x34, 0x51, 0x50, 0x59, 0x44, 0xb1, 0x0b, 0x50, 0x95, 0x6c, 0x48, 0x7e, + 0x14, 0xa4, 0xc6, 0xd9, 0xd3, 0xa5, 0xd6, 0xd0, 0xc5, 0x97, 0xf0, 0x45, 0xd0, 0x98, 0x51, 0x91, + 0x9f, 0xa3, 0x43, 0x51, 0x05, 0x90, 0xee, 0xca, 0x7e, 0x5f, 0x72, 0x53, 0xb1, 0xd3, 0xaf, 0x36, + 0x08, 0x75, 0xb0, 0x9b, 0xe0, 0x0d, 0x43, 0x88, 0xaa, 0x27, 0x44, 0x11 + }, + { // region 2, $19A5F8 + 0xf9, 0x19, 0xf3, 0x09, 0xa0, 0x11, 0xe0, 0x11, 0x10, 0x22, 0xfd, 0x8e, 0xd3, 0xc8, 0x31, 0x67, + 0xc0, 0x10, 0x3c, 0xc2, 0x03, 0xf2, 0x6a, 0x0a, 0x54, 0x49, 0xca, 0xb5, 0x4b, 0xe0, 0x94, 0xe8, + 0x8d, 0xc8, 0x90, 0xee, 0x6b, 0x6f, 0xfa, 0x09, 0x76, 0x84, 0x6f, 0x55, 0xd1, 0x94, 0xca, 0x9c, + 0xe1, 0x22, 0xc6, 0x02, 0xb5, 0x8c, 0xf9, 0x3a, 0x52, 0x10, 0xf0, 0x22, 0xe4, 0x11, 0x15, 0x73, + 0x5e, 0x9e, 0xde, 0xc4, 0x5a, 0xbd, 0xa3, 0x89, 0xe7, 0x9b, 0x95, 0x5d, 0x75, 0xf6, 0xc3, 0x9f, + 0xe4, 0xcf, 0x65, 0x73, 0x90, 0xd0, 0x75, 0x56, 0xfa, 0xcc, 0xe4, 0x3e, 0x9c, 0x41, 0x81, 0x62, + 0xb1, 0xd3, 0x28, 0xbd, 0x6c, 0xed, 0x60, 0x28, 0x27, 0xee, 0xf2, 0xa1, 0xb4, 0x2c, 0x6c, 0xbb, + 0x42, 0xd7, 0x1d, 0x62, 0xc0, 0x33, 0x7d, 0xf9, 0xe4, 0x5c, 0xe2, 0x41, 0xa4, 0x1c, 0x98, 0xa1, + 0x87, 0x95, 0xad, 0x61, 0x56, 0x96, 0x40, 0x08, 0x6b, 0xe2, 0x4b, 0x95, 0x7b, 0x1b, 0xd8, 0x64, + 0xb3, 0xee, 0x9d, 0x79, 0x69, 0xea, 0x5d, 0xcf, 0x01, 0x91, 0xea, 0x3f, 0x70, 0x29, 0xdc, 0xe0, + 0x08, 0x20, 0xbf, 0x46, 0x90, 0xa8, 0xfc, 0x29, 0x14, 0xd1, 0x0d, 0x20, 0x79, 0xd2, 0x2c, 0xe9, + 0x52, 0xa6, 0x8c, 0xbd, 0xa3, 0x3e, 0x88, 0x2d, 0xb8, 0x4e, 0xf2, 0x74, 0x50, 0xcc, 0x12, 0xde, + 0xd3, 0x5a, 0xa4, 0x7b, 0xa2, 0x8d, 0x91, 0x68, 0x12, 0x0c, 0x9c, 0xb9, 0x6d, 0x26, 0x66, 0x60, + 0xc3, 0x6d, 0xd0, 0x11, 0x33, 0x05, 0x1d, 0xa8, 0xb6, 0x51, 0xe6, 0xe0, 0x58, 0x61, 0x74, 0x37, + 0xcc, 0x3a, 0x4d, 0x6a, 0x0a, 0x09, 0x71, 0xe3, 0x7e, 0xa5, 0x3b, 0xe9 + }, + { // region 3, $1F9508 + 0x73, 0x59, 0xf3, 0x09, 0xa0, 0x11, 0xe1, 0x11, 0x10, 0x55, 0x18, 0x0d, 0xe8, 0x29, 0x2d, 0x04, + 0x85, 0x39, 0x88, 0xbe, 0x8b, 0xcb, 0xd9, 0x0b, 0x32, 0x36, 0x94, 0xac, 0x74, 0xc3, 0x3b, 0x5d, + 0x2a, 0x83, 0x46, 0xb3, 0x3a, 0xac, 0xd8, 0x55, 0x68, 0x21, 0x57, 0xab, 0x6e, 0xd1, 0xd0, 0xfc, + 0xe2, 0xbe, 0x63, 0xd0, 0x6b, 0x79, 0x23, 0x40, 0x58, 0xd4, 0xe7, 0x73, 0x22, 0x67, 0x7f, 0x88, + 0x05, 0xbd, 0xdf, 0x7a, 0x65, 0x41, 0x90, 0x3a, 0x52, 0x83, 0x28, 0xae, 0xe9, 0x8e, 0x65, 0x82, + 0x0e, 0xdf, 0x98, 0x88, 0xe1, 0x86, 0x21, 0x3e, 0x1a, 0x87, 0x6d, 0x62, 0x7a, 0xf6, 0xaf, 0x2c, + 0xd5, 0xc5, 0x10, 0x2d, 0xa9, 0xda, 0x93, 0xa1, 0x9b, 0xc7, 0x35, 0xd4, 0x15, 0x78, 0x18, 0xd5, + 0x75, 0x6a, 0xd7, 0xdb, 0x12, 0x2a, 0x6a, 0xc8, 0x36, 0x53, 0x57, 0xa6, 0xf0, 0x13, 0x67, 0x43, + 0x79, 0xf0, 0x0e, 0x49, 0xb1, 0xec, 0xcd, 0xa4, 0x8a, 0x61, 0x06, 0xb9, 0xea, 0x53, 0xf2, 0x47, + 0x7d, 0xd6, 0xf8, 0x9d, 0x2e, 0xaa, 0x27, 0x35, 0x61, 0xce, 0x9b, 0x63, 0xbc, 0x07, 0x51, 0x5a, + 0xc2, 0x0d, 0x39, 0x42, 0xd2, 0x5e, 0x21, 0x20, 0x10, 0xa0, 0xe5, 0x08, 0xf7, 0x3d, 0x28, 0x04, + 0x99, 0x93, 0x97, 0xaf, 0xf9, 0x12, 0xc0, 0x01, 0x2d, 0xea, 0xf3, 0x98, 0x0b, 0x46, 0xc2, 0x26, + 0x93, 0x10, 0x69, 0x1d, 0x71, 0x8e, 0x33, 0x00, 0x5e, 0x80, 0x2f, 0x47, 0x0a, 0xcc, 0x94, 0x16, + 0xe7, 0x37, 0x45, 0xd0, 0x61, 0x79, 0x32, 0x86, 0x08, 0x2a, 0x5b, 0x55, 0xfe, 0xee, 0x52, 0x38, + 0xaa, 0x18, 0xe9, 0x39, 0x1a, 0x1e, 0xb8, 0x26, 0x6b, 0x3d, 0x4b, 0xa9 + }, + { // region 4, $1CA7B8 + 0x06, 0x01, 0xf3, 0x39, 0xa0, 0x11, 0xf0, 0x11, 0x10, 0x6f, 0x32, 0x8b, 0xfd, 0x89, 0x29, 0xa0, + 0x4a, 0x62, 0xed, 0xa1, 0x2d, 0xa4, 0x49, 0xf2, 0x10, 0x3c, 0x77, 0xa3, 0x84, 0x8d, 0xfa, 0xd1, + 0xc6, 0x57, 0xe2, 0x78, 0xef, 0xe9, 0xb6, 0xa1, 0x5a, 0xbd, 0x3f, 0x02, 0x0b, 0x28, 0xd6, 0x76, + 0xfc, 0x5b, 0x19, 0x9f, 0x21, 0x66, 0x4c, 0x2d, 0x45, 0x99, 0xde, 0xab, 0x46, 0xbd, 0xe9, 0x84, + 0xc4, 0xdc, 0xc7, 0x30, 0x70, 0xdd, 0x64, 0xea, 0xbc, 0x6b, 0xd3, 0xe6, 0x45, 0x3f, 0x07, 0x7e, + 0x50, 0xef, 0xb2, 0x84, 0x33, 0x3c, 0xcc, 0x3f, 0x39, 0x5b, 0xf5, 0x6d, 0x71, 0xc5, 0xdd, 0xf5, + 0xf9, 0xd0, 0xf7, 0x9c, 0xe6, 0xc7, 0xad, 0x1b, 0x29, 0xb9, 0x90, 0x08, 0x75, 0xc4, 0xc3, 0xef, + 0xa8, 0xfc, 0xab, 0x55, 0x7c, 0x21, 0x57, 0x97, 0x87, 0x4a, 0xcb, 0x0c, 0x56, 0x0a, 0x4f, 0xcb, + 0x52, 0x33, 0x87, 0x31, 0xf3, 0x43, 0x5b, 0x41, 0x90, 0xf8, 0xc0, 0xdd, 0x5a, 0xa4, 0x26, 0x2a, + 0x60, 0xa5, 0x6d, 0xda, 0xf2, 0x6a, 0xf0, 0xb3, 0xda, 0x25, 0x33, 0x87, 0x22, 0xe4, 0xac, 0xd3, + 0x96, 0xe0, 0x99, 0x3e, 0xfb, 0x14, 0x45, 0x17, 0x25, 0x56, 0xbe, 0xef, 0x8f, 0x8e, 0x3d, 0x1e, + 0xc7, 0x99, 0xa2, 0xa1, 0x50, 0xfe, 0xdf, 0xd4, 0xa1, 0x87, 0xf4, 0xd5, 0xde, 0xa6, 0x8c, 0x6d, + 0x6c, 0xde, 0x47, 0xbe, 0x59, 0x8f, 0xd4, 0x97, 0xc3, 0xf4, 0xda, 0xbb, 0xa6, 0x73, 0xa9, 0xcb, + 0xf2, 0x01, 0xb9, 0x90, 0x8f, 0xed, 0x60, 0x64, 0x40, 0x1c, 0xb6, 0xc9, 0xa5, 0x7c, 0x17, 0x52, + 0x6f, 0xdc, 0x6d, 0x08, 0x2a, 0x1a, 0xe6, 0x68, 0x3f, 0xd4, 0x42, 0x69 + }, + { // region 5, $1A19FA + 0x7f, 0x41, 0xf3, 0x39, 0xa0, 0x11, 0xf1, 0x11, 0x10, 0xa2, 0x4c, 0x23, 0x13, 0xe9, 0x25, 0x3d, + 0x0f, 0x72, 0x3a, 0x9d, 0xb5, 0x96, 0xd1, 0xda, 0x07, 0x29, 0x41, 0x9a, 0xad, 0x70, 0xba, 0x46, + 0x63, 0x2b, 0x7f, 0x3d, 0xbe, 0x40, 0xad, 0xd4, 0x4c, 0x73, 0x27, 0x58, 0xa7, 0x65, 0xdc, 0xd6, + 0xfd, 0xde, 0xb5, 0x6e, 0xd6, 0x6c, 0x75, 0x1a, 0x32, 0x45, 0xd5, 0xe3, 0x6a, 0x14, 0x6d, 0x80, + 0x84, 0x15, 0xaf, 0xcc, 0x7b, 0x61, 0x51, 0x82, 0x40, 0x53, 0x7f, 0x38, 0xa0, 0xd6, 0x8f, 0x61, + 0x79, 0x19, 0xe5, 0x99, 0x84, 0xd8, 0x78, 0x27, 0x3f, 0x16, 0x97, 0x78, 0x4f, 0x7b, 0x0c, 0xa6, + 0x37, 0xdb, 0xc6, 0x0c, 0x24, 0xb4, 0xc7, 0x94, 0x9d, 0x92, 0xd2, 0x3b, 0xd5, 0x11, 0x6f, 0x0a, + 0xdb, 0x76, 0x66, 0xe7, 0xcd, 0x18, 0x2b, 0x66, 0xd8, 0x41, 0x40, 0x58, 0xa2, 0x01, 0x1e, 0x6d, + 0x44, 0x75, 0xe7, 0x19, 0x4f, 0xb2, 0xe8, 0xc4, 0x96, 0x77, 0x62, 0x02, 0xc9, 0xdc, 0x59, 0xf3, + 0x43, 0x8d, 0xc8, 0xfe, 0x9e, 0x2a, 0xba, 0x32, 0x3b, 0x62, 0xe3, 0x92, 0x6e, 0xc2, 0x08, 0x4d, + 0x51, 0xcd, 0xf9, 0x3a, 0x3e, 0xc9, 0x50, 0x27, 0x21, 0x25, 0x97, 0xd7, 0x0e, 0xf8, 0x39, 0x38, + 0xf5, 0x86, 0x94, 0x93, 0xbf, 0xeb, 0x18, 0xa8, 0xfc, 0x24, 0xf5, 0xf9, 0x99, 0x20, 0x3d, 0xcd, + 0x2c, 0x94, 0x25, 0x79, 0x28, 0x77, 0x8f, 0x2f, 0x10, 0x69, 0x86, 0x30, 0x43, 0x01, 0xd7, 0x9a, + 0x17, 0xe3, 0x47, 0x37, 0xbd, 0x62, 0x75, 0x42, 0x78, 0xf4, 0x2b, 0x57, 0x4c, 0x0a, 0xdb, 0x53, + 0x4d, 0xa1, 0x0a, 0xd6, 0x3a, 0x16, 0x15, 0xaa, 0x2c, 0x6c, 0x39, 0x42 + }, + { // region 6, $2937EA + 0x12, 0x09, 0xf3, 0x29, 0xa0, 0x11, 0xf0, 0x11, 0x10, 0xd5, 0x66, 0xa1, 0x28, 0x4a, 0x21, 0xc0, + 0xd3, 0x9b, 0x86, 0x80, 0x57, 0x6f, 0x41, 0xc2, 0xe4, 0x2f, 0x0b, 0x91, 0xbd, 0x3a, 0x7a, 0xba, + 0x00, 0xe5, 0x35, 0x02, 0x74, 0x7d, 0x8b, 0x21, 0x57, 0x10, 0x0f, 0xae, 0x44, 0xbb, 0xe2, 0x37, + 0x18, 0x7b, 0x52, 0x3d, 0x8c, 0x59, 0x9e, 0x20, 0x1f, 0x0a, 0xcc, 0x1c, 0x8e, 0x6a, 0xd7, 0x95, + 0x2b, 0x34, 0xb0, 0x82, 0x6d, 0xfd, 0x25, 0x33, 0xaa, 0x3b, 0x2b, 0x70, 0x15, 0x87, 0x31, 0x5d, + 0xbb, 0x29, 0x19, 0x95, 0xd5, 0x8e, 0x24, 0x28, 0x5e, 0xd0, 0x20, 0x83, 0x46, 0x4a, 0x21, 0x70, + 0x5b, 0xcd, 0xae, 0x7b, 0x61, 0xa1, 0xfa, 0xf4, 0x2b, 0x84, 0x15, 0x6e, 0x36, 0x5d, 0x1b, 0x24, + 0x0f, 0x09, 0x3a, 0x61, 0x38, 0x0f, 0x18, 0x35, 0x11, 0x38, 0xb4, 0xbd, 0xee, 0xf7, 0xec, 0x0f, + 0x1d, 0xb7, 0x48, 0x01, 0xaa, 0x09, 0x8f, 0x61, 0xb5, 0x0f, 0x1d, 0x26, 0x39, 0x2e, 0x8c, 0xd6, + 0x26, 0x5c, 0x3d, 0x23, 0x63, 0xe9, 0x6b, 0x97, 0xb4, 0x9f, 0x7b, 0xb6, 0xba, 0xa0, 0x7c, 0xc6, + 0x25, 0xa1, 0x73, 0x36, 0x67, 0x7f, 0x74, 0x1e, 0x1d, 0xda, 0x70, 0xbf, 0xa5, 0x63, 0x35, 0x39, + 0x24, 0x8c, 0x9f, 0x85, 0x16, 0xd8, 0x50, 0x95, 0x71, 0xc0, 0xf6, 0x1e, 0x6d, 0x80, 0xed, 0x15, + 0xeb, 0x63, 0xe9, 0x1b, 0xf6, 0x78, 0x31, 0xc6, 0x5c, 0xdd, 0x19, 0xbd, 0xdf, 0xa7, 0xec, 0x50, + 0x22, 0xad, 0xbb, 0xf6, 0xeb, 0xd6, 0xa3, 0x20, 0xc9, 0xe6, 0x9f, 0xcb, 0xf2, 0x97, 0xb9, 0x54, + 0x12, 0x66, 0xa6, 0xbe, 0x4a, 0x12, 0x43, 0xec, 0x00, 0xea, 0x49, 0x02 + }, + { // region 7, $255E8C + 0xa4, 0x49, 0xf3, 0x29, 0xa0, 0x11, 0xf1, 0x11, 0x10, 0xef, 0x80, 0x20, 0x3d, 0xaa, 0x36, 0x5d, + 0x98, 0xc4, 0xd2, 0x63, 0xdf, 0x61, 0xb0, 0xc3, 0xc2, 0x35, 0xd4, 0x88, 0xe6, 0x1d, 0x3a, 0x2f, + 0x9c, 0xb9, 0xd1, 0xc6, 0x43, 0xba, 0x69, 0x6d, 0x49, 0xac, 0xdd, 0x05, 0xe0, 0xf8, 0xe8, 0x97, + 0x19, 0x18, 0x08, 0x0c, 0x42, 0x46, 0xc7, 0x0d, 0x25, 0xce, 0xc3, 0x54, 0xb2, 0xd9, 0x42, 0x91, + 0xea, 0x53, 0x98, 0x38, 0x78, 0x81, 0x12, 0xca, 0x15, 0x23, 0xbd, 0xc1, 0x70, 0x1f, 0xd2, 0x40, + 0xfd, 0x39, 0x33, 0xaa, 0x27, 0x2b, 0xe8, 0x10, 0x7d, 0xa4, 0xa8, 0x8e, 0x3d, 0x00, 0x4f, 0x3a, + 0x7f, 0xd8, 0x96, 0xea, 0x9e, 0x8e, 0x15, 0x6e, 0x9f, 0x76, 0x57, 0xba, 0x7d, 0xc2, 0xdf, 0x57, + 0x42, 0x82, 0xf4, 0xda, 0x89, 0x06, 0x05, 0x04, 0x62, 0x2f, 0x29, 0x23, 0x54, 0xd5, 0xbb, 0x97, + 0xf5, 0xf9, 0xc1, 0xcf, 0xec, 0x5f, 0x1d, 0xfd, 0xbb, 0xa6, 0xd7, 0x4a, 0xa8, 0x66, 0xbf, 0xb9, + 0x09, 0x44, 0xb1, 0x60, 0x28, 0xa9, 0x35, 0x16, 0x15, 0xf5, 0x13, 0xc1, 0x07, 0x7e, 0xd7, 0x40, + 0xdf, 0x8e, 0xd3, 0x32, 0xa9, 0x35, 0x98, 0x15, 0x32, 0xa9, 0x49, 0xc0, 0x24, 0xb4, 0x4a, 0x53, + 0x6b, 0x79, 0xaa, 0x77, 0x6c, 0xc5, 0x88, 0x69, 0xe5, 0x5d, 0xde, 0x42, 0x28, 0xf9, 0xb7, 0x5c, + 0xab, 0x19, 0xc7, 0xbc, 0xc5, 0x60, 0xeb, 0x5e, 0xa8, 0x52, 0xc4, 0x32, 0x7c, 0x35, 0x02, 0x06, + 0x46, 0x77, 0x30, 0xb6, 0x33, 0x4b, 0xb8, 0xfd, 0x02, 0xd8, 0x14, 0x40, 0x99, 0x25, 0x7e, 0x55, + 0xd6, 0x44, 0x43, 0x8d, 0x73, 0x0e, 0x71, 0x48, 0xd3, 0x82, 0x40, 0xda + } +}; - switch(mode) +static UINT32 olds_prot_addr(UINT16 addr) +{ + switch (addr & 0xff) { case 0x0: case 0x5: - case 0xa: - realaddr = 0x402a00 + (offset << 2); - break; - + case 0xa: return 0x402a00 + ((addr >> 8) << 2); case 0x2: - case 0x8: - realaddr = 0x402e00 + (offset << 2); - break; - - case 0x1: - realaddr = 0x40307e; - break; - - case 0x3: - realaddr = 0x403090; - break; - - case 0x4: - realaddr = 0x40309a; - break; - - case 0x6: - realaddr = 0x4030a4; - break; - - case 0x7: - realaddr = 0x403000; - break; - - case 0x9: - realaddr = 0x40306e; - break; - - default: - realaddr = 0; + case 0x8: return 0x402e00 + ((addr >> 8) << 2); + case 0x1: return 0x40307e; + case 0x3: return 0x403090; + case 0x4: return 0x40309a; + case 0x6: return 0x4030a4; + case 0x7: return 0x403000; + case 0x9: return 0x40306e; } - return realaddr; + return 0; } static UINT32 olds_read_reg(UINT16 addr) @@ -2128,101 +3085,239 @@ static UINT32 olds_read_reg(UINT16 addr) return sharedprotram[protaddr] << 16 | sharedprotram[protaddr + 1]; } -static void olds_write_reg(UINT16 addr, UINT32 val) +static void olds_write_reg( UINT16 addr, UINT32 val ) { sharedprotram[(olds_prot_addr(addr) - 0x400000) / 2] = val >> 16; sharedprotram[(olds_prot_addr(addr) - 0x400000) / 2 + 1] = val & 0xffff; } -UINT16 __fastcall olds_protection_read(UINT32 address) +static void IGS028_do_dma(UINT16 src, UINT16 dst, UINT16 size, UINT16 mode) { - UINT16 res = 0; + UINT16 param = mode >> 8; + UINT16 *PROTROM = (UINT16*)(PGMUSER0 + 0x10000); - if (address & 2) + mode &= 0x0f; + + switch (mode) { - if (kb_cmd == 1) - res = kb_reg & 0x7f; - if (kb_cmd == 2) - res = olds_bs | 0x80; - if (kb_cmd == 3) - res = olds_cmd3; - else if (kb_cmd == 5) + case 0x00: // This mode copies code later on in the game! Encrypted somehow? + // src:2fc8, dst: 045a, size: 025e, mode: 0000 + // jumps from 12beb4 in unprotected set + // jumps from 1313e0 in protected set + case 0x01: // swap bytes and nibbles + case 0x02: // ^= encryption + case 0x05: // copy + case 0x06: // += encryption (correct?) { - UINT32 protvalue = 0x900000 | PgmInput[7]; // region from protection device. - res = (protvalue >> (8 * (kb_ptr - 1))) & 0xff; // includes region 1 = taiwan , 2 = china, 3 = japan (title = orlegend special), 4 = korea, 5 = hongkong, 6 = world + UINT8 extraoffset = param & 0xff; + UINT8 *dectable = (UINT8 *)(PROTROM + (0x100 / 2)); + for (INT32 x = 0; x < size; x++) + { + UINT16 dat2 = PROTROM[src + x]; + + int taboff = ((x*2)+extraoffset) & 0xff; // must allow for overflow in instances of odd offsets + unsigned short extraxor = ((dectable[taboff + 0]) << 0) | (dectable[taboff + 1] << 8); + + if (mode==0) dat2 = 0x4e75; // hack + if (mode==1) dat2 = ((dat2 & 0xf000) >> 12) | ((dat2 & 0x0f00) >> 4) | ((dat2 & 0x00f0) << 4) | ((dat2 & 0x000f) << 12); + if (mode==2) dat2 ^= extraxor; + //if (mode==5) dat2 = dat2; + if (mode==6) dat2 += extraxor; + + if (mode==2 || mode==6) dat2 = (dat2<<8)|(dat2>>8); + + sharedprotram[dst + x] = (dat2 << 8) | (dat2 >> 8); + } } } - - return res; } -void __fastcall olds_protection_write(UINT32 address, UINT16 data) +static void olds_protection_calculate_hold(int y, int z) // calculated in routine $12dbc2 in olds { - if ((address & 2) == 0) - kb_cmd = data; - else //offset==2 + unsigned short old = m_olds_prot_hold; + + m_olds_prot_hold = ((old << 1) | (old >> 15)); + + m_olds_prot_hold ^= 0x2bad; + m_olds_prot_hold ^= BIT(z, y); + m_olds_prot_hold ^= BIT( old, 7) << 0; + m_olds_prot_hold ^= BIT(~old, 13) << 4; + m_olds_prot_hold ^= BIT( old, 3) << 11; + + m_olds_prot_hold ^= (m_olds_prot_hilo & ~0x0408) << 1; // $81790c +} + +static void olds_protection_calculate_hilo() // calculated in routine $12dbc2 in olds +{ + UINT8 source; + + m_olds_prot_hilo_select++; + if (m_olds_prot_hilo_select > 0xeb) { + m_olds_prot_hilo_select = 0; + } + + source = olds_source_data[PgmInput[7] - 1][m_olds_prot_hilo_select]; + + if (m_olds_prot_hilo_select & 1) // $8178fa { - if (kb_cmd == 0) - kb_reg = data; - else if(kb_cmd == 2) //a bitswap= - { - INT32 reg = 0; - if (data & 0x01) reg |= 0x40; - if (data & 0x02) reg |= 0x80; - if (data & 0x04) reg |= 0x20; - if (data & 0x08) reg |= 0x10; - olds_bs = reg; - } - else if (kb_cmd == 3) - { - UINT16 cmd = sharedprotram[0x3026 / 2]; + m_olds_prot_hilo = (m_olds_prot_hilo & 0x00ff) | (source << 8); // $8178d8 + } + else + { + m_olds_prot_hilo = (m_olds_prot_hilo & 0xff00) | (source << 0); // $8178d8 + } +} - switch (cmd) +static void __fastcall olds_protection_w(UINT32 offset, UINT16 data) +{ + offset &= 2; + + if (offset == 0) + { + m_olds_cmd = data; + } + else + { + switch (m_olds_cmd) + { + case 0x00: + m_olds_reg = data; + break; + + case 0x02: + m_olds_bs = ((data & 0x03) << 6) | ((data & 0x04) << 3) | ((data & 0x08) << 1); + break; + + case 0x03: { - case 0x11: - case 0x12: - break; - case 0x64: - { - UINT16 cmd0 = sharedprotram[0x3082 / 2]; - UINT16 val0 = sharedprotram[0x3050 / 2]; //CMD_FORMAT - { - if ((cmd0 & 0xff) == 0x2) - olds_write_reg(val0, olds_read_reg(val0) + 0x10000); - } - break; - } + UINT16 cmd = sharedprotram[0x3026 / 2]; - default: - break; + switch (cmd) + { + case 0x12: + { + UINT16 mode = sharedprotram[0x303e / 2]; // ? + UINT16 src = sharedprotram[0x306a / 2] >> 1; // ? + UINT16 dst = sharedprotram[0x3084 / 2] & 0x1fff; + UINT16 size = sharedprotram[0x30a2 / 2] & 0x1fff; + + IGS028_do_dma(src, dst, size, mode); + } + break; + + case 0x64: // incomplete... + { + UINT16 p1 = sharedprotram[0x3050 / 2]; + UINT16 p2 = sharedprotram[0x3082 / 2]; + + if (p2 == 0x02) + olds_write_reg(p1, olds_read_reg(p1) + 0x10000); + } + break; + } + + m_olds_cmd3 = ((data >> 4) + 1) & 0x3; + } + break; + + case 0x04: + m_olds_ptr = data; + break; + + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + m_olds_ptr++; + olds_protection_calculate_hold(m_olds_cmd & 0x0f, data & 0xff); + break; + } + } +} + +static UINT16 __fastcall olds_protection_r(UINT32 offset) +{ + offset &= 2; + + if (offset) + { + switch (m_olds_cmd) + { + case 0x01: + return m_olds_reg & 0x7f; + + case 0x02: + return m_olds_bs | 0x80; + + case 0x03: + return m_olds_cmd3; + + case 0x05: + { + switch (m_olds_ptr) + { + case 1: return 0x3f00 | PgmInput[7]; + + case 2: + return 0x3f00 | 0x00; + + case 3: + return 0x3f00 | 0x90; + + case 4: + return 0x3f00 | 0x00; + + case 5: + default: // >= 5 + return 0x3f00 | BITSWAP08(m_olds_prot_hold, 5,2,9,7,10,13,12,15); // $817906 + } } - olds_cmd3 = ((data >> 4) + 1) & 0x3; + case 0x40: + olds_protection_calculate_hilo(); + return 0; // unused? } - else if (kb_cmd == 4) - kb_ptr = data; - else if(kb_cmd == 0x20) - kb_ptr++; } -} -static UINT16 __fastcall olds_mainram_read_word(UINT32 address) -{ - if (SekGetPC(-1) >= 0x100000 && address != 0x8178d8) SekWriteWord(0x8178f4, SekReadWord(0x8178D8)); - - return BURN_ENDIAN_SWAP_INT16(*((UINT16*)(PGM68KRAM + (address & 0x1fffe)))); -} - -static UINT8 __fastcall olds_mainram_read_byte(UINT32 address) -{ - return PGM68KRAM[(address & 0x1ffff)^1]; + return 0; } static void reset_olds() { - olds_bs = olds_cmd3 = kb_cmd = kb_ptr = rego = 0; - memcpy (PGMUSER0, PGMUSER0 + 0x10000, 0x04000); +// written by protection device +// there seems to be an auto-dma that writes from $401000-402573? + sharedprotram[0x1000/2] = 0x4749; // 'IGS.28' + sharedprotram[0x1002/2] = 0x2E53; + sharedprotram[0x1004/2] = 0x3832; + sharedprotram[0x3064/2] = 0xB315; // crc or status check? + +// Should these be written by command 64?? +// sharedprotram[0x2a00/2] = 0x0000; // ? +// sharedprotram[0x2a02/2] = 0x0000; // ? + sharedprotram[0x2a04/2] = 0x0002; // ? +// sharedprotram[0x2a06/2] = 0x0000; // ? +// sharedprotram[0x2ac0/2] = 0x0000; // ? + sharedprotram[0x2ac2/2] = 0x0001; // ? +// sharedprotram[0x2e00/2] = 0x0000; // ? +// sharedprotram[0x2e02/2] = 0x0000; // ? +// sharedprotram[0x2e04/2] = 0x0000; // ? + sharedprotram[0x2e06/2] = 0x0009; // seconds on char. select timer +// sharedprotram[0x2e08/2] = 0x0000; // ? + sharedprotram[0x2e0a/2] = 0x0006; // ? + + m_olds_prot_hold = 0; + m_olds_prot_hilo = 0; + m_olds_prot_hilo_select = 0; + m_olds_cmd = 0; + m_olds_reg = 0; + m_olds_ptr = 0; + m_olds_bs = 0; + m_olds_cmd3 = 0; } static INT32 oldsScan(INT32 nAction, INT32 *) @@ -2238,11 +3333,14 @@ static INT32 oldsScan(INT32 nAction, INT32 *) } if (nAction & ACB_DRIVER_DATA) { - SCAN_VAR(olds_cmd3); - SCAN_VAR(rego); - SCAN_VAR(olds_bs); - SCAN_VAR(kb_ptr); - SCAN_VAR(kb_cmd); + SCAN_VAR(m_olds_prot_hold); + SCAN_VAR(m_olds_prot_hilo); + SCAN_VAR(m_olds_prot_hilo_select); + SCAN_VAR(m_olds_cmd); + SCAN_VAR(m_olds_reg); + SCAN_VAR(m_olds_ptr); + SCAN_VAR(m_olds_bs); + SCAN_VAR(m_olds_cmd3); } return 0; @@ -2257,35 +3355,18 @@ void install_protection_asic25_asic28_olds() // no protection rom and different offset for olds100a if (strcmp(BurnDrvGetTextA(DRV_NAME), "olds100a") == 0) { - BurnLoadRom(PGMUSER0 + 0x10000, 16, 1); + BurnLoadRom(PGMUSER0 + 0x10000, 15, 1); } else { - BurnLoadRom(PGMUSER0 + 0x10000, 20, 1); - BurnLoadRom(PGMUSER0 + 0x20000, 19, 1); - BurnByteswap(PGMUSER0 + 0x20000, 0x10000); - - // copy in some 68k code from protection rom - memcpy (PGMUSER0 + 0x10200, PGMUSER0 + 0x20300, 0x6B4); - } - - { - UINT16 *gptr = (UINT16*)(PGMUSER0 + 0x10000); - - for(INT32 i = 0; i < 0x4000 / 2; i++) { - if (gptr[i] == (0xffff - i)) gptr[i] = BURN_ENDIAN_SWAP_INT16(0x4e75); - } + BurnLoadRom(PGMUSER0 + 0x10000, 19, 1); } SekOpen(0); SekMapMemory(PGMUSER0, 0x400000, 0x403fff, SM_RAM); - SekMapHandler(4, 0xdcb400, 0xdcb403, SM_READ | SM_WRITE); - SekSetReadWordHandler(4, olds_protection_read); - SekSetWriteWordHandler(4, olds_protection_write); - - SekMapHandler(5, 0x8178f4, 0x8178f5, SM_READ | SM_FETCH); - SekSetReadWordHandler(5, olds_mainram_read_word); - SekSetReadByteHandler(5, olds_mainram_read_byte); + SekMapHandler(4, 0xdcb400, 0xdcb403, SM_READ | SM_WRITE); + SekSetReadWordHandler(4, olds_protection_r); + SekSetWriteWordHandler(4, olds_protection_w); SekClose(); }