[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
630b122b	1	#include "misc.h"
630b122b	2	#include "sio.h"
cdee2d81	3	#include "ppf.h"
630b122b	4	#include "new_dynarec/new_dynarec.h"
8bccdd17	5	#include "lightrec/plugin.h"
630b122b	6
	7	/* It's duplicated from emu_if.c */
	8	#define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))
	9
8bccdd17 PC	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
d0d2939d	15	static const char * const MemorycardHack_db[] =
630b122b	16	{
630b122b	17	/* Lifeforce Tenka, also known as Codename Tenka */
d0d2939d	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
fae38d7a	28	static const char * const gpu_slow_llist_db[] =
fae38d7a	29	{
fe564285 WVP	30	/* Bomberman Fantasy Race */
fe564285 WVP	31	"SLES01712", "SLPS01525", "SLPS91138", "SLPM87102", "SLUS00823",
fae38d7a	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
55ff7130	42	static const char * const gpu_busy_hack_db[] =
	43	{
	44	/* ToHeart (Japan) */
	45	"SLPS01919", "SLPS01920",
	46	};
	47
d0d2939d	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),
fae38d7a	61	HACK_ENTRY(gpu_slow_list_walking, gpu_slow_llist_db),
55ff7130	62	HACK_ENTRY(gpu_busy_hack, gpu_busy_hack_db),
630b122b	63	};
630b122b	64
d7907215	65	static const struct
	66	{
	67	const char * const id;
	68	int mult;
	69	}
1562ed57	70	cycle_multiplier_overrides[] =
d7907215	71	{
9170c48e	72	/* note: values are = (10000 / gui_option) */
d7907215	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 },
b8f3d43d	79	/* Brave Fencer Musashi - cd sectors arrive too fast */
	80	{ "SLUS00726", 170 },
	81	{ "SLPS01490", 170 },
86be2515	82	#if defined(DRC_DISABLE) \|\| defined(LIGHTREC) /* new_dynarec has a hack for this game */
1562ed57	83	/* Parasite Eve II - internal timer checks */
	84	{ "SLUS01042", 125 },
	85	{ "SLUS01055", 125 },
	86	{ "SLES02558", 125 },
	87	{ "SLES12558", 125 },
	88	#endif
b99a48f2	89	/* Discworld Noir - audio skips if CPU runs too fast */
	90	{ "SLES01549", 222 },
	91	{ "SLES02063", 222 },
	92	{ "SLES02064", 222 },
9170c48e	93	/* Judge Dredd - could also be poor MDEC timing */
	94	{ "SLUS00630", 128 },
	95	{ "SLES00755", 128 },
	96	/* Digimon World */
	97	{ "SLUS01032", 153 },
	98	{ "SLES02914", 153 },
d7907215	99	};
d7907215	100
8bccdd17 PC	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
630b122b	130	/* Function for automatic patching according to GameID. */
cdee2d81	131	void Apply_Hacks_Cdrom(void)
630b122b	132	{
d0d2939d	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
630b122b	149	/* Apply Memory card hack for Codename Tenka. (The game needs one of the memory card slots to be empty) */
d0d2939d	150	for (i = 0; i < ARRAY_SIZE(MemorycardHack_db); i++)
630b122b	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;
d0d2939d	158	break;
630b122b	159	}
	160	}
	161
	162	/* Dynarec game-specific hacks */
	163	new_dynarec_hacks_pergame = 0;
1562ed57	164	Config.cycle_multiplier_override = 0;
630b122b	165
1562ed57	166	for (i = 0; i < ARRAY_SIZE(cycle_multiplier_overrides); i++)
630b122b	167	{
1562ed57	168	if (strcmp(CdromId, cycle_multiplier_overrides[i].id) == 0)
d7907215	169	{
1562ed57	170	Config.cycle_multiplier_override = cycle_multiplier_overrides[i].mult;
d7907215	171	new_dynarec_hacks_pergame \|= NDHACK_OVERRIDE_CYCLE_M;
1562ed57	172	SysPrintf("using cycle_multiplier_override: %d\n",
1562ed57	173	Config.cycle_multiplier_override);
d7907215	174	break;
d7907215	175	}
630b122b	176	}
8bccdd17 PC	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	}
630b122b	188	}
cdee2d81	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	}