src/hddsupport.c

   1 #include "sys/fcntl.h"
   2 #include "include/usbld.h"
   3 #include "include/lang.h"
   4 #include "include/gui.h"
   5 #include "include/supportbase.h"
   6 #include "include/hddsupport.h"
   7 #include "include/util.h"
   8 #include "include/themes.h"
   9 #include "include/textures.h"
  10 #include "include/ioman.h"
  11 #include "include/system.h"
  12
  13 extern void *hdd_cdvdman_irx;
  14 extern int size_hdd_cdvdman_irx;
  15
  16 extern void *hdd_pcmcia_cdvdman_irx;
  17 extern int size_hdd_pcmcia_cdvdman_irx;
  18
  19 extern void *hdd_hdpro_cdvdman_irx;
  20 extern int size_hdd_hdpro_cdvdman_irx;
  21
  22 extern void *ps2dev9_irx;
  23 extern int size_ps2dev9_irx;
  24
  25 extern void *ps2atad_irx;
  26 extern int size_ps2atad_irx;
  27
  28 extern void *hdpro_atad_irx;
  29 extern int size_hdpro_atad_irx;
  30
  31 extern void *ps2hdd_irx;
  32 extern int size_ps2hdd_irx;
  33
  34 extern void *ps2fs_irx;
  35 extern int size_ps2fs_irx;
  36
  37 #ifdef VMC
  38 extern void *hdd_mcemu_irx;
  39 extern int size_hdd_mcemu_irx;
  40 #endif
  41
  42 static int hddForceUpdate = 1;
  43 static char *hddPrefix = "pfs0:";
  44 static int hddGameCount = 0;
  45 static hdl_games_list_t* hddGames;
  46
  47 const char *oplPart = "hdd0:+OPL";
  48
  49 static int hddHDProKitDetected = 0;
  50
  51 // forward declaration
  52 static item_list_t hddGameList;
  53
  54 static void hddInitModules(void) {
  55
  56         hddLoadModules();
  57
  58         // update Themes
  59         char path[255];
  60         sprintf(path, "%sTHM", hddPrefix);
  61         thmAddElements(path, "/", hddGameList.mode);
  62
  63         sprintf(path, "%sCFG", hddPrefix);
  64         checkCreateDir(path);
  65
  66 #ifdef VMC
  67         sprintf(path, "%sVMC", hddPrefix);
  68         checkCreateDir(path);
  69 #endif
  70 }
  71
  72 // HD Pro Kit is mapping the 1st word in ROM0 seg as a main ATA controller,
  73 // The pseudo ATA controller registers are accessed (input/ouput) by writing
  74 // an id to the main ATA controller
  75 #define HDPROreg_IO8          (*(volatile unsigned char *)0xBFC00000)
  76 #define CDVDreg_STATUS        (*(volatile unsigned char *)0xBF40200A)
  77
  78 static int hddCheckHDProKit(void)
  79 {
  80         int ret = 0;
  81
  82         DIntr();
  83         ee_kmode_enter();
  84         // HD Pro IO start commands sequence
  85         HDPROreg_IO8 = 0x72;
  86         CDVDreg_STATUS = 0;
  87         HDPROreg_IO8 = 0x34;
  88         CDVDreg_STATUS = 0;
  89         HDPROreg_IO8 = 0x61;
  90         CDVDreg_STATUS = 0;
  91         u32 res = HDPROreg_IO8;
  92         CDVDreg_STATUS = 0;
  93         ee_kmode_exit();
  94         EIntr();
  95
  96         FlushCache(0);
  97         FlushCache(2);
  98
  99         DIntr();
 100         ee_kmode_enter();
 101
 102         // check result
 103         if ((res & 0xff) == 0xe7) {
 104                 HDPROreg_IO8 = 0xe3;
 105                 CDVDreg_STATUS = 0;
 106                 // HD Pro IO finish commands sequence
 107                 HDPROreg_IO8 = 0xf3;
 108                 CDVDreg_STATUS = 0;
 109                 ret = 1;
 110         }
 111         ee_kmode_exit();
 112         EIntr();
 113
 114         FlushCache(0);
 115         FlushCache(2);
 116
 117         if (ret)
 118                 LOG("hddCheckHDPro() HD Pro Kit detected!\n");
 119
 120         return ret;
 121 }
 122
 123 void hddLoadModules(void) {
 124         int ret;
 125         static char hddarg[] = "-o" "\0" "4" "\0" "-n" "\0" "20";
 126
 127         LOG("hddLoadModules()\n");
 128
 129         gHddStartup = 4;
 130
 131         ret = sysLoadModuleBuffer(&ps2dev9_irx, size_ps2dev9_irx, 0, NULL);
 132         if (ret < 0) {
 133                 gHddStartup = -1;
 134                 return;
 135         }
 136
 137         gHddStartup = 3;
 138
 139         // try to detect HD Pro Kit (not the connected HDD),
 140         // if detected it loads the specific ATAD module
 141         hddHDProKitDetected = hddCheckHDProKit();
 142         if (hddHDProKitDetected)
 143                 ret = sysLoadModuleBuffer(&hdpro_atad_irx, size_hdpro_atad_irx, 0, NULL);
 144         else
 145                 ret = sysLoadModuleBuffer(&ps2atad_irx, size_ps2atad_irx, 0, NULL);
 146         if (ret < 0) {
 147                 gHddStartup = -1;
 148                 return;
 149         }
 150
 151         gHddStartup = 2;
 152
 153         ret = sysLoadModuleBuffer(&ps2hdd_irx, size_ps2hdd_irx, sizeof(hddarg), hddarg);
 154         if (ret < 0) {
 155                 gHddStartup = -1;
 156                 return;
 157         }
 158
 159         gHddStartup = 1;
 160
 161         ret = sysLoadModuleBuffer(&ps2fs_irx, size_ps2fs_irx, 0, NULL);
 162         if (ret < 0) {
 163                 gHddStartup = -1;
 164                 return;
 165         }
 166
 167         LOG("hddLoadModules: modules loaded\n");
 168
 169         hddSetIdleTimeout(gHDDSpindown * 12); // gHDDSpindown [0..20] -> spindown [0..240] -> seconds [0..1200]
 170
 171         ret = fileXioMount(hddPrefix, oplPart, FIO_MT_RDWR);
 172         if (ret < 0) {
 173                 fileXioUmount(hddPrefix);
 174                 fileXioMount(hddPrefix, oplPart, FIO_MT_RDWR);
 175         }
 176
 177         gHddStartup = 0;
 178 }
 179
 180 void hddInit(void) {
 181         LOG("hddInit()\n");
 182         hddForceUpdate = 1;
 183
 184         ioPutRequest(IO_CUSTOM_SIMPLEACTION, &hddInitModules);
 185
 186         hddGameList.enabled = 1;
 187 }
 188
 189 item_list_t* hddGetObject(int initOnly) {
 190         if (initOnly && !hddGameList.enabled)
 191                 return NULL;
 192         return &hddGameList;
 193 }
 194
 195 static int hddNeedsUpdate(void) {
 196         if (hddForceUpdate) {
 197                 hddForceUpdate = 0;
 198                 return 1;
 199         }
 200
 201         return 0;
 202 }
 203
 204 static int hddUpdateGameList(void) {
 205         int ret = hddGetHDLGamelist(&hddGames);
 206         if (ret != 0)
 207                 hddGameCount = 0;
 208         else
 209                 hddGameCount = hddGames->count;
 210         return hddGameCount;
 211 }
 212
 213 static int hddGetGameCount(void) {
 214         return hddGameCount;
 215 }
 216
 217 static void* hddGetGame(int id) {
 218         return (void*) &hddGames->games[id];
 219 }
 220
 221 static char* hddGetGameName(int id) {
 222         return hddGames->games[id].name;
 223 }
 224
 225 static int hddGetGameNameLength(int id) {
 226         return HDL_GAME_NAME_MAX + 1;
 227 }
 228
 229 static char* hddGetGameStartup(int id) {
 230         return hddGames->games[id].startup;
 231 }
 232
 233 #ifndef __CHILDPROOF
 234 static void hddDeleteGame(int id) {
 235         hddDeleteHDLGame(&hddGames->games[id]);
 236         hddForceUpdate = 1;
 237 }
 238
 239 static void hddRenameGame(int id, char* newName) {
 240         hdl_game_info_t* game = &hddGames->games[id];
 241         strcpy(game->name, newName);
 242         hddSetHDLGameInfo(&hddGames->games[id]);
 243         hddForceUpdate = 1;
 244 }
 245 #endif
 246
 247 #ifdef VMC
 248 static int hddPrepareMcemu(hdl_game_info_t* game, config_set_t* configSet) {
 249         char vmc[2][32];
 250         char vmc_path[255];
 251         u32 vmc_size;
 252         pfs_inode_t pfs_inode;
 253         apa_header part_hdr;
 254         hdd_vmc_infos_t hdd_vmc_infos;
 255         vmc_superblock_t vmc_superblock;
 256         int i, j, fd, part_valid = 0, size_mcemu_irx = 0;
 257
 258         configGetVMC(configSet, vmc[0], 0);
 259         configGetVMC(configSet, vmc[1], 1);
 260
 261         if(!vmc[0][0] && !vmc[1][0]) return 0;  // skip if both empty
 262
 263         // virtual mc informations
 264         memset(&hdd_vmc_infos, 0, sizeof(hdd_vmc_infos_t));
 265
 266         fileXioUmount(hddPrefix);
 267         fd = fileXioOpen(oplPart, O_RDONLY, FIO_S_IRUSR | FIO_S_IWUSR | FIO_S_IXUSR | FIO_S_IRGRP | FIO_S_IWGRP | FIO_S_IXGRP | FIO_S_IROTH | FIO_S_IWOTH | FIO_S_IXOTH);
 268         if(fd >= 0) {
 269                 if(fileXioIoctl2(fd, APA_IOCTL2_GETHEADER, NULL, 0, (void*)&part_hdr, sizeof(apa_header)) == sizeof(apa_header)) {
 270                         if(part_hdr.nsub <= 4) {
 271                                 hdd_vmc_infos.parts[0].start = part_hdr.start;
 272                                 hdd_vmc_infos.parts[0].length = part_hdr.length;
 273                                 LOG("hdd_vmc_infos.parts[0].start : 0x%X\n", hdd_vmc_infos.parts[0].start);
 274                                 LOG("hdd_vmc_infos.parts[0].length : 0x%X\n", hdd_vmc_infos.parts[0].length);
 275                                 for(i = 0; i < part_hdr.nsub; i++) {
 276                                         hdd_vmc_infos.parts[i+1].start = part_hdr.subs[i].start;
 277                                         hdd_vmc_infos.parts[i+1].length = part_hdr.subs[i].length;
 278                                         LOG("hdd_vmc_infos.parts[%d].start : 0x%X\n", i+1, hdd_vmc_infos.parts[i+1].start);
 279                                         LOG("hdd_vmc_infos.parts[%d].length : 0x%X\n", i+1, hdd_vmc_infos.parts[i+1].length);
 280                                 }
 281                                 part_valid = 1;
 282                         }
 283
 284                 }
 285                 fileXioClose(fd);
 286         }
 287
 288         if(!part_valid) return -1;
 289
 290         fileXioMount(hddPrefix, oplPart, FIO_MT_RDWR); // if this fails, something is really screwed up
 291         for(i=0; i<2; i++) {
 292                 if(!vmc[i][0]) // skip if empty
 293                         continue;
 294
 295                 memset(&vmc_superblock, 0, sizeof(vmc_superblock_t));
 296                 hdd_vmc_infos.active = 0;
 297
 298                 snprintf(vmc_path, 255, "%sVMC/%s.bin", hddPrefix, vmc[i]);
 299
 300                 fd = fileXioOpen(vmc_path, O_RDWR, FIO_S_IRUSR | FIO_S_IWUSR | FIO_S_IXUSR | FIO_S_IRGRP | FIO_S_IWGRP | FIO_S_IXGRP | FIO_S_IROTH | FIO_S_IWOTH | FIO_S_IXOTH);
 301
 302                 if (fd >= 0) {
 303                         size_mcemu_irx = -1;
 304                         LOG("%s open\n", vmc_path);
 305
 306                         vmc_size = fileXioLseek(fd, 0, SEEK_END);
 307                         fileXioLseek(fd, 0, SEEK_SET);
 308                         fileXioRead(fd, (void*)&vmc_superblock, sizeof(vmc_superblock_t));
 309                         fileXioLseek(fd, 0, SEEK_SET);
 310
 311                         LOG("File size            : 0x%X\n", vmc_size);
 312                         LOG("Magic     : %s\n", vmc_superblock.magic);
 313                         LOG("Card type : %d\n", vmc_superblock.mc_type);
 314
 315                         if(!strncmp(vmc_superblock.magic, "Sony PS2 Memory Card Format", 27) && vmc_superblock.mc_type == 0x2) {
 316                                 hdd_vmc_infos.flags            = vmc_superblock.mc_flag & 0xFF;
 317                                 hdd_vmc_infos.flags           |= 0x100;
 318                                 hdd_vmc_infos.specs.page_size  = vmc_superblock.page_size;
 319                                 hdd_vmc_infos.specs.block_size = vmc_superblock.pages_per_block;
 320                                 hdd_vmc_infos.specs.card_size  = vmc_superblock.pages_per_cluster * vmc_superblock.clusters_per_card;
 321
 322                                 LOG("hdd_vmc_infos.flags            : 0x%X\n", hdd_vmc_infos.flags           );
 323                                 LOG("hdd_vmc_infos.specs.page_size  : 0x%X\n", hdd_vmc_infos.specs.page_size );
 324                                 LOG("hdd_vmc_infos.specs.block_size : 0x%X\n", hdd_vmc_infos.specs.block_size);
 325                                 LOG("hdd_vmc_infos.specs.card_size  : 0x%X\n", hdd_vmc_infos.specs.card_size );
 326
 327                                 if(vmc_size == hdd_vmc_infos.specs.card_size * hdd_vmc_infos.specs.page_size) {
 328                                         // Check vmc inode block chain (write operation can cause damage)
 329                                         if(fileXioIoctl2(fd, PFS_IOCTL2_GET_INODE, NULL, 0, (void*)&pfs_inode, sizeof(pfs_inode_t)) == sizeof(pfs_inode_t)) {
 330                                                 if(pfs_inode.number_data <= 11) {
 331                                                         for(j = 0; j < pfs_inode.number_data-1; j++) {
 332                                                                 hdd_vmc_infos.active = 1;
 333                                                                 hdd_vmc_infos.blocks[j].number  = pfs_inode.data[j+1].number;
 334                                                                 hdd_vmc_infos.blocks[j].subpart = pfs_inode.data[j+1].subpart;
 335                                                                 hdd_vmc_infos.blocks[j].count   = pfs_inode.data[j+1].count;
 336                                                                 LOG("hdd_vmc_infos.blocks[%d].number     : 0x%X\n", j, hdd_vmc_infos.blocks[j].number );
 337                                                                 LOG("hdd_vmc_infos.blocks[%d].subpart    : 0x%X\n", j, hdd_vmc_infos.blocks[j].subpart);
 338                                                                 LOG("hdd_vmc_infos.blocks[%d].count      : 0x%X\n", j, hdd_vmc_infos.blocks[j].count  );
 339                                                         }
 340                                                 } // else Vmc file too much fragmented
 341                                         }
 342                                 }
 343                         }
 344                         fileXioClose(fd);
 345                 }
 346                 for (j=0; j<size_hdd_mcemu_irx; j++) {
 347                         if (((u32*)&hdd_mcemu_irx)[j] == (0xC0DEFAC0 + i)) {
 348                                 if(hdd_vmc_infos.active)
 349                                         size_mcemu_irx = size_hdd_mcemu_irx;
 350                                 memcpy(&((u32*)&hdd_mcemu_irx)[j], &hdd_vmc_infos, sizeof(hdd_vmc_infos_t));
 351                                 break;
 352                         }
 353                 }
 354         }
 355         return size_mcemu_irx;
 356 }
 357 #endif
 358
 359 static void hddLaunchGame(int id, config_set_t* configSet) {
 360         int i, size_irx = 0;
 361         void** irx = NULL;
 362         char filename[32];
 363
 364         hdl_game_info_t* game = &hddGames->games[id];
 365
 366         if (gRememberLastPlayed) {
 367                 configSetStr(configGetByType(CONFIG_LAST), "last_played", game->startup);
 368                 saveConfig(CONFIG_LAST, 0);
 369         }
 370
 371         char gid[5];
 372         configGetDiscIDBinary(configSet, gid);
 373
 374         int dmaType = 0, dmaMode = 0, compatMode = 0;
 375         configGetInt(configSet, CONFIG_ITEM_DMA, &dmaMode);
 376         configGetInt(configSet, CONFIG_ITEM_COMPAT, &compatMode);
 377         if(dmaMode < 3)
 378                 dmaType = 0x20;
 379         else {
 380                 dmaType = 0x40;
 381                 dmaMode -= 3;
 382         }
 383         hddSetTransferMode(dmaType, dmaMode);
 384         hddSetIdleTimeout(gHDDSpindown * 12);
 385
 386         if (hddHDProKitDetected) {
 387                 size_irx = size_hdd_hdpro_cdvdman_irx;
 388                 irx = &hdd_hdpro_cdvdman_irx;
 389         }
 390         else if (sysPcmciaCheck()) {
 391                 size_irx = size_hdd_pcmcia_cdvdman_irx;
 392                 irx = &hdd_pcmcia_cdvdman_irx;
 393         }
 394         else {
 395                 size_irx = size_hdd_cdvdman_irx;
 396                 irx = &hdd_cdvdman_irx;
 397         }
 398
 399         for (i=0;i<size_irx;i++){
 400                 if(!strcmp((const char*)((u32)irx+i),"######    GAMESETTINGS    ######")){
 401                         break;
 402                 }
 403         }
 404
 405         if (compatMode & COMPAT_MODE_2) {
 406                 u32 alt_read_mode = 1;
 407                 memcpy((void*)((u32)irx+i+35),&alt_read_mode,1);
 408         }
 409         if (compatMode & COMPAT_MODE_5) {
 410                 u32 no_dvddl = 1;
 411                 memcpy((void*)((u32)irx+i+36),&no_dvddl,4);
 412         }
 413         if (compatMode & COMPAT_MODE_4) {
 414                 u32 no_pss = 1;
 415                 memcpy((void*)((u32)irx+i+40),&no_pss,4);
 416         }
 417
 418         // patch 48bit flag
 419         u8 flag_48bit = hddIs48bit() & 0xff;
 420         memcpy((void*)((u32)irx+i+34), &flag_48bit, 1);
 421
 422         // patch start_sector
 423         memcpy((void*)((u32)irx+i+44), &game->start_sector, 4);
 424
 425         for (i=0;i<size_irx;i++){
 426                 if(!strcmp((const char*)((u32)irx+i),"B00BS")){
 427                         break;
 428                 }
 429         }
 430         // game id
 431         memcpy((void*)((u32)irx+i), &gid, 5);
 432
 433         // patches cdvdfsv
 434         void *cdvdfsv_irx;
 435         int size_cdvdfsv_irx;
 436
 437         sysGetCDVDFSV(&cdvdfsv_irx, &size_cdvdfsv_irx);
 438         u32 *p = (u32 *)cdvdfsv_irx;
 439         for (i = 0; i < (size_cdvdfsv_irx >> 2); i++) {
 440                 if (*p == 0xC0DEC0DE) {
 441                         if (compatMode & COMPAT_MODE_7)
 442                                 *p = 1;
 443                         else
 444                                 *p = 0;
 445                         break;
 446                 }
 447                 p++;
 448         }
 449
 450 #ifdef VMC
 451         int size_mcemu_irx = hddPrepareMcemu(game, configSet);
 452         if (size_mcemu_irx == -1) {
 453                 if (guiMsgBox(_l(_STR_ERR_VMC_CONTINUE), 1, NULL))
 454                         size_mcemu_irx = 0;
 455                 else
 456                         return;
 457         }
 458 #endif
 459
 460         char *altStartup = NULL;
 461         if (configGetStr(configSet, CONFIG_ITEM_ALTSTARTUP, &altStartup))
 462                 strncpy(filename, altStartup, 32);
 463         else
 464                 sprintf(filename, "%s", game->startup);
 465         shutdown(NO_EXCEPTION); // CAREFUL: shutdown will call hddCleanUp, so hddGames/game will be freed
 466         FlushCache(0);
 467
 468 #ifdef VMC
 469         sysLaunchLoaderElf(filename, "HDD_MODE", size_irx, irx, size_mcemu_irx, &hdd_mcemu_irx, compatMode, compatMode & COMPAT_MODE_1);
 470 #else
 471         sysLaunchLoaderElf(filename, "HDD_MODE", size_irx, irx, compatMode, compatMode & COMPAT_MODE_1);
 472 #endif
 473 }
 474
 475 static config_set_t* hddGetConfig(int id) {
 476         char path[255];
 477         hdl_game_info_t* game = &hddGames->games[id];
 478
 479         snprintf(path, 255, "%sCFG/%s.cfg", hddPrefix, game->startup);
 480         config_set_t* config = configAlloc(0, NULL, path);
 481         configRead(config);
 482
 483         configSetStr(config, CONFIG_ITEM_NAME, game->name);
 484         configSetInt(config, CONFIG_ITEM_SIZE, game->total_size_in_kb >> 10);
 485         configSetStr(config, CONFIG_ITEM_FORMAT, "HDL");
 486         if (game->disctype == 0x12)
 487                 configSetStr(config, CONFIG_ITEM_MEDIA, "CD");
 488         else
 489                 configSetStr(config, CONFIG_ITEM_MEDIA, "DVD");
 490         configSetStr(config, CONFIG_ITEM_STARTUP, game->startup);
 491
 492         return config;
 493 }
 494
 495 static int hddGetImage(char* folder, int isRelative, char* value, char* suffix, GSTEXTURE* resultTex, short psm) {
 496         char path[255];
 497         if (isRelative)
 498                 sprintf(path, "%s%s/%s_%s", hddPrefix, folder, value, suffix);
 499         else
 500                 sprintf(path, "%s%s_%s", folder, value, suffix);
 501         return texDiscoverLoad(resultTex, path, -1, psm);
 502 }
 503
 504 static void hddCleanUp(int exception) {
 505         if (hddGameList.enabled) {
 506                 LOG("hddCleanUp()\n");
 507
 508                 hddFreeHDLGamelist(hddGames);
 509
 510                 if ((exception & UNMOUNT_EXCEPTION) == 0)
 511                         fileXioUmount(hddPrefix);
 512         }
 513 }
 514
 515 #ifdef VMC
 516 static int hddCheckVMC(char* name, int createSize) {
 517         return sysCheckVMC(hddPrefix, "/", name, createSize);
 518 }
 519 #endif
 520
 521 static item_list_t hddGameList = {
 522                 HDD_MODE, 0, COMPAT_FULL, 0, MENU_MIN_INACTIVE_FRAMES, "HDD Games", _STR_HDD_GAMES, &hddInit, &hddNeedsUpdate, &hddUpdateGameList,
 523 #ifdef __CHILDPROOF
 524                 &hddGetGameCount, &hddGetGame, &hddGetGameName, &hddGetGameNameLength, &hddGetGameStartup, NULL, NULL,
 525 #else
 526                 &hddGetGameCount, &hddGetGame, &hddGetGameName, &hddGetGameNameLength, &hddGetGameStartup, &hddDeleteGame, &hddRenameGame,
 527 #endif
 528 #ifdef VMC
 529                 &hddLaunchGame, &hddGetConfig, &hddGetImage, &hddCleanUp, &hddCheckVMC, HDD_ICON
 530 #else
 531                 &hddLaunchGame, &hddGetConfig, &hddGetImage, &hddCleanUp, HDD_ICON
 532 #endif
 533 };