shieldD revolution dvd/nand mostly done (#2922)

* 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
2026-07-09 14:55:32 -04:00 · 2025-12-08 02:44:29 -08:00
parent 251d49c6f1
commit 353721578d
53 changed files with 11021 additions and 135 deletions
@@ -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);
@@ -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_
@@ -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_
@@ -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_
@@ -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_
@@ -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_
@@ -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
 }
@@ -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
@@ -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
@@ -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
@@ -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;
@@ -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);
@@ -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 {