[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
{
	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 },
	/* Syphon Filter - reportedly hangs under unknown conditions */
	{ "SCUS94240", 169 },
};

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