video_in_hal/systemservice/rom_access_library/library/rom/src/ss_sm_rom_access.cpp

   1 /*
   2  * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18 /// \ingroup  tag_SS_RomAccess
  19 /// \brief    This file supports ROM Access.
  20 ///
  21 ///////////////////////////////////////////////////////////////////////////////
  22 #include "system_service/ss_sm_rom_access.h"
  23 #include <fcntl.h>
  24 #include <stdlib.h>
  25 #include <stdio.h>
  26 #include <sys/types.h>
  27 #include <sys/stat.h>
  28 #include <unistd.h>
  29
  30 #include <native_service/frameworkunified_types.h>
  31 #include <native_service/frameworkunified_framework_types.h>
  32
  33 #include <stub/el_mem.h>
  34 #include <native_service/cl_lock.h>
  35 #include <native_service/cl_lockid.h>
  36
  37 #include "ss_rom_access_if_romaccesslibrarylog.h"
  38 #include "ss_sm_checksum.h"
  39 #include "ss_rom_access_define.h"
  40
  41 #define ROM_ACCESS_DIR  "/nv/BS/ss/rom_access_library/rwdata"
  42 #define ROM_ACCESS_FILE "romdata.dat"
  43 const CHAR kDefaultRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE;
  44 const CHAR kRecoveryRomDevice[] = ROM_ACCESS_DIR"/"ROM_ACCESS_FILE".old";
  45 static const uint8_t kMagic[] = { 0xDE, 0xAD, 0xBE, 0xEF };
  46
  47 typedef enum {
  48   INDEX_BOOTFLAG = 0,
  49   INDEX_ACTIVE_FLASHLOADER,
  50   INDEX_PARTITIONS_RW_FLAG,
  51   INDEX_LAST_USER_MODE,
  52   INDEX_TRANSPORT_MODE,
  53   INDEX_PRODUCTION_MODE,
  54   INDEX_LIMP_HOME_CUT_OFF_REQUEST,
  55   INDEX_DATARESET_MODE,
  56   INDEX_RESET_COUNT,
  57   INDEX_LAST_ILGRESET,
  58   INDEX_PROGUPDATE_STATE,
  59   INDEX_ERR_LOG_COUNT,
  60   INDEX_NEXT_WAKEUP_TYPE,
  61   INDEX_SIGNATURE = 15,  // As far as possible, do not modify this index value!!!!!
  62   INDEX_PROG_STATE = 20,
  63   INDEX_PROG_STATE_END = 63,
  64   INDEX_PRODUCT_PRIVATE,  // 64
  65   INDEX_PRODUCT_PRIVATE_END = (INDEX_PRODUCT_PRIVATE + ROM_PRODUCT_PRIVATE_MAX
  66       - 1),
  67   INDEX_MAX
  68 } eRomIndices;
  69
  70 void* ROM_AccessIf::g_m_plock = NULL;
  71 void* ROM_AccessIf::g_m_bakup_map = MAP_FAILED;
  72 bool ROM_AccessIf::g_m_is_dram_valid = false;
  73
  74 typedef struct {
  75   char magic_in[4];
  76   bool is_dirty;
  77   UI_32 data[INDEX_MAX];
  78   uint32_t checksum;
  79   char magic_out[4];
  80 } ROM_SM_DRAM_INFO_t;
  81
  82 ROM_AccessIf::ROM_AccessIf()
  83     : m_pBoot(NULL),
  84       m_norIsDirty(false) {
  85   bzero(&m_nor, sizeof(m_nor));
  86
  87   if (g_m_plock == NULL) {
  88     g_m_plock = CL_LockMap(LOCK_ROM_ACCESS_IF);
  89     // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed
  90     if (g_m_plock == MAP_FAILED) {
  91     // LCOV_EXCL_BR_STOP
  92       ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed
  93       // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed
  94       FRAMEWORKUNIFIEDLOG(
  95           ZONE_ERR, __FUNCTION__,
  96           "CL_LockMap Error, please check whether you call CL_LockProcessInit");
  97       // LCOV_EXCL_BR_STOP
  98     }
  99   }
 100   // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed
 101   if (g_m_plock) {
 102   // LCOV_EXCL_BR_STOP
 103     // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed
 104     if (0 != CL_LockGet(g_m_plock)) {
 105     // LCOV_EXCL_BR_STOP
 106       ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 6:impossible to confirm because g_m_plock can not be changed
 107     }
 108   }
 109 }
 110
 111 ROM_AccessIf::~ROM_AccessIf() {
 112   if (m_pBoot) {
 113     if (m_norIsDirty) {
 114       ROM_ACCESS_ASERT(eFrameworkunifiedStatusOK == m_pBoot->setBootInfo(&m_nor));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 115     }
 116     delete m_pBoot;  // LCOV_EXCL_BR_LINE 11:unexpected branch
 117     m_pBoot = NULL;
 118   }
 119   // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_plock can not be changed
 120   if (g_m_plock) {
 121     ROM_ACCESS_ASERT(0 == CL_LockRelease(g_m_plock));
 122   }  // LCOV_EXCL_BR_STOP
 123 }
 124
 125 EFrameworkunifiedStatus ROM_AccessIf::LBA_Read(UI_32 offset, UI_32* buffer,
 126                                   UI_32 word_count) {
 127   ROM_SM_DRAM_INFO_t* p_buf;
 128   // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed
 129   if (g_m_bakup_map == MAP_FAILED) {
 130   // LCOV_EXCL_BR_STOP
 131     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize");
 132     return eFrameworkunifiedStatusFail;
 133   }
 134
 135   p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map);
 136   memcpy(buffer, &p_buf->data[offset], word_count * sizeof(UI_32));
 137
 138   return eFrameworkunifiedStatusOK;
 139 }
 140
 141 EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32 value) {
 142   UI_32 l_value = value;
 143   return LBA_Write(offset, &l_value, sizeof(UI_32));
 144 }
 145
 146 EFrameworkunifiedStatus ROM_AccessIf::LBA_Write(UI_32 offset, UI_32* value, UI_32 size) {
 147   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 148   const CHAR *l_file = kDefaultRomDevice;
 149   SI_32 fd = -1;
 150   ROM_SM_DRAM_INFO_t* p_buf;
 151   if (g_m_bakup_map == MAP_FAILED) {
 152     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " g_m_bakup_map uninitialize");
 153     return eFrameworkunifiedStatusFail;
 154   }
 155
 156   p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map);
 157
 158   if (memcmp(&p_buf->data[offset], value, size) == 0) {
 159     // Not Write when the value does not change
 160     return eFrameworkunifiedStatusOK;
 161   }
 162
 163   p_buf->is_dirty = true;
 164   memcpy(&p_buf->data[offset], value, size);
 165
 166   CSMChecksum l_checksum;
 167   p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data),  // LCOV_EXCL_BR_LINE 11:unexpected branch
 168                                             sizeof(p_buf->data));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 169
 170   if (0 != rename(kDefaultRomDevice, kRecoveryRomDevice)) {
 171     ROM_ACCESS_ERRNO(0);
 172   } else {
 173     int sync_fd;
 174     sync_fd = open(kRecoveryRomDevice, O_RDWR | O_DSYNC | O_CLOEXEC);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 175     // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
 176     if (sync_fd != -1) {
 177     // LCOV_EXCL_BR_STOP
 178       ROM_ACCESS_ERRNO(0 == fsync(sync_fd));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 179       ROM_ACCESS_ERRNO(0 == close(sync_fd));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 180     } else {
 181       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 182       ROM_ACCESS_ERRNO(0);  // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed.
 183     }
 184   }
 185   fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC, 00664);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 186   if (fd == -1) {
 187     ROM_ACCESS_ERRNO(0);
 188     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: open(%s) returned -1", l_file);
 189     eStatus = eFrameworkunifiedStatusFail;
 190     goto ERROR;
 191   }
 192
 193   /** Write the value of 32-bits at offset location */
 194   if (sizeof(p_buf->data) != write(fd, p_buf->data, sizeof(p_buf->data))) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 195     // LCOV_EXCL_START 5:It's impossible to mock write() function,so this line can not be passed.
 196     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 197     ROM_ACCESS_ERRNO(0);
 198     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: write(%s) returned -1", l_file);
 199     eStatus = eFrameworkunifiedStatusFail;
 200     goto ERROR;
 201     // LCOV_EXCL_STOP
 202   } else {
 203     ROM_ACCESS_ERRNO(0 == close(fd));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 204     fd = -1;
 205
 206     if (0 != unlink(kRecoveryRomDevice)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 207       // LCOV_EXCL_START 5:It's impossible to mock unlink() function,so this line can not be passed.
 208       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 209       ROM_ACCESS_ERRNO(0);
 210       // LCOV_EXCL_STOP
 211     }
 212
 213     int sync_fd;
 214     sync_fd = open(ROM_ACCESS_DIR, O_RDONLY);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 215     // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
 216     if (sync_fd != -1) {
 217       // LCOV_EXCL_BR_STOP
 218       ROM_ACCESS_ERRNO(0 == fsync(sync_fd));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 219       ROM_ACCESS_ERRNO(0 == close(sync_fd));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 220     } else {
 221       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 222       ROM_ACCESS_ERRNO(0);  // LCOV_EXCL_LINE 5:It's impossible to mock open() function,so this line can not be passed.
 223     }
 224   }
 225   p_buf->is_dirty = false;
 226   ERROR: if (fd != -1) {  // LCOV_EXCL_BR_LINE 5:It's impossible to mock open() function,so this line can not be passed.
 227     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 228     close(fd);  // LCOV_EXCL_LINE 5:It's impossible to mock write() function,so this line can not be passed.
 229   }
 230   // @todo memory value is not restored if non-volatile area writing fails after writing to memory
 231   return eStatus;
 232 }
 233
 234 EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode_sub(EDATARESET_MODE* pDataResetMode) {
 235   EFrameworkunifiedStatus eStatus;
 236   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 237   // LCOV_EXCL_BR_START 11:unexpected branch
 238   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_DATARESET_MODE,
 239                              reinterpret_cast<UI_32 *>(pDataResetMode), 1))) {
 240   // LCOV_EXCL_BR_STOP
 241     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 242     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 243            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 244   }
 245   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 246   return eStatus;
 247 }
 248
 249 // This function may be called in duplicate,
 250 // so it is necessary to operate normally even if it is called in duplicate.
 251 EFrameworkunifiedStatus ROM_AccessIf::SystemInitialize(DRAM_BACKUP_STATE bkupState) {
 252   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 253   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 254
 255   ROM_ACCESS_STATIC_ASERT(sizeof(ROM_SM_DRAM_INFO_t) <= SS_SYS_AREA_ROM_MAX_SIZE);
 256
 257   // Checksum calculations expect 4-bytes alignments
 258   ROM_ACCESS_STATIC_ASERT((sizeof(ROM_SM_DRAM_INFO_t) % sizeof(UI_32)) == 0);
 259   // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed
 260   if (g_m_bakup_map == MAP_FAILED) {
 261   // LCOV_EXCL_BR_STOP
 262     g_m_bakup_map = EL_mem_exram_mmap(
 263         EL_MEM_TYPE_REGION_SYS,
 264         EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET,
 265         SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
 266         EL_MEM_CACHE_INVALID);
 267     if (g_m_bakup_map == MAP_FAILED) {
 268       ROM_ACCESS_ERRNO(0);
 269       return eFrameworkunifiedStatusFail;
 270     }
 271   }
 272
 273   if (bkupState
 274       == DRAM_BACKUP_STATE_NG) {
 275     // BACKUP NG
 276     ROM_SM_DRAM_INFO_t* p_buf;
 277     CSMChecksum l_checksum;
 278
 279     p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map);
 280     bzero(&(p_buf->magic_in), sizeof(p_buf->magic_in));
 281     bzero(&(p_buf->magic_out), sizeof(p_buf->magic_out));
 282     g_m_is_dram_valid = false;
 283   }
 284
 285   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 286   return eStatus;
 287 }
 288
 289 EFrameworkunifiedStatus ROM_AccessIf::Initialize() {
 290   const CHAR *l_file = kDefaultRomDevice;
 291   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 292   CSMChecksum l_checksum;
 293   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 294   if (g_m_bakup_map == MAP_FAILED) {
 295     g_m_bakup_map = EL_mem_exram_mmap(  // LCOV_EXCL_BR_LINE 11:unexpected branch
 296         EL_MEM_TYPE_REGION_SYS,
 297         EL_mem_getOffset(EL_MEM_ID_SYS_BOOT) + SS_SYS_AREA_ROM_OFFSET,  // LCOV_EXCL_BR_LINE 11:unexpected branch
 298         SS_SYS_AREA_ROM_MAX_SIZE, PROT_READ | PROT_WRITE, MAP_SHARED,
 299         EL_MEM_CACHE_INVALID);
 300     // LCOV_EXCL_BR_START 6:impossible to confirm because g_m_bakup_map can not be changed
 301     if (g_m_bakup_map == MAP_FAILED) {
 302     // LCOV_EXCL_BR_STOP
 303       ROM_ACCESS_ERRNO(0);
 304       return eFrameworkunifiedStatusFail;
 305     }
 306   }
 307   if (!g_m_is_dram_valid) {
 308     SI_32 fd = -1;
 309     ROM_SM_DRAM_INFO_t* p_buf;
 310     p_buf = static_cast<ROM_SM_DRAM_INFO_t*>(g_m_bakup_map);
 311     if ((p_buf->is_dirty)
 312         || (memcmp(kMagic, p_buf->magic_in, sizeof(kMagic)) != 0)
 313         || (memcmp(kMagic, p_buf->magic_out, sizeof(kMagic)) != 0)
 314         || ((l_checksum.cal_checksum(&(p_buf->data), sizeof(p_buf->data)) != p_buf->checksum))) {
 315         // Need to synchronize the NVs with the data on the DRAM
 316       struct stat stutInfo;
 317       if (0 != stat(ROM_ACCESS_DIR, &stutInfo)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 318         // LCOV_EXCL_BR_START 5:It's impossible to mock stat() function,so this line can not be passed.
 319         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s not found", ROM_ACCESS_DIR);
 320         // LCOV_EXCL_BR_STOP
 321         ROM_ACCESS_ASERT(0 == mkdir(ROM_ACCESS_DIR, 0775));  // LCOV_EXCL_BR_LINE 11:unexpected branch
 322       }
 323       int expectSize = (INT32)(INDEX_MAX * sizeof(UI_32));
 324       int sigSize = (INT32)((INDEX_SIGNATURE + 1) * sizeof(UI_32));
 325
 326       if (access(kRecoveryRomDevice, F_OK) == 0) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 327         // LCOV_EXCL_BR_START 5:It's impossible to mock access() function,so this line can not be passed.
 328         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s is found", kRecoveryRomDevice);
 329         // LCOV_EXCL_BR_STOP
 330         if (0 != unlink(kDefaultRomDevice)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 331           // LCOV_EXCL_BR_START 5:It's impossible to mock unlink() function,so this line can not be passed.
 332           FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "Error:unlink(%s)", kDefaultRomDevice);
 333           // LCOV_EXCL_BR_STOP
 334         }
 335         if (0 != rename(kRecoveryRomDevice, kDefaultRomDevice)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 336           ROM_ACCESS_ERRNO(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 337         }
 338       }
 339       if (0 == stat(kDefaultRomDevice, &stutInfo)  // LCOV_EXCL_BR_LINE 11:unexpected branch
 340           && stutInfo.st_size >= sigSize) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 341         // Use this value if there are more sizes than SIGNITURE
 342     #define ROM_ACCESS_INFO_SIZE (sizeof(ROM_SM_DRAM_INFO_t) - (sizeof(UI_32)*INDEX_MAX))
 343     #define ROM_ACCESS_MAX_SIZE  (INT32)(SS_SYS_AREA_ROM_MAX_SIZE - ROM_ACCESS_INFO_SIZE)
 344         // Maximum size of RAM area - An upper size limit of the management info size
 345         if (stutInfo.st_size > ROM_ACCESS_MAX_SIZE) {
 346           ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 347           stutInfo.st_size = ROM_ACCESS_MAX_SIZE;
 348         }
 349         fd = open(l_file,  // LCOV_EXCL_BR_LINE 11:unexpected branch
 350                   O_RDWR | O_DSYNC | O_CLOEXEC);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 351         // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
 352         if (fd != -1) {
 353           int ret;
 354           if (stutInfo.st_size < expectSize) {
 355             // If the files are large, APPEND them
 356             FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "PADDING");
 357             ret = ftruncate(fd, expectSize);
 358             ROM_ACCESS_ERRNO(ret == 0);
 359             fsync(fd);
 360           } else if (stutInfo.st_size > expectSize) {
 361             // If the files are small, TRANC them
 362             FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "CUT");
 363             ret = ftruncate(fd, expectSize);
 364             ROM_ACCESS_ERRNO(ret == 0);
 365             fsync(fd);
 366           }
 367         }
 368         // LCOV_EXCL_BR_STOP
 369         } else {
 370         // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h"
 371         FRAMEWORKUNIFIEDLOG(ZONE_WARN, __FUNCTION__, "%s size is not crrect",
 372                kDefaultRomDevice);
 373         // LCOV_EXCL_BR_STOP
 374         fd = open(l_file, O_CREAT | O_TRUNC | O_RDWR | O_DSYNC | O_CLOEXEC,
 375                   00664);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 376         // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
 377         if (fd != -1) {
 378           UI_32 buf[INDEX_MAX];
 379           bzero(buf, sizeof(buf));
 380           ROM_ACCESS_ASERT(sizeof(buf) == write(fd, buf, sizeof(buf)))
 381           fsync(fd);
 382         }
 383       // LCOV_EXCL_BR_STOP
 384       }
 385       // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
 386       if (fd != -1) {
 387       // LCOV_EXCL_BR_STOP
 388         UI_32 read_buf[INDEX_MAX];
 389         if (-1 == lseek(fd, 0, SEEK_SET)) {
 390           // LCOV_EXCL_START 5:It's impossible to mock lseek() function,so this line can not be passed.
 391           AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 392           ROM_ACCESS_ERRNO(0);
 393           // LCOV_EXCL_STOP
 394         } else {
 395           if (-1 == read(fd, read_buf, sizeof(read_buf))) {
 396             // LCOV_EXCL_START 5:It's impossible to mock read() function,so this line can not be passed.
 397             AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 398             ROM_ACCESS_ERRNO(0);
 399             // LCOV_EXCL_STOP
 400           } else {
 401             memcpy(p_buf->magic_in, kMagic, sizeof(kMagic));
 402             memcpy(&p_buf->data, read_buf, sizeof(p_buf->data));
 403             p_buf->checksum = l_checksum.cal_checksum(&(p_buf->data),
 404                                                       sizeof(p_buf->data));
 405             memcpy(p_buf->magic_out, kMagic, sizeof(kMagic));
 406             p_buf->is_dirty = false;
 407
 408             // Synchronization of NV data with data on the DRAM completed
 409             g_m_is_dram_valid = true;
 410           }
 411         }
 412         close(fd);
 413       } else {
 414         // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h"
 415         FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, "Error:open(%s)", l_file);
 416         // LCOV_EXCL_BR_STOP
 417       }
 418     } else {
 419       // No need to synchronize NV data with data on the DRAM
 420       g_m_is_dram_valid = true;
 421     }
 422   } else {
 423     // LCOV_EXCL_BR_START 15:marco defined in "native_service/ns_logger_if.h"
 424     FRAMEWORKUNIFIEDLOG(ZONE_INFO, __FUNCTION__, " alreay initialized");
 425     // LCOV_EXCL_BR_STOP
 426   }
 427   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 428   return eStatus;
 429 }
 430
 431 EFrameworkunifiedStatus ROM_AccessIf::GetSignature(UI_32* pSigValue) {
 432   EFrameworkunifiedStatus eStatus;
 433   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 434   // LCOV_EXCL_BR_START 11:unexpected branch
 435   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_SIGNATURE,
 436                                           reinterpret_cast<UI_32 *>(pSigValue), 1))) {
 437   // LCOV_EXCL_BR_STOP
 438     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 439     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 440            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 441   }
 442   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 443   return eStatus;
 444 }
 445
 446 EFrameworkunifiedStatus ROM_AccessIf::SetSignature(UI_32 sigValue) {
 447   EFrameworkunifiedStatus eStatus;
 448   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 449   // LCOV_EXCL_BR_START 11:unexpected branch
 450   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_SIGNATURE,
 451                        sigValue))) {
 452   // LCOV_EXCL_BR_STOP
 453     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(0x%X) errored: 0x%X",
 454            sigValue, eStatus);
 455   }
 456   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 457   return eStatus;
 458 }
 459
 460 EFrameworkunifiedStatus ROM_AccessIf::GetBootMode(EBOOT_MODE* pBootMode) {
 461   EFrameworkunifiedStatus eStatus;
 462   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 463   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_BOOTFLAG,
 464                              reinterpret_cast<UI_32 *>(pBootMode), 1))) {
 465     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,
 466            " Error: LBA_Read() errored: 0x%X", eStatus);
 467   }
 468   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 469   return eStatus;
 470 }
 471
 472 EFrameworkunifiedStatus ROM_AccessIf::SetBootMode(EBOOT_MODE bootMode) {
 473   EFrameworkunifiedStatus eStatus;
 474   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 475   // LCOV_EXCL_BR_START 11:unexpected branch
 476   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_BOOTFLAG, bootMode))) {
 477   // LCOV_EXCL_BR_STOP
 478     // LCOV_EXCL_START 11:unexpected branch
 479     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 480     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%d) errored: 0x%X",
 481            bootMode, eStatus);
 482     // LCOV_EXCL_STOP
 483   }
 484   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 485   return eStatus;
 486 }
 487
 488 EFrameworkunifiedStatus ROM_AccessIf::GetLastUserMode(EUSER_MODE* pUserMode) {
 489   EFrameworkunifiedStatus eStatus;
 490   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 491   // LCOV_EXCL_BR_START 11:unexpected branch
 492   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_USER_MODE,
 493                                           reinterpret_cast<UI_32 *>(pUserMode), 1))) {
 494   // LCOV_EXCL_BR_STOP
 495     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 496     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 497            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 498   }
 499   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 500   return eStatus;
 501 }
 502
 503 EFrameworkunifiedStatus ROM_AccessIf::SetLastUserMode(EUSER_MODE userMode) {
 504   EFrameworkunifiedStatus eStatus;
 505   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 506   // LCOV_EXCL_BR_START 11:unexpected branch
 507   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_LAST_USER_MODE, userMode))) {
 508   // LCOV_EXCL_BR_STOP
 509     // LCOV_EXCL_START 11:unexpected branch
 510     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 511     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X",
 512            userMode == USER_OFF ? "USER_OFF" : "USER_ON", eStatus);
 513     // LCOV_EXCL_STOP
 514   }
 515   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 516   return eStatus;
 517 }
 518
 519 EFrameworkunifiedStatus ROM_AccessIf::GetTransportMode(ECONTROL_MODE* pControlMode) {
 520   EFrameworkunifiedStatus eStatus;
 521   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 522   // LCOV_EXCL_BR_START 11:unexpected branch
 523   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_TRANSPORT_MODE,
 524                              reinterpret_cast<UI_32 *>(pControlMode), 1))) {
 525   // LCOV_EXCL_BR_STOP
 526     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 527     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 528            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 529   }
 530   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 531   return eStatus;
 532 }
 533
 534 EFrameworkunifiedStatus ROM_AccessIf::SetTransportMode(ECONTROL_MODE controlMode) {
 535   EFrameworkunifiedStatus eStatus;
 536   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 537   // LCOV_EXCL_BR_START 11:unexpected branch
 538   if (eFrameworkunifiedStatusOK
 539       != (eStatus = LBA_Write(INDEX_TRANSPORT_MODE, controlMode))) {
 540   // LCOV_EXCL_BR_STOP
 541     // LCOV_EXCL_START 11:unexpected branch
 542     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 543     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X",
 544            controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE",
 545            eStatus);
 546     // LCOV_EXCL_STOP
 547   }
 548   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 549   return eStatus;
 550 }
 551
 552
 553 EFrameworkunifiedStatus ROM_AccessIf::GetProductionMode(ECONTROL_MODE* pControlMode) {
 554   EFrameworkunifiedStatus eStatus;
 555   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 556   // LCOV_EXCL_BR_START 11:unexpected branch
 557   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PRODUCTION_MODE,
 558                              reinterpret_cast<UI_32 *>(pControlMode), 1))) {
 559   // LCOV_EXCL_BR_STOP
 560     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 561     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 562            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 563   }
 564   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 565   return eStatus;
 566 }
 567
 568 EFrameworkunifiedStatus ROM_AccessIf::SetProductionMode(ECONTROL_MODE controlMode) {
 569   EFrameworkunifiedStatus eStatus;
 570   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 571   // LCOV_EXCL_BR_START 11:unexpected branch
 572   if (eFrameworkunifiedStatusOK
 573       != (eStatus = LBA_Write(INDEX_PRODUCTION_MODE, controlMode))) {
 574   // LCOV_EXCL_BR_STOP
 575     // LCOV_EXCL_START 11:unexpected branch
 576     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 577     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X",
 578            controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE",
 579            eStatus);
 580     // LCOV_EXCL_STOP
 581   }
 582   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 583   return eStatus;
 584 }
 585
 586 EFrameworkunifiedStatus ROM_AccessIf::GetLimpHomeCutOffReqMode(ECONTROL_MODE* pControlMode) {
 587   EFrameworkunifiedStatus eStatus;
 588   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 589   // LCOV_EXCL_BR_START 11:unexpected branch
 590   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LIMP_HOME_CUT_OFF_REQUEST,
 591                              reinterpret_cast<UI_32 *>(pControlMode), 1))) {
 592   // LCOV_EXCL_BR_STOP
 593     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 594     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 595            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 596   }
 597   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 598   return eStatus;
 599 }
 600
 601 EFrameworkunifiedStatus ROM_AccessIf::SetLimpHomeCutOffReqMode(ECONTROL_MODE controlMode) {
 602   EFrameworkunifiedStatus eStatus;
 603   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 604   // LCOV_EXCL_BR_START 11:unexpected branch
 605   if (eFrameworkunifiedStatusOK
 606       != (eStatus = LBA_Write(INDEX_LIMP_HOME_CUT_OFF_REQUEST, controlMode))) {
 607   // LCOV_EXCL_BR_STOP
 608     // LCOV_EXCL_START 11:unexpected branch
 609     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 610     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write(%s) errored: 0x%X",
 611            controlMode == DISABLE_MODE ? "DISABLE_MODE" : "ENABLE_MODE",
 612            eStatus);
 613     // LCOV_EXCL_STOP
 614   }
 615   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 616   return eStatus;
 617 }
 618
 619 EFrameworkunifiedStatus ROM_AccessIf::GetDataResetMode(EDATARESET_MODE* pDataResetMode) {
 620   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 621   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 622   try {
 623     UI_32 sts;
 624     if (m_pBoot == NULL) {  // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed
 625       m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 626       if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 627         ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 628         throw eFrameworkunifiedStatusFail;
 629       }
 630     }
 631
 632     if ((m_nor.sts1 == m_nor.sts2) || (m_nor.sts1 == m_nor.sts3)) {
 633       sts = m_nor.sts1;
 634     } else if (m_nor.sts2 == m_nor.sts3) {
 635       sts = m_nor.sts2;
 636       ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 637     } else {
 638       sts = SYSUP_CND_NORMAL;
 639       ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 640     }
 641
 642     if (sts == SYSUP_CND_FACTRESET) {
 643       *pDataResetMode = DATARESET_FACTORY;
 644     } else {
 645       eStatus = GetDataResetMode_sub(pDataResetMode);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 646     }
 647   } catch (const EFrameworkunifiedStatus& e) {
 648     eStatus = e;
 649   } catch (...) {  // LCOV_EXCL_START 8:dead code
 650     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 651     eStatus = eFrameworkunifiedStatusFail;
 652   }  // LCOV_EXCL_STOP
 653
 654   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 655   return eStatus;
 656 }
 657
 658 EFrameworkunifiedStatus ROM_AccessIf::GetDataResetModeFast(EDATARESET_MODE* pDataResetMode) {
 659   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 660   void* p_map = MAP_FAILED;
 661   size_t mapSize = 0;
 662   try {
 663     LBM_RAM_t* p_lbm = NULL;
 664     mapSize = SS_SYS_AREA_BOOT_MAX_SIZE;
 665
 666     if (EL_mem_getLength(EL_MEM_ID_SYS_BOOT) < SS_SYS_AREA_BOOT_MAX_SIZE) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 667       mapSize = EL_mem_getLength(EL_MEM_ID_SYS_BOOT);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 668     }
 669     // LCOV_EXCL_BR_START 11:unexpected branch
 670     p_map = reinterpret_cast<LBM_RAM_t*>(EL_mem_exram_mmap(EL_MEM_TYPE_REGION_SYS,
 671                                            EL_mem_getOffset(EL_MEM_ID_SYS_BOOT),
 672                                            mapSize, PROT_READ | PROT_WRITE,
 673                                            MAP_SHARED, EL_MEM_CACHE_INVALID));
 674     // LCOV_EXCL_BR_STOP
 675     if (p_map == MAP_FAILED) {  // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed
 676       ROM_ACCESS_ERRNO(0);  // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed
 677       throw eFrameworkunifiedStatusFail;
 678     }
 679     p_lbm = static_cast<LBM_RAM_t*>(p_map);
 680     if (p_lbm->sts == SYSUP_CND_FACTRESET) {
 681       *pDataResetMode = DATARESET_FACTORY;
 682     } else {
 683       eStatus = GetDataResetMode_sub(pDataResetMode);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 684     }
 685   } catch (const EFrameworkunifiedStatus& e) {
 686     ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 687     eStatus = e;
 688   } catch (...) {  // LCOV_EXCL_START 8:dead code
 689     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 690     ROM_ACCESS_ASERT(0);
 691     eStatus = eFrameworkunifiedStatusFail;
 692   }  // LCOV_EXCL_STOP
 693
 694   if (p_map != MAP_FAILED) {  // LCOV_EXCL_BR_LINE 6:impossible to confirm because p_map can not be changed
 695     ROM_ACCESS_ERRNO(0 == EL_mem_exram_munmap(p_map,  // LCOV_EXCL_BR_LINE 11:unexpected branch
 696                         mapSize));
 697   }
 698   return eStatus;  // LCOV_EXCL_BR_LINE 11:unexpected branch
 699 }
 700
 701 EFrameworkunifiedStatus ROM_AccessIf::SetDataResetMode(EDATARESET_MODE dataResetMode) {
 702   EFrameworkunifiedStatus eStatus;
 703   EDATARESET_MODE l_mode = dataResetMode;
 704   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 705   try {
 706     if (m_pBoot == NULL) {  // LCOV_EXCL_BR_LINE 6:impossible to confirm because m_pBoot can not be changed
 707       // LCOV_EXCL_BR_START 11:unexpected branch
 708       m_pBoot = new BOOT_AccessIf(BAI_OPEN_RW);
 709       // LCOV_EXCL_BR_STOP
 710       if (eFrameworkunifiedStatusOK != m_pBoot->getBootInfo(&m_nor)) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 711         ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 712         throw eFrameworkunifiedStatusFail;
 713       }
 714     }
 715     m_norIsDirty = true;
 716     if (dataResetMode == DATARESET_FACTORY) {
 717       m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_FACTRESET;
 718       l_mode = DATARESET_NONE;
 719     } else {
 720       m_nor.sts1 = m_nor.sts2 = m_nor.sts3 = SYSUP_CND_NORMAL;
 721     }
 722
 723     // LCOV_EXCL_BR_START 11:unexpected branch
 724     if (eFrameworkunifiedStatusOK != (eStatus = LBA_Write(INDEX_DATARESET_MODE, l_mode))) {
 725     // LCOV_EXCL_BR_STOP
 726       // LCOV_EXCL_START 11:unexpected branch
 727       AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 728       FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",
 729              eStatus);
 730       // LCOV_EXCL_STOP
 731     }
 732   } catch (const EFrameworkunifiedStatus& e) {
 733     ROM_ACCESS_ASERT(0);  // LCOV_EXCL_BR_LINE 11:unexpected branch
 734     eStatus = e;
 735   } catch (...) {  // LCOV_EXCL_START 8:dead code
 736     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 737     ROM_ACCESS_ASERT(0);
 738     eStatus = eFrameworkunifiedStatusFail;
 739   }  // LCOV_EXCL_STOP
 740
 741   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 742   return eStatus;
 743 }
 744
 745 EFrameworkunifiedStatus ROM_AccessIf::GetResetCount(UI_32* pResetCount) {
 746   EFrameworkunifiedStatus eStatus;
 747   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 748   // LCOV_EXCL_BR_START 11:unexpected branch
 749   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_RESET_COUNT, reinterpret_cast<UI_32 *>(pResetCount),
 750                              1))) {
 751   // LCOV_EXCL_BR_STOP
 752     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 753     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 754            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 755   }
 756
 757   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 758   return eStatus;
 759 }
 760 EFrameworkunifiedStatus ROM_AccessIf::SetResetCount(UI_32 resetCount) {
 761   EFrameworkunifiedStatus eStatus;
 762   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 763   if (eFrameworkunifiedStatusOK != (eStatus =  // LCOV_EXCL_BR_LINE 11:unexpected branch
 764       LBA_Write(INDEX_RESET_COUNT, resetCount))) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 765     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 766     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",  // LCOV_EXCL_LINE 11:unexpected branch
 767            eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 768   }
 769
 770   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 771   return eStatus;
 772 }
 773 EFrameworkunifiedStatus ROM_AccessIf::GetLastIlgReset(ELASTILGRESET_MODE* pLastIlgReset) {
 774   EFrameworkunifiedStatus eStatus;
 775   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 776
 777   // LCOV_EXCL_BR_START 11:unexpected branch
 778   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_LAST_ILGRESET,
 779                              reinterpret_cast<UI_32 *>(pLastIlgReset), 1))) {
 780   // LCOV_EXCL_BR_STOP
 781     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 782     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 783            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 784   }
 785
 786   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 787   return eStatus;
 788 }
 789
 790 EFrameworkunifiedStatus ROM_AccessIf::SetLastIlgReset(ELASTILGRESET_MODE lastIlgReset) {
 791   EFrameworkunifiedStatus eStatus;
 792   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 793
 794   // LCOV_EXCL_BR_START 11:unexpected branch
 795   if (eFrameworkunifiedStatusOK
 796       != (eStatus = LBA_Write(INDEX_LAST_ILGRESET, lastIlgReset))) {
 797   // LCOV_EXCL_BR_STOP
 798     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 799     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",  // LCOV_EXCL_LINE 11:unexpected branch
 800            eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 801   }
 802
 803   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 804   return eStatus;
 805 }
 806
 807 EFrameworkunifiedStatus ROM_AccessIf::GetProgUpdateState(
 808     EPROGUPDATE_STATE* pProgUpdateState) {
 809   EFrameworkunifiedStatus eStatus;
 810   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 811
 812   // LCOV_EXCL_BR_START 11:unexpected branch
 813   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_PROGUPDATE_STATE,
 814                              reinterpret_cast<UI_32 *>(pProgUpdateState), 1))) {
 815   // LCOV_EXCL_BR_STOP
 816     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 817     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 818            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 819   }
 820
 821   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 822   return eStatus;
 823 }
 824
 825 EFrameworkunifiedStatus ROM_AccessIf::SetProgUpdateState(EPROGUPDATE_STATE progUpdateState) {
 826   EFrameworkunifiedStatus eStatus;
 827   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 828
 829   // LCOV_EXCL_BR_START 11:unexpected branch
 830   if (eFrameworkunifiedStatusOK
 831       != (eStatus = LBA_Write(INDEX_PROGUPDATE_STATE, progUpdateState))) {
 832   // LCOV_EXCL_BR_STOP
 833     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 834     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",  // LCOV_EXCL_LINE 11:unexpected branch
 835            eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 836   }
 837
 838   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 839   return eStatus;
 840 }
 841
 842 EFrameworkunifiedStatus ROM_AccessIf::GetErrLogCount(UI_32* pErrLogCount) {
 843   EFrameworkunifiedStatus eStatus;
 844   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 845
 846   // LCOV_EXCL_BR_START 11:unexpected branch
 847   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_ERR_LOG_COUNT,
 848                              reinterpret_cast<UI_32 *>(pErrLogCount), 1))) {
 849   // LCOV_EXCL_BR_STOP
 850     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 851     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 852            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 853   }
 854
 855   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 856   return eStatus;
 857 }
 858
 859 EFrameworkunifiedStatus ROM_AccessIf::SetErrLogCount(UI_32 errLogCount) {
 860   EFrameworkunifiedStatus eStatus;
 861   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 862
 863   if (eFrameworkunifiedStatusOK != (eStatus =  // LCOV_EXCL_BR_LINE 11:unexpected branch
 864       LBA_Write(INDEX_ERR_LOG_COUNT, errLogCount))) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
 865     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 866     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",  // LCOV_EXCL_LINE 11:unexpected branch
 867            eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 868   }
 869
 870   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 871   return eStatus;
 872 }
 873
 874 EFrameworkunifiedStatus ROM_AccessIf::GetNextWakeupType(ENEXT_WAKEUP_TYPE *pNextWakeupType) {
 875   EFrameworkunifiedStatus eStatus;
 876   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 877
 878   // LCOV_EXCL_BR_START 11:unexpected branch
 879   if (eFrameworkunifiedStatusOK != (eStatus = LBA_Read((UI_32) INDEX_NEXT_WAKEUP_TYPE,
 880                              reinterpret_cast<UI_32 *>(pNextWakeupType), 1))) {
 881   // LCOV_EXCL_BR_STOP
 882     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 883     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 884            " Error: LBA_Read() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 885   }
 886
 887   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 888   return eStatus;
 889 }
 890
 891 EFrameworkunifiedStatus ROM_AccessIf::SetNextWakeupType(ENEXT_WAKEUP_TYPE nextWakeupType) {
 892   EFrameworkunifiedStatus eStatus;
 893   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 894
 895   // LCOV_EXCL_BR_START 11:unexpected branch
 896   if (eFrameworkunifiedStatusOK
 897       != (eStatus = LBA_Write(INDEX_NEXT_WAKEUP_TYPE, nextWakeupType))) {
 898   // LCOV_EXCL_BR_STOP
 899     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 900     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__,  // LCOV_EXCL_LINE 11:unexpected branch
 901            " Error: LBA_Write() errored: 0x%X", eStatus);  // LCOV_EXCL_LINE 11:unexpected branch
 902   }
 903
 904   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 905   return eStatus;
 906 }
 907
 908 EFrameworkunifiedStatus ROM_AccessIf::SetActiveFlashloader(
 909     EACTIVE_FLASHLOADER activeFlashloader) {
 910   EFrameworkunifiedStatus eStatus;
 911   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 912
 913   // LCOV_EXCL_BR_START 11:unexpected branch
 914   if (eFrameworkunifiedStatusOK
 915       != (eStatus = LBA_Write(INDEX_ACTIVE_FLASHLOADER, activeFlashloader))) {
 916   // LCOV_EXCL_BR_STOP
 917     // LCOV_EXCL_START 11:unexpected branch
 918     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 919     FRAMEWORKUNIFIEDLOG(
 920         ZONE_ERR,
 921         __FUNCTION__,
 922         " Error: LBA_Write(%s) errored: 0x%X",
 923         activeFlashloader == NEW_FLASHLOADER ?
 924             "NEW_FLASHLOADER" : "OLD_FLASHLOADER",
 925         eStatus);
 926     // LCOV_EXCL_STOP
 927   }
 928   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 929   return eStatus;
 930 }
 931
 932 EFrameworkunifiedStatus ROM_AccessIf::SetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) {
 933   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 934
 935   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 936   // LCOV_EXCL_BR_START 11:unexpected branch
 937   if (eFrameworkunifiedStatusOK
 938       != (eStatus = LBA_Write(INDEX_PRODUCT_PRIVATE, reinterpret_cast<UI_32*>(buf),
 939                               ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) {
 940   // LCOV_EXCL_BR_STOP
 941     // LCOV_EXCL_START 11:unexpected branch
 942     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 943     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Write() errored: 0x%X",
 944            eStatus);
 945     // LCOV_EXCL_STOP
 946   }
 947   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 948   return eStatus;
 949 }
 950
 951 EFrameworkunifiedStatus ROM_AccessIf::GetProductPrivate(UI_8 buf[ROM_PRODUCT_PRIVATE_MAX]) {
 952   EFrameworkunifiedStatus eStatus = eFrameworkunifiedStatusOK;
 953
 954   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "+");
 955
 956   // LCOV_EXCL_BR_START 11:unexpected branch
 957   if (eFrameworkunifiedStatusOK
 958       != (eStatus = LBA_Read(INDEX_PRODUCT_PRIVATE, reinterpret_cast<UI_32 *>(buf),
 959                              ROM_PRODUCT_PRIVATE_MAX / sizeof(UI_32)))) {
 960   // LCOV_EXCL_BR_STOP
 961     // LCOV_EXCL_START 11:unexpected branch
 962     AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
 963     FRAMEWORKUNIFIEDLOG(ZONE_ERR, __FUNCTION__, " Error: LBA_Read() errored: 0x%X", eStatus);
 964     // LCOV_EXCL_STOP
 965   }
 966   FRAMEWORKUNIFIEDLOG(ZONE_FUNC, __FUNCTION__, "-");
 967
 968   return eStatus;
 969 }