libpcsxcore/database.c

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