ams: allow bootloader to merely approximate correct target firmware
This commit is contained in:
Michael Scire
2
fusee/program/source/fatfs/fusee_diskio.cpp
vendored
2
fusee/program/source/fatfs/fusee_diskio.cpp
vendored
@@ -27,7 +27,7 @@ bool diskio_write_sd_card(size_t sector_index, size_t sector_count, const void *
|
||||
}
|
||||
|
||||
bool diskio_read_system(void *dst, size_t size, size_t sector_index, size_t sector_count) {
|
||||
return R_SUCCEEDED(::ams::nxboot::ReadSystem(sector_index * 0x200, dst, size));
|
||||
return false;
|
||||
}
|
||||
|
||||
bool diskio_write_system(size_t sector_index, size_t sector_count, const void *src, size_t size) {
|
||||
|
||||
@@ -27,10 +27,8 @@ namespace ams::fs {
|
||||
constexpr size_t MaxDirectories = 2;
|
||||
|
||||
constinit bool g_is_sd_mounted = false;
|
||||
constinit bool g_is_sys_mounted = false;
|
||||
|
||||
alignas(0x10) constinit FATFS g_sd_fs = {};
|
||||
alignas(0x10) constinit FATFS g_sys_fs = {};
|
||||
|
||||
alignas(0x10) constinit FIL g_files[MaxFiles] = {};
|
||||
alignas(0x10) constinit DIR g_dirs[MaxDirectories] = {};
|
||||
@@ -131,18 +129,6 @@ namespace ams::fs {
|
||||
g_is_sd_mounted = false;
|
||||
}
|
||||
|
||||
bool MountSystem() {
|
||||
AMS_ASSERT(!g_is_sys_mounted);
|
||||
g_is_sys_mounted = f_mount(std::addressof(g_sys_fs), "sys:", 1) == FR_OK;
|
||||
return g_is_sys_mounted;
|
||||
}
|
||||
|
||||
void UnmountSystem() {
|
||||
AMS_ASSERT(g_is_sys_mounted);
|
||||
f_unmount("sys:");
|
||||
g_is_sys_mounted = false;
|
||||
}
|
||||
|
||||
Result GetEntryType(DirectoryEntryType *out_entry_type, bool *out_archive, const char *path) {
|
||||
/* Get the file info. */
|
||||
FILINFO info;
|
||||
|
||||
@@ -98,9 +98,6 @@ namespace ams::fs {
|
||||
bool MountSdCard();
|
||||
void UnmountSdCard();
|
||||
|
||||
bool MountSystem();
|
||||
void UnmountSystem();
|
||||
|
||||
Result GetEntryType(DirectoryEntryType *out_entry_type, bool *out_archive, const char *path);
|
||||
|
||||
Result CreateFile(const char *path, s64 size);
|
||||
|
||||
@@ -181,112 +181,6 @@ namespace ams::nxboot {
|
||||
constinit fs::IStorage *g_boot0_storage = nullptr;
|
||||
constinit fs::IStorage *g_user_storage = nullptr;
|
||||
|
||||
class SystemPartitionStorage : public fs::IStorage {
|
||||
private:
|
||||
static constexpr size_t CacheEntries = BITSIZEOF(u32);
|
||||
static constexpr size_t SectorSize = 0x4000;
|
||||
private:
|
||||
fs::SubStorage m_storage;
|
||||
u8 *m_sector_cache;
|
||||
u32 *m_sector_ids;
|
||||
u32 m_sector_flags;
|
||||
u32 m_next_idx;
|
||||
private:
|
||||
Result LoadSector(u8 *sector, u32 sector_id) {
|
||||
/* Read the sector data. */
|
||||
R_TRY(m_storage.Read(static_cast<s64>(sector_id) * SectorSize, sector, SectorSize));
|
||||
|
||||
/* Decrypt the sector. */
|
||||
se::DecryptAes128Xts(sector, SectorSize, pkg1::AesKeySlot_BootloaderSystem0, pkg1::AesKeySlot_BootloaderSystem1, sector, SectorSize, sector_id);
|
||||
|
||||
/* Mark the sector as freshly loaded. */
|
||||
m_sector_flags &= ~(1u << (sector_id % CacheEntries));
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
Result GetSector(u8 **out_sector, u32 sector_id) {
|
||||
/* Try to find in the cache. */
|
||||
for (size_t i = 0; i < CacheEntries; ++i) {
|
||||
if (m_sector_ids[i] == sector_id) {
|
||||
m_sector_flags &= ~(1u << i);
|
||||
*out_sector = m_sector_cache + SectorSize * i;
|
||||
return ResultSuccess();
|
||||
}
|
||||
}
|
||||
|
||||
/* Find a sector to evict. */
|
||||
while ((m_sector_flags & (1u << m_next_idx)) == 0) {
|
||||
m_sector_flags |= (1u << m_next_idx);
|
||||
m_next_idx = (m_next_idx + 1) % CacheEntries;
|
||||
}
|
||||
|
||||
/* Get the chosen sector. */
|
||||
*out_sector = m_sector_cache + SectorSize * m_next_idx;
|
||||
m_next_idx = (m_next_idx + 1) % CacheEntries;
|
||||
|
||||
/* Load the sector. */
|
||||
return this->LoadSector(*out_sector, sector_id);
|
||||
}
|
||||
public:
|
||||
SystemPartitionStorage(s64 ofs, s64 size) : m_storage(*g_user_storage, ofs, size) {
|
||||
/* Allocate sector cache. */
|
||||
m_sector_cache = static_cast<u8 *>(AllocateAligned(CacheEntries * SectorSize, SectorSize));
|
||||
|
||||
/* Allocate sector ids. */
|
||||
m_sector_ids = static_cast<u32 *>(AllocateAligned(CacheEntries * sizeof(u32), alignof(u32)));
|
||||
for (size_t i = 0; i < CacheEntries; ++i) {
|
||||
m_sector_ids[i] = std::numeric_limits<u32>::max();
|
||||
}
|
||||
|
||||
/* All sectors are dirty. */
|
||||
m_sector_flags = ~0u;
|
||||
|
||||
/* Next sector is 0. */
|
||||
m_next_idx = 0;
|
||||
}
|
||||
|
||||
virtual Result Read(s64 offset, void *buffer, size_t size) override {
|
||||
u32 sector_id = offset / SectorSize;
|
||||
s64 subofs = offset % SectorSize;
|
||||
|
||||
u8 *cur_dst = static_cast<u8 *>(buffer);
|
||||
while (size > 0) {
|
||||
/* Get the current sector. */
|
||||
u8 *sector;
|
||||
R_TRY(this->GetSector(std::addressof(sector), sector_id++));
|
||||
|
||||
/* Copy the data. */
|
||||
const size_t cur_size = std::min<size_t>(SectorSize - subofs, size);
|
||||
std::memcpy(cur_dst, sector + subofs, cur_size);
|
||||
|
||||
/* Advance. */
|
||||
cur_dst += cur_size;
|
||||
size -= cur_size;
|
||||
subofs = 0;
|
||||
}
|
||||
|
||||
return ResultSuccess();
|
||||
}
|
||||
|
||||
virtual Result Flush() override {
|
||||
return m_storage.Flush();
|
||||
}
|
||||
|
||||
virtual Result GetSize(s64 *out) override {
|
||||
return m_storage.GetSize(out);
|
||||
}
|
||||
|
||||
virtual Result Write(s64 offset, const void *buffer, size_t size) override {
|
||||
return fs::ResultUnsupportedOperation();
|
||||
}
|
||||
|
||||
virtual Result SetSize(s64 size) override {
|
||||
return fs::ResultUnsupportedOperation();
|
||||
}
|
||||
};
|
||||
|
||||
constinit SystemPartitionStorage *g_system_storage = nullptr;
|
||||
constinit fs::SubStorage *g_package2_storage = nullptr;
|
||||
|
||||
struct Guid {
|
||||
@@ -333,10 +227,6 @@ namespace ams::nxboot {
|
||||
};
|
||||
static_assert(sizeof(Gpt) == 16_KB + 0x200);
|
||||
|
||||
constexpr const u16 SystemPartitionName[] = {
|
||||
'S', 'Y', 'S', 'T', 'E', 'M', 0
|
||||
};
|
||||
|
||||
constexpr const u16 Package2PartitionName[] = {
|
||||
'B', 'C', 'P', 'K', 'G', '2', '-', '1', '-', 'N', 'o', 'r', 'm', 'a', 'l', '-', 'M', 'a', 'i', 'n', 0
|
||||
};
|
||||
@@ -447,27 +337,15 @@ namespace ams::nxboot {
|
||||
const s64 offset = INT64_C(0x200) * gpt->entries[i].starting_lba;
|
||||
const u64 size = UINT64_C(0x200) * (gpt->entries[i].ending_lba + 1 - gpt->entries[i].starting_lba);
|
||||
|
||||
if (std::memcmp(gpt->entries[i].partition_name, SystemPartitionName, sizeof(SystemPartitionName)) == 0) {
|
||||
g_system_storage = AllocateObject<SystemPartitionStorage>(offset, size);
|
||||
} else if (std::memcmp(gpt->entries[i].partition_name, Package2PartitionName, sizeof(Package2PartitionName)) == 0) {
|
||||
if (std::memcmp(gpt->entries[i].partition_name, Package2PartitionName, sizeof(Package2PartitionName)) == 0) {
|
||||
g_package2_storage = AllocateObject<fs::SubStorage>(*g_user_storage, offset, size);
|
||||
}
|
||||
}
|
||||
|
||||
/* Check that we created system storage. */
|
||||
if (g_system_storage == nullptr) {
|
||||
ShowFatalError("Failed to initialize SYSTEM\n");
|
||||
}
|
||||
|
||||
/* Check that we created package2 storage. */
|
||||
if (g_package2_storage == nullptr) {
|
||||
ShowFatalError("Failed to initialize Package2\n");
|
||||
}
|
||||
|
||||
/* Mount system. */
|
||||
if (!fs::MountSystem()) {
|
||||
ShowFatalError("Failed to mount SYSTEM\n");
|
||||
}
|
||||
}
|
||||
|
||||
Result ReadBoot0(s64 offset, void *dst, size_t size) {
|
||||
@@ -478,8 +356,4 @@ namespace ams::nxboot {
|
||||
return g_package2_storage->Read(offset, dst, size);
|
||||
}
|
||||
|
||||
Result ReadSystem(s64 offset, void *dst, size_t size) {
|
||||
return g_system_storage->Read(offset, dst, size);
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@@ -118,26 +118,12 @@ namespace ams::nxboot {
|
||||
return R_SUCCEEDED(fs::GetEntryType(std::addressof(entry_type), std::addressof(archive), path)) && entry_type == fs::DirectoryEntryType_Directory;
|
||||
}
|
||||
|
||||
[[maybe_unused]] bool IsFileExist(const char *path) {
|
||||
bool IsFileExist(const char *path) {
|
||||
fs::DirectoryEntryType entry_type;
|
||||
bool archive;
|
||||
return R_SUCCEEDED(fs::GetEntryType(std::addressof(entry_type), std::addressof(archive), path)) && entry_type == fs::DirectoryEntryType_File;
|
||||
}
|
||||
|
||||
bool IsConcatenationFileExist(const char *path) {
|
||||
fs::DirectoryEntryType entry_type;
|
||||
bool archive;
|
||||
return R_SUCCEEDED(fs::GetEntryType(std::addressof(entry_type), std::addressof(archive), path)) && ((entry_type == fs::DirectoryEntryType_File) || (entry_type == fs::DirectoryEntryType_Directory && archive));
|
||||
}
|
||||
|
||||
constinit char g_nca_path[0x40] = "sys:/contents/registered/xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.nca";
|
||||
|
||||
bool IsNcaExist(const char *nca_name) {
|
||||
std::memcpy(g_nca_path + 0x19, nca_name, 0x20);
|
||||
|
||||
return IsConcatenationFileExist(g_nca_path);
|
||||
}
|
||||
|
||||
bool ConfigureEmummc() {
|
||||
/* Set magic. */
|
||||
g_emummc_cfg.base_cfg.magic = secmon::EmummcBaseConfiguration::Magic;
|
||||
@@ -220,143 +206,56 @@ namespace ams::nxboot {
|
||||
return package1;
|
||||
}
|
||||
|
||||
ams::TargetFirmware GetTargetFirmware(const u8 *package1) {
|
||||
/* Get first an approximation of the target firmware. */
|
||||
ams::TargetFirmware target_firmware = ams::TargetFirmware_Current;
|
||||
ams::TargetFirmware GetApproximateTargetFirmware(const u8 *package1) {
|
||||
/* Get an approximation of the target firmware. */
|
||||
switch (package1[0x1F]) {
|
||||
case 0x01:
|
||||
target_firmware = ams::TargetFirmware_1_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_1_0_0;
|
||||
case 0x02:
|
||||
target_firmware = ams::TargetFirmware_2_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_2_0_0;
|
||||
case 0x04:
|
||||
target_firmware = ams::TargetFirmware_3_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_3_0_0;
|
||||
case 0x07:
|
||||
target_firmware = ams::TargetFirmware_4_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_4_0_0;
|
||||
case 0x0B:
|
||||
target_firmware = ams::TargetFirmware_5_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_5_0_0;
|
||||
case 0x0E:
|
||||
if (std::memcmp(package1 + 0x10, "20180802", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_6_0_0;
|
||||
return ams::TargetFirmware_6_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20181107", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_6_2_0;
|
||||
} else {
|
||||
ShowFatalError("Unable to identify package1!\n");
|
||||
return ams::TargetFirmware_6_2_0;
|
||||
}
|
||||
break;
|
||||
case 0x0F:
|
||||
target_firmware = ams::TargetFirmware_7_0_0;
|
||||
break;
|
||||
return ams::TargetFirmware_7_0_0;
|
||||
case 0x10:
|
||||
if (std::memcmp(package1 + 0x10, "20190314", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_8_0_0;
|
||||
return ams::TargetFirmware_8_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20190531", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_8_1_0;
|
||||
return ams::TargetFirmware_8_1_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20190809", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_9_0_0;
|
||||
return ams::TargetFirmware_9_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20191021", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_9_1_0;
|
||||
return ams::TargetFirmware_9_1_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20200303", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_10_0_0;
|
||||
return ams::TargetFirmware_10_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20201030", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_11_0_0;
|
||||
return ams::TargetFirmware_11_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20210129", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_12_0_0;
|
||||
return ams::TargetFirmware_12_0_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20210422", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_12_0_2;
|
||||
return ams::TargetFirmware_12_0_2;
|
||||
} else if (std::memcmp(package1 + 0x10, "20210607", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_12_1_0;
|
||||
return ams::TargetFirmware_12_1_0;
|
||||
} else if (std::memcmp(package1 + 0x10, "20210805", 8) == 0) {
|
||||
target_firmware = ams::TargetFirmware_13_0_0;
|
||||
} else {
|
||||
ShowFatalError("Unable to identify package1!\n");
|
||||
return ams::TargetFirmware_13_0_0;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
ShowFatalError("Unable to identify package1!\n");
|
||||
break;
|
||||
}
|
||||
|
||||
#define CHECK_NCA(NCA_ID, VERSION) do { if (IsNcaExist(NCA_ID)) { return ams::TargetFirmware_##VERSION; } } while(0)
|
||||
|
||||
if (target_firmware >= ams::TargetFirmware_13_0_0) {
|
||||
CHECK_NCA("bf2337ee88bd9f963a33b3ecbbc3732a", 13_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_12_1_0) {
|
||||
CHECK_NCA("9d9d83d68d9517f245f3e8cd7f93c416", 12_1_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_12_0_2) {
|
||||
CHECK_NCA("a1863a5c0e1cedd442f5e60b0422dc15", 12_0_3);
|
||||
CHECK_NCA("63d928b5a3016fe8cc0e76d2f06f4e98", 12_0_2);
|
||||
} else if (target_firmware >= ams::TargetFirmware_12_0_0) {
|
||||
CHECK_NCA("e65114b456f9d0b566a80e53bade2d89", 12_0_1);
|
||||
CHECK_NCA("bd4185843550fbba125b20787005d1d2", 12_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_11_0_0) {
|
||||
CHECK_NCA("56211c7a5ed20a5332f5cdda67121e37", 11_0_1);
|
||||
CHECK_NCA("594c90bcdbcccad6b062eadba0cd0e7e", 11_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_10_0_0) {
|
||||
CHECK_NCA("26325de4db3909e0ef2379787c7e671d", 10_2_0);
|
||||
CHECK_NCA("5077973537f6735b564dd7475b779f87", 10_1_1); /* Exclusive to China. */
|
||||
CHECK_NCA("fd1faed0ca750700d254c0915b93d506", 10_1_0);
|
||||
CHECK_NCA("34728c771299443420820d8ae490ea41", 10_0_4);
|
||||
CHECK_NCA("5b1df84f88c3334335bbb45d8522cbb4", 10_0_3);
|
||||
CHECK_NCA("e951bc9dedcd54f65ffd83d4d050f9e0", 10_0_2);
|
||||
CHECK_NCA("36ab1acf0c10a2beb9f7d472685f9a89", 10_0_1);
|
||||
CHECK_NCA("5625cdc21d5f1ca52f6c36ba261505b9", 10_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_9_1_0) {
|
||||
CHECK_NCA("09ef4d92bb47b33861e695ba524a2c17", 9_2_0);
|
||||
CHECK_NCA("c5fbb49f2e3648c8cfca758020c53ecb", 9_1_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_9_0_0) {
|
||||
CHECK_NCA("fd1ffb82dc1da76346343de22edbc97c", 9_0_1);
|
||||
CHECK_NCA("a6af05b33f8f903aab90c8b0fcbcc6a4", 9_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_8_1_0) {
|
||||
CHECK_NCA("724d9b432929ea43e787ad81bf09ae65", 8_1_1); /* 8.1.1-100 from Lite */
|
||||
CHECK_NCA("e9bb0602e939270a9348bddd9b78827b", 8_1_1); /* 8.1.1-12 from chinese gamecard */
|
||||
CHECK_NCA("7eedb7006ad855ec567114be601b2a9d", 8_1_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_8_0_0) {
|
||||
CHECK_NCA("6c5426d27c40288302ad616307867eba", 8_0_1);
|
||||
CHECK_NCA("4fe7b4abcea4a0bcc50975c1a926efcb", 8_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_7_0_0) {
|
||||
CHECK_NCA("e6b22c40bb4fa66a151f1dc8db5a7b5c", 7_0_1);
|
||||
CHECK_NCA("c613bd9660478de69bc8d0e2e7ea9949", 7_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_6_2_0) {
|
||||
CHECK_NCA("6dfaaf1a3cebda6307aa770d9303d9b6", 6_2_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_6_0_0) {
|
||||
CHECK_NCA("1d21680af5a034d626693674faf81b02", 6_1_0);
|
||||
CHECK_NCA("663e74e45ffc86fbbaeb98045feea315", 6_0_1);
|
||||
CHECK_NCA("258c1786b0f6844250f34d9c6f66095b", 6_0_0); /* Release 6.0.0-5.0 */
|
||||
CHECK_NCA("286e30bafd7e4197df6551ad802dd815", 6_0_0); /* Pre-Release 6.0.0-4.0 */
|
||||
} else if (target_firmware >= ams::TargetFirmware_5_0_0) {
|
||||
CHECK_NCA("fce3b0ea366f9c95fe6498b69274b0e7", 5_1_0);
|
||||
CHECK_NCA("c5758b0cb8c6512e8967e38842d35016", 5_0_2);
|
||||
CHECK_NCA("53eb605d4620e8fd50064b24fd57783a", 5_0_1);
|
||||
CHECK_NCA("09a2f9c16ce1c121ae6d231b35d17515", 5_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_4_0_0) {
|
||||
CHECK_NCA("77e1ae7661ad8a718b9b13b70304aeea", 4_1_0);
|
||||
CHECK_NCA("d0e5d20e3260f3083bcc067483b71274", 4_0_1);
|
||||
CHECK_NCA("483a24ee3fd7149f9112d1931166a678", 4_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_3_0_0) {
|
||||
CHECK_NCA("704129fc89e1fcb85c37b3112e51b0fc", 3_0_2);
|
||||
CHECK_NCA("1fb00543307337d523ccefa9923e0c50", 3_0_1);
|
||||
CHECK_NCA("6ebd3447473bade18badbeb5032af87d", 3_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_2_0_0) {
|
||||
CHECK_NCA("d1c991c53a8a9038f8c3157a553d876d", 2_3_0);
|
||||
CHECK_NCA("7f90353dff2d7ce69e19e07ebc0d5489", 2_2_0);
|
||||
CHECK_NCA("e9b3e75fce00e52fe646156634d229b4", 2_1_0);
|
||||
CHECK_NCA("7a1f79f8184d4b9bae1755090278f52c", 2_0_0);
|
||||
} else if (target_firmware >= ams::TargetFirmware_1_0_0) {
|
||||
CHECK_NCA("a1b287e07f8455e8192f13d0e45a2aaf", 1_0_0); /* 1.0.0 from Factory */
|
||||
CHECK_NCA("117f7b9c7da3e8cef02340596af206b3", 1_0_0); /* 1.0.0 from Gamecard */
|
||||
} else {
|
||||
ShowFatalError("Unable to determine target firmware!\n");
|
||||
}
|
||||
|
||||
#undef CHECK_NCA
|
||||
|
||||
/* If we didn't find a more specific firmware, return our package1 approximation. */
|
||||
return target_firmware;
|
||||
ShowFatalError("Unable to identify package1!\n");
|
||||
}
|
||||
|
||||
u8 *LoadBootConfigAndPackage2() {
|
||||
@@ -825,7 +724,7 @@ namespace ams::nxboot {
|
||||
const u8 * const package1 = LoadPackage1(soc_type);
|
||||
|
||||
/* Get target firmware. */
|
||||
const auto target_firmware = GetTargetFirmware(package1);
|
||||
const auto target_firmware = GetApproximateTargetFirmware(package1);
|
||||
|
||||
/* Read/decrypt package2. */
|
||||
u8 * const package2 = LoadBootConfigAndPackage2();
|
||||
|
||||
Reference in New Issue
Block a user