[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",
};

#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_hack, gpu_busy_hack_db),
};

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

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