/*---------------------------------------------------------------------------* Copyright (C) 2009-2013 Nintendo. All rights reserved. These coded instructions, statements, and computer programs contain proprietary information of Nintendo of America Inc. and/or Nintendo Company Ltd., and are protected by Federal copyright law. They may not be disclosed to third parties or copied or duplicated in any form, in whole or in part, without the prior written consent of Nintendo. *---------------------------------------------------------------------------*/ private: static const s32 SIZE_LEGACY_DESCRIPTION = 10; static const s32 SIZE_LEGACY_SUMMARY = 4; static const s32 SIZE_LEGACY_LEVEL = 4; static const s32 SIZE_LEGACY_RESERVED1 = 2; static const s32 SIZE_LEGACY_MODULE = 7; static const s32 SIZE_LEGACY_SIGNATURE = 2; static const s32 SHIFTS_LEGACY_DESCRIPTION = 0; static const s32 SHIFTS_LEGACY_SUMMARY = SHIFTS_LEGACY_DESCRIPTION + SIZE_LEGACY_DESCRIPTION; static const s32 SHIFTS_LEGACY_LEVEL = SHIFTS_LEGACY_SUMMARY + SIZE_LEGACY_SUMMARY; static const s32 SHIFTS_LEGACY_RESERVED1 = SHIFTS_LEGACY_LEVEL + SIZE_LEGACY_LEVEL; static const s32 SHIFTS_LEGACY_MODULE = SHIFTS_LEGACY_RESERVED1 + SIZE_LEGACY_RESERVED1; static const s32 SHIFTS_LEGACY_SIGNATURE = SHIFTS_LEGACY_MODULE + SIZE_LEGACY_MODULE; //NN_STATIC_ASSERT( SHIFTS_LEGACY_SIGNATURE + SIZE_LEGACY_SIGNATURE == SIZE_DESCRIPTION + SIZE_MODULE ); #define NN_RESULT_H_MAKE_MASK(size, shift) (((~0u) >> (32 - (size))) << (shift)) #define NN_RESULT_H_MAKE_MASK_HELPER(c) \ static const u32 MASK_ ## c = NN_RESULT_H_MAKE_MASK(SIZE_ ## c, SHIFTS_ ## c) NN_RESULT_H_MAKE_MASK_HELPER(LEGACY_DESCRIPTION); NN_RESULT_H_MAKE_MASK_HELPER(LEGACY_SUMMARY); NN_RESULT_H_MAKE_MASK_HELPER(LEGACY_LEVEL); NN_RESULT_H_MAKE_MASK_HELPER(LEGACY_MODULE); NN_RESULT_H_MAKE_MASK_HELPER(LEGACY_SIGNATURE); #undef NN_RESULT_H_MAKE_MASK_HELPER #undef NN_RESULT_H_MAKE_MASK #define NN_RESULT_H_MAKE_MAX(size) ((~0u) >> (32 - (size))) #define NN_RESULT_H_MAKE_MAX_HELPER(c) \ static const s32 MAX_ ## c = NN_RESULT_H_MAKE_MAX(SIZE_ ## c) NN_RESULT_H_MAKE_MAX_HELPER(LEGACY_DESCRIPTION); NN_RESULT_H_MAKE_MAX_HELPER(LEGACY_SUMMARY); NN_RESULT_H_MAKE_MAX_HELPER(LEGACY_LEVEL); NN_RESULT_H_MAKE_MAX_HELPER(LEGACY_MODULE); NN_RESULT_H_MAKE_MAX_HELPER(LEGACY_SIGNATURE); #undef NN_RESULT_H_MAKE_MAX_HELPER #undef NN_RESULT_H_MAKE_MAX public: enum LegacyLevelImpl { // Success. There is additional information. LEVEL_INFO = 1, // Fatal system level error. Software recovery is not possible. Jump to the support center guide sequence. LEVEL_RESET = -4, // Error that requires the module to be reinitialized. LEVEL_REINIT = -5, // Common error. You cannot try again. LEVEL_PERMANENT = -6, // Temporary failure. You can try again immediately with the same argument. Succeeds if the number of attempts is relatively low. LEVEL_TEMPORARY = -7 }; typedef int LegacyLevel; /* * @brief Enumeration type that indicates an overview of the errors. (Do not use this type for error handling.) */ enum Summary { SUMMARY_SUCCESS = 0, // Succeeded. SUMMARY_NOTHING_HAPPENED = 1, // Nothing happened. SUMMARY_WOULD_BLOCK = 2, // The process may be blocked. SUMMARY_OUT_OF_RESOURCE = 3, // The resources needed for the process could not be allocated. SUMMARY_NOT_FOUND = 4, // The object does not exist. SUMMARY_INVALID_STATE = 5, // The requested process cannot be executed with the current internal state. SUMMARY_NOT_SUPPORTED = 6, // Not currently supported by the SDK. SUMMARY_INVALID_ARGUMENT = 7, // The argument is invalid. SUMMARY_WRONG_ARGUMENT = 8, // A parameter other than the argument is invalid. SUMMARY_CANCELLED = 9, // Process was canceled. SUMMARY_STATUS_CHANGED = 10, // Status changed. (Example: Internal status changed while the process was running.) SUMMARY_INTERNAL = 11, // Error that is used within the library. SUMMARY_INVALID_RESULT_VALUE = MAX_LEGACY_SUMMARY // These values are not used. }; /* * @brief Enumerated type that indicates the modules in which errors occurred. (Do not use this type for error handling.) * * The enumerated type definitions may change in the future. * * With the exception of MODULE_APPLICATION, these values are defined for use inside the SDK. Do not use. */ enum { MODULE_COMMON = 0, MODULE_NN_KERNEL = 1, MODULE_NN_UTIL, MODULE_NN_FILE_SERVER, MODULE_NN_LOADER_SERVER, MODULE_NN_TCB, MODULE_NN_OS, MODULE_NN_DBG, MODULE_NN_DMNT, MODULE_NN_PDN, MODULE_NN_GX, MODULE_NN_I2C, MODULE_NN_GPIO, MODULE_NN_DD, MODULE_NN_CODEC, MODULE_NN_SPI, MODULE_NN_PXI, MODULE_NN_FS, MODULE_NN_DI, MODULE_NN_HID, MODULE_NN_CAMERA, MODULE_NN_PI, MODULE_NN_PM, MODULE_NN_PMLOW, MODULE_NN_FSI, MODULE_NN_SRV, MODULE_NN_NDM, MODULE_NN_NWM, MODULE_NN_SOCKET, MODULE_NN_LDR, MODULE_NN_ACC, MODULE_NN_ROMFS, MODULE_NN_AM, MODULE_NN_HIO, MODULE_NN_UPDATER, MODULE_NN_MIC, MODULE_NN_FND, MODULE_NN_MP, MODULE_NN_MPWL, MODULE_NN_AC, MODULE_NN_HTTP, MODULE_NN_DSP, MODULE_NN_SND, MODULE_NN_DLP, MODULE_NN_HIOLOW, MODULE_NN_CSND, MODULE_NN_SSL, MODULE_NN_AMLOW, MODULE_NN_NEX, MODULE_NN_FRIENDS, MODULE_NN_RDT, MODULE_NN_APPLET, MODULE_NN_NIM, MODULE_NN_PTM, MODULE_NN_MIDI, MODULE_NN_MC, MODULE_NN_SWC, MODULE_NN_FATFS, MODULE_NN_NGC, MODULE_NN_CARD, MODULE_NN_CARDNOR, MODULE_NN_SDMC, MODULE_NN_BOSS, MODULE_NN_DBM, MODULE_NN_CFG, MODULE_NN_PS, MODULE_NN_CEC, MODULE_NN_IR, MODULE_NN_UDS, MODULE_NN_PL, MODULE_NN_CUP, MODULE_NN_GYROSCOPE, MODULE_NN_MCU, MODULE_NN_NS, MODULE_NN_NEWS, MODULE_NN_RO, MODULE_NN_GD, MODULE_NN_CARDSPI, MODULE_NN_EC, MODULE_NN_WEBBRS, MODULE_NN_TEST, MODULE_NN_ENC, MODULE_NN_PIA }; typedef s32 Module; /* * @brief Enumeration type that indicates the details of errors. (Do not use this type for error handling.) * * Negative values are common to all SDK libraries. Positive values are defined independently by each library. */ enum Description { DESCRIPTION_INVALID_SELECTION = MAX_LEGACY_DESCRIPTION - 23, // An invalid value was specified (when a specifiable value is discrete). DESCRIPTION_TOO_LARGE = MAX_LEGACY_DESCRIPTION - 22, // The value is too large. DESCRIPTION_NOT_AUTHORIZED = MAX_LEGACY_DESCRIPTION - 21, // Unauthorized operation. DESCRIPTION_ALREADY_DONE = MAX_LEGACY_DESCRIPTION - 20, // The internal status has already been specified. DESCRIPTION_INVALID_SIZE = MAX_LEGACY_DESCRIPTION - 19, // Invalid size. DESCRIPTION_INVALID_ENUM_VALUE = MAX_LEGACY_DESCRIPTION - 18, // The value is outside the range for enum values. DESCRIPTION_INVALID_COMBINATION = MAX_LEGACY_DESCRIPTION - 17, // Invalid parameter combination. DESCRIPTION_NO_DATA = MAX_LEGACY_DESCRIPTION - 16, // No data. DESCRIPTION_BUSY = MAX_LEGACY_DESCRIPTION - 15, // Could not be run because another process was already being performed. DESCRIPTION_MISALIGNED_ADDRESS = MAX_LEGACY_DESCRIPTION - 14, // Invalid address alignment. DESCRIPTION_MISALIGNED_SIZE = MAX_LEGACY_DESCRIPTION - 13, // Invalid size alignment. DESCRIPTION_OUT_OF_MEMORY = MAX_LEGACY_DESCRIPTION - 12, // Insufficient memory. DESCRIPTION_NOT_IMPLEMENTED = MAX_LEGACY_DESCRIPTION - 11, // Not yet implemented. DESCRIPTION_INVALID_ADDRESS = MAX_LEGACY_DESCRIPTION - 10, // Invalid address. DESCRIPTION_INVALID_POINTER = MAX_LEGACY_DESCRIPTION - 9, // Invalid pointer. DESCRIPTION_INVALID_HANDLE = MAX_LEGACY_DESCRIPTION - 8, // Invalid handle. DESCRIPTION_NOT_INITIALIZED = MAX_LEGACY_DESCRIPTION - 7, // Not initialized. DESCRIPTION_ALREADY_INITIALIZED = MAX_LEGACY_DESCRIPTION - 6, // Already initialized. DESCRIPTION_NOT_FOUND = MAX_LEGACY_DESCRIPTION - 5, // The object does not exist. DESCRIPTION_CANCEL_REQUESTED = MAX_LEGACY_DESCRIPTION - 4, // Request canceled. DESCRIPTION_ALREADY_EXISTS = MAX_LEGACY_DESCRIPTION - 3, // The object already exists. DESCRIPTION_OUT_OF_RANGE = MAX_LEGACY_DESCRIPTION - 2, // The value is outside of the defined range. DESCRIPTION_TIMEOUT = MAX_LEGACY_DESCRIPTION - 1 // The process timed out. }; private: static const u32 LEGACY_SIGNATURE = 0x3; static Level MakeLevelFromLegacyLevel(LegacyLevel legacyLevel) { switch(legacyLevel) { case LEVEL_INFO: return LEVEL_SUCCESS; case LEVEL_RESET: case LEVEL_REINIT: case LEVEL_PERMANENT: return LEVEL_FATAL; case LEVEL_TEMPORARY: return LEVEL_STATUS; } return static_cast(legacyLevel); } template class TemplateMakeLegacyResult { private: static const s32 Level = TLegacyLevel == LEVEL_INFO ? LEVEL_SUCCESS : TLegacyLevel == LEVEL_RESET ? LEVEL_FATAL : TLegacyLevel == LEVEL_REINIT ? LEVEL_FATAL : TLegacyLevel == LEVEL_PERMANENT ? LEVEL_FATAL : TLegacyLevel == LEVEL_TEMPORARY ? LEVEL_STATUS : TLegacyLevel; public: static const bit32 Value = static_cast( ((static_cast(Level) << SHIFTS_LEVEL) & MASK_LEVEL) | ((static_cast(LEGACY_SIGNATURE) << SHIFTS_LEGACY_SIGNATURE) & MASK_LEGACY_SIGNATURE) | ((static_cast(TModule) << SHIFTS_LEGACY_MODULE) & MASK_LEGACY_MODULE) | ((static_cast(TLegacyLevel) << SHIFTS_LEGACY_LEVEL) & MASK_LEGACY_LEVEL) | ((static_cast(TSummary) << SHIFTS_LEGACY_SUMMARY) & MASK_LEGACY_SUMMARY) | ((static_cast(TDescription) << SHIFTS_LEGACY_DESCRIPTION) & MASK_LEGACY_DESCRIPTION) ); }; static bit32 MakeLegacyResultValue(LegacyLevel legacyLevel, Summary summary, Module module, int description) { return static_cast( ((MakeLevelFromLegacyLevel(legacyLevel) << SHIFTS_LEVEL) & MASK_LEVEL) | ((static_cast(LEGACY_SIGNATURE) << SHIFTS_LEGACY_SIGNATURE) & MASK_LEGACY_SIGNATURE) | ((static_cast(module) << SHIFTS_LEGACY_MODULE) & MASK_LEGACY_MODULE) | ((static_cast(legacyLevel) << SHIFTS_LEGACY_LEVEL) & MASK_LEGACY_LEVEL) | ((static_cast(summary) << SHIFTS_LEGACY_SUMMARY) & MASK_LEGACY_SUMMARY) | ((static_cast(description) << SHIFTS_LEGACY_DESCRIPTION) & MASK_LEGACY_DESCRIPTION) ); } LegacyLevel GetLegacyLevel() const { return static_cast(GetCodeBits(MASK_LEGACY_LEVEL, SHIFTS_LEGACY_LEVEL)); } Module GetLegacyModule() const { return static_cast(GetCodeBits(MASK_LEGACY_MODULE, SHIFTS_LEGACY_MODULE)); } Summary GetLegacySummary() const { return static_cast(GetCodeBits(MASK_LEGACY_SUMMARY, SHIFTS_LEGACY_SUMMARY)); } int GetLegacyDescription() const { return static_cast(GetCodeBits(MASK_LEGACY_DESCRIPTION, SHIFTS_LEGACY_DESCRIPTION)); } public: Result(int legacyLevel, int summary, int module, int description) : m_Code( MakeLegacyResultValue(legacyLevel, static_cast(summary), static_cast(module), description) ) { } template struct Const; template friend struct Const; template struct Const_LSM; template struct Const_LM; template struct Const_LS; template struct Const_L; bool IsLegacy() const { return GetCodeBits(MASK_LEGACY_SIGNATURE, SHIFTS_LEGACY_SIGNATURE) == LEGACY_SIGNATURE; } int GetSummary() const { if (IsLegacy()) return GetLegacySummary(); return 0; }