encounter/tp
0
0
Fork 0
mirror of https://github.com/encounter/tp.git synced 2026-07-11 06:18:46 -07:00
Code Issues Packages Projects Releases Wiki Activity

shieldD revolution dvd/nand mostly done (#2922)

Browse Source 
* shieldD revo dvd mostly done

* shieldD revo nand mostly done

* shieldD revo fs mostly done

* shieldD revo ipc mostly done

* shieldD revo sdk pad done
This commit is contained in:
TakaRikka
2025-12-08 12:44:29 +02:00
committed by GitHub
parent 251d49c6f1
commit 353721578d
53 changed files with 11021 additions and 135 deletions
Download Patch File Download Diff File Expand all files Collapse all files
config/ShieldD/splits.txt
+4 -4
View File
@@ -4330,7 +4330,7 @@ revolution/dvd/dvdDeviceError.c:
.rodata start:0x8065EA50 end:0x8065EA70
.data start:0x8073A040 end:0x8073A1D8
.sdata start:0x8074BFE0 end:0x8074BFE8
.sbss start:0x8074D530 end:0x8074D53C
.sbss start:0x8074D530 end:0x8074D538
.sdata2 start:0x80752E30 end:0x80752E38
.bss start:0x80801880 end:0x808018A0
@@ -4338,7 +4338,7 @@ revolution/dvd/dvd_broadway.c:
.text start:0x80607A70 end:0x80609A20
.data start:0x8073A1D8 end:0x8073B118
.sdata start:0x8074BFE8 end:0x8074BFF8
.sbss start:0x8074D53C end:0x8074D560
.sbss start:0x8074D538 end:0x8074D560
.bss start:0x808018A0 end:0x80801A20
revolution/ai/ai.c:
@@ -4412,7 +4412,7 @@ revolution/sc/scsystem.c:
.rodata start:0x8065EE18 end:0x8065EE70
.data start:0x8073DB08 end:0x8073DDB0
.sdata start:0x8074C078 end:0x8074C1C0
.sbss start:0x8074D5EC end:0x8074D604
.sbss start:0x8074D5EC end:0x8074D600
.bss start:0x80801DC0 end:0x80809F60
revolution/sc/scapi.c:
@@ -4435,7 +4435,7 @@ revolution/esp/esp.c:
revolution/ipc/ipcMain.c:
.text start:0x80612240 end:0x806123B0
.data start:0x8073DE10 end:0x8073DE48
.sbss start:0x8074D604 end:0x8074D618
.sbss start:0x8074D600 end:0x8074D618
revolution/ipc/ipcclt.c:
.text start:0x806123B0 end:0x80613CC0
configure.py
+47
View File
@@ -397,6 +397,7 @@ cflags_revolution_retail = [
cflags_revolution_debug = [
*cflags_revolution_base,
"-opt off",
"-inline off",
"-DDEBUG=1",
]
@@ -1497,6 +1498,52 @@ config.libs = [
Object(MatchingFor("ShieldD"), "revolution/os/__ppc_eabi_init.cpp"),
],
),
RevolutionLib(
"dvd",
[
Object(NonMatching, "revolution/dvd/dvdfs.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvd.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvdqueue.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvderror.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvdidutils.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvdFatal.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvdDeviceError.c", extra_cflags=["-char signed"]),
Object(NonMatching, "revolution/dvd/dvd_broadway.c", extra_cflags=["-char signed"]),
],
),
RevolutionLib(
"nand",
[
Object(NonMatching, "revolution/nand/nand.c"),
Object(NonMatching, "revolution/nand/NANDOpenClose.c"),
Object(NonMatching, "revolution/nand/NANDCore.c"),
Object(NonMatching, "revolution/nand/NANDCheck.c"),
Object(NonMatching, "revolution/nand/NANDLogging.c"),
Object(NonMatching, "revolution/nand/NANDErrorMessage.c"),
],
),
RevolutionLib(
"fs",
[
Object(NonMatching, "revolution/fs/fs.c"),
],
),
RevolutionLib(
"ipc",
[
Object(NonMatching, "revolution/ipc/ipcMain.c"),
Object(NonMatching, "revolution/ipc/ipcclt.c"),
Object(NonMatching, "revolution/ipc/memory.c"),
Object(NonMatching, "revolution/ipc/ipcProfile.c"),
],
),
RevolutionLib(
"pad",
[
Object(NonMatching, "revolution/pad/Padclamp.c"),
Object(NonMatching, "revolution/pad/Pad.c"),
],
),
{
"lib": "Runtime.PPCEABI.H",
"mw_version": MWVersion(config.version),
include/revolution/dvd.h
+85 -26
View File
@@ -66,6 +66,8 @@ extern "C" {
#define DVD_COMMAND_BS_CHANGE_DISK 15
#define DVD_COMMAND_UNK_16 16
#define DVD_RESETCOVER_TIMELAG_TICKS2 OSMillisecondsToTicks(100)
typedef struct DVDDiskID {
char gameName[4];
char company[2];
@@ -137,6 +139,29 @@ typedef struct DVDDriveInfo {
/* 0x08 */ u8 padding[24];
} DVDDriveInfo;
typedef struct DVDCommandInfo DVDCommandInfo;
struct DVDCommandInfo {
u32 command;
u32 offset;
u32 length;
u32 intType;
u32 tick;
};
typedef struct DVDErrorInfo DVDErrorInfo;
struct DVDErrorInfo {
char gameName[4];
u8 diskNumber;
u8 gameVersion;
u8 reserved0[2];
u32 error;
u32 dateTime;
u32 status;
u32 unk_0x14;
u32 nextOffset;
DVDCommandInfo lastCommand[5];
};
typedef struct DVDGamePartition {
ESTicket ticket;
u32 tmdSize;
@@ -157,25 +182,50 @@ typedef struct DVDGameTOC {
DVDPartitionInfo* partitionInfos;
} DVDGameTOC;
#define ROUND(n, a) (((u32)(n) + (a)-1) & ~((a)-1))
typedef struct DVDPartitionParams DVDPartitionParams;
struct DVDPartitionParams {
ESTicket ticket;
u8 padding0[ROUND(sizeof(ESTicket), 32) - sizeof(ESTicket)];
ESTicketView ticketView;
u8 padding1[ROUND(sizeof(ESTicketView), 32) - sizeof(ESTicketView)];
u32 numTmdBytes;
u8 padding2[28];
ESTitleMeta tmd;
u8 padding3[ROUND(sizeof(ESTitleMeta), 32) - sizeof(ESTitleMeta)];
u32 numCertBytes;
u8 padding4[28];
u8 certificates[4096];
u32 dataWordOffset;
u8 padding5[28];
u8 h3Hash[98304];
};
typedef struct diRegVals {
u32 ImmRegVal;
u32 CoverRegVal;
u32 pad[6];
} diRegVals_t;
typedef struct diCommand {
u8 theCommand;
u8 pad1[3];
u32 arg[5];
u32 pad2[2];
} diCommand_t;
typedef struct DVDVideoReportKey {
u8 data[32];
} DVDVideoReportKey;
// DVD
void DVDInit(void);
int DVDReadAbsAsyncPrio(DVDCommandBlock* block, void* addr, s32 length, s32 offset, DVDCBCallback callback, s32 prio);
int DVDSeekAbsAsyncPrio(DVDCommandBlock* block, s32 offset, DVDCBCallback callback, s32 prio);
int DVDReadAbsAsyncForBS(DVDCommandBlock* block, void* addr, s32 length, s32 offset, DVDCBCallback callback);
int DVDReadDiskID(DVDCommandBlock* block, DVDDiskID* diskID, DVDCBCallback callback);
int DVDPrepareStreamAbsAsync(DVDCommandBlock* block, u32 length, u32 offset, DVDCBCallback callback);
int DVDCancelStreamAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDCancelStream(DVDCommandBlock* block);
int DVDStopStreamAtEndAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDStopStreamAtEnd(DVDCommandBlock* block);
int DVDGetStreamErrorStatusAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDGetStreamErrorStatus(DVDCommandBlock* block);
int DVDGetStreamPlayAddrAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDGetStreamPlayAddr(DVDCommandBlock* block);
int DVDGetStreamStartAddrAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDGetStreamStartAddr(DVDCommandBlock* block);
int DVDGetStreamLengthAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDGetStreamLength(DVDCommandBlock* block);
int DVDChangeDiskAsyncForBS(DVDCommandBlock* block, DVDCBCallback callback);
int DVDChangeDiskAsync(DVDCommandBlock* block, DVDDiskID* id, DVDCBCallback callback);
s32 DVDChangeDisk(DVDCommandBlock* block, DVDDiskID* id);
@@ -191,7 +241,7 @@ BOOL DVDSetAutoInvalidation(BOOL autoInval);
void DVDPause(void);
void DVDResume(void);
int DVDCancelAsync(DVDCommandBlock* block, DVDCBCallback callback);
s32 DVDCancel(volatile DVDCommandBlock* block);
s32 DVDCancel(DVDCommandBlock* block);
int DVDCancelAllAsync(DVDCBCallback callback);
s32 DVDCancelAll(void);
DVDDiskID* DVDGetCurrentDiskID(void);
@@ -199,6 +249,7 @@ BOOL DVDCheckDisk(void);
// DVD FATAL
int DVDSetAutoFatalMessaging(BOOL enable);
BOOL __DVDGetAutoFatalMessaging(void);
// DVD FS
s32 DVDConvertPathToEntrynum(const char* pathPtr);
@@ -218,9 +269,6 @@ int DVDOpenDir(const char* dirName, DVDDir* dir);
int DVDReadDir(DVDDir* dir, DVDDirEntry* dirent);
int DVDCloseDir(DVDDir* dir);
void DVDRewindDir(DVDDir* dir);
void* DVDGetFSTLocation(void);
BOOL DVDPrepareStreamAsync(DVDFileInfo* fileInfo, u32 length, u32 offset, DVDCallback callback);
s32 DVDPrepareStream(DVDFileInfo* fileInfo, u32 length, u32 offset);
s32 DVDGetTransferredSize(DVDFileInfo* fileinfo);
#define DVDReadAsync(fileInfo, addr, length, offset, callback) \
@@ -233,16 +281,11 @@ DVDDiskID* DVDGenerateDiskID(DVDDiskID* id, const char* game, const char* compan
// DVD LOW
BOOL DVDLowRead(void* addr, u32 length, u32 offset, DVDLowCallback callback);
BOOL DVDLowSeek(u32 offset, DVDLowCallback callback);
BOOL DVDLowWaitCoverClose(DVDLowCallback callback);
BOOL DVDLowReadDiskID(DVDDiskID* diskID, DVDLowCallback callback);
BOOL DVDLowStopMotor(DVDLowCallback callback);
BOOL DVDLowRequestError(DVDLowCallback callback);
BOOL DVDLowInquiry(DVDDriveInfo* info, DVDLowCallback callback);
BOOL DVDLowAudioStream(u32 subcmd, u32 length, u32 offset, DVDLowCallback callback);
BOOL DVDLowRequestAudioStatus(u32 subcmd, DVDLowCallback callback);
BOOL DVDLowAudioBufferConfig(BOOL enable, u32 size, DVDLowCallback callback);
void DVDLowReset(void);
DVDLowCallback DVDLowSetResetCoverCallback(DVDLowCallback callback);
BOOL DVDLowAudioBufferConfig(u8 enable, u32 size, DVDLowCallback callback);
BOOL DVDLowReset(DVDLowCallback callback);
BOOL DVDLowBreak(void);
DVDLowCallback DVDLowClearCallback(void);
u32 DVDLowGetCoverStatus(void);
@@ -250,8 +293,24 @@ u32 DVDLowGetCoverStatus(void);
// DVD QUEUE
void DVDDumpWaitingQueue(void);
// unsorted revo
// DVD BROADWAY
BOOL DVDLowFinalize(void);
BOOL DVDLowInit(void);
BOOL DVDLowUnmaskStatusInterrupts(void);
BOOL DVDLowMaskCoverInterrupt(void);
BOOL DVDLowClearCoverInterrupt(DVDLowCallback callback);
BOOL DVDLowSetSpinupFlag(u32 spinUp);
u32 DVDLowGetImmBufferReg(void);
BOOL DVDLowSetMaximumRotation(u32 subcmd, DVDLowCallback callback);
u32 DVDLowGetCoverRegister(void);
BOOL DVDLowPrepareCoverRegister(DVDLowCallback callback);
BOOL DVDLowGetNoDiscBufferSizes(const u32 partitionWordOffset, u32* numTmdBytes, u32* numCertBytes, DVDLowCallback callback);
BOOL DVDLowGetNoDiscOpenPartitionParams(const u32 partitionWordOffset, ESTicket* eTicket, u32* numTmdBytes, ESTitleMeta* tmd, u32* numCertBytes, u8* certificates, u32* dataWordOffset, u8* h3HashPtr, DVDLowCallback callback);
BOOL DVDLowReportKey(DVDVideoReportKey* reportKey, u32 format, u32 lsn, DVDLowCallback callback);
u32 DVDLowGetControlRegister(void);
u32 DVDLowGetStatusRegister(void);
BOOL DVDLowPrepareControlRegister(DVDLowCallback callback);
BOOL DVDLowPrepareStatusRegister(DVDLowCallback callback);
BOOL DVDLowUnencryptedRead(void*, u32, u32, DVDLowCallback);
BOOL DVDLowClosePartition(DVDLowCallback);
BOOL DVDLowOpenPartitionWithTmdAndTicketView(const u32, const ESTicketView* const, const u32, const ESTitleMeta* const, const u32, const u8* const, DVDLowCallback);
include/revolution/fs.h
+100
View File
@@ -0,0 +1,100 @@
#ifndef _REVOLUTION_FS_H_
#define _REVOLUTION_FS_H_
#include <revolution/types.h>
#include <revolution/private/iostypes.h>
#include <revolution/private/iosrestypes.h>
#ifdef __cplusplus
extern "C" {
#endif
#define ISFS_ERROR_OK 0
#define ISFS_ERROR_INVALID -101
#define ISFS_ERROR_ACCESS -102
#define ISFS_ERROR_CORRUPT -103
#define ISFS_ERROR_NOTREADY -104
#define ISFS_ERROR_EXISTS -105
#define ISFS_ERROR_NOEXISTS -106
#define ISFS_ERROR_MAXFILES -107
#define ISFS_ERROR_MAXBLOCKS -108
#define ISFS_ERROR_MAXFD -109
#define ISFS_ERROR_MAXDEPTH -110
#define ISFS_ERROR_OPENFD -111
#define ISFS_ERROR_BADBLOCK -112
#define ISFS_ERROR_ECC -113
#define ISFS_ERROR_ECC_CRIT -114
#define ISFS_ERROR_NOTEMPTY -115
#define ISFS_ERROR_HMAC -116
#define ISFS_ERROR_UNKNOWN -117
#define ISFS_ERROR_BUSY -118
#define ISFS_ERROR_SHUTDOWN -119
#define ISFS_INODE_NAMELEN 12
typedef s32 ISFSError;
typedef void (*ISFSCallback) (ISFSError, void *ctxt);
typedef struct {
u32 blockSize;
u32 freeBlocks;
u32 occupiedBlcocks;
u32 badBlocks;
u32 reservedBlocks;
u32 freeInodes;
u32 occupedInodes;
} ISFSStats;
typedef struct {
u32 size;
u32 offset;
} ISFSFileStats;
typedef struct {
IOSUid ownerId;
IOSGid groupId;
u8 path[64];
u8 ownerAccess;
u8 groupAccess;
u8 othersAccess;
u8 attr;
} ISFSPathAttrArgs;
typedef struct {
u8 path1[64];
u8 path2[64];
} ISFSPathsArgs;
ISFSError ISFS_OpenLib(void);
s32 ISFS_CreateDir(const u8* dname, u32 dirAttr, u32 ownerAcc, u32 groupAcc, u32 othersAcc);
s32 ISFS_CreateDirAsync(const u8* dname, u32 dirAttr, u32 ownerAcc, u32 groupAcc, u32 othersAcc, ISFSCallback cb, void* fsCtxt);
s32 ISFS_ReadDir(const u8* dname, u8* nameList, u32* num);
s32 ISFS_ReadDirAsync(const u8* dname, u8* nameList, u32* num, ISFSCallback cb, void* fsCtxt);
s32 ISFS_GetAttr(const u8* name, IOSUid* ownerId, IOSGid* groupId, u32* attr, u32* ownerAcc, u32* groupAcc, u32* othersAcc);
s32 ISFS_GetAttrAsync(const u8* name, IOSUid* ownerId, IOSGid* groupId, u32* attr, u32* ownerAcc, u32* groupAcc, u32* othersAcc, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Delete(const u8* name);
s32 ISFS_DeleteAsync(const u8* name, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Rename(const u8* oldName, const u8* newName);
s32 ISFS_RenameAsync(const u8* oldName, const u8* newName, ISFSCallback cb, void* fsCtxt);
s32 ISFS_GetUsage(const u8* dname, u32* nblocks, u32* ninodes);
s32 ISFS_CreateFile(const u8* fname, u32 fileAttr, u32 ownerAcc, u32 groupAcc, u32 othersAcc);
s32 ISFS_CreateFileAsync(const u8* fname, u32 fileAttr, u32 ownerAcc, u32 groupAcc, u32 othersAcc, ISFSCallback cb, void* fsCtxt);
IOSFd ISFS_Open(const u8* fname, u32 access);
IOSFd ISFS_OpenAsync(const u8* fname, u32 access, ISFSCallback cb, void* fsCtxt);
s32 ISFS_GetFileStats(IOSFd fd, ISFSFileStats* stats);
s32 ISFS_GetFileStatsAsync(IOSFd fd, ISFSFileStats* stats, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Seek(IOSFd fd, s32 offset, u32 whence);
s32 ISFS_SeekAsync(IOSFd fd, s32 offset, u32 whence, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Read(s32 fd, u8* pBuffer, u32 bufSize);
s32 ISFS_ReadAsync(IOSFd fd, u8* buf, u32 size, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Write(IOSFd fd, const u8* buf, u32 size);
s32 ISFS_WriteAsync(IOSFd fd, const u8* buf, u32 size, ISFSCallback cb, void* fsCtxt);
s32 ISFS_Close(IOSFd fd);
s32 ISFS_CloseAsync(IOSFd fd, ISFSCallback cb, void* fsCtxt);
s32 ISFS_ShutdownAsync(ISFSCallback cb, void* fsCtxt);
#ifdef __cplusplus
}
#endif
#endif // _REVOLUTION_FS_H_
include/revolution/ipc.h
+24
View File
@@ -0,0 +1,24 @@
#ifndef _REVOLUTION_IPC_H_
#define _REVOLUTION_IPC_H_
#include <revolution/ipc/ipcclt.h>
#include <revolution/ipc/ipcProfile.h>
#include <revolution/ipc/memory.h>
#ifdef __cplusplus
extern "C" {
#endif
void IPCInit(void);
void IPCReInit(void);
u32 IPCReadReg(u32 regIdx);
void IPCWriteReg(u32 regIdx, u32 data);
void* IPCGetBufferHi(void);
void* IPCGetBufferLo(void);
void IPCSetBufferLo(void* newLo);
#ifdef __cplusplus
}
#endif
#endif // _REVOLUTION_IPC_H_
include/revolution/ipc/ipcProfile.h
+19
View File
@@ -0,0 +1,19 @@
#ifndef _REVOLUTION_IPCPROFILE_H_
#define _REVOLUTION_IPCPROFILE_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <revolution/types.h>
void IPCiProfInit(void);
void IPCiProfQueueReq(void* req, s32 handle);
void IPCiProfReply(void* req, s32 handle);
void IPCiProfAck(void);
#ifdef __cplusplus
}
#endif
#endif // _REVOLUTION_IPCPROFILE_H_
include/revolution/ipc/ipcclt.h
+37
View File
@@ -0,0 +1,37 @@
#ifndef _REVOLUTION_IPCCLT_H_
#define _REVOLUTION_IPCCLT_H_
#ifdef __cplusplus
extern "C" {
#endif
#include <revolution/types.h>
#include <revolution/private/iosrestypes.h>
#include <revolution/private/iostypes.h>
typedef IOSError (*IOSIpcCb)(IOSError, void*);
IOSError IPCCltInit(void);
IOSError IPCCltReInit(void);
IOSError IOS_OpenAsync(const char* pPath, u32 flags, IOSIpcCb cb, void* callback_arg);
IOSError IOS_Open(const char* path, u32 flags);
IOSError IOS_CloseAsync(IOSFd fd, IOSIpcCb cb, void* cbArg);
IOSError IOS_Close(IOSFd fd);
IOSError IOS_ReadAsync(IOSFd fd, void* buf, u32 len, IOSIpcCb cb, void* cbArg);
IOSError IOS_Read(IOSFd fd, void* buf, u32 len);
IOSError IOS_WriteAsync(IOSFd fd, void* buf, u32 len, IOSIpcCb cb, void* cbArg);
IOSError IOS_Write(IOSFd fd, void* buf, u32 len);
IOSError IOS_SeekAsync(IOSFd fd, s32 offset, u32 whence, IOSIpcCb cb, void* cbArg);
IOSError IOS_Seek(IOSFd fd, s32 offset, u32 whence);
IOSError IOS_IoctlAsync(IOSFd fd, s32 cmd, void* input, u32 inputLen, void* output, u32 outputLen, IOSIpcCb cb, void* cbArg);
IOSError IOS_Ioctl(IOSFd fd, s32 cmd, void* input, u32 inputLen, void* output, u32 outputLen);
IOSError IOS_IoctlvAsync(IOSFd fd, s32 cmd, u32 readCount, u32 writeCount, IOSIoVector* vect, IOSIpcCb cb, void* cbArg);
IOSError IOS_Ioctlv(IOSFd fd, s32 cmd, u32 readCount, u32 writeCount, IOSIoVector* vect);
IOSError IOS_IoctlvReboot(IOSFd fd, s32 cmd, u32 readCount, u32 writeCount, IOSIoVector* vect);
#ifdef __cplusplus
}
#endif
#endif // _REVOLUTION_IPCCLT_H_
include/revolution/ipc/memory.h
+18
View File
@@ -0,0 +1,18 @@
#ifndef _REVOLUTION_IPCMEMORY_H_
#define _REVOLUTION_IPCMEMORY_H_
#include <revolution/private/iostypes.h>
#ifdef __cplusplus
extern "C" {
#endif
IOSError iosFree(IOSHeapId id, void* ptr);
void* iosAllocAligned(IOSHeapId id, u32 size, u32 alignment);
IOSHeapId iosCreateHeap(void* ptr, u32 size);
#ifdef __cplusplus
}
#endif
#endif // _REVOLUTION_IPCMEMORY_H_
include/revolution/nand.h
+67 -22
View File
@@ -2,6 +2,7 @@
#define _REVOLUTION_NAND_H_
#include <revolution/types.h>
#include <revolution/fs.h>
#ifdef __cplusplus
extern "C" {
@@ -122,11 +123,56 @@ typedef struct {
typedef void (*NANDCallback)(s32, NANDCommandBlock*);
typedef void (*NANDAsyncCallback)(s32 result, struct NANDCommandBlock* block);
typedef void (*NANDLoggingCallback)(BOOL, s32);
// NAND
s32 NANDCreate(const char* path, const u8 perm, const u8 attr);
s32 NANDPrivateCreate(const char* path, u8 perm, u8 attr);
s32 NANDPrivateCreateAsync(const char *path, u8 perm, u8 attr, NANDCallback cb, NANDCommandBlock* block);
s32 NANDDelete(const char* path);
s32 NANDPrivateDelete(const char* path);
s32 NANDPrivateDeleteAsync(const char* path, NANDCallback cb, NANDCommandBlock* block);
s32 NANDRead(NANDFileInfo* info, void* buf, const u32 length);
s32 NANDReadAsync(NANDFileInfo* info, void* buf, const u32 length,
NANDCallback cb, NANDCommandBlock* block);
s32 NANDWrite(NANDFileInfo* info, const void* buf, const u32 length);
s32 NANDWriteAsync(NANDFileInfo* info, const void* buf, const u32 length,
NANDCallback cb, NANDCommandBlock* block);
s32 NANDSeek(NANDFileInfo* info, const s32 offset, const s32 whence);
s32 NANDSeekAsync(NANDFileInfo* info, const s32 offset, const s32 whence,
NANDCallback cb, NANDCommandBlock* block);
s32 NANDPrivateCreateDir(const char* path, u8 perm, u8 attr);
s32 NANDPrivateCreateDirAsync(const char *path, u8 perm, u8 attr, NANDCallback cb, NANDCommandBlock *block);
s32 NANDMove(const char* path, const char* destDir);
s32 NANDGetLength(NANDFileInfo* info, u32* length);
s32 NANDGetLengthAsync(NANDFileInfo* info, u32* length, NANDCallback cb,
NANDCommandBlock* block);
s32 NANDGetStatus(const char* path, NANDStatus* stat);
s32 NANDPrivateGetStatus(const char* path, NANDStatus* stat);
s32 NANDPrivateGetStatusAsync(const char* path, NANDStatus* stat,
NANDCallback cb, NANDCommandBlock* block);
void NANDSetUserData(NANDCommandBlock* block, void* data);
void* NANDGetUserData(const NANDCommandBlock* block);
// NANDCore
s32 NANDInit(void);
s32 NANDGetHomeDir(char[NAND_MAX_PATH]);
s32 NANDPrivateGetTypeAsync(const char* path, u8* type, NANDCallback cb, NANDCommandBlock* block);
void NANDInitBanner(NANDBanner* bnr, u32 const flag, const u16* title, const u16* comment);
s32 NANDCreate(const char*, u8, u8);
s32 NANDPrivateCreate(const char*, u8, u8);
// NANDCheck
s32 NANDCheck(const u32 fsBlock, const u32 inode, u32* answer);
// NANDOpenClose
s32 NANDOpen(const char*, NANDFileInfo*, u8);
s32 NANDPrivateOpen(const char*, NANDFileInfo*, u8);
s32 NANDOpenAsync(const char*, NANDFileInfo*, u8, NANDCallback, NANDCommandBlock*);
@@ -134,31 +180,30 @@ s32 NANDPrivateOpenAsync(const char*, NANDFileInfo*, const u8, NANDCallback, NAN
s32 NANDClose(NANDFileInfo*);
s32 NANDCloseAsync(NANDFileInfo*, NANDCallback, NANDCommandBlock*);
s32 NANDRead(NANDFileInfo*, void*, u32);
s32 NANDReadAsync(NANDFileInfo*, void*, u32, NANDCallback, NANDCommandBlock*);
s32 NANDGetLength(NANDFileInfo*, u32*);
s32 NANDSimpleSafeOpen(const char* path, NANDFileInfo* info, const u8 accType, void* buf, const u32 length);
s32 NANDSimpleSafeClose(NANDFileInfo* info);
s32 NANDPrivateSafeOpenAsync(const char* path, NANDFileInfo* info, const u8 accType, void* buf, const u32 length, NANDCallback cb, NANDCommandBlock* block);
s32 NANDSafeCloseAsync(NANDFileInfo* info, NANDCallback cb, NANDCommandBlock* block);
s32 NANDDelete(const char*);
// NANDLogging
BOOL NANDLoggingAddMessageAsync(NANDLoggingCallback cb, s32 errorCode, const char* fmt, ...);
s32 NANDMove(const char*, const char*);
// NANDErrorMessage
BOOL NANDSetAutoErrorMessaging(BOOL show);
void __NANDPrintErrorMessage(s32 errorCode);
s32 NANDCheck(u32, u32, u32*);
s32 NANDWrite(NANDFileInfo*, const void*, u32);
s32 NANDWriteAsync(NANDFileInfo*, const void*, u32, NANDCallback, NANDCommandBlock*);
s32 NANDSeekAsync(NANDFileInfo*, s32, s32, NANDCallback, NANDCommandBlock*);
s32 NANDPrivateGetStatus(const char*, NANDStatus*);
s32 NANDPrivateDelete(const char*);
s32 NANDPrivateCreate(const char*, u8, u8);
s32 NANDGetHomeDir(char[NAND_MAX_PATH]);
s32 NANDGetStatus(const char*, NANDStatus*);
s32 NANDSecretGetUsage(const char*, u32*, u32*);
const char* nandGetHomeDir();
void nandGenerateAbsPath(char* absPath, const char* path);
BOOL nandIsPrivatePath(const char* path);
BOOL nandIsInitialized(void);
s32 nandConvertErrorCode(const ISFSError err);
void nandGetRelativeName(char* name, const char* path);
BOOL nandIsUnderPrivatePath(const char* path);
BOOL nandIsRelativePath(const char* path);
void nandGetParentDirectory(char* parentDir, const char* absPath);
BOOL nandIsAbsolutePath(const char* path);
#ifdef __cplusplus
}
include/revolution/os.h
+17 -3
View File
@@ -46,6 +46,7 @@ typedef u32 OSTick;
#include <revolution/os/OSStateFlags.h>
#include <revolution/os/OSIpc.h>
#include <revolution/os/OSNandbootInfo.h>
#include <revolution/os/OSNet.h>
// private macro, maybe shouldn't be defined here?
#define OFFSET(addr, align) (((u32)(addr) & ((align)-1)))
@@ -68,16 +69,29 @@ OSThread* __OSCurrentThread AT_ADDRESS(OS_BASE_CACHED | 0x00E4);
u32 __OSSimulatedMemSize AT_ADDRESS(OS_BASE_CACHED | 0x00F0);
u32 __OSBusClock AT_ADDRESS(OS_BASE_CACHED | 0x00F8);
u32 __OSCoreClock AT_ADDRESS(OS_BASE_CACHED | 0x00FC);
volatile u16 __OSDeviceCode AT_ADDRESS(OS_BASE_CACHED | 0x30E6);
vu16 __OSDeviceCode AT_ADDRESS(OS_BASE_CACHED | 0x30E6);
vu8 __OSLockedFlag AT_ADDRESS(OS_BASE_CACHED | 0x3187);
u16 __OSWirelessPadFixMode AT_ADDRESS(OS_BASE_CACHED | 0x30E0);
vu32 __OSLaunchPartitionType AT_ADDRESS(OS_BASE_CACHED | 0x3194);
vu8 __OSDeviceCheckCode AT_ADDRESS(OS_BASE_CACHED | 0x319C);
// unknowns
OSThread* __gUnkThread1 AT_ADDRESS(OS_BASE_CACHED | 0x00D8);
int __gUnknown800030C0[2] AT_ADDRESS(OS_BASE_CACHED | 0x30C0);
u8 __gUnknown800030E3 AT_ADDRESS(OS_BASE_CACHED | 0x30E3);
#else
#define __OSBusClock (*(u32 *)(OS_BASE_CACHED | 0x00F8))
#define __OSCoreClock (*(u32 *)(OS_BASE_CACHED | 0x00FC))
#define __OSPhysicalMemSize (*(u32*)(OS_BASE_CACHED | 0x0028))
#define __OSTVMode (*(volatile int*)(OS_BASE_CACHED | 0x00CC))
#define __OSActiveThreadQueue (*(OSThreadQueue*)(OS_BASE_CACHED | 0x00DC))
#define __OSCurrentThread ((OSThread*)(OS_BASE_CACHED | 0x00E4))
#define __OSSimulatedMemSize (*(u32*)(OS_BASE_CACHED | 0x00F0))
#define __OSBusClock (*(u32*)(OS_BASE_CACHED | 0x00F8))
#define __OSCoreClock (*(u32*)(OS_BASE_CACHED | 0x00FC))
#define __OSDeviceCode (*(vu16*)(OS_BASE_CACHED | 0x30E6))
#define __OSLockedFlag (*(vu8*)(OS_BASE_CACHED | 0x3187))
#define __OSWirelessPadFixMode (*(u16*)(OS_BASE_CACHED | 0x30E0))
#define __OSLaunchPartitionType (*(vu32*)(OS_BASE_CACHED | 0x3194))
#define __OSDeviceCheckCode (*(vu8*)(OS_BASE_CACHED | 0x319C))
#endif
#define OS_BUS_CLOCK __OSBusClock
include/revolution/os/OSNet.h
+29
View File
@@ -0,0 +1,29 @@
#ifndef _REVOLUTION_OSNET_H_
#define _REVOLUTION_OSNET_H_
#include <revolution/ipc.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef enum NWC24Err {
NWC24_OK = 0,
} NWC24Err;
NWC24Err NWC24iPrepareShutdown(void);
NWC24Err NWC24iSynchronizeRtcCounter(BOOL);
NWC24Err NWC24iOpenResourceManager_(const char* callerName, const char* path, IOSFd* fd, u32 flags);
NWC24Err NWC24SuspendScheduler(void);
NWC24Err NWC24iSetRtcCounter_(int rtc, BOOL);
NWC24Err NWC24iIoctlResourceManager_(const char* callerName, IOSFd fd, s32 cmd, void* input, u32 inputLen, void* output, u32 outputLen);
NWC24Err NWC24iCloseResourceManager_(const char* callerName, IOSFd);
NWC24Err NWC24iRequestShutdown(u32 event, s32* result);
NWC24Err NWC24iIoctlResourceManagerAsync_(const char* callerName, IOSFd fd, s32 cmd, void* input, u32 inputLen, void* output, u32 outputLen, void* cbArg);
BOOL NWC24iIsAsyncRequestPending_(void);
#ifdef __cplusplus
}
#endif
#endif
include/revolution/os/OSPlayRecord.h
+8
View File
@@ -3,6 +3,10 @@
#include <revolution/os.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
u32 checkSum;
u16 titleName[2][21];
@@ -16,4 +20,8 @@ typedef struct {
void __OSStartPlayRecord(void);
void __OSStopPlayRecord(void);
#ifdef __cplusplus
}
#endif
#endif // OSPLAYRECORD_H
include/revolution/os/OSReset.h
+2 -2
View File
@@ -17,10 +17,10 @@ typedef struct OSShutdownFunctionQueue {
OSShutdownFunctionInfo* tail;
} OSShutdownFunctionQueue;
typedef BOOL (*OSResetFunction)(BOOL, u32);
typedef BOOL (*OSShutdownFunction)(BOOL, u32);
struct OSShutdownFunctionInfo {
OSResetFunction func;
OSShutdownFunction func;
u32 priority;
OSShutdownFunctionInfo* next;
OSShutdownFunctionInfo* prev;
include/revolution/private/iosresclt.h
-9
View File
@@ -1,9 +0,0 @@
#pragma once
#include <revolution/private/iosrestypes.h>
#include <revolution/private/iostypes.h>
#include <revolution/types.h>
typedef IOSError (*IOSIpcCb) (IOSError, void *);
s32 IOS_Read(s32, void*, u32);
include/revolution/private/iosrestypes.h
+7 -7
View File
@@ -33,19 +33,19 @@ typedef u32 IOSResourceHandle;
#define IOS_ERROR_INVALID_SIZE -23
typedef struct {
u8 *path;
u8* path;
u32 flags;
IOSUid uid;
IOSGid gid;
} IOSResourceOpen;
typedef struct {
u8 *outPtr;
u8* outPtr;
u32 outLen;
} IOSResourceRead;
typedef struct {
u8 *inPtr;
u8* inPtr;
u32 inLen;
} IOSResourceWrite;
@@ -56,14 +56,14 @@ typedef struct {
typedef struct {
u32 cmd;
u8 *inPtr;
u8* inPtr;
u32 inLen;
u8 *outPtr;
u8* outPtr;
u32 outLen;
} IOSResourceIoctl;
typedef struct {
u8 *base;
u8* base;
u32 length;
} IOSIoVector;
@@ -71,7 +71,7 @@ typedef struct {
u32 cmd;
u32 readCount;
u32 writeCount;
IOSIoVector *vector;
IOSIoVector* vector;
} IOSResourceIoctlv;
typedef struct {
src/revolution/dvd/__dvd.h
+15 -19
View File
@@ -1,8 +1,8 @@
#ifndef _DOLPHIN_DVD_INTERNAL_H_
#define _DOLPHIN_DVD_INTERNAL_H_
#ifndef _REVOLUTION_DVD_INTERNAL_H_
#define _REVOLUTION_DVD_INTERNAL_H_
#include <dolphin/os.h>
#include <dolphin/dvd.h>
#include <revolution/os.h>
#include <revolution/dvd.h>
#ifdef __cplusplus
extern "C" {
@@ -11,17 +11,21 @@ extern "C" {
// DVD
DVDCommandChecker __DVDSetOptionalCommandChecker(DVDCommandChecker func);
void __DVDSetImmCommand(u32 command);
void __DVDSetDmaCommand(u32 command);
void* __DVDGetIssueCommandAddr(void);
void __DVDAudioBufferConfig(DVDCommandBlock* block, u32 enable, u32 size, DVDCBCallback callback);
void __DVDPrepareResetAsync(DVDCBCallback callback);
int __DVDTestAlarm(const OSAlarm* alarm);
BOOL __DVDLowBreak(void);
u32 __DVDGetCoverStatus(void);
void __DVDPrepareReset(void);
extern vu32 __DVDLayoutFormat;
// DVD ERROR
void __DVDStoreErrorCode(u32 error);
void __DVDStoreErrorCode(u32 error, DVDCBCallback callback);
BOOL __DVDCheckDevice(void);
// DVD FATAL
void __DVDPrintFatalMessage(void);
void __DVDShowFatalMessage(void);
// DVD FS
extern OSThreadQueue __DVDThreadQueue;
@@ -29,10 +33,7 @@ extern u32 __DVDLongFileNameFlag;
void __DVDFSInit(void);
// DVD LOW
void __DVDInitWA(void);
void __DVDInterruptHandler(__OSInterrupt interrupt, OSContext* context);
void __DVDLowSetWAType(u32 type, s32 seekLoc);
// DVD BROADWAY
int __DVDLowTestAlarm(const OSAlarm* alarm);
// DVD QUEUE
@@ -42,15 +43,10 @@ DVDCommandBlock* __DVDPopWaitingQueue(void);
int __DVDCheckWaitingQueue(void);
int __DVDDequeueWaitingQueue(DVDCommandBlock* block);
int __DVDIsBlockInWaitingQueue(DVDCommandBlock* block);
// FST LOAD
void __fstLoad(void);
// unsorted
u32 __DVDGetCoverStatus(void);
DVDCommandBlock* __DVDGetNextWaitingQueue(void);
#ifdef __cplusplus
}
#endif
#endif // _DOLPHIN_DVD_INTERNAL_H_
#endif // _REVOLUTION_DVD_INTERNAL_H_
src/revolution/dvd/dvd.c
+2553
View File
File diff suppressed because it is too large Load Diff
src/revolution/dvd/dvdDeviceError.c
+200
View File
@@ -0,0 +1,200 @@
#include <revolution/os.h>
#include <revolution/dvd.h>
#include <revolution/sc.h>
#include "__os.h"
#include "__dvd.h"
static u8 CheckBuffer[32] ATTRIBUTE_ALIGN(32);
static volatile BOOL lowDone = TRUE;
static volatile u32 lowIntType = 0;
static void lowCallback(u32 intType) {
lowIntType = intType;
lowDone = TRUE;
}
void __DVDShowDeviceErrorMessage(void);
BOOL __DVDCheckDevice(void) {
u32 checkCode = 0x460A0000;
u32 outOfRangeError = 0xFFFFFFFF;
u32 reportKeyError = 0xFFFFFFFF;
OSIOSRev iosRev;
if (OSGetPhysicalMem2Size() == 0x08000000) {
return TRUE;
}
__OSGetIOSRev(&iosRev);
if (iosRev.major < 30 || iosRev.major >= 254) {
return TRUE;
}
if (__OSDeviceCheckCode == 129) {
checkCode = 0x7ED40000;
}
lowDone = FALSE;
DVDLowUnencryptedRead((void*)CheckBuffer, 32, checkCode, lowCallback);\
while (!lowDone) {
}
switch (lowIntType) {
case 2:
break;
case 1:
goto invalid;
break;
default:
goto fatal;
break;
}
lowDone = FALSE;
DVDLowRequestError(lowCallback);
while (!lowDone) {
}
outOfRangeError = DVDLowGetImmBufferReg();
switch (lowIntType) {
case 1: {
if ((DVDLowGetImmBufferReg() & 0xFF000000) != 0) {
goto recover;
break;
}
switch (DVDLowGetImmBufferReg() & 0xFFFFFF) {
case 0x52100:
break;
default:
goto invalid;
break;
}
break;
}
default:
goto fatal;
break;
}
lowDone = FALSE;
DVDLowReportKey((DVDVideoReportKey*)CheckBuffer, 0x40000, 0, lowCallback);
while (!lowDone) {
}
switch (lowIntType) {
case 2:
break;
case 1:
goto invalid;
break;
default:
goto fatal;
break;
}
lowDone = FALSE;
DVDLowRequestError(lowCallback);
while (!lowDone) {
}
reportKeyError = DVDLowGetImmBufferReg();
switch (lowIntType) {
case 1:
if ((DVDLowGetImmBufferReg() & 0xFF000000) != 0) {
goto recover;
break;
}
switch (DVDLowGetImmBufferReg() & 0xFFFFFF) {
case 0x53100:
case 0x52000:
break;
default:
goto invalid;
break;
}
break;
default:
goto fatal;
break;
}
valid:
return TRUE;
invalid:
__DVDShowDeviceErrorMessage();
return FALSE;
recover:
return FALSE;
fatal:
__DVDShowFatalMessage();
return FALSE;
}
const char* const __DVDDeviceErrorMessage[] = {
"\n\n\nエラーコード００１。\n"
"不明なデバイスが見つかりました。",
"\n\n\nError #001,\n"
"unauthorized device has been detected.",
"\n\n\nFehler #001:\n"
"Es wurde eine unzul舖sige Komponente\n"
"entdeckt.",
"\n\n\nErreur 001:\n"
"un dispositif non autoris\xE9\x20""a \xE9\x74\xE9\x20""d\xE9\x74""ect\xE9\x2E",
"\n\n\nError 001:\n"
"Se ha detectado un dispositivo no\n"
"autorizado.",
"\n\n\nErrore #001:\n"
"rilevato un dispositivo non autorizzato.",
"\n\n\nFout #001:\n"
"ongeoorloofd onderdeel gevonden."
};
void __DVDShowDeviceErrorMessage(void) {
const char* message;
const char* const* messageList;
GXColor bg = { 0, 0, 0, 0 };
GXColor fg = { 255, 255, 255, 0 };
if (SCGetLanguage() == 0) {
OSSetFontEncode(1);
} else {
OSSetFontEncode(0);
}
messageList = __DVDDeviceErrorMessage;
if (SCGetLanguage() > 6) {
message = messageList[1];
} else {
message = messageList[SCGetLanguage()];
}
OSFatal(fg, bg, message);
}
src/revolution/dvd/dvdFatal.c
+211
View File
@@ -0,0 +1,211 @@
#include <revolution.h>
#include <revolution/dvd.h>
#include <revolution/sc.h>
#include "__dvd.h"
static void (*FatalFunc)();
const char* const __DVDErrorMessageDefault[] = {
"\n"
"\n"
"\n"
"エラーが発生しました。\n"
"\n"
"イジェクトボタンを押してディスクを取り出してか\n"
"ら、本体の電源をOFFにして、本体の取扱説明書の\n"
"指示に従ってください。",
"\n"
"\n"
"\n"
"An error has occurred.\n"
"Press the Eject Button, remove the\n"
"Game Disc, and turn off the power to the\n"
"console. Please read the Wii Operations\n"
"Manual for further instructions.",
"\n"
"\n"
"\n"
"Ein Fehler ist aufgetreten.\n"
"Dr""\xFC""cke den Ausgabeknopf, entnimm die\n"
"Disc und schalte die Wii-Konsole aus.\n"
"Bitte lies die Wii-Bedienungsanleitung,\n"
"um weitere Informationen zu erhalten.",
"\n"
"\n"
"\n"
"Une erreur est survenue.\n"
"Appuyez sur le bouton EJECT, retirez\n"
"le disque et ""\xE9""teignez la console.\n"
"Veuillez vous r""\xE9""f""\xE9""rer au Mode d'emploi\n"
"de la Wii pour plus de d""\xE9""tails.",
"\n"
"\n"
"\n"
"Ocurri\xF3 un Error.\n"
"Oprime el Bot\xF3n EJECT, saca el disco\n"
"y apaga la consola. Consulta el manual\n"
"de operaciones de la consola Wii para\n"
"obtener m\xE1s informaci\xF3n.",
"\n"
"\n"
"\n"
"Si \xE8 verificato un errore.\n"
"Premi il pulsante EJECT, estrai il disco\n"
"e spegni la console. Per maggiori\n"
"informazioni, consulta il manuale di\n"
"istruzioni della console Wii.",
"\n"
"\n"
"\n"
"Er is een fout opgetreden.\n"
"Druk op de EJECT-knop, verwijder de\n"
"disk en zet het Wii-systeem uit. Lees\n"
"de Wii-handleiding voor meer informatie."
};
const char* const __DVDErrorMessageEurope[] = {
"\n"
"\n"
"\n"
"エラーが発生しました。\n"
"\n"
"イジェクトボタンを押してディスクを取り出してか\n"
"ら、本体の電源をOFFにして、本体の取扱説明書の\n"
"指示に従ってください。",
"\n"
"\n"
"\n"
"An error has occurred.\n"
"Press the EJECT Button, remove the Disc,\n"
"and turn off the power to the console.\n"
"Please refer to the Wii Operations Manual\n"
"for details.",
"\n"
"\n"
"\n"
"Ein Fehler ist aufgetreten.\n"
"Dr""\xFC""cke den Ausgabeknopf, entnimm die\n"
"Disc und schalte die Wii-Konsole aus.\n"
"Bitte lies die Wii-Bedienungsanleitung,\n"
"um weitere Informationen zu erhalten.",
"\n"
"\n"
"\n"
"Une erreur est survenue.\n"
"Appuyez sur le bouton EJECT, retirez\n"
"le disque et ""\xE9""teignez la console.\n"
"Veuillez vous r""\xE9""f""\xE9""rer au mode d'emploi\n"
"Wii pour plus de d""\xE9""tails.",
"\n"
"\n"
"\n"
"Se ha producido un error.\n"
"Pulsa el Bot\xF3n EJECT, extrae el disco y\n"
"apaga la consola. Consulta el manual de\n"
"instrucciones de la consola Wii para\n"
"obtener m\xE1s informaci\xF3n.",
"\n"
"\n"
"\n"
"Si \xE8 verificato un errore.\n"
"Premi il pulsante EJECT, estrai il disco\n"
"e spegni la console. Per maggiori\n"
"informazioni, consulta il manuale di\n"
"istruzioni della console Wii.",
"\n"
"\n"
"\n"
"Er is een fout opgetreden.\n"
"Druk op de EJECT-knop, verwijder de\n"
"disk en zet het Wii-systeem uit. Lees\n"
"de Wii-handleiding voor meer informatie."
};
const char* __DVDErrorMessageChinaKorea [] = {
"\n"
"\n"
"エラーコード１０４。\n"
"エラーが発生しました。\n"
"\n"
"イジェクトボタンを押してディスクを取り出してか\n"
"ら、本体の電源をOFFにして、本体の取扱説明書の\n"
"指示に従ってください。",
"\n"
"\n"
"Error #104,\n"
"An error has occurred.\n"
"Press the EJECT Button, remove the\n"
"Game Disc, and turn the power off.\n"
"Please read the Wii Operations Manual\n"
"for more information."
};
void __DVDShowFatalMessage(void) {
const char* message;
const char* const* messageList;
GXColor bg = { 0, 0, 0, 0 };
GXColor fg = { 255, 255, 255, 0 };
if (SCGetLanguage() == SC_LANG_JAPANESE) {
OSSetFontEncode(OS_FONT_ENCODE_SJIS);
} else {
OSSetFontEncode(OS_FONT_ENCODE_ANSI);
}
switch (SCGetProductGameRegion()) {
case 0:
case 1:
case 3:
default:
messageList = __DVDErrorMessageDefault;
break;
case 2:
messageList = __DVDErrorMessageEurope;
break;
case 4:
case 5:
messageList = __DVDErrorMessageChinaKorea;
break;
}
if (SCGetLanguage() > SC_LANG_DUTCH) {
message = messageList[1];
} else {
message = messageList[SCGetLanguage()];
}
OSFatal(fg, bg, message);
}
BOOL DVDSetAutoFatalMessaging(BOOL enable) {
BOOL enabled, prev;
enabled = OSDisableInterrupts();
prev = FatalFunc ? TRUE : FALSE;
FatalFunc = enable ? __DVDShowFatalMessage : NULL;
OSRestoreInterrupts(enabled);
return prev;
}
BOOL __DVDGetAutoFatalMessaging(void) {
return FatalFunc ? TRUE : FALSE;
}
void __DVDPrintFatalMessage(void) {
if (FatalFunc) {
FatalFunc();
}
}
src/revolution/dvd/dvd_broadway.c
+978
View File
File diff suppressed because it is too large Load Diff

Some files were not shown because too many files have changed in this diff Show More