[pcsx_rearmed.git] / libpcsxcore / database.c

#include "misc.h"
#include "sio.h"
#include "ppf.h"
#include "new_dynarec/new_dynarec.h"
#include "lightrec/plugin.h"

/* It's duplicated from emu_if.c */
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

/* Corresponds to LIGHTREC_OPT_INV_DMA_ONLY of lightrec.h */
#define LIGHTREC_HACK_INV_DMA_ONLY (1 << 0)

u32 lightrec_hacks;

static const char * const MemorycardHack_db[] =
{
	/* Lifeforce Tenka, also known as Codename Tenka */
	"SLES00613", "SLED00690", "SLES00614", "SLES00615",
	"SLES00616", "SLES00617", "SCUS94409"
};

static const char * const cdr_read_hack_db[] =
{
	/* T'ai Fu - Wrath of the Tiger */
	"SLUS00787",
};

static const char * const gpu_slow_llist_db[] =
{
	/* Bomberman Fantasy Race */
	"SLES01712", "SLPS01525", "SLPS91138", "SLPM87102", "SLUS00823",
	/* Crash Bash */
	"SCES02834", "SCUS94570", "SCUS94616", "SCUS94654",
	/* Final Fantasy IV */
	"SCES03840", "SLPM86028", "SLUS01360",
	/* Spot Goes to Hollywood */
	"SLES00330", "SLPS00394", "SLUS00014",
	/* Vampire Hunter D */
	"SLES02731", "SLPS02477", "SLPS03198", "SLUS01138",
};

static const char * const gpu_busy_hack_db[] =
{
	/* ToHeart (Japan) */
	"SLPS01919", "SLPS01920",
};

static const char * const gpu_centering_hack_db[] =
{
	/* Gradius Gaiden */
	"SLPM86042", "SLPM86103", "SLPM87323",
	/* Sexy Parodius */
	"SLPM86009",
};

#define HACK_ENTRY(var, list) \
	{ #var, &Config.hacks.var, list, ARRAY_SIZE(list) }

static const struct
{
	const char *name;
	boolean *var;
	const char * const * id_list;
	size_t id_list_len;
}
hack_db[] =
{
	HACK_ENTRY(cdr_read_timing, cdr_read_hack_db),
	HACK_ENTRY(gpu_slow_list_walking, gpu_slow_llist_db),
	HACK_ENTRY(gpu_busy, gpu_busy_hack_db),
	HACK_ENTRY(gpu_centering, gpu_centering_hack_db),
};

static const struct
{
	int mult;
	const char * const id[4];
}
cycle_multiplier_overrides[] =
{
	/* note: values are = (10000 / gui_option) */
	/* Internal Section - fussy about timings */
	{ 202, { "SLPS01868" } },
	/* Super Robot Taisen Alpha - on the edge with 175,
	 * changing memcard settings is enough to break/unbreak it */
	{ 190, { "SLPS02528", "SLPS02636" } },
	/* Brave Fencer Musashi - cd sectors arrive too fast */
	{ 170, { "SLUS00726", "SLPS01490" } },
#if defined(DRC_DISABLE) || defined(LIGHTREC) /* new_dynarec has a hack for this game */
	/* Parasite Eve II - internal timer checks */
	{ 125, { "SLUS01042", "SLUS01055", "SLES02558", "SLES12558" } },
#endif
	/* Discworld Noir - audio skips if CPU runs too fast */
	{ 222, { "SLES01549", "SLES02063", "SLES02064" } },
	/* Judge Dredd - could also be poor MDEC timing */
	{ 128, { "SLUS00630", "SLES00755" } },
	/* Digimon World */
	{ 153, { "SLUS01032", "SLES02914" } },
	/* Syphon Filter - reportedly hangs under unknown conditions */
	{ 169, { "SCUS94240" } },
	/* Psychic Detective - some weird race condition in the game's cdrom code */
	{ 222, { "SLUS00165", "SLUS00166", "SLUS00167" } },
	{ 222, { "SLES00070", "SLES10070", "SLES20070" } },
};

static const struct
{
	const char * const id;
	u32 hacks;
}
lightrec_hacks_db[] =
{
	/* Formula One Arcade */
	{ "SCES03886", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One '99 */
	{ "SLUS00870", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCPS10101", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SLES01979", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One 2000 */
	{ "SLUS01134", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02777", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02778", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES02779", LIGHTREC_HACK_INV_DMA_ONLY },

	/* Formula One 2001 */
	{ "SCES03404", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03423", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03424", LIGHTREC_HACK_INV_DMA_ONLY },
	{ "SCES03524", LIGHTREC_HACK_INV_DMA_ONLY },
};

/* Function for automatic patching according to GameID. */
void Apply_Hacks_Cdrom(void)
{
	size_t i, j;

	memset(&Config.hacks, 0, sizeof(Config.hacks));

	for (i = 0; i < ARRAY_SIZE(hack_db); i++)
	{
		for (j = 0; j < hack_db[i].id_list_len; j++)
		{
			if (strncmp(CdromId, hack_db[i].id_list[j], 9))
				continue;
			*hack_db[i].var = 1;
			SysPrintf("using hack: %s\n", hack_db[i].name);
			break;
		}
	}

	/* Apply Memory card hack for Codename Tenka. (The game needs one of the memory card slots to be empty) */
	for (i = 0; i < ARRAY_SIZE(MemorycardHack_db); i++)
	{
		if (strncmp(CdromId, MemorycardHack_db[i], 9) == 0)
		{
			/* Disable the second memory card slot for the game */
			Config.Mcd2[0] = 0;
			/* This also needs to be done because in sio.c, they don't use Config.Mcd2 for that purpose */
			McdDisable[1] = 1;
			break;
		}
	}

	/* Dynarec game-specific hacks */
	new_dynarec_hacks_pergame = 0;
	Config.cycle_multiplier_override = 0;

	for (i = 0; i < ARRAY_SIZE(cycle_multiplier_overrides); i++)
	{
		const char * const * const ids = cycle_multiplier_overrides[i].id;
		for (j = 0; j < ARRAY_SIZE(cycle_multiplier_overrides[i].id); j++)
			if (ids[j] && strcmp(ids[j], CdromId) == 0)
				break;
		if (j < ARRAY_SIZE(cycle_multiplier_overrides[i].id))
		{
			Config.cycle_multiplier_override = cycle_multiplier_overrides[i].mult;
			new_dynarec_hacks_pergame |= NDHACK_OVERRIDE_CYCLE_M;
			SysPrintf("using cycle_multiplier_override: %d\n",
				Config.cycle_multiplier_override);
			break;
		}
	}

	lightrec_hacks = 0;

	for (i = 0; drc_is_lightrec() && i < ARRAY_SIZE(lightrec_hacks_db); i++) {
		if (strcmp(CdromId, lightrec_hacks_db[i].id) == 0)
		{
			lightrec_hacks = lightrec_hacks_db[i].hacks;
			SysPrintf("using lightrec_hacks: 0x%x\n", lightrec_hacks);
			break;
		}
	}
}

// from duckstation's gamedb.json
static const u16 libcrypt_ids[] = {
	   17,   311,   995,  1041,  1226,  1241,  1301,  1362,  1431,  1444,
	 1492,  1493,  1494,  1495,  1516,  1517,  1518,  1519,  1545,  1564,
	 1695,  1700,  1701,  1702,  1703,  1704,  1715,  1733,  1763,  1882,
	 1906,  1907,  1909,  1943,  1979,  2004,  2005,  2006,  2007,  2024,
	 2025,  2026,  2027,  2028,  2029,  2030,  2031,  2061,  2071,  2080,
	 2081,  2082,  2083,  2084,  2086,  2104,  2105,  2112,  2113,  2118,
	 2181,  2182,  2184,  2185,  2207,  2208,  2209,  2210,  2211,  2222,
	 2264,  2290,  2292,  2293,  2328,  2329,  2330,  2354,  2355,  2365,
	 2366,  2367,  2368,  2369,  2395,  2396,  2402,  2430,  2431,  2432,
	 2433,  2487,  2488,  2489,  2490,  2491,  2529,  2530,  2531,  2532,
	 2533,  2538,  2544,  2545,  2546,  2558,  2559,  2560,  2561,  2562,
	 2563,  2572,  2573,  2681,  2688,  2689,  2698,  2700,  2704,  2705,
	 2706,  2707,  2708,  2722,  2723,  2724,  2733,  2754,  2755,  2756,
	 2763,  2766,  2767,  2768,  2769,  2824,  2830,  2831,  2834,  2835,
	 2839,  2857,  2858,  2859,  2860,  2861,  2862,  2965,  2966,  2967,
	 2968,  2969,  2975,  2976,  2977,  2978,  2979,  3061,  3062,  3189,
	 3190,  3191,  3241,  3242,  3243,  3244,  3245,  3324,  3489,  3519,
	 3520,  3521,  3522,  3523,  3530,  3603,  3604,  3605,  3606,  3607,
	 3626,  3648, 12080, 12081, 12082, 12083, 12084, 12328, 12329, 12330,
	12558, 12559, 12560, 12561, 12562, 12965, 12966, 12967, 12968, 12969,
	22080, 22081, 22082, 22083, 22084, 22328, 22329, 22330, 22965, 22966,
	22967, 22968, 22969, 32080, 32081, 32082, 32083, 32084, 32965, 32966,
	32967, 32968, 32969
};

// as documented by nocash
static const u16 libcrypt_sectors[16] = {
	14105, 14231, 14485, 14579, 14649, 14899, 15056, 15130,
	15242, 15312, 15378, 15628, 15919, 16031, 16101, 16167
};

int check_unsatisfied_libcrypt(void)
{
	const char *p = CdromId + 4;
	u16 id, key = 0;
	size_t i;

	if (strncmp(CdromId, "SCE", 3) && strncmp(CdromId, "SLE", 3))
		return 0;
	while (*p == '0')
		p++;
	id = (u16)atoi(p);
	for (i = 0; i < ARRAY_SIZE(libcrypt_ids); i++)
		if (id == libcrypt_ids[i])
			break;
	if (i == ARRAY_SIZE(libcrypt_ids))
		return 0;

	// detected a protected game
	if (!CDR_getBufferSub(libcrypt_sectors[0]) && !sbi_sectors) {
		SysPrintf("==================================================\n");
		SysPrintf("LibCrypt game detected with missing SBI/subchannel\n");
		SysPrintf("==================================================\n");
		return 1;
	}

	if (sbi_sectors) {
		// calculate key just for fun (we don't really need it)
		for (i = 0; i < 16; i++)
			if (CheckSBI(libcrypt_sectors[i] - 2*75))
				key |= 1u << (15 - i);
	}
	if (key)
		SysPrintf("%s, possible key=%04X\n", "LibCrypt detected", key);
	else
		SysPrintf("%s\n", "LibCrypt detected");
	return 0;
}
Commit	Line	Data
	1	#include "misc.h"
	2	#include "sio.h"
	3	#include "ppf.h"
	4	#include "new_dynarec/new_dynarec.h"
	5	#include "lightrec/plugin.h"
	6
	7	/* It's duplicated from emu_if.c */
	8	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	9
	10	/* Corresponds to LIGHTREC_OPT_INV_DMA_ONLY of lightrec.h */
	11	#define LIGHTREC_HACK_INV_DMA_ONLY (1 << 0)
	12
	13	u32 lightrec_hacks;
	14
	15	static const char * const MemorycardHack_db[] =
	16	{
	17	/* Lifeforce Tenka, also known as Codename Tenka */
	18	"SLES00613", "SLED00690", "SLES00614", "SLES00615",
	19	"SLES00616", "SLES00617", "SCUS94409"
	20	};
	21
	22	static const char * const cdr_read_hack_db[] =
	23	{
	24	/* T'ai Fu - Wrath of the Tiger */
	25	"SLUS00787",
	26	};
	27
	28	static const char * const gpu_slow_llist_db[] =
	29	{
	30	/* Bomberman Fantasy Race */
	31	"SLES01712", "SLPS01525", "SLPS91138", "SLPM87102", "SLUS00823",
	32	/* Crash Bash */
	33	"SCES02834", "SCUS94570", "SCUS94616", "SCUS94654",
	34	/* Final Fantasy IV */
	35	"SCES03840", "SLPM86028", "SLUS01360",
	36	/* Spot Goes to Hollywood */
	37	"SLES00330", "SLPS00394", "SLUS00014",
	38	/* Vampire Hunter D */
	39	"SLES02731", "SLPS02477", "SLPS03198", "SLUS01138",
	40	};
	41
	42	static const char * const gpu_busy_hack_db[] =
	43	{
	44	/* ToHeart (Japan) */
	45	"SLPS01919", "SLPS01920",
	46	};
	47
	48	static const char * const gpu_centering_hack_db[] =
	49	{
	50	/* Gradius Gaiden */
	51	"SLPM86042", "SLPM86103", "SLPM87323",
	52	/* Sexy Parodius */
	53	"SLPM86009",
	54	};
	55
	56	#define HACK_ENTRY(var, list) \
	57	{ #var, &Config.hacks.var, list, ARRAY_SIZE(list) }
	58
	59	static const struct
	60	{
	61	const char *name;
	62	boolean *var;
	63	const char * const * id_list;
	64	size_t id_list_len;
	65	}
	66	hack_db[] =
	67	{
	68	HACK_ENTRY(cdr_read_timing, cdr_read_hack_db),
	69	HACK_ENTRY(gpu_slow_list_walking, gpu_slow_llist_db),
	70	HACK_ENTRY(gpu_busy, gpu_busy_hack_db),
	71	HACK_ENTRY(gpu_centering, gpu_centering_hack_db),
	72	};
	73
	74	static const struct
	75	{
	76	int mult;
	77	const char * const id[4];
	78	}
	79	cycle_multiplier_overrides[] =
	80	{
	81	/* note: values are = (10000 / gui_option) */
	82	/* Internal Section - fussy about timings */
	83	{ 202, { "SLPS01868" } },
	84	/* Super Robot Taisen Alpha - on the edge with 175,
	85	* changing memcard settings is enough to break/unbreak it */
	86	{ 190, { "SLPS02528", "SLPS02636" } },
	87	/* Brave Fencer Musashi - cd sectors arrive too fast */
	88	{ 170, { "SLUS00726", "SLPS01490" } },
	89	#if defined(DRC_DISABLE) \|\| defined(LIGHTREC) /* new_dynarec has a hack for this game */
	90	/* Parasite Eve II - internal timer checks */
	91	{ 125, { "SLUS01042", "SLUS01055", "SLES02558", "SLES12558" } },
	92	#endif
	93	/* Discworld Noir - audio skips if CPU runs too fast */
	94	{ 222, { "SLES01549", "SLES02063", "SLES02064" } },
	95	/* Judge Dredd - could also be poor MDEC timing */
	96	{ 128, { "SLUS00630", "SLES00755" } },
	97	/* Digimon World */
	98	{ 153, { "SLUS01032", "SLES02914" } },
	99	/* Syphon Filter - reportedly hangs under unknown conditions */
	100	{ 169, { "SCUS94240" } },
	101	/* Psychic Detective - some weird race condition in the game's cdrom code */
	102	{ 222, { "SLUS00165", "SLUS00166", "SLUS00167" } },
	103	{ 222, { "SLES00070", "SLES10070", "SLES20070" } },
	104	};
	105
	106	static const struct
	107	{
	108	const char * const id;
	109	u32 hacks;
	110	}
	111	lightrec_hacks_db[] =
	112	{
	113	/* Formula One Arcade */
	114	{ "SCES03886", LIGHTREC_HACK_INV_DMA_ONLY },
	115
	116	/* Formula One '99 */
	117	{ "SLUS00870", LIGHTREC_HACK_INV_DMA_ONLY },
	118	{ "SCPS10101", LIGHTREC_HACK_INV_DMA_ONLY },
	119	{ "SCES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	120	{ "SLES01979", LIGHTREC_HACK_INV_DMA_ONLY },
	121
	122	/* Formula One 2000 */
	123	{ "SLUS01134", LIGHTREC_HACK_INV_DMA_ONLY },
	124	{ "SCES02777", LIGHTREC_HACK_INV_DMA_ONLY },
	125	{ "SCES02778", LIGHTREC_HACK_INV_DMA_ONLY },
	126	{ "SCES02779", LIGHTREC_HACK_INV_DMA_ONLY },
	127
	128	/* Formula One 2001 */
	129	{ "SCES03404", LIGHTREC_HACK_INV_DMA_ONLY },
	130	{ "SCES03423", LIGHTREC_HACK_INV_DMA_ONLY },
	131	{ "SCES03424", LIGHTREC_HACK_INV_DMA_ONLY },
	132	{ "SCES03524", LIGHTREC_HACK_INV_DMA_ONLY },
	133	};
	134
	135	/* Function for automatic patching according to GameID. */
	136	void Apply_Hacks_Cdrom(void)
	137	{
	138	size_t i, j;
	139
	140	memset(&Config.hacks, 0, sizeof(Config.hacks));
	141
	142	for (i = 0; i < ARRAY_SIZE(hack_db); i++)
	143	{
	144	for (j = 0; j < hack_db[i].id_list_len; j++)
	145	{
	146	if (strncmp(CdromId, hack_db[i].id_list[j], 9))
	147	continue;
	148	*hack_db[i].var = 1;
	149	SysPrintf("using hack: %s\n", hack_db[i].name);
	150	break;
	151	}
	152	}
	153
	154	/* Apply Memory card hack for Codename Tenka. (The game needs one of the memory card slots to be empty) */
	155	for (i = 0; i < ARRAY_SIZE(MemorycardHack_db); i++)
	156	{
	157	if (strncmp(CdromId, MemorycardHack_db[i], 9) == 0)
	158	{
	159	/* Disable the second memory card slot for the game */
	160	Config.Mcd2[0] = 0;
	161	/* This also needs to be done because in sio.c, they don't use Config.Mcd2 for that purpose */
	162	McdDisable[1] = 1;
	163	break;
	164	}
	165	}
	166
	167	/* Dynarec game-specific hacks */
	168	new_dynarec_hacks_pergame = 0;
	169	Config.cycle_multiplier_override = 0;
	170
	171	for (i = 0; i < ARRAY_SIZE(cycle_multiplier_overrides); i++)
	172	{
	173	const char * const * const ids = cycle_multiplier_overrides[i].id;
	174	for (j = 0; j < ARRAY_SIZE(cycle_multiplier_overrides[i].id); j++)
	175	if (ids[j] && strcmp(ids[j], CdromId) == 0)
	176	break;
	177	if (j < ARRAY_SIZE(cycle_multiplier_overrides[i].id))
	178	{
	179	Config.cycle_multiplier_override = cycle_multiplier_overrides[i].mult;
	180	new_dynarec_hacks_pergame \|= NDHACK_OVERRIDE_CYCLE_M;
	181	SysPrintf("using cycle_multiplier_override: %d\n",
	182	Config.cycle_multiplier_override);
	183	break;
	184	}
	185	}
	186
	187	lightrec_hacks = 0;
	188
	189	for (i = 0; drc_is_lightrec() && i < ARRAY_SIZE(lightrec_hacks_db); i++) {
	190	if (strcmp(CdromId, lightrec_hacks_db[i].id) == 0)
	191	{
	192	lightrec_hacks = lightrec_hacks_db[i].hacks;
	193	SysPrintf("using lightrec_hacks: 0x%x\n", lightrec_hacks);
	194	break;
	195	}
	196	}
	197	}
	198
	199	// from duckstation's gamedb.json
	200	static const u16 libcrypt_ids[] = {
	201	17, 311, 995, 1041, 1226, 1241, 1301, 1362, 1431, 1444,
	202	1492, 1493, 1494, 1495, 1516, 1517, 1518, 1519, 1545, 1564,
	203	1695, 1700, 1701, 1702, 1703, 1704, 1715, 1733, 1763, 1882,
	204	1906, 1907, 1909, 1943, 1979, 2004, 2005, 2006, 2007, 2024,
	205	2025, 2026, 2027, 2028, 2029, 2030, 2031, 2061, 2071, 2080,
	206	2081, 2082, 2083, 2084, 2086, 2104, 2105, 2112, 2113, 2118,
	207	2181, 2182, 2184, 2185, 2207, 2208, 2209, 2210, 2211, 2222,
	208	2264, 2290, 2292, 2293, 2328, 2329, 2330, 2354, 2355, 2365,
	209	2366, 2367, 2368, 2369, 2395, 2396, 2402, 2430, 2431, 2432,
	210	2433, 2487, 2488, 2489, 2490, 2491, 2529, 2530, 2531, 2532,
	211	2533, 2538, 2544, 2545, 2546, 2558, 2559, 2560, 2561, 2562,
	212	2563, 2572, 2573, 2681, 2688, 2689, 2698, 2700, 2704, 2705,
	213	2706, 2707, 2708, 2722, 2723, 2724, 2733, 2754, 2755, 2756,
	214	2763, 2766, 2767, 2768, 2769, 2824, 2830, 2831, 2834, 2835,
	215	2839, 2857, 2858, 2859, 2860, 2861, 2862, 2965, 2966, 2967,
	216	2968, 2969, 2975, 2976, 2977, 2978, 2979, 3061, 3062, 3189,
	217	3190, 3191, 3241, 3242, 3243, 3244, 3245, 3324, 3489, 3519,
	218	3520, 3521, 3522, 3523, 3530, 3603, 3604, 3605, 3606, 3607,
	219	3626, 3648, 12080, 12081, 12082, 12083, 12084, 12328, 12329, 12330,
	220	12558, 12559, 12560, 12561, 12562, 12965, 12966, 12967, 12968, 12969,
	221	22080, 22081, 22082, 22083, 22084, 22328, 22329, 22330, 22965, 22966,
	222	22967, 22968, 22969, 32080, 32081, 32082, 32083, 32084, 32965, 32966,
	223	32967, 32968, 32969
	224	};
	225
	226	// as documented by nocash
	227	static const u16 libcrypt_sectors[16] = {
	228	14105, 14231, 14485, 14579, 14649, 14899, 15056, 15130,
	229	15242, 15312, 15378, 15628, 15919, 16031, 16101, 16167
	230	};
	231
	232	int check_unsatisfied_libcrypt(void)
	233	{
	234	const char *p = CdromId + 4;
	235	u16 id, key = 0;
	236	size_t i;
	237
	238	if (strncmp(CdromId, "SCE", 3) && strncmp(CdromId, "SLE", 3))
	239	return 0;
	240	while (*p == '0')
	241	p++;
	242	id = (u16)atoi(p);
	243	for (i = 0; i < ARRAY_SIZE(libcrypt_ids); i++)
	244	if (id == libcrypt_ids[i])
	245	break;
	246	if (i == ARRAY_SIZE(libcrypt_ids))
	247	return 0;
	248
	249	// detected a protected game
	250	if (!CDR_getBufferSub(libcrypt_sectors[0]) && !sbi_sectors) {
	251	SysPrintf("==================================================\n");
	252	SysPrintf("LibCrypt game detected with missing SBI/subchannel\n");
	253	SysPrintf("==================================================\n");
	254	return 1;
	255	}
	256
	257	if (sbi_sectors) {
	258	// calculate key just for fun (we don't really need it)
	259	for (i = 0; i < 16; i++)
	260	if (CheckSBI(libcrypt_sectors[i] - 2*75))
	261	key \|= 1u << (15 - i);
	262	}
	263	if (key)
	264	SysPrintf("%s, possible key=%04X\n", "LibCrypt detected", key);
	265	else
	266	SysPrintf("%s\n", "LibCrypt detected");
	267	return 0;
	268	}