Exact match (23/23, diffs 0). DOL SHA1 26116613f624061ba99c8d1a299aaa6efa85670d. Adds ChannelSlot/ChannelPage overlays (slots at +0x30, page stride 0xC0) so the loop uses typed .valid/.titleId instead of raw byte loads.
1231 lines
42 KiB
C++
1231 lines
42 KiB
C++
#include "system/iplSaveDataManager.h"
|
|
|
|
#include "system/iplChannelManager.h"
|
|
|
|
#include "iplSystem.h"
|
|
|
|
#include "iplUtility.h"
|
|
|
|
#include <revolution.h>
|
|
#include <revolution/sc.h>
|
|
|
|
#include <cstring>
|
|
|
|
#include "titledb.h"
|
|
|
|
#include "config.h"
|
|
|
|
extern "C" void _savegpr_14();
|
|
extern "C" void _restgpr_14();
|
|
extern "C" void _savegpr_26();
|
|
extern "C" void _restgpr_26();
|
|
extern "C" void _savegpr_16();
|
|
extern "C" void _restgpr_16();
|
|
extern "C" void _savegpr_28();
|
|
extern "C" void _restgpr_28();
|
|
extern "C" void _savegpr_20();
|
|
extern "C" void _restgpr_20();
|
|
extern "C" void _savegpr_22();
|
|
extern "C" void _restgpr_22();
|
|
|
|
namespace ipl {
|
|
// clang-format off
|
|
#define DISK_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_DISK, channel::SECONARY_TYPE_SYSTEM, SCENE_DISK_CHANNEL, 0)
|
|
#define NIGAOE_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_CHANNEL, channel::SECONARY_TYPE_SYSTEM, SCENE_NORMAL_CHANNEL, TITLE_NIGAOE_ALL)
|
|
#define PHOTO_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_CHANNEL, channel::SECONARY_TYPE_SYSTEM, SCENE_NORMAL_CHANNEL, TITLE_PHOTO_ALL)
|
|
#define SHOPPING_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_CHANNEL, channel::SECONARY_TYPE_SYSTEM, SCENE_NORMAL_CHANNEL, TITLE_SHOPPING_ALL)
|
|
#define WEATHER_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_CHANNEL, channel::SECONARY_TYPE_SYSTEM, SCENE_NORMAL_CHANNEL, TITLE_WEATHER_ALL)
|
|
#define NEWS_CHANNEL CHANNEL_INFO(channel::PRIMARY_TYPE_CHANNEL, channel::SECONARY_TYPE_SYSTEM, SCENE_NORMAL_CHANNEL, TITLE_NEWS_ALL)
|
|
#define NO_CHANNEL CHANNEL_INFO_NULL
|
|
|
|
#define DEFAULT_CHANNEL_COUNT 6
|
|
static const channel::SInfo cDefaultChanList/*[MAX_CHANNEL_PAGE][MAX_CHANNEL_INDEX]*/[MAX_CHANNEL_TOTAL] = {
|
|
// Page 1
|
|
//{
|
|
/* =============================================================*/
|
|
DISK_CHANNEL, NIGAOE_CHANNEL, PHOTO_CHANNEL, SHOPPING_CHANNEL,
|
|
/* =============================================================*/
|
|
WEATHER_CHANNEL, NEWS_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
//},
|
|
// Page 2
|
|
//{
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
//},
|
|
// Page 3
|
|
//{
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
//},
|
|
// Page 4
|
|
//{
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
NO_CHANNEL, NO_CHANNEL, NO_CHANNEL, NO_CHANNEL,
|
|
/* =============================================================*/
|
|
//},
|
|
};
|
|
// clang-format on
|
|
|
|
static const char* csSavePath = "/title/00000001/00000002/data/iplsave.bin";
|
|
|
|
namespace savedata {
|
|
Manager::Manager(EGG::Heap* heap) {
|
|
mpHeap = heap;
|
|
mLastPrevPage = 0;
|
|
mLastSDPrevPage = 0;
|
|
mbBadSDPrevPage = true;
|
|
|
|
mpFile = NULL;
|
|
|
|
mpUpdatedFile = NULL;
|
|
|
|
mbInit = false;
|
|
|
|
mLastError = 0;
|
|
}
|
|
|
|
Manager::~Manager() {
|
|
if (mpUpdatedFile) {
|
|
delete mpUpdatedFile;
|
|
}
|
|
}
|
|
|
|
void Manager::initManager() {
|
|
mbInit = false;
|
|
System::getTask3()->request(initManagerTask, this, NULL);
|
|
}
|
|
|
|
void Manager::setPrevPage(int prevPage) {
|
|
mData.prevPage = prevPage;
|
|
}
|
|
|
|
void Manager::setChanInfo(int page, int index, const channel::SInfo& chanInfo) {
|
|
mData.chanInfo[page][index] = chanInfo;
|
|
}
|
|
|
|
void Manager::setMemoSetting(const textinput::extend::savedata::MemoSetting& memoSetting) {
|
|
mData.memoSetting = memoSetting;
|
|
}
|
|
|
|
nand::File* Manager::flushAsync(EGG::Heap* flushHeap) {
|
|
int old = OSDisableInterrupts();
|
|
|
|
NETMD5Sum md5;
|
|
NETCalcMD5(md5, &mData, sizeof(mData) - NET_MD5_DIGEST_SIZE);
|
|
memcpy(mData.MD5Sum, md5, NET_MD5_DIGEST_SIZE);
|
|
|
|
nand::File* result = System::getNandManager()->writeAsync(flushHeap, csSavePath, &mData, sizeof(mData), NAND_PERM_USER);
|
|
mpFile = result;
|
|
|
|
OSRestoreInterrupts(old);
|
|
|
|
return result;
|
|
}
|
|
|
|
BOOL Manager::isFinished(nand::File* file) {
|
|
if (file->isFinished() || file->isFatalError()) {
|
|
mpFile = NULL;
|
|
}
|
|
return file->isFinished();
|
|
}
|
|
|
|
asm ESTitleId Manager::hasChannel(register ESTitleId titleId, register int* outIndex, register int* outPage) const {
|
|
nofralloc
|
|
stwu r1, -0x30(r1)
|
|
mflr r0
|
|
stw r0, 0x34(r1)
|
|
addi r11, r1, 0x30
|
|
bl _savegpr_22
|
|
li r0, -1
|
|
and. r0, r5, r0
|
|
beq hasChannel_L1
|
|
li r10, -1
|
|
li r9, -1
|
|
b hasChannel_L2
|
|
hasChannel_L1:
|
|
li r10, -1
|
|
li r9, 0
|
|
hasChannel_L2:
|
|
li r4, -0x100
|
|
li r0, -1
|
|
and r12, r10, r4
|
|
li r31, 0
|
|
and r11, r9, r0
|
|
li r27, 0
|
|
li r28, 0xc
|
|
hasChannel_L3:
|
|
add r0, r3, r27
|
|
li r30, 0
|
|
li r26, 0
|
|
mtctr r28
|
|
hasChannel_L4:
|
|
add r22, r0, r26
|
|
lbz r4, 0x30(r22)
|
|
cmplwi r4, 3
|
|
bne hasChannel_L5
|
|
lwz r4, 0x3c(r22)
|
|
lwz r29, 0x38(r22)
|
|
and r23, r4, r10
|
|
and r22, r29, r9
|
|
xor r23, r6, r23
|
|
xor r22, r5, r22
|
|
or. r22, r23, r22
|
|
beq hasChannel_L6
|
|
and r22, r4, r12
|
|
and r24, r6, r12
|
|
and r23, r29, r11
|
|
and r25, r5, r11
|
|
xor r24, r22, r24
|
|
xor r25, r23, r25
|
|
or. r25, r24, r25
|
|
bne hasChannel_L5
|
|
clrlwi r25, r6, 0x18
|
|
xori r25, r25, 0x41
|
|
cmpwi r25, 0
|
|
bne hasChannel_L5
|
|
hasChannel_L6:
|
|
cmpwi r7, 0
|
|
beq hasChannel_L7
|
|
stw r31, 0(r7)
|
|
hasChannel_L7:
|
|
cmpwi r8, 0
|
|
beq hasChannel_L8
|
|
stw r30, 0(r8)
|
|
hasChannel_L8:
|
|
mr r3, r29
|
|
b hasChannel_L9
|
|
hasChannel_L5:
|
|
addi r30, r30, 1
|
|
addi r26, r26, 0x10
|
|
bdnz hasChannel_L4
|
|
addi r31, r31, 1
|
|
addi r27, r27, 0xc0
|
|
cmpwi r31, 4
|
|
blt hasChannel_L3
|
|
li r4, 0
|
|
li r3, 0
|
|
hasChannel_L9:
|
|
addi r11, r1, 0x30
|
|
bl _restgpr_22
|
|
lwz r0, 0x34(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x30
|
|
blr
|
|
}
|
|
|
|
int Manager::getNumValidChannel() const {
|
|
const ChannelSlot* q;
|
|
int dens = 12;
|
|
const ChannelPage* p;
|
|
int slot;
|
|
int count = 0;
|
|
int page;
|
|
u8 flag;
|
|
s32 val;
|
|
for (page = 0; page < 4; page++) {
|
|
p = (const ChannelPage*)((const u8*)this + page * 0xc0);
|
|
for (slot = 0; slot < dens; slot++) {
|
|
q = &p->slots[slot];
|
|
flag = q->valid;
|
|
if (flag != 0) {
|
|
val = q->titleId;
|
|
if (val != 0) {
|
|
count++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return count;
|
|
}
|
|
|
|
BOOL Manager::isResetAcceptable() {
|
|
if (mpFile == NULL || mpFile->isFinished() || mpFile->isFatalError()) {
|
|
return TRUE;
|
|
} else {
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
void Manager::initManagerTask(void* work) {
|
|
Manager* manager = static_cast<Manager*>(work);
|
|
s32 ret;
|
|
|
|
u32 fileLen = sizeof(Data);
|
|
BOOL bCreateNew = FALSE;
|
|
bool bNeedFlush = false;
|
|
|
|
ES_SetUid(SYSMENU_TITLE_ID);
|
|
|
|
if (manager->mpUpdatedFile == NULL) {
|
|
NANDFileInfo fileInfo;
|
|
ret = nand::wrapper::Open(csSavePath, &fileInfo, NAND_ACCESS_RW);
|
|
|
|
if (manager->nand_error_handling(ret)) {
|
|
u32 fileLenCheck;
|
|
ret = nand::wrapper::GetLength(&fileInfo, &fileLenCheck);
|
|
manager->nand_error_handling(ret);
|
|
|
|
if (fileLenCheck == 0) {
|
|
// Create a new file if blank
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
// Read header
|
|
ret = nand::wrapper::Read(&fileInfo, &manager->mData, 0x20);
|
|
manager->nand_error_handling(ret);
|
|
|
|
if (manager->mLastError == NAND_RESULT_AUTHENTICATION || manager->mLastError == NAND_RESULT_ECC_CRIT) {
|
|
// Access to file is broken, create new
|
|
ret = nand::wrapper::Delete(csSavePath);
|
|
manager->nand_error_handling(ret);
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
if (manager->mData.version > SAVEDATA_VERSION) {
|
|
// Save data too high, create new
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
if (!NAND_CHECK_MAGIC4(manager->mData.sig, 'R', 'I', 'P', 'L')) {
|
|
// Signature incorrect, create new
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
ret = nand::wrapper::GetLength(&fileInfo, &fileLen);
|
|
if (ret != NAND_RESULT_OK || manager->mData.fileSize < 0x20 || manager->mData.fileSize > fileLen) {
|
|
// Invalid filesize, create new
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
fileLen = manager->mData.fileSize;
|
|
|
|
ret = nand::wrapper::Seek(&fileInfo, 0, NAND_SEEK_BEG);
|
|
manager->nand_error_handling(ret);
|
|
ret = nand::wrapper::Read(&fileInfo, &manager->mData, fileLen);
|
|
manager->nand_error_handling(ret);
|
|
|
|
if (manager->mLastError == NAND_RESULT_AUTHENTICATION || manager->mLastError == NAND_RESULT_ECC_CRIT) {
|
|
// Access to file is broken, create new
|
|
ret = nand::wrapper::Delete(csSavePath);
|
|
manager->nand_error_handling(ret);
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
NETMD5Sum md5;
|
|
NETCalcMD5(md5, &manager->mData, fileLen - NET_MD5_DIGEST_SIZE);
|
|
|
|
u8* data = (u8*)manager;
|
|
u32* loopFileLen = &fileLen;
|
|
volatile NETMD5Sum& md5Ref = md5;
|
|
u32 i = 0;
|
|
while (i < NET_MD5_DIGEST_SIZE) {
|
|
u8 md5Byte = md5Ref[i];
|
|
u32 offset = i;
|
|
offset += *loopFileLen;
|
|
u32 fileByte = *(u8*)(offset + (u32)data + NET_MD5_DIGEST_SIZE);
|
|
if (md5Byte != fileByte) {
|
|
// Invalid MD5 sum, create new
|
|
bCreateNew = TRUE;
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
ret = nand::wrapper::Close(&fileInfo);
|
|
manager->nand_error_handling(ret);
|
|
} else {
|
|
if (manager->mLastError == NAND_RESULT_NOEXISTS) {
|
|
// Create a new file if it does not exist
|
|
bCreateNew = TRUE;
|
|
} else {
|
|
// Otherwise something is wrong
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "NAND", manager->mLastError, 450);
|
|
}
|
|
}
|
|
|
|
if (bCreateNew) {
|
|
manager->setDefaultSaveData();
|
|
bNeedFlush = TRUE;
|
|
} else {
|
|
u32 oldVersion = manager->mData.version;
|
|
if (oldVersion < SAVEDATA_VERSION) {
|
|
manager->updateVersion(SAVEDATA_VERSION, oldVersion);
|
|
bNeedFlush = TRUE;
|
|
}
|
|
}
|
|
|
|
// Previous page of ChannelSelect
|
|
if (manager->mData.prevPage != 0) {
|
|
manager->mLastPrevPage = manager->mData.prevPage;
|
|
bNeedFlush = TRUE;
|
|
manager->mData.prevPage = 0;
|
|
}
|
|
|
|
// Prevous page on SDChannelSelect
|
|
if (manager->mData.prevSDPage >= 0 && manager->mData.prevSDPage < 20) {
|
|
if (manager->mbBadSDPrevPage) {
|
|
manager->mLastSDPrevPage = manager->mData.prevSDPage;
|
|
manager->mbBadSDPrevPage = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool flush = bNeedFlush | manager->updateChanInfos();
|
|
if (flush) {
|
|
if (manager->mpUpdatedFile) {
|
|
delete manager->mpUpdatedFile;
|
|
}
|
|
|
|
manager->mpUpdatedFile = manager->flushAsync(manager->mpHeap);
|
|
manager->mpFile = NULL;
|
|
}
|
|
|
|
manager->mbInit = true;
|
|
}
|
|
|
|
void Manager::setDefaultSaveData() {
|
|
setDefaultHeader();
|
|
memcpy(mData.chanInfo, cDefaultChanList, MAX_CHANNEL_INFO_SIZE);
|
|
setDefaultKeyboard();
|
|
setDefaultTVRC();
|
|
setDefaultSDMenu();
|
|
|
|
for (int i = 0; i < 0x0C; i++) {
|
|
mData.padding[i] = 0;
|
|
}
|
|
}
|
|
|
|
void Manager::setDefaultHeader() {
|
|
mData.sig[0] = 'R';
|
|
mData.sig[1] = 'I';
|
|
mData.sig[2] = 'P';
|
|
mData.sig[3] = 'L';
|
|
mData.fileSize = sizeof(mData);
|
|
mData.version = SAVEDATA_VERSION;
|
|
mData.prevPage = 0;
|
|
}
|
|
|
|
void Manager::setDefaultKeyboard() {
|
|
mData.memoSetting.uRevisionAndType = 0x11;
|
|
|
|
mData.memoSetting.uDictionary = 0xFA;
|
|
mData.memoSetting.uPredictOnOff = 0x00;
|
|
mData.memoSetting.uSignPage = 0x00;
|
|
|
|
mData.memoSetting.uKeitaiUpperCaseJP = TRUE;
|
|
mData.memoSetting.uKeitaiInputMode = 0x02;
|
|
|
|
mData.memoSetting.uQwertyABC = FALSE;
|
|
|
|
mData.memoSetting.uABCInputMode = 0x01;
|
|
mData.memoSetting.uAIUInputMode = 0x00;
|
|
|
|
mData.memoSetting.uNumLockOff = FALSE;
|
|
|
|
mData.memoSetting.uReserve2 = 0x00;
|
|
mData.memoSetting.uReserve3 = 0x00;
|
|
mData.memoSetting.uReserve4 = 0x00;
|
|
}
|
|
|
|
void Manager::setDefaultTVRC() {
|
|
mData.tvrcData[0] = 0;
|
|
mData.tvrcData[1] = 0;
|
|
mData.tvrcData[2] = 0;
|
|
mData.tvrcData[3] = 0;
|
|
}
|
|
|
|
BOOL Manager::updateChanInfos() {
|
|
u32 titleCount;
|
|
ES_ListTitlesOnCard(NULL, &titleCount);
|
|
|
|
u64* titleIds = new (mpHeap, -DEFAULT_ALIGN) u64[titleCount];
|
|
|
|
s32 ret = ES_ListTitlesOnCard(titleIds, &titleCount);
|
|
if (ret != ES_ERR_OK) {
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "ES", ret, 637);
|
|
}
|
|
|
|
mbPhoto2 = false;
|
|
mbPhoto2Check = false;
|
|
mbPhotoMP3 = false;
|
|
|
|
mPhotoId = TITLE_PHOTO;
|
|
|
|
deleteInvalidTitle(titleIds, titleCount);
|
|
checkSpecialTitles(titleIds, titleCount);
|
|
checkTmpTitle(titleIds, titleCount);
|
|
|
|
ESTitleId unk[MAX_CHANNEL_TOTAL] = {0};
|
|
|
|
makePriorTitleIDList(unk, titleIds, titleCount);
|
|
integrateTitleIDList(unk, titleIds, titleCount);
|
|
|
|
delete[] titleIds;
|
|
|
|
return doUpdateChanInfos(unk);
|
|
}
|
|
|
|
void Manager::deleteInvalidTitle(ESTitleId* titleIds, u32 titleCount) {
|
|
for (int i = 0; i < titleCount; i++) {
|
|
s32 ret;
|
|
if ((ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_CHANNEL &&
|
|
(ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_SYSTEM_CHANNEL &&
|
|
(ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_DISC &&
|
|
(ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_DISC_CHANNEL &&
|
|
(ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_UNK6 && (ESTitleId32)ES_TITLE_TYPE(titleIds[i]) != TITLE_TYPE_UNK3) {
|
|
titleIds[i] = TITLE_NULL;
|
|
} else {
|
|
ESTmdView* tmd = NULL;
|
|
ret = utility::ESMisc::GetTmdView(mpHeap, titleIds[i], &tmd);
|
|
if (ret == ES_ERR_OK) {
|
|
if (tmd->contents[0].size == 0x40 && TITLE_NO_REGION(titleIds[i]) != TITLE_PHOTO) {
|
|
titleIds[i] = TITLE_NULL;
|
|
}
|
|
}
|
|
if (tmd) {
|
|
mpHeap->free(tmd);
|
|
}
|
|
|
|
if (TITLE_NO_REGION(titleIds[i]) == TITLE_PHOTO) {
|
|
ESTmdView* tmd = NULL;
|
|
ret = utility::ESMisc::GetTmdView(mpHeap, titleIds[i], &tmd);
|
|
if (ret == ES_ERR_OK && tmd->head.titleVersion == 65280) {
|
|
mbPhotoMP3 = true;
|
|
}
|
|
if (tmd) {
|
|
mpHeap->free(tmd);
|
|
}
|
|
} else if (TITLE_NO_REGION(titleIds[i]) == TITLE_PHOTO_2) {
|
|
if (checkValidApp(titleIds[i])) {
|
|
mbPhoto2 = true;
|
|
}
|
|
} else if (TITLE_NO_REGION(titleIds[i]) == TITLE_PHOTO_2_CHECK) {
|
|
if (checkValidApp(titleIds[i])) {
|
|
mbPhoto2Check = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void Manager::checkSpecialTitles(ESTitleId* titleIds, u32 titleCount) {
|
|
if (mbPhoto2 || mbPhoto2Check) {
|
|
for (int i = 0; i < titleCount; i++) {
|
|
if (titleIds[i]) {
|
|
ESTitleId titleIdNoRegion = TITLE_NO_REGION(titleIds[i]);
|
|
if (mbPhoto2 && mbPhoto2Check) {
|
|
if (titleIdNoRegion == TITLE_PHOTO) {
|
|
titleIds[i] = 0;
|
|
} else if (titleIdNoRegion == TITLE_PHOTO_2_CHECK) {
|
|
titleIds[i] = 0;
|
|
}
|
|
} else if (!mbPhoto2 && mbPhoto2Check) {
|
|
if (titleIdNoRegion == TITLE_PHOTO) {
|
|
titleIds[i] = 0;
|
|
}
|
|
} else if (mbPhoto2 && !mbPhoto2Check && mbPhotoMP3) {
|
|
if (titleIdNoRegion == TITLE_PHOTO) {
|
|
titleIds[i] = 0;
|
|
}
|
|
} else if (mbPhoto2 && !mbPhoto2Check && !mbPhotoMP3) {
|
|
if (titleIdNoRegion == TITLE_PHOTO_2) {
|
|
titleIds[i] = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (mbPhoto2 && mbPhoto2Check) {
|
|
mPhotoId = TITLE_PHOTO_2;
|
|
} else if (!mbPhoto2 && mbPhoto2Check) {
|
|
mPhotoId = TITLE_PHOTO_2_CHECK;
|
|
} else if (mbPhoto2 && !mbPhoto2Check && mbPhotoMP3) {
|
|
mPhotoId = TITLE_PHOTO_2;
|
|
} else if (mbPhoto2 && !mbPhoto2Check && !mbPhotoMP3) {
|
|
mPhotoId = TITLE_PHOTO;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Manager::checkTmpTitle(ESTitleId* titleIds, u32 titleCount) {
|
|
bool foundTmp = false;
|
|
|
|
ESTitleId tmpId = SCGetTmpTitleID();
|
|
if (tmpId) {
|
|
for (int i = 0; i < titleCount; i++) {
|
|
if (titleIds[i] == tmpId) {
|
|
titleIds[i] = 0;
|
|
foundTmp = true;
|
|
}
|
|
}
|
|
|
|
if (foundTmp) {
|
|
if (!checkValidApp(tmpId)) {
|
|
SCSetTmpTitleID(TITLE_NULL);
|
|
SCFlush();
|
|
}
|
|
} else {
|
|
SCSetTmpTitleID(TITLE_NULL);
|
|
SCFlush();
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef __MWERKS__
|
|
extern "C" int isEqualChannel__Q33ipl8savedata7ManagerFUxUx();
|
|
extern "C" int checkValidApp__Q33ipl8savedata7ManagerFUx();
|
|
extern "C" int getAvailableInList__Q33ipl8savedata7ManagerFPCUxUl();
|
|
extern "C" int getAvailableNumInList__Q33ipl8savedata7ManagerFPCUxUl();
|
|
extern "C" int isDefaultChannel__Q33ipl8savedata7ManagerFUlUl();
|
|
extern "C" void makeTmpList__Q33ipl8savedata7ManagerFPUxUlPUxUl();
|
|
extern "C" void moveTitleTmpToPrior__Q33ipl8savedata7ManagerFPUxPCUx();
|
|
|
|
asm void Manager::makePriorTitleIDList(register ESTitleId* titleIdsOut, register ESTitleId* titleIdsIn, register u32 titleCount) {
|
|
nofralloc
|
|
stwu r1, -0x50(r1)
|
|
mflr r0
|
|
stw r0, 0x54(r1)
|
|
addi r11, r1, 0x50
|
|
bl _savegpr_14
|
|
mr r15, r3
|
|
mr r16, r4
|
|
mr r17, r5
|
|
mr r18, r6
|
|
li r23, 0
|
|
li r31, 0
|
|
li r30, 0
|
|
lis r26, 0x4841
|
|
li r14, -0x100
|
|
li r27, 0
|
|
makePriorTitleIDList_L1:
|
|
add r25, r15, r31
|
|
li r22, 0
|
|
li r29, 0
|
|
makePriorTitleIDList_L2:
|
|
add r3, r25, r29
|
|
lbz r0, 0x30(r3)
|
|
cmplwi r0, 3
|
|
bne makePriorTitleIDList_L8
|
|
lwz r21, 0x38(r3)
|
|
add r24, r22, r30
|
|
lwz r20, 0x3c(r3)
|
|
li r19, 0
|
|
li r28, 0
|
|
b makePriorTitleIDList_L7C
|
|
makePriorTitleIDList_L3:
|
|
add r3, r17, r28
|
|
lwzx r0, r17, r28
|
|
lwz r3, 4(r3)
|
|
or. r0, r3, r0
|
|
beq makePriorTitleIDList_L7
|
|
slwi r0, r24, 3
|
|
add r4, r16, r0
|
|
lwzx r3, r16, r0
|
|
lwz r4, 4(r4)
|
|
or. r0, r4, r3
|
|
beq makePriorTitleIDList_L4
|
|
mr r21, r3
|
|
mr r20, r4
|
|
b makePriorTitleIDList_L6
|
|
makePriorTitleIDList_L4:
|
|
li r0, -1
|
|
lis r4, 1
|
|
and r3, r20, r14
|
|
addi r5, r26, 0x4100
|
|
and r0, r21, r0
|
|
addi r6, r4, 2
|
|
xor r5, r3, r5
|
|
xor r4, r0, r6
|
|
or. r4, r5, r4
|
|
beq makePriorTitleIDList_L5
|
|
addi r5, r26, 0x5900
|
|
xor r4, r0, r6
|
|
xor r5, r3, r5
|
|
or. r4, r5, r4
|
|
beq makePriorTitleIDList_L5
|
|
addi r5, r26, 0x5a00
|
|
xoris r4, r0, 1
|
|
xor r5, r3, r5
|
|
or. r4, r5, r4
|
|
bne makePriorTitleIDList_L6
|
|
makePriorTitleIDList_L5:
|
|
lwz r4, 0x4f8(r15)
|
|
lwz r5, 0x4fc(r15)
|
|
xor r0, r0, r4
|
|
xor r3, r3, r5
|
|
or. r0, r3, r0
|
|
beq makePriorTitleIDList_L6
|
|
ori r20, r5, 0x41
|
|
mr r21, r4
|
|
makePriorTitleIDList_L6:
|
|
add r4, r17, r28
|
|
lwzx r7, r17, r28
|
|
lwz r8, 4(r4)
|
|
mr r3, r15
|
|
mr r6, r20
|
|
mr r5, r21
|
|
bl isEqualChannel__Q33ipl8savedata7ManagerFUxUx
|
|
cmpwi r3, -2
|
|
beq makePriorTitleIDList_L6A
|
|
cmpwi r3, 0
|
|
bne makePriorTitleIDList_L6B
|
|
makePriorTitleIDList_L6A:
|
|
mr r3, r15
|
|
mr r6, r20
|
|
mr r5, r21
|
|
bl checkValidApp__Q33ipl8savedata7ManagerFUx
|
|
cmpwi r3, 0
|
|
beq makePriorTitleIDList_L6C
|
|
slwi r0, r24, 3
|
|
add r3, r16, r0
|
|
stw r20, 4(r3)
|
|
stwx r21, r16, r0
|
|
makePriorTitleIDList_L6C:
|
|
add r3, r17, r28
|
|
stw r27, 4(r3)
|
|
stwx r27, r17, r28
|
|
b makePriorTitleIDList_L7
|
|
makePriorTitleIDList_L6B:
|
|
cmpwi r3, 1
|
|
bne makePriorTitleIDList_L7
|
|
add r4, r17, r28
|
|
lwzx r5, r17, r28
|
|
lwz r6, 4(r4)
|
|
mr r3, r15
|
|
bl checkValidApp__Q33ipl8savedata7ManagerFUx
|
|
cmpwi r3, 0
|
|
beq makePriorTitleIDList_L6D
|
|
slwi r0, r24, 3
|
|
add r5, r17, r28
|
|
add r3, r16, r0
|
|
lwzx r4, r17, r28
|
|
lwz r0, 4(r5)
|
|
stw r0, 4(r3)
|
|
stw r4, 0(r3)
|
|
makePriorTitleIDList_L6D:
|
|
add r3, r17, r28
|
|
stw r27, 4(r3)
|
|
stwx r27, r17, r28
|
|
makePriorTitleIDList_L7:
|
|
addi r19, r19, 1
|
|
addi r28, r28, 8
|
|
makePriorTitleIDList_L7C:
|
|
cmplw r19, r18
|
|
blt makePriorTitleIDList_L3
|
|
makePriorTitleIDList_L8:
|
|
addi r22, r22, 1
|
|
addi r29, r29, 0x10
|
|
cmpwi r22, 0xc
|
|
blt makePriorTitleIDList_L2
|
|
addi r23, r23, 1
|
|
addi r30, r30, 0xc
|
|
cmpwi r23, 4
|
|
addi r31, r31, 0xc0
|
|
blt makePriorTitleIDList_L1
|
|
addi r11, r1, 0x50
|
|
bl _restgpr_14
|
|
lwz r0, 0x54(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x50
|
|
blr
|
|
}
|
|
|
|
void Manager::integrateTitleIDList(ESTitleId* titleIdsOut, ESTitleId* titleIdsIn, u32 titleCount) {
|
|
ESTitleId temporaryTitleIds[0x36] = {0};
|
|
int availableCount = getAvailableNumInList(titleIdsOut, 0x30);
|
|
if (availableCount != 0) {
|
|
makeTmpList(temporaryTitleIds, availableCount, titleIdsIn, titleCount);
|
|
moveTitleTmpToPrior(titleIdsOut, temporaryTitleIds);
|
|
}
|
|
}
|
|
|
|
asm void Manager::makeTmpList(register ESTitleId* titleIdsOut, register u32 availableCount, register ESTitleId* titleIdsIn, register u32 titleCount) {
|
|
nofralloc
|
|
stwu r1, -0x50(r1)
|
|
mflr r0
|
|
stw r0, 0x54(r1)
|
|
addi r11, r1, 0x50
|
|
bl _savegpr_16
|
|
mr r22, r3
|
|
mr r23, r4
|
|
mr r24, r5
|
|
mr r25, r6
|
|
mr r26, r7
|
|
li r29, 6
|
|
li r21, 0x30
|
|
li r28, 0
|
|
li r27, 0
|
|
li r20, 0
|
|
li r31, -1
|
|
li r18, 0
|
|
b makeTmpList_L8
|
|
makeTmpList_L1:
|
|
add r30, r25, r20
|
|
lwzx r5, r25, r20
|
|
lwz r6, 4(r30)
|
|
or. r0, r6, r5
|
|
beq makeTmpList_L7
|
|
mr r3, r22
|
|
bl checkValidApp__Q33ipl8savedata7ManagerFUx
|
|
cmpwi r3, 0
|
|
beq makeTmpList_L6
|
|
li r3, -1
|
|
li r16, 0
|
|
li r19, 0
|
|
b makeTmpList_L3
|
|
makeTmpList_L2:
|
|
add r17, r23, r19
|
|
lwz r7, 0(r30)
|
|
lwzx r5, r23, r19
|
|
mr r3, r22
|
|
lwz r6, 4(r17)
|
|
lwz r8, 4(r30)
|
|
bl isEqualChannel__Q33ipl8savedata7ManagerFUxUx
|
|
cmpwi r3, -2
|
|
beq makeTmpList_L5
|
|
cmpwi r3, 0
|
|
beq makeTmpList_L5
|
|
cmpwi r3, 1
|
|
bne makeTmpList_L4
|
|
lwz r0, 0(r30)
|
|
lwz r4, 4(r30)
|
|
stw r4, 4(r17)
|
|
stw r0, 0(r17)
|
|
b makeTmpList_L5
|
|
makeTmpList_L4:
|
|
addi r16, r16, 1
|
|
addi r19, r19, 8
|
|
makeTmpList_L3:
|
|
cmpw r16, r29
|
|
blt makeTmpList_L2
|
|
makeTmpList_L5:
|
|
cmpwi r3, -1
|
|
beq makeTmpList_L5B
|
|
stw r18, 4(r30)
|
|
stw r18, 0(r30)
|
|
b makeTmpList_L7
|
|
makeTmpList_L5B:
|
|
lwz r0, 0(r30)
|
|
mr r3, r22
|
|
lwz r5, 4(r30)
|
|
and r4, r0, r31
|
|
and r5, r5, r31
|
|
bl isDefaultChannel__Q33ipl8savedata7ManagerFUlUl
|
|
cmpwi r3, -1
|
|
bne makeTmpList_L5C
|
|
lwz r0, 0(r30)
|
|
add r3, r23, r21
|
|
lwz r4, 4(r30)
|
|
addi r29, r29, 1
|
|
stw r4, 4(r3)
|
|
stwx r0, r23, r21
|
|
addi r21, r21, 8
|
|
b makeTmpList_L5D
|
|
makeTmpList_L5C:
|
|
slwi r0, r3, 3
|
|
lwz r4, 0(r30)
|
|
lwz r5, 4(r30)
|
|
add r3, r23, r0
|
|
stw r5, 4(r3)
|
|
stwx r4, r23, r0
|
|
makeTmpList_L5D:
|
|
addi r28, r28, 1
|
|
makeTmpList_L6:
|
|
stw r18, 4(r30)
|
|
cmplw r28, r24
|
|
stw r18, 0(r30)
|
|
bge makeTmpList_L9
|
|
makeTmpList_L7:
|
|
addi r27, r27, 1
|
|
addi r20, r20, 8
|
|
makeTmpList_L8:
|
|
cmplw r27, r26
|
|
blt makeTmpList_L1
|
|
makeTmpList_L9:
|
|
addi r11, r1, 0x50
|
|
bl _restgpr_16
|
|
lwz r0, 0x54(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x50
|
|
blr
|
|
}
|
|
|
|
void Manager::moveTitleTmpToPrior(ESTitleId* titleIdsOut, const ESTitleId* titleIdsIn) {
|
|
for (int titleIndex = 0; titleIndex < 0x36; titleIndex++) {
|
|
if (titleIdsIn[titleIndex] != TITLE_NULL) {
|
|
int availableIndex = getAvailableInList(titleIdsOut, 0x30);
|
|
if (availableIndex == -1) {
|
|
return;
|
|
}
|
|
titleIdsOut[availableIndex] = titleIdsIn[titleIndex];
|
|
}
|
|
}
|
|
}
|
|
|
|
asm BOOL Manager::doUpdateChanInfos(register ESTitleId* titleIds) {
|
|
nofralloc
|
|
stwu r1, -0x40(r1)
|
|
mflr r0
|
|
stw r0, 0x44(r1)
|
|
addi r11, r1, 0x40
|
|
bl _savegpr_20
|
|
mr r27, r3
|
|
mr r28, r4
|
|
li r3, 0
|
|
li r30, 0
|
|
li r26, 0
|
|
li r25, 0
|
|
li r20, 3
|
|
li r21, 0
|
|
li r22, 0xe
|
|
li r23, -1
|
|
doUpdateChanInfos_L1:
|
|
add r31, r27, r26
|
|
li r29, 0
|
|
li r24, 0
|
|
doUpdateChanInfos_L2:
|
|
add r4, r31, r24
|
|
lbz r0, 0x30(r4)
|
|
cmplwi r0, 1
|
|
beq doUpdateChanInfos_L5
|
|
add r0, r29, r25
|
|
lwz r9, 0x38(r4)
|
|
slwi r0, r0, 3
|
|
lwz r5, 0x3c(r4)
|
|
add r8, r28, r0
|
|
lwzx r6, r28, r0
|
|
lwz r7, 4(r8)
|
|
xor r0, r9, r6
|
|
xor r5, r5, r7
|
|
or. r0, r5, r0
|
|
beq doUpdateChanInfos_L5
|
|
or. r0, r7, r6
|
|
bne doUpdateChanInfos_L4
|
|
addi r3, r4, 0x30
|
|
li r4, 0
|
|
li r5, 0x10
|
|
bl memset
|
|
b doUpdateChanInfos_L6
|
|
doUpdateChanInfos_L4:
|
|
stb r20, 0x30(r4)
|
|
stb r21, 0x31(r4)
|
|
stb r21, 0x32(r4)
|
|
stb r21, 0x33(r4)
|
|
stw r22, 0x34(r4)
|
|
lwz r0, 0(r8)
|
|
and r0, r0, r23
|
|
stw r0, 0x38(r4)
|
|
lwz r0, 4(r8)
|
|
and r0, r0, r23
|
|
stw r0, 0x3c(r4)
|
|
doUpdateChanInfos_L6:
|
|
li r3, 1
|
|
doUpdateChanInfos_L5:
|
|
addi r29, r29, 1
|
|
addi r24, r24, 0x10
|
|
cmpwi r29, 0xc
|
|
blt doUpdateChanInfos_L2
|
|
addi r30, r30, 1
|
|
addi r25, r25, 0xc
|
|
cmpwi r30, 4
|
|
addi r26, r26, 0xc0
|
|
blt doUpdateChanInfos_L1
|
|
addi r11, r1, 0x40
|
|
bl _restgpr_20
|
|
lwz r0, 0x44(r1)
|
|
mtlr r0
|
|
addi r1, r1, 0x40
|
|
blr
|
|
}
|
|
#endif
|
|
|
|
BOOL Manager::checkValidApp(ESTitleId titleId) {
|
|
BOOL result = TRUE;
|
|
|
|
u32 tikCount = 0;
|
|
s32 ret = ES_GetTicketViews(titleId, NULL, &tikCount);
|
|
if (ret < ES_ERR_OK || tikCount == 0) {
|
|
return FALSE;
|
|
}
|
|
|
|
if (!utility::ESMisc::PrivateContentsExist(titleId)) {
|
|
return FALSE;
|
|
}
|
|
|
|
ESTmdView* tmd = NULL;
|
|
ret = utility::ESMisc::GetTmdView(mpHeap, titleId, &tmd);
|
|
if (ret != ES_ERR_OK && ret != ES_ERR_NO_TMD_FILE_FOUND) {
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "ES", ret, 1138);
|
|
}
|
|
|
|
if (ret == ES_ERR_NO_TMD_FILE_FOUND || utility::ESMisc::checkContentsNum(titleId, tmd)) {
|
|
if (ret != ES_ERR_OK && ret != ES_ERR_NO_TMD_FILE_FOUND) {
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "ES", ret, 1149);
|
|
}
|
|
result = FALSE;
|
|
}
|
|
|
|
if (tmd) {
|
|
mpHeap->free(tmd);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
int Manager::getAvailableNumInList(const ESTitleId* titleIds, u32 titleCount) {
|
|
int count = 0;
|
|
for (int i = 0; i < titleCount; i++) {
|
|
if (titleIds[i] == 0) {
|
|
count++;
|
|
}
|
|
}
|
|
return count - 1;
|
|
}
|
|
|
|
int Manager::getAvailableInList(const ESTitleId* titleIds, u32 titleCount) {
|
|
int dens = 12;
|
|
u32 i;
|
|
for (i = 0; i < titleCount; i++) {
|
|
if (titleIds[i] == 0) {
|
|
int page = (int)i / dens;
|
|
int slot = (int)i % dens;
|
|
u8* p = (u8*)this + page * 0xc0;
|
|
p += slot * 16;
|
|
if (*(p + 0x30) != 1) {
|
|
return (int)i;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
asm int Manager::isEqualChannel(register ESTitleId titleId0, register ESTitleId titleId1) {
|
|
nofralloc
|
|
xor r3, r6, r8
|
|
xor r0, r5, r7
|
|
or. r0, r3, r0
|
|
bne isEqualChannel_L1
|
|
li r3, -2
|
|
blr
|
|
isEqualChannel_L1:
|
|
li r3, -0x100
|
|
li r0, -1
|
|
and r9, r6, r3
|
|
and r3, r8, r3
|
|
and r4, r5, r0
|
|
and r0, r7, r0
|
|
xor r3, r9, r3
|
|
xor r0, r4, r0
|
|
or. r0, r3, r0
|
|
bne isEqualChannel_L4
|
|
clrlwi r3, r6, 0x18
|
|
xori r0, r3, 0x41
|
|
cmpwi r0, 0
|
|
beq isEqualChannel_L2
|
|
clrlwi r0, r8, 0x18
|
|
xori r0, r0, 0x41
|
|
cmpwi r0, 0
|
|
bne isEqualChannel_L2
|
|
li r3, 0
|
|
blr
|
|
isEqualChannel_L2:
|
|
xori r0, r3, 0x41
|
|
cmpwi r0, 0
|
|
bne isEqualChannel_L3
|
|
clrlwi r0, r8, 0x18
|
|
xori r0, r0, 0x41
|
|
cmpwi r0, 0
|
|
beq isEqualChannel_L3
|
|
li r3, 1
|
|
blr
|
|
isEqualChannel_L3:
|
|
li r3, -1
|
|
blr
|
|
isEqualChannel_L4:
|
|
li r3, -1
|
|
blr
|
|
}
|
|
|
|
int Manager::isDefaultChannel(ESTitleId32 titleType, ESTitleId32 titleCode) {
|
|
for (int i = 0; i < DEFAULT_CHANNEL_COUNT; i++) {
|
|
if (cDefaultChanList[i].titleType == titleType && (cDefaultChanList[i].titleCode & 0xFFFFFF00) == (titleCode & 0xFFFFFF00)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
void Manager::updateVersion(u32 newVersion, u32 oldVersion) {
|
|
if ((newVersion & 0xFFFF0000) != (oldVersion & 0xFFFF0000)) {
|
|
OSReport("[SaveDataManager] Invalid major version change %d -> %d\n", oldVersion >> 16, newVersion >> 16);
|
|
OSHalt("\0\0\0", 1344);
|
|
}
|
|
mData.fileSize = sizeof(Data);
|
|
mData.version = newVersion;
|
|
|
|
switch (newVersion) {
|
|
case 2: {
|
|
setDefaultKeyboard();
|
|
break;
|
|
}
|
|
case 3: {
|
|
switch ((u16)oldVersion) {
|
|
case 0:
|
|
case 1: {
|
|
setDefaultKeyboard();
|
|
}
|
|
case 2: {
|
|
setDefaultSDMenu();
|
|
}
|
|
default: {
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
void Manager::setDefaultSDMenu() {
|
|
mData.didntGotoSDMenu = TRUE;
|
|
memset(mData.titleCache, 0, sizeof(mData.titleCache));
|
|
mData.prevSDPage = 0;
|
|
}
|
|
|
|
#ifdef __MWERKS__
|
|
asm void Manager::pushTitleCache(register ESTitleId titleId) {
|
|
nofralloc
|
|
lis r7, 0x4841
|
|
lis r4, 1
|
|
addi r0, r7, 0x5445
|
|
addi r8, r4, 1
|
|
xor r4, r6, r0
|
|
xor r0, r5, r8
|
|
or. r0, r4, r0
|
|
beqlr
|
|
addi r4, r7, 0x4445
|
|
xor r0, r5, r8
|
|
xor r4, r6, r4
|
|
or. r0, r4, r0
|
|
bne pushTitleCache_L1
|
|
blr
|
|
pushTitleCache_L1:
|
|
addis r0, r5, -1
|
|
cmplwi r0, 1
|
|
beq pushTitleCache_L2
|
|
cmplwi r0, 3
|
|
beq pushTitleCache_L2
|
|
cmplwi r0, 4
|
|
beq pushTitleCache_L2
|
|
cmplwi r0, 6
|
|
bnelr
|
|
pushTitleCache_L2:
|
|
li r0, 0x30
|
|
li r9, 0
|
|
li r4, 0
|
|
mtctr r0
|
|
pushTitleCache_L3:
|
|
add r7, r3, r4
|
|
lwz r0, 0x340(r7)
|
|
lwz r7, 0x344(r7)
|
|
xor r0, r5, r0
|
|
xor r7, r6, r7
|
|
or. r0, r7, r0
|
|
beq pushTitleCache_L4
|
|
addi r9, r9, 1
|
|
addi r4, r4, 8
|
|
bdnz pushTitleCache_L3
|
|
pushTitleCache_L4:
|
|
cmpwi r9, 0x30
|
|
bne pushTitleCache_L5
|
|
li r9, 0x2f
|
|
pushTitleCache_L5:
|
|
slwi r4, r9, 3
|
|
mtctr r9
|
|
cmpwi r9, 0
|
|
ble pushTitleCache_L6
|
|
pushTitleCache_L7:
|
|
addi r0, r9, -1
|
|
add r7, r3, r4
|
|
slwi r0, r0, 3
|
|
addi r9, r9, -1
|
|
add r8, r3, r0
|
|
addi r4, r4, -8
|
|
lwz r0, 0x340(r8)
|
|
lwz r8, 0x344(r8)
|
|
stw r8, 0x344(r7)
|
|
stw r0, 0x340(r7)
|
|
bdnz pushTitleCache_L7
|
|
pushTitleCache_L6:
|
|
stw r6, 0x344(r3)
|
|
stw r5, 0x340(r3)
|
|
blr
|
|
}
|
|
|
|
extern "C" BOOL isTitleCached(void* manager, ESTitleId titleId) {
|
|
Manager* savedataManager = static_cast<Manager*>(manager);
|
|
for (int index = 0; index < MAX_CHANNEL_TOTAL; index++) {
|
|
if (savedataManager->mData.titleCache[0][index] == titleId) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
#endif
|
|
|
|
BOOL Manager::nand_error_handling(int code) {
|
|
BOOL result = FALSE;
|
|
|
|
mLastError = code;
|
|
if (code >= NAND_RESULT_OK) {
|
|
return TRUE;
|
|
} else {
|
|
switch (code) {
|
|
case NAND_RESULT_AUTHENTICATION:
|
|
case NAND_RESULT_NOEXISTS:
|
|
case NAND_RESULT_ECC_CRIT: {
|
|
break;
|
|
}
|
|
case NAND_RESULT_EXISTS: {
|
|
result = TRUE;
|
|
break;
|
|
}
|
|
case NAND_RESULT_CORRUPT: {
|
|
IPLErrorDisplay(MESG_ERR_NAND);
|
|
break;
|
|
}
|
|
case NAND_RESULT_OPENFD:
|
|
case NAND_RESULT_NOTEMPTY:
|
|
case NAND_RESULT_MAXFILES:
|
|
case NAND_RESULT_MAXFD:
|
|
case NAND_RESULT_MAXBLOCKS:
|
|
case NAND_RESULT_INVALID:
|
|
case NAND_RESULT_UNUSED_7:
|
|
default: {
|
|
IPLErrorLogAndDisplay(MESG_ERR_FILE, "NAND", code, 1503);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|
|
} // namespace savedata
|
|
} // namespace ipl
|