diff options
author | takeshi_hoshina <takeshi_hoshina@mail.toyota.co.jp> | 2020-10-27 11:16:21 +0900 |
---|---|---|
committer | takeshi_hoshina <takeshi_hoshina@mail.toyota.co.jp> | 2020-10-27 11:16:21 +0900 |
commit | 947c78887e791596d4a5ec2d1079f8b1a049628b (patch) | |
tree | 3981e88eb8764d7180722f8466f36b756dc005af /systemservice/rom_access_library/library/rom/src | |
parent | 706ad73eb02caf8532deaf5d38995bd258725cb8 (diff) |
basesystem 0.1sandbox/ToshikazuOhiwa/basesystem
Diffstat (limited to 'systemservice/rom_access_library/library/rom/src')
4 files changed, 1343 insertions, 0 deletions
diff --git a/systemservice/rom_access_library/library/rom/src/ss_sm_boot_access.cpp b/systemservice/rom_access_library/library/rom/src/ss_sm_boot_access.cpp new file mode 100644 index 00000000..44e8a531 --- /dev/null +++ b/systemservice/rom_access_library/library/rom/src/ss_sm_boot_access.cpp @@ -0,0 +1,122 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "system_service/ss_sm_boot_access.h" +#include <stdio.h> +#include <native_service/cl_lock.h> +#include <native_service/cl_lockid.h> +#include "system_service/nor_backup.h" +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_rom_access_define.h" + +#define BAI_MTD_DEV_RO "/dev/mtd1ro" // NOR device for RO +#define BAI_MTD_DEV_RW "/dev/mtd1" // NOR device for RW + +#define BAI_SERCTOR_OFFSET 0 +#define BAI_DATA_OFFSET 0 + +void* BOOT_AccessIf::g_m_plock = NULL; + +BOOT_AccessIf::BOOT_AccessIf(BAI_OPEN_t type) + : m_type(type) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (!(m_type == BAI_OPEN_RO // LCOV_EXCL_BR_LINE 6: double check + || m_type == BAI_OPEN_RW)) { // LCOV_EXCL_BR_LINE 6: double check + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + throw __LINE__; // LCOV_EXCL_LINE 6: double check + } + + if (g_m_plock == NULL) { + g_m_plock = CL_LockMap(LOCK_BOOT_ACCESS_IF); + + if (g_m_plock == MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + } + } + + if (g_m_plock) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0 == CL_LockGet(g_m_plock)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +BOOT_AccessIf::~BOOT_AccessIf() { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (g_m_plock) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); +} + +EFrameworkunifiedStatus BOOT_AccessIf::getBootInfo(LBM_NOR_t* p_bootInfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus eRet = eFrameworkunifiedStatusOK; + try { + int ret; + if (p_bootInfo == NULL) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + ret = mtdn_backup_Read((const char *) BAI_MTD_DEV_RO, BAI_SERCTOR_OFFSET, + BAI_DATA_OFFSET, sizeof(LBM_NOR_t), p_bootInfo); // LCOV_EXCL_BR_LINE 11:unexpected branch + + if (ret != 0) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + } catch (...) { + eRet = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eRet; +} + +EFrameworkunifiedStatus BOOT_AccessIf::setBootInfo(LBM_NOR_t* p_bootInfo) { + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + EFrameworkunifiedStatus eRet = eFrameworkunifiedStatusOK; + try { + int ret; + if (p_bootInfo == NULL) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + if (m_type != BAI_OPEN_RW) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw __LINE__; + } + ret = mtdn_backup_Write((const char *) BAI_MTD_DEV_RW, BAI_SERCTOR_OFFSET, + BAI_DATA_OFFSET, sizeof(LBM_NOR_t), p_bootInfo); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (ret != 0) { // LCOV_EXCL_BR_LINE 5:c API error case + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); // LCOV_EXCL_LINE 5:c API error case + throw __LINE__; // LCOV_EXCL_LINE 5:c API error case + } + } catch (...) { + eRet = eFrameworkunifiedStatusFail; + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eRet; +} + diff --git a/systemservice/rom_access_library/library/rom/src/ss_sm_checksum.cpp b/systemservice/rom_access_library/library/rom/src/ss_sm_checksum.cpp new file mode 100644 index 00000000..52cb1147 --- /dev/null +++ b/systemservice/rom_access_library/library/rom/src/ss_sm_checksum.cpp @@ -0,0 +1,37 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SystemManager +/// \brief This file provides for checksum calculation. +/// +/////////////////////////////////////////////////////////////////////////////// +#include "ss_sm_checksum.h" + +CSMChecksum::CSMChecksum() {} +CSMChecksum::~CSMChecksum() {} +UI_32 CSMChecksum::cal_checksum(const void* p_buf, size_t bufSize) { + size_t num; + UI_32 sum = 0; + const UI_32 *p_calcBuf = reinterpret_cast<const UI_32 *>(p_buf); + num = bufSize / sizeof(UI_32); + + for (size_t i = 0; i < num; i++) { + sum += p_calcBuf[i]; + } + return sum; +} + diff --git a/systemservice/rom_access_library/library/rom/src/ss_sm_ram_access.cpp b/systemservice/rom_access_library/library/rom/src/ss_sm_ram_access.cpp new file mode 100644 index 00000000..b5cf244b --- /dev/null +++ b/systemservice/rom_access_library/library/rom/src/ss_sm_ram_access.cpp @@ -0,0 +1,215 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "system_service/ss_sm_ram_access.h" +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <native_service/cl_lock.h> +#include <native_service/cl_lockid.h> +#include <stub/el_mem.h> +#include "system_service/ss_sm_boot_access.h" +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_sm_checksum.h" +#include "ss_rom_access_define.h" + + + +#define RAM_PATH "/nv/BS/ss/rom_access_library/rwdata/ramdata.dat" +#define RAM_OLD_PATH RAM_PATH".old" +static const uint8_t kSigNature[] = { 0xDE, 0xAD, 0xBE, 0xEF }; +static const uint8_t kMagic[] = { 0xDE, 0xAD, 0xBE, 0xEF }; + +void* RAM_AccessIf::g_m_plock = NULL; +void* RAM_AccessIf::g_m_bakup_map = MAP_FAILED; +bool RAM_AccessIf::g_m_is_first_access = false; + +typedef struct { + char magic_in[4]; + RAM_SM_INFO_t data0; + uint32_t checksum0; + RAM_SM_INFO_t data1; + uint32_t checksum1; + char magic_out[4]; +} RAM_SM_DRAM_INFO_t; + +void RAM_AccessIf::initRamBackupEnable(RAM_WAKEUP_STATE wupState) { + RAM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + + ROM_ACCESS_STATIC_ASERT(sizeof(RAM_SM_DRAM_INFO_t) <= SS_SYS_AREA_RAM_MAX_SIZE); + // Checking sizes because checksum calculations expect 4 bytes alignments + ROM_ACCESS_STATIC_ASERT((sizeof(RAM_SM_DRAM_INFO_t) % sizeof(UI_32)) == 0); + + if (g_m_bakup_map == MAP_FAILED) { + g_m_bakup_map = EL_mem_exram_mmap( // LCOV_EXCL_BR_LINE 11:unexpected branch + EL_MEM_TYPE_REGION_SYS, + EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_RAM_OFFSET, // LCOV_EXCL_BR_LINE 11:unexpected branch + SS_SYS_AREA_RAM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, + EL_MEM_CACHE_INVALID); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + return; // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + } + } + p_buf = static_cast<RAM_SM_DRAM_INFO_t*>(g_m_bakup_map); + + // LCOV_EXCL_BR_START 6:impossible to confirm because wupState can not be changed + if ((RAM_WAKEUP_STATE_BACKUP_NG == wupState) || + (RAM_WAKEUP_STATE_BATTERY_DOWN == wupState) || + (memcmp(p_buf->magic_out, kMagic, sizeof(kMagic)) != 0) || + (memcmp(p_buf->magic_in, p_buf->magic_out, sizeof(p_buf->magic_in)) != 0)) { + // LCOV_EXCL_BR_STOP + // BACKUP NG + g_m_is_first_access = false; + bzero(p_buf, sizeof(RAM_SM_DRAM_INFO_t)); + } + + if (!g_m_is_first_access) { + // LCOV_EXCL_BR_START 11:unexpected branch + if ((memcmp(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)) == 0) + && (memcmp(p_buf->data0.signature_out, kSigNature, + sizeof(kSigNature)) == 0) + && (l_checksum.cal_checksum(&(p_buf->data0), sizeof(p_buf->data0)) == p_buf->checksum0)) { + // LCOV_EXCL_BR_STOP + // Use data0 content + memcpy(&(p_buf->data1), &(p_buf->data0), sizeof(p_buf->data1)); + p_buf->checksum1 = p_buf->checksum0; + // LCOV_EXCL_BR_START 11:unexpected branch + } else if ((memcmp(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)) == 0) + && (memcmp(p_buf->data1.signature_out, kSigNature, + sizeof(kSigNature)) == 0) + && (l_checksum.cal_checksum(&(p_buf->data1), sizeof(p_buf->data1)) == p_buf->checksum1)) { + // LCOV_EXCL_BR_STOP + // Use data1 content + memcpy(&(p_buf->data0), &(p_buf->data1), sizeof(p_buf->data0)); + p_buf->checksum0 = p_buf->checksum1; + } else { + // BACKUP NG or SIGNATURE CHECK or CHECK SUM NG + bzero(p_buf, sizeof(RAM_SM_DRAM_INFO_t)); + memcpy(p_buf->magic_in, kMagic, sizeof(kMagic)); + // data0 + memcpy(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)); + memcpy(p_buf->data0.signature_out, kSigNature, sizeof(kSigNature)); + p_buf->checksum0 = + l_checksum.cal_checksum(&(p_buf->data0), sizeof(p_buf->data0)); // LCOV_EXCL_BR_LINE 11:unexpected branch + // data1 + memcpy(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)); + memcpy(p_buf->data1.signature_out, kSigNature, sizeof(kSigNature)); + p_buf->checksum1 = + l_checksum.cal_checksum(&(p_buf->data1), sizeof(p_buf->data1)); // LCOV_EXCL_BR_LINE 11:unexpected branch + memcpy(p_buf->magic_out, kMagic, sizeof(kMagic)); + } + } + memcpy(&m_buf, &(p_buf->data0), sizeof(p_buf->data0)); +} + +void RAM_AccessIf::finalRamBackupEnable(void) { + RAM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + return; // LCOV_EXCL_LINE 6:impossible to confirm because g_m_bakup_map can not be changed + } + + p_buf = static_cast<RAM_SM_DRAM_INFO_t*>(g_m_bakup_map); + + // kSigNature is cleared during writing + bzero(m_buf.signature_in, sizeof(kSigNature)); + + // data0 + memcpy(&(p_buf->data0), &m_buf, sizeof(p_buf->data0)); + memcpy(p_buf->data0.signature_in, kSigNature, sizeof(kSigNature)); + p_buf->checksum0 = l_checksum.cal_checksum(&(p_buf->data0), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data0)); + + // data1 + memcpy(&(p_buf->data1), &m_buf, sizeof(p_buf->data1)); + memcpy(p_buf->data1.signature_in, kSigNature, sizeof(kSigNature)); + p_buf->checksum1 = l_checksum.cal_checksum(&(p_buf->data1), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data1)); + + // Set kSigNature + memcpy(m_buf.signature_in, kSigNature, + sizeof(kSigNature)); +} + +RAM_AccessIf::RAM_AccessIf( + RAM_WAKEUP_STATE wupState /* = RAM_WAKEUP_STATE_DONT_CARE */) + : m_buf(), + m_dirty(false) { + + if (g_m_plock == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + g_m_plock = CL_LockMap(LOCK_RAM_ACCESS_IF); + if (g_m_plock == MAP_FAILED) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + g_m_plock = NULL; + } + } + if (g_m_plock) { + if (0 != CL_LockGet(g_m_plock)) { + ROM_ACCESS_ASERT(0); + } + } + + if (RAM_WAKEUP_STATE_BATTERY_DOWN == wupState) { // LCOV_EXCL_BR_LINE 13: + // Models without DRAM backups are initialized when +B is down. + // Deletes files because models with DRAM backups are also backwards compatible + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + unlink(RAM_PATH); // LCOV_EXCL_LINE 13: + unlink(RAM_OLD_PATH); // LCOV_EXCL_LINE 13: + } + + initRamBackupEnable(wupState); + g_m_is_first_access = true; +} + +RAM_AccessIf::~RAM_AccessIf() { + if (m_dirty) { + finalRamBackupEnable(); + } + if (g_m_plock) { + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); + } + + return; +} + +EFrameworkunifiedStatus RAM_AccessIf::getRamInfo(RAM_SM_INFO_t* p_bootInfo) { + *p_bootInfo = m_buf; + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus RAM_AccessIf::setRamInfo(RAM_SM_INFO_t* p_bootInfo) { + if (0 != memcmp(&m_buf, p_bootInfo, sizeof(m_buf))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + m_buf = *p_bootInfo; + m_dirty = true; + } + + return eFrameworkunifiedStatusOK; +} diff --git a/systemservice/rom_access_library/library/rom/src/ss_sm_rom_access.cpp b/systemservice/rom_access_library/library/rom/src/ss_sm_rom_access.cpp new file mode 100644 index 00000000..53589c29 --- /dev/null +++ b/systemservice/rom_access_library/library/rom/src/ss_sm_rom_access.cpp @@ -0,0 +1,969 @@ +/* + * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +/////////////////////////////////////////////////////////////////////////////// +/// \ingroup tag_SS_RomAccess +/// \brief This file supports ROM Access. +/// +/////////////////////////////////////////////////////////////////////////////// +#include "system_service/ss_sm_rom_access.h" +#include <fcntl.h> +#include <stdlib.h> +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <unistd.h> + +#include <native_service/frameworkunified_types.h> +#include <native_service/frameworkunified_framework_types.h> + +#include <stub/el_mem.h> +#include <native_service/cl_lock.h> +#include <native_service/cl_lockid.h> + +#include "ss_rom_access_if_romaccesslibrarylog.h" +#include "ss_sm_checksum.h" +#include "ss_rom_access_define.h" + +#define ROM_ACCESS_DIR "/nv/BS/ss/rom_access_library/rwdata" +#define ROM_ACCESS_FILE "romdata.dat" +const CHAR kDefaultRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE; +const CHAR kRecoveryRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE".old"; +static const uint8_t kMagic[] = { 0xDE, 0xAD, 0xBE, 0xEF }; + +typedef enum { + INDEX_BOOTFLAG = 0, + INDEX_ACTIVE_FLASHLOADER, + INDEX_PARTITIONS_RW_FLAG, + INDEX_LAST_USER_MODE, + INDEX_TRANSPORT_MODE, + INDEX_PRODUCTION_MODE, + INDEX_LIMP_HOME_CUT_OFF_REQUEST, + INDEX_DATARESET_MODE, + INDEX_RESET_COUNT, + INDEX_LAST_ILGRESET, + INDEX_PROGUPDATE_STATE, + INDEX_ERR_LOG_COUNT, + INDEX_NEXT_WAKEUP_TYPE, + INDEX_SIGNATURE = 15, // As far as possible, do not modify this index value!!!!! + INDEX_PROG_STATE = 20, + INDEX_PROG_STATE_END = 63, + INDEX_PRODUCT_PRIVATE, // 64 + INDEX_PRODUCT_PRIVATE_END = (INDEX_PRODUCT_PRIVATE + ROM_PRODUCT_PRIVATE_MAX + - 1), + INDEX_MAX +} eRomIndices; + +void* ROM_AccessIf::g_m_plock = NULL; +void* ROM_AccessIf::g_m_bakup_map = MAP_FAILED; +bool ROM_AccessIf::g_m_is_dram_valid = false; + +typedef struct { + char magic_in[4]; + bool is_dirty; + UI_32 data[INDEX_MAX]; + uint32_t checksum; + char magic_out[4]; +} ROM_SM_DRAM_INFO_t; + +ROM_AccessIf::ROM_AccessIf() + : m_pBoot(NULL), + m_norIsDirty(false) { + bzero(&m_nor, sizeof(m_nor)); + + if (g_m_plock == NULL) { + g_m_plock = CL_LockMap(LOCK_ROM_ACCESS_IF); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, __FUNCTION__, + "CL_LockMap Error, please check whether you call CL_LockProcessInit"); + // LCOV_EXCL_BR_STOP + } + } + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (0 != CL_LockGet(g_m_plock)) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed + } + } +} + +ROM_AccessIf::~ROM_AccessIf() { + if (m_pBoot) { + if (m_norIsDirty) { + ROM_ACCESS_ASERT(eFrameworkunifiedStatusOK == m_pBoot->setBootInfo(&m_nor)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + delete m_pBoot; // LCOV_EXCL_BR_LINE 11:unexpected branch + m_pBoot = NULL; + } + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed + if (g_m_plock) { + ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock)); + } // LCOV_EXCL_BR_STOP +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Read(UI_32 offset, UI_32* buffer, + UI_32 word_count) { + ROM_SM_DRAM_INFO_t* p_buf; + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize"); + return eFrameworkunifiedStatusFail; + } + + p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map); + memcpy(buffer, &p_buf->data[offset], word_count * sizeof(UI_32)); + + return eFrameworkunifiedStatusOK; +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32 value) { + UI_32 l_value = value; + return LBA_Write(offset, &l_value, sizeof(UI_32)); +} + +EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32* value, UI_32 size) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + const CHAR *l_file = kDefaultRomDevice; + SI_32 fd = -1; + ROM_SM_DRAM_INFO_t* p_buf; + if (g_m_bakup_map == MAP_FAILED) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize"); + return eFrameworkunifiedStatusFail; + } + + p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map); + + if (memcmp(&p_buf->data[offset], value, size) == 0) { + // Not Write when the value does not change + return eFrameworkunifiedStatusOK; + } + + p_buf->is_dirty = true; + memcpy(&p_buf->data[offset], value, size); + + CSMChecksum l_checksum; + p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data), // LCOV_EXCL_BR_LINE 11:unexpected branch + sizeof(p_buf->data)); // LCOV_EXCL_BR_LINE 11:unexpected branch + + if (0 != rename(kDefaultRomDevice, kRecoveryRomDevice)) { + ROM_ACCESS_ERRNO(0); + } else { + int sync_fd; + sync_fd = open(kRecoveryRomDevice, O_RDWR | O_DSYNC | O_CLOEXEC); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (sync_fd != -1) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0 == fsync(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0 == close(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed. + } + } + fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC, 00664); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (fd == -1) { + ROM_ACCESS_ERRNO(0); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: open(%s) returned -1", l_file); + eStatus = eFrameworkunifiedStatusFail; + goto ERROR; + } + + /** Write the value of 32-bits at offset location */ + if (sizeof(p_buf->data) != write(fd, p_buf->data, sizeof(p_buf->data))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_START 5:It's impossible to mock write() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: write(%s) returned -1", l_file); + eStatus = eFrameworkunifiedStatusFail; + goto ERROR; + // LCOV_EXCL_STOP + } else { + ROM_ACCESS_ERRNO(0 == close(fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + fd = -1; + + if (0 != unlink(kRecoveryRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_START 5:It's impossible to mock unlink() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } + + int sync_fd; + sync_fd = open(ROM_ACCESS_DIR, O_RDONLY); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (sync_fd != -1) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0 == fsync(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0 == close(sync_fd)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed. + } + } + p_buf->is_dirty = false; + ERROR: if (fd != -1) { // LCOV_EXCL_BR_LINE 5:It's impossible to mock open() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + close(fd); // LCOV_EXCL_LINE 5:It's impossible to mock write() function,so this line can not be passed. + } + // @todo memory value is not restored if non-volatile area writing fails after writing to memory + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode_sub(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_DATARESET_MODE, + reinterpret_cast<UI_32 *>(pDataResetMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +// This function may be called in duplicate, +// so it is necessary to operate normally even if it is called in duplicate. +EFrameworkunifiedStatus ROM_AccessIf::SystemInitialize(DRAM_BACKUP_STATE bkupState) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + ROM_ACCESS_STATIC_ASERT(sizeof(ROM_SM_DRAM_INFO_t) <= SS_SYS_AREA_ROM_MAX_SIZE); + + // Checksum calculations expect 4-bytes alignments + ROM_ACCESS_STATIC_ASERT((sizeof(ROM_SM_DRAM_INFO_t) % sizeof(UI_32)) == 0); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + g_m_bakup_map = EL_mem_exram_mmap( + EL_MEM_TYPE_REGION_SYS, + EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET, + SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, + EL_MEM_CACHE_INVALID); + if (g_m_bakup_map == MAP_FAILED) { + ROM_ACCESS_ERRNO(0); + return eFrameworkunifiedStatusFail; + } + } + + if (bkupState + == DRAM_BACKUP_STATE_NG) { + // BACKUP NG + ROM_SM_DRAM_INFO_t* p_buf; + CSMChecksum l_checksum; + + p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map); + bzero(&(p_buf->magic_in), sizeof(p_buf->magic_in)); + bzero(&(p_buf->magic_out), sizeof(p_buf->magic_out)); + g_m_is_dram_valid = false; + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::Initialize() { + const CHAR *l_file = kDefaultRomDevice; + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + CSMChecksum l_checksum; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (g_m_bakup_map == MAP_FAILED) { + g_m_bakup_map = EL_mem_exram_mmap( // LCOV_EXCL_BR_LINE 11:unexpected branch + EL_MEM_TYPE_REGION_SYS, + EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET, // LCOV_EXCL_BR_LINE 11:unexpected branch + SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, + EL_MEM_CACHE_INVALID); + // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed + if (g_m_bakup_map == MAP_FAILED) { + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ERRNO(0); + return eFrameworkunifiedStatusFail; + } + } + if (!g_m_is_dram_valid) { + SI_32 fd = -1; + ROM_SM_DRAM_INFO_t* p_buf; + p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map); + if ((p_buf->is_dirty) + || (memcmp(kMagic, p_buf->magic_in, sizeof(kMagic)) != 0) + || (memcmp(kMagic, p_buf->magic_out, sizeof(kMagic)) != 0) + || ((l_checksum.cal_checksum(&(p_buf->data), sizeof(p_buf->data)) != p_buf->checksum))) { + // Need to synchronize the NVs with the data on the DRAM + struct stat stutInfo; + if (0 != stat(ROM_ACCESS_DIR, &stutInfo)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock stat() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s not found", ROM_ACCESS_DIR); + // LCOV_EXCL_BR_STOP + ROM_ACCESS_ASERT(0 == mkdir(ROM_ACCESS_DIR, 0775)); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + int expectSize = (INT32)(INDEX_MAX * sizeof(UI_32)); + int sigSize = (INT32)((INDEX_SIGNATURE + 1) * sizeof(UI_32)); + + if (access(kRecoveryRomDevice, F_OK) == 0) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock access() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s is found", kRecoveryRomDevice); + // LCOV_EXCL_BR_STOP + if (0 != unlink(kDefaultRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock unlink() function,so this line can not be passed. + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error:unlink(%s)", kDefaultRomDevice); + // LCOV_EXCL_BR_STOP + } + if (0 != rename(kRecoveryRomDevice, kDefaultRomDevice)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } + if (0 == stat(kDefaultRomDevice, &stutInfo) // LCOV_EXCL_BR_LINE 11:unexpected branch + && stutInfo.st_size >= sigSize) { // LCOV_EXCL_BR_LINE 11:unexpected branch + // Use this value if there are more sizes than SIGNITURE + #define ROM_ACCESS_INFO_SIZE (sizeof(ROM_SM_DRAM_INFO_t) - (sizeof(UI_32)*INDEX_MAX)) + #define ROM_ACCESS_MAX_SIZE (INT32)(SS_SYS_AREA_ROM_MAX_SIZE - ROM_ACCESS_INFO_SIZE) + // Maximum size of RAM area - An upper size limit of the management info size + if (stutInfo.st_size > ROM_ACCESS_MAX_SIZE) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + stutInfo.st_size = ROM_ACCESS_MAX_SIZE; + } + fd = open(l_file, // LCOV_EXCL_BR_LINE 11:unexpected branch + O_RDWR | O_DSYNC | O_CLOEXEC); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + int ret; + if (stutInfo.st_size < expectSize) { + // If the files are large, APPEND them + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "PADDING"); + ret = ftruncate(fd, expectSize); + ROM_ACCESS_ERRNO(ret == 0); + fsync(fd); + } else if (stutInfo.st_size > expectSize) { + // If the files are small, TRANC them + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "CUT"); + ret = ftruncate(fd, expectSize); + ROM_ACCESS_ERRNO(ret == 0); + fsync(fd); + } + } + // LCOV_EXCL_BR_STOP + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s size is not crrect", + kDefaultRomDevice); + // LCOV_EXCL_BR_STOP + fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC, + 00664); // LCOV_EXCL_BR_LINE 11:unexpected branch + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + UI_32 buf[INDEX_MAX]; + bzero(buf, sizeof(buf)); + ROM_ACCESS_ASERT(sizeof(buf) == write(fd, buf, sizeof(buf))) + fsync(fd); + } + // LCOV_EXCL_BR_STOP + } + // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed. + if (fd != -1) { + // LCOV_EXCL_BR_STOP + UI_32 read_buf[INDEX_MAX]; + if (-1 == lseek(fd, 0, SEEK_SET)) { + // LCOV_EXCL_START 5:It's impossible to mock lseek() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } else { + if (-1 == read(fd, read_buf, sizeof(read_buf))) { + // LCOV_EXCL_START 5:It's impossible to mock read() function,so this line can not be passed. + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ERRNO(0); + // LCOV_EXCL_STOP + } else { + memcpy(p_buf->magic_in, kMagic, sizeof(kMagic)); + memcpy(&p_buf->data, read_buf, sizeof(p_buf->data)); + p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data), + sizeof(p_buf->data)); + memcpy(p_buf->magic_out, kMagic, sizeof(kMagic)); + p_buf->is_dirty = false; + + // Synchronization of NV data with data on the DRAM completed + g_m_is_dram_valid = true; + } + } + close(fd); + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:open(%s)", l_file); + // LCOV_EXCL_BR_STOP + } + } else { + // No need to synchronize NV data with data on the DRAM + g_m_is_dram_valid = true; + } + } else { + // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h" + FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " alreay initialized"); + // LCOV_EXCL_BR_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetSignature(UI_32* pSigValue) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_SIGNATURE, + reinterpret_cast<UI_32 *>(pSigValue), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetSignature(UI_32 sigValue) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_SIGNATURE, + sigValue))) { + // LCOV_EXCL_BR_STOP + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(0x%X) errored: 0x%X", + sigValue, eStatus); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetBootMode(EBOOT_MODE* pBootMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_BOOTFLAG, + reinterpret_cast<UI_32 *>(pBootMode), 1))) { + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, + " Error: LBA_Read() errored: 0x%X", eStatus); + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetBootMode(EBOOT_MODE bootMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_BOOTFLAG, bootMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%d) errored: 0x%X", + bootMode, eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetLastUserMode(EUSER_MODE* pUserMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_USER_MODE, + reinterpret_cast<UI_32 *>(pUserMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLastUserMode(EUSER_MODE userMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_LAST_USER_MODE, userMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + userMode == USER_OFF ? "USER_OFF" : "USER_ON", eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetTransportMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_TRANSPORT_MODE, + reinterpret_cast<UI_32 *>(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetTransportMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_TRANSPORT_MODE, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + + +EFrameworkunifiedStatus ROM_AccessIf::GetProductionMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PRODUCTION_MODE, + reinterpret_cast<UI_32 *>(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProductionMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PRODUCTION_MODE, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetLimpHomeCutOffReqMode(ECONTROL_MODE* pControlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LIMP_HOME_CUT_OFF_REQUEST, + reinterpret_cast<UI_32 *>(pControlMode), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLimpHomeCutOffReqMode(ECONTROL_MODE controlMode) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_LIMP_HOME_CUT_OFF_REQUEST, controlMode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X", + controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + try { + UI_32 sts; + if (m_pBoot == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed + m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW); // LCOV_EXCL_BR_LINE 11:unexpected branch + if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw eFrameworkunifiedStatusFail; + } + } + + if ((m_nor.sts1 == m_nor.sts2) || (m_nor.sts1 == m_nor.sts3)) { + sts = m_nor.sts1; + } else if (m_nor.sts2 == m_nor.sts3) { + sts = m_nor.sts2; + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } else { + sts = SYSUP_CND_NORMAL; + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + + if (sts == SYSUP_CND_FACTRESET) { + *pDataResetMode = DATARESET_FACTORY; + } else { + eStatus = GetDataResetMode_sub(pDataResetMode); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } catch (const EFrameworkunifiedStatus& e) { + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetDataResetModeFast(EDATARESET_MODE* pDataResetMode) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + void* p_map = MAP_FAILED; + size_t mapSize = 0; + try { + LBM_RAM_t* p_lbm = NULL; + mapSize = SS_SYS_AREA_BOOT_MAX_SIZE; + + if (EL_mem_getLength(EL_MEM_ID_SYS_BOOT) < SS_SYS_AREA_BOOT_MAX_SIZE) { // LCOV_EXCL_BR_LINE 11:unexpected branch + mapSize = EL_mem_getLength(EL_MEM_ID_SYS_BOOT); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + // LCOV_EXCL_BR_START 11:unexpected branch + p_map = reinterpret_cast<LBM_RAM_t*>(EL_mem_exram_mmap(EL_MEM_TYPE_REGION_SYS, + EL_mem_getOffset(EL_MEM_ID_SYS_BOOT), + mapSize, PROT_READ | PROT_WRITE, + MAP_SHARED, EL_MEM_CACHE_INVALID)); + // LCOV_EXCL_BR_STOP + if (p_map == MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed + ROM_ACCESS_ERRNO(0); // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed + throw eFrameworkunifiedStatusFail; + } + p_lbm = static_cast<LBM_RAM_t*>(p_map); + if (p_lbm->sts == SYSUP_CND_FACTRESET) { + *pDataResetMode = DATARESET_FACTORY; + } else { + eStatus = GetDataResetMode_sub(pDataResetMode); // LCOV_EXCL_BR_LINE 11:unexpected branch + } + } catch (const EFrameworkunifiedStatus& e) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + if (p_map != MAP_FAILED) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed + ROM_ACCESS_ERRNO(0 == EL_mem_exram_munmap(p_map, // LCOV_EXCL_BR_LINE 11:unexpected branch + mapSize)); + } + return eStatus; // LCOV_EXCL_BR_LINE 11:unexpected branch +} + +EFrameworkunifiedStatus ROM_AccessIf::SetDataResetMode(EDATARESET_MODE dataResetMode) { + EFrameworkunifiedStatus eStatus; + EDATARESET_MODE l_mode = dataResetMode; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + try { + if (m_pBoot == NULL) { // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed + // LCOV_EXCL_BR_START 11:unexpected branch + m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW); + // LCOV_EXCL_BR_STOP + if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) { // LCOV_EXCL_BR_LINE 11:unexpected branch + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + throw eFrameworkunifiedStatusFail; + } + } + m_norIsDirty = true; + if (dataResetMode == DATARESET_FACTORY) { + m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_FACTRESET; + l_mode = DATARESET_NONE; + } else { + m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_NORMAL; + } + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_DATARESET_MODE, l_mode))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", + eStatus); + // LCOV_EXCL_STOP + } + } catch (const EFrameworkunifiedStatus& e) { + ROM_ACCESS_ASERT(0); // LCOV_EXCL_BR_LINE 11:unexpected branch + eStatus = e; + } catch (...) { // LCOV_EXCL_START 8:dead code + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + ROM_ACCESS_ASERT(0); + eStatus = eFrameworkunifiedStatusFail; + } // LCOV_EXCL_STOP + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetResetCount(UI_32* pResetCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_RESET_COUNT, reinterpret_cast<UI_32 *>(pResetCount), + 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} +EFrameworkunifiedStatus ROM_AccessIf::SetResetCount(UI_32 resetCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + if (eFrameworkunifiedStatusOK != (eStatus = // LCOV_EXCL_BR_LINE 11:unexpected branch + LBA_Write(INDEX_RESET_COUNT, resetCount))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} +EFrameworkunifiedStatus ROM_AccessIf::GetLastIlgReset(ELASTILGRESET_MODE* pLastIlgReset) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_ILGRESET, + reinterpret_cast<UI_32 *>(pLastIlgReset), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetLastIlgReset(ELASTILGRESET_MODE lastIlgReset) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_LAST_ILGRESET, lastIlgReset))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetProgUpdateState( + EPROGUPDATE_STATE* pProgUpdateState) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PROGUPDATE_STATE, + reinterpret_cast<UI_32 *>(pProgUpdateState), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProgUpdateState(EPROGUPDATE_STATE progUpdateState) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PROGUPDATE_STATE, progUpdateState))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetErrLogCount(UI_32* pErrLogCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_ERR_LOG_COUNT, + reinterpret_cast<UI_32 *>(pErrLogCount), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetErrLogCount(UI_32 errLogCount) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + if (eFrameworkunifiedStatusOK != (eStatus = // LCOV_EXCL_BR_LINE 11:unexpected branch + LBA_Write(INDEX_ERR_LOG_COUNT, errLogCount))) { // LCOV_EXCL_BR_LINE 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", // LCOV_EXCL_LINE 11:unexpected branch + eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetNextWakeupType(ENEXT_WAKEUP_TYPE *pNextWakeupType) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_NEXT_WAKEUP_TYPE, + reinterpret_cast<UI_32 *>(pNextWakeupType), 1))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Read() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetNextWakeupType(ENEXT_WAKEUP_TYPE nextWakeupType) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_NEXT_WAKEUP_TYPE, nextWakeupType))) { + // LCOV_EXCL_BR_STOP + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, // LCOV_EXCL_LINE 11:unexpected branch + " Error: LBA_Write() errored: 0x%X", eStatus); // LCOV_EXCL_LINE 11:unexpected branch + } + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetActiveFlashloader( + EACTIVE_FLASHLOADER activeFlashloader) { + EFrameworkunifiedStatus eStatus; + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_ACTIVE_FLASHLOADER, activeFlashloader))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG( + ZONE_ERR, + __FUNCTION__, + " Error: LBA_Write(%s) errored: 0x%X", + activeFlashloader == NEW_FLASHLOADER ? + "NEW_FLASHLOADER" : "OLD_FLASHLOADER", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::SetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Write(INDEX_PRODUCT_PRIVATE, reinterpret_cast<UI_32*>(buf), + ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X", + eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + return eStatus; +} + +EFrameworkunifiedStatus ROM_AccessIf::GetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) { + EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK; + + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+"); + + // LCOV_EXCL_BR_START 11:unexpected branch + if (eFrameworkunifiedStatusOK + != (eStatus = LBA_Read(INDEX_PRODUCT_PRIVATE, reinterpret_cast<UI_32 *>(buf), + ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) { + // LCOV_EXCL_BR_STOP + // LCOV_EXCL_START 11:unexpected branch + AGL_ASSERT_NOT_TESTED(); // LCOV_EXCL_LINE 200: test assert + FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Read() errored: 0x%X", eStatus); + // LCOV_EXCL_STOP + } + FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-"); + + return eStatus; +} |