[Feature][Modem]Update MTK MODEM V1.6 baseline version: MOLY.NR15.R3.MD700.IVT.MP1MR3.MP.V1.6
MTK modem version: MT2735_IVT_MOLY.NR15.R3.MD700.IVT.MP1MR3.MP.V1.6.tar.gz
RF modem version: NA
Change-Id: I45a4c2752fa9d1a618beacd5d40737fb39ab64fb
diff --git a/mcu/service/nvram/src/nvram_util.c b/mcu/service/nvram/src/nvram_util.c
new file mode 100644
index 0000000..f54a24b
--- /dev/null
+++ b/mcu/service/nvram/src/nvram_util.c
@@ -0,0 +1,2912 @@
+/*****************************************************************************
+* Copyright Statement:
+* --------------------
+* This software is protected by Copyright and the information contained
+* herein is confidential. The software may not be copied and the information
+* contained herein may not be used or disclosed except with the written
+* permission of MediaTek Inc. (C) 2005
+*
+* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
+* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
+* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
+* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
+* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
+* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
+* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
+* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
+* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
+* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
+* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
+*
+* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
+* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
+* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
+* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
+* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
+*
+* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
+* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
+* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
+* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
+* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
+*
+*****************************************************************************/
+
+/*****************************************************************************
+ *
+ * Filename:
+ * ---------
+ * nvram_util.c
+ *
+ * Project:
+ * --------
+ * MAUI
+ *
+ * Description:
+ * ------------
+ * This is utility for NVRAM
+ *
+ * Author:
+ * -------
+ * -------
+ *
+ *============================================================================
+ * HISTORY
+ * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *------------------------------------------------------------------------------
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ * removed!
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *
+ * removed!
+ * removed!
+ *
+ *------------------------------------------------------------------------------
+ * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
+ *============================================================================
+ ****************************************************************************/
+
+/*****************************************************************************
+* Include
+*****************************************************************************/
+#include "stdio.h"
+#include "string.h"
+#include "stdarg.h"
+#include "kal_general_types.h"
+#include "kal_internal_api.h" /* basename */
+#include "kal_public_api.h"
+#include "kal_trace.h"
+#include "kal_public_defs.h" //MSBB change #include "stack_config.h"
+#include "nvram_main.h"
+#include "che_api.h"
+#include "dcl.h"
+#include "che_api.h" // to calculate checksum
+#if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+#include "dcl_gpt.h"
+#endif
+#include <ex_public.h>
+
+#ifdef __NVRAM_LID_CACHE__
+#include "nvram_cache_interface.h"
+#endif
+#include "us_timer.h"
+#include "stdlib.h"
+#include "ex_public.h"
+
+#if defined(__NVRAM_STRUCTURE_CHANGE_RESET__) || defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+#if defined(__MTK_TARGET__) //target load
+#include "nvram_checksum_reset.h"
+#else //modis load define a dummy table to avoid build error
+const checksum_reset_struct lid_default_value_chksum[] ={
+ {NVRAM_EF_CHKSUM_RESET_REC_LID, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}},
+};
+
+const checksum_reset_struct lid_structure_chksum[] ={
+ {NVRAM_EF_CHKSUM_RESET_REC_LID, {0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F}},
+};
+
+kal_uint32 lid_structure_chksum_num = sizeof(lid_structure_chksum)/sizeof(checksum_reset_struct);
+kal_uint32 lid_default_value_chksum_num = sizeof(lid_default_value_chksum)/sizeof(checksum_reset_struct);
+#endif
+#endif
+
+
+#ifdef __NVRAM_INIT_TIME_UT__
+kal_uint16 init_time_tick[10] = {0};
+nvram_init_flow_trace init_trace = 0;
+#endif
+#ifdef __NVRAM_INIT_LID_BUFFER__
+typedef enum
+{
+ NVRAM_INIT_LID_BUF_INVALID = 0,
+ NVRAM_INIT_LID_BUF_ENPTY,
+ NVRAM_INIT_LID_BUF_READ,
+ NVRAM_INIT_LID_BUF_VALID,
+ NVRAM_INIT_LID_BUF_DIRTY,
+} nvram_init_lid_buffer_status;
+
+typedef struct
+{
+ nvram_lid_enum LID;
+ nvram_ltable_entry_struct *ldi_ptr;
+ kal_uint8 *buffer;
+ nvram_init_lid_buffer_status status;
+} nvram_init_lid_buffer_struct;
+
+nvram_init_lid_buffer_struct lid_buffer_list[] = {
+ {NVRAM_EF_LTECSR_PROFILE_LID, NULL, NULL, 0},
+ {NVRAM_EF_IMS_PROFILE_LID, NULL, NULL, 0},
+ {NVRAM_EF_VDM_ADS_PROFILE_LID, NULL, NULL, 0},
+ {NVRAM_EF_SDM_ADS_PROFILE_LID, NULL, NULL, 0},
+ {NVRAM_EF_SBP_MODEM_DATA_CONFIG_LID, NULL, NULL, 0},
+ {NVRAM_EF_SBP_MODEM_CONFIG_LID, NULL, NULL, 0},
+ {NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_FDD_LID, NULL, NULL, 0},
+ {NVRAM_EF_UMTS_USIME_RRC_DYNAMIC_CAP_TDD_LID, NULL, NULL, 0},
+ {NVRAM_EF_LTE_PREFERENCE_LID, NULL, NULL, 0},
+ {NVRAM_EF_REGIONAL_PHONE_MODE_LID, NULL, NULL, 0},
+ {NVRAM_EF_MSCAP_LID, NULL, NULL, 0},
+ {NVRAM_EF_ERRC_PERFORMANCE_PARA_LID, NULL, NULL, 0},
+ {NVRAM_EF_UE_EUTRA_CAP_CSFB_LID, NULL, NULL, 0},
+ {NVRAM_EF_NVRAM_SEC_CHECK_LID, NULL, NULL, 0},
+};
+kal_uint16 lid_buffer_list_num = sizeof(lid_buffer_list)/sizeof(nvram_init_lid_buffer_struct);
+kal_uint8 *nvram_init_lid_buffer = NULL;
+kal_bool nvram_init_lid_buffer_en = KAL_FALSE;
+#endif
+
+kal_int8 g_access_trace_setting_file_result = 0;
+kal_uint32 g_nvram_trace_setting= 0;
+#ifdef __NV_CHKSUM_ENHANCE__
+extern nvram_algo_info *chksum_algo_ptr;
+#endif
+
+extern void InitDebugPrint(void);
+extern void DebugPrint(kal_uint8, kal_uint8, kal_uint8*);
+
+#if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+extern void nvram_gpt_timeout_callback(void *data);
+#endif
+
+
+#define NVRAM_TRC_SIZE 256
+
+/*
+ * External variables
+ */
+extern kal_mutexid g_nvram_impt_mutex;
+extern kal_mutexid g_nvram_fs_mutex;
+extern ilm_struct *g_ilm_ptr;
+extern kal_uint32 g_nvram_task_idx;
+extern kal_bool is_nvram_in_ota_flow;
+#if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+extern DCL_HANDLE nvram_gpt_handle;
+#endif
+extern kal_bool is_nvram_factory_reset;
+
+
+extern nvram_ee_info_type* nvram_ee_info;
+extern kal_char nvram_trace_dump_temp_buffer[];
+extern kal_char nvram_trace_dump_buffer[];
+extern kal_mutexid g_nvram_dump_trace_mutex;
+extern kal_wchar nvram_trace_filename[];
+extern FS_HANDLE nvram_trace_file_hdl;
+extern kal_uint32 nvram_trace_dump_buffer_offset;
+
+extern module_type stack_get_active_module_id( void );
+
+static kal_uint8 g_util_chksum[128] = {0};
+
+
+#if defined(__NVRAM_STRUCTURE_CHANGE_RESET__) || defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+kal_int32 nvram_get_structure_chksum_index(nvram_lid_enum LID)
+{
+ kal_int32 index = 0;
+
+ for(; index < lid_structure_chksum_num && LID != lid_structure_chksum[index].LID; index++)
+ {}
+
+ if(index >= lid_structure_chksum_num)
+ {
+ index = -1;
+ }
+
+ return index;
+}
+
+kal_int32 nvram_get_defval_chksum_index(nvram_lid_enum LID)
+{
+ kal_int32 index = 0;
+
+ for(; index < lid_default_value_chksum_num && LID != lid_default_value_chksum[index].LID; index++)
+ {}
+
+ if(index >= lid_default_value_chksum_num)
+ {
+ index = -1;
+ }
+
+ return index;
+}
+#endif
+
+
+kal_bool nvram_util_next_data_item(nvram_ltable_entry_struct **entry)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ nvram_ltable_entry_struct *ldi = *entry;
+ kal_uint32 end = (kal_uint32)logical_data_item_table + nvram_ptr->ltable.area_size;
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ if (ldi == NULL)
+ {
+ ldi = &logical_data_item_table[0];
+ if (ldi->fileprefix[0])
+ {
+ *entry = ldi;
+ return KAL_TRUE;
+ }
+ }
+
+ while((kal_uint32)++ldi < end)
+ {
+ if (ldi->fileprefix[0])
+ {
+ *entry = ldi;
+ return KAL_TRUE;
+ }
+ }
+
+ *entry = NULL;
+ return KAL_FALSE;
+}
+
+
+kal_bool nvram_util_get_data_item(nvram_ltable_entry_struct **ldi, nvram_lid_enum LID)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ kal_uint32 i = 0, count = 0;
+ kal_uint32 end = (kal_uint32)logical_data_item_table + nvram_ptr->ltable.area_size;
+
+ do
+ {
+ if (logical_data_item_table[i].fileprefix[0])
+ {
+ count++;
+
+ if (logical_data_item_table[i].LID == LID)
+ {
+ if (ldi) {
+ *ldi = &logical_data_item_table[i];
+ }
+ return KAL_TRUE;
+ }
+ }
+ i++;
+ }while(count < nvram_ptr->ltable.total_LID && ((kal_uint32)&logical_data_item_table[i] < end));
+
+ if (ldi)
+ *ldi = NULL;
+
+ return KAL_FALSE;
+}
+
+kal_bool nvram_util_get_data_item_by_fileprefix(nvram_ltable_entry_struct **ldi, kal_char *fileprefix)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ kal_uint32 i = 0, count = 0;
+ kal_uint32 end = (kal_uint32)logical_data_item_table + nvram_ptr->ltable.area_size;
+
+ do
+ {
+ if (logical_data_item_table[i].fileprefix[0])
+ {
+ count++;
+ //if (!memcmp(logical_data_item_table[i].fileprefix, fileprefix, FILE_PREFIX_LEN))
+ //speed up search
+ if((kal_mem_cmp(fileprefix,logical_data_item_table[i].fileprefix,FILE_PREFIX_LEN) == 0) && (logical_data_item_table[i].LID != NVRAM_EF_READ_RESERVED_LID))
+ {
+ if (ldi) {
+ *ldi = &logical_data_item_table[i];
+ return KAL_TRUE;
+ }
+ }
+ }
+ i++;
+ }while(count < nvram_ptr->ltable.total_LID && ((kal_uint32)&logical_data_item_table[i] < end));
+
+ if (ldi)
+ *ldi = NULL;
+
+ return KAL_FALSE;
+}
+
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_drval_caculate_checksum
+ * DESCRIPTION
+ * produce the check sum of the given record.
+ * PARAMETERS
+ * checksum [?]
+ * buf [?]
+ * size [IN]
+ * RETURNS
+ * checksum(?)
+ *****************************************************************************/
+kal_uint16 nvram_util_cal_checksum_simple(const kal_uint8 *buf, kal_uint32 size)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ kal_uint32 i;
+ kal_uint16 chksum = 0;
+ kal_uint8 *byte_chksum = (kal_uint8*) &chksum;
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+
+ if (buf == NVRAM_EF_ZERO_DEFAULT)
+ {
+ return 0xCDEF;
+ }
+ else if (buf == NVRAM_EF_FF_DEFAULT)
+ {
+ for (i = 0 ;i < size; i++)
+ {
+ if (i & 0x1)
+ {
+ *(byte_chksum + 1) += 0xFF;
+ }
+ else
+ {
+ *byte_chksum += 0xFF;
+ }
+ }
+ return chksum;
+ }
+
+ for (i = 0; i < size; i++)
+ {
+ if (i & 0x1)
+ {
+ *(byte_chksum + 1) += *(buf + i);
+ }
+ else
+ {
+ *byte_chksum += *(buf + i);
+ }
+ }
+
+ //Replace conflict chksum
+ if (chksum == 0)
+ return 0xCDEF;
+ else if(chksum == 0xCDEF)
+ return 0xCEDF;
+ else
+ return chksum;
+}
+
+kal_bool nvram_util_zero_data_check(const kal_uint8 *buf, kal_uint32 size)
+{
+ while(size > 0) {
+ if((size < 7) || ((kal_uint32)buf & 0x3)) {
+ if(*buf != 0) {
+ return KAL_FALSE;
+ }
+ buf += 1;
+ size -= 1;
+ }
+ else {
+ if(*(kal_uint64*)buf != 0) {
+ return KAL_FALSE;
+ }
+ buf += 8;
+ size -= 8;
+ }
+ }
+ return KAL_TRUE;
+}
+
+kal_uint16 nvram_util_md5_checksum_convert(const kal_uint8 *checksum_buf_8B, kal_uint8 *checksum_buf_2B, kal_bool Check_CDEF)
+{
+ kal_uint8 i;
+ kal_uint64 const EmptyChksum = 0xCDEF;
+ kal_uint16 val = 0;
+ kal_uint16 *chk_ptr = (kal_uint16*)checksum_buf_8B;
+ kal_uint32 nvram_chksum_size = 0;
+ #ifdef __NV_CHKSUM_ENHANCE__
+ nvram_chksum_size = MD5_CHKSUM_LENGTH_8;
+ #else
+ nvram_chksum_size = NVRAM_CHKSUM_SIZE;
+ #endif
+
+ //Check Empty
+ if(Check_CDEF && !kal_mem_cmp(checksum_buf_8B, (kal_uint8*)&EmptyChksum, nvram_chksum_size)) {
+ if(checksum_buf_2B != NULL) {
+ checksum_buf_2B[0] = 0xEF;
+ checksum_buf_2B[1] = 0xCD;
+ }
+ return 0xCDEF;
+ }
+
+ //Merge 8B MD5 to 2B
+ for(i = 0; i < (nvram_chksum_size / 2); i++){
+ val += chk_ptr[i];
+ }
+
+ //Replace conflict chksum
+ if(val == 0xCDEF) {
+ val = 0xCEDF;
+ }
+
+ //Return
+ if(checksum_buf_2B != NULL) {
+ kal_mem_cpy(checksum_buf_2B, (kal_uint8*)&val, 2);
+ }
+ return val;
+}
+
+kal_uint16 nvram_util_caculate_checksum(nvram_ltable_entry_struct *ldi, const kal_uint8 *buf, kal_uint32 size, kal_uint8* checksum_buf)
+{
+ kal_uint8 i=0;
+ kal_uint16 chksum_2B = 0;
+ nvram_lid_chksum_info lid_chksum_info = {0};
+ kal_uint64 const EmptyChksum = 0xCDEF;
+ kal_uint8 *byte_chksum = (kal_uint8*) &chksum_2B;
+ kal_uint8 *temp_chksum_buf = NULL;
+ kal_uint32 temp_chksum_buf_size = 0;
+ NVRAM_ALGO_TYPE chksum_algo_type = NVRAM_MD5;
+
+ nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
+
+ #ifdef __NV_CHKSUM_ENHANCE__
+ if(lid_chksum_info.algo_info.chksum_algo_type == chksum_algo_ptr->cur_algo.def_algo_type)
+ {
+ temp_chksum_buf_size = chksum_algo_ptr->cur_algo.def_algo_length;
+ }
+ else if(lid_chksum_info.algo_info.chksum_algo_type == chksum_algo_ptr->cur_algo.en_algo_type)
+ {
+ temp_chksum_buf_size = chksum_algo_ptr->cur_algo.en_algo_length;
+ }
+ chksum_algo_type = lid_chksum_info.algo_info.chksum_algo_type;
+ #else
+ temp_chksum_buf_size = NVRAM_CHKSUM_SIZE * 2;
+ chksum_algo_type = NVRAM_MD5;
+ #endif
+
+ if (buf == NVRAM_EF_ZERO_DEFAULT || nvram_util_zero_data_check(buf, size))
+ {
+ if(temp_chksum_buf_size < sizeof(EmptyChksum))
+ {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[NVUT_UTIL_CAL]%s(): LDI<0x%x> chksize(%d) too small\n\r", __FUNCTION__, ldi->LID, temp_chksum_buf_size);
+ kal_prompt_trace(MOD_NVRAM,"[NVUT_UTIL_CAL] %s(): LDI<0x%x> chksize(%d) too small.\n\r", __FUNCTION__, ldi->LID, temp_chksum_buf_size);
+ NVRAM_EXT_ASSERT(KAL_FALSE, ldi->LID, NVRAM_LOC_CHKSUM_ALGO_MISSMATCH_FAIL, chksum_algo_type, temp_chksum_buf_size);
+ }
+ kal_mem_cpy(checksum_buf, (kal_uint8*)&EmptyChksum, sizeof(EmptyChksum));
+ return 0xCDEF;
+ }
+
+ if(INT_QueryExceptionStatus()== KAL_TRUE)
+ {
+ temp_chksum_buf = (kal_uint8 *)g_util_chksum;
+ }
+ else
+ {
+ temp_chksum_buf = (kal_uint8*) get_ctrl_buffer(temp_chksum_buf_size);
+ }
+ kal_mem_set(temp_chksum_buf, 0, temp_chksum_buf_size);
+ nvram_calculate_checksum(chksum_algo_type, (kal_uint8 *)buf, size, temp_chksum_buf);
+
+ //Merge 16B MD5 to 8B
+ if(chksum_algo_type == NVRAM_MD5)
+ {
+ for(i = 0; i< NVRAM_CHKSUM_SIZE; i++)
+ {
+ checksum_buf[i] = temp_chksum_buf[i]^temp_chksum_buf[i+8];
+ }
+
+ //Merge 8B MD5 to 2B
+ nvram_util_md5_checksum_convert(checksum_buf, byte_chksum, KAL_FALSE);
+ }
+ else
+ {
+ kal_mem_cpy(checksum_buf, temp_chksum_buf, temp_chksum_buf_size);
+ }
+
+ if(INT_QueryExceptionStatus() != KAL_TRUE)
+ {
+ free_ctrl_buffer(temp_chksum_buf);
+ }
+
+ return chksum_2B;
+}
+
+
+
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_make_lid_filename
+ * DESCRIPTION
+ * PARAMETERS
+ * RETURNS
+ *****************************************************************************/
+void nvram_util_make_lid_filename(nvram_ltable_entry_struct *ldi, NVRAM_FILE_NAME nvramname, kal_bool first_copy)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+
+ if (ldi == NULL)
+ {
+ EXT_ASSERT(KAL_FALSE,(kal_uint32)ldi,NVRAM_LOC_LID_PTR_IS_NULL_2, 0);
+ return;
+ }
+
+#ifdef __NVRAM_PSEUDO_MERGE__
+ if (NVRAM_IS_ATTR_PACKAGE(ldi->attr))
+ {
+ nvram_make_package_filename(nvramname, 'A');
+ return;
+ }
+#endif
+
+ if (NVRAM_IS_ATTR_MULTIPLE(ldi->attr))
+ {
+ if (first_copy)
+ {
+ nvram_util_make_filename(nvramname, ldi->fileprefix, 'A', ldi->fileverno);
+ }
+ else
+ {
+ #if defined(__NVRAM_WRITE_PROTECT_ENABLE__) && defined(__NVRAM_IMPORTANT_PARTITIONS__) && defined(__CCCIFS_SUPPORT__)
+ nvram_util_make_filename(nvramname, ldi->fileprefix, 'A', ldi->fileverno);
+ #else
+ nvram_util_make_filename(nvramname, ldi->fileprefix, 'B', ldi->fileverno);
+ #endif
+ }
+ }
+ else
+ {
+ nvram_util_make_filename(nvramname, ldi->fileprefix, '_', ldi->fileverno);
+ }
+
+ return;
+
+}
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_make_lid_filename
+ * DESCRIPTION
+ * PARAMETERS
+ * RETURNS
+ *****************************************************************************/
+void nvram_util_make_filename(NVRAM_FILE_NAME buf, kal_char* prefix, kal_char M, kal_char* verno)
+{
+ buf[0] = prefix[0];
+ buf[1] = prefix[1];
+ buf[2] = prefix[2];
+ buf[3] = prefix[3];
+ buf[4] = M;
+ buf[5] = verno[0];
+ buf[6] = verno[1];
+ buf[7] = verno[2];
+ buf[8] = '\0';
+};
+
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_util_is_usbboot
+ * DESCRIPTION
+ * old function name: INT_USBBoot
+ * PARAMETERS
+ * RETURNS
+ *****************************************************************************/
+kal_bool nvram_util_is_usbboot(void)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ PW_CTRL_IS_USB_BOOT CtrlVal;
+ DCL_HANDLE handle;
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ handle=DclPW_Open(DCL_PW, FLAGS_NONE);
+ DclPW_Control(handle, PW_CMD_IS_USB_BOOT,(DCL_CTRL_DATA_T *)&CtrlVal);
+ DclPW_Close(handle);
+ return ((kal_bool)CtrlVal.val);
+}
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_util_poweron
+ * DESCRIPTION
+ * old function name: DRV_POWERON
+ * PARAMETERS
+ * RETURNS
+ *****************************************************************************/
+kal_bool nvram_util_poweron(void)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ DCL_HANDLE handle;
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ handle=DclPW_Open(DCL_PW, FLAGS_NONE);
+ DclPW_Control(handle,PW_CMD_POWERON,NULL);
+ DclPW_Close(handle);
+ return KAL_TRUE;
+}
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_util_poweron
+ * DESCRIPTION
+ * old function name: DRV_POWERON
+ * PARAMETERS
+ * RETURNS
+ *****************************************************************************/
+void nvram_util_poweroff(void)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ DCL_HANDLE handle;
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ handle=DclPW_Open(DCL_PW, FLAGS_NONE);
+ DclPW_Control(handle,PW_CMD_POWEROFF,NULL);
+ DclPW_Close(handle);
+}
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_get_total_num_lid
+ * DESCRIPTION
+ * Get the total LID number
+ * PARAMETERS
+ * void
+ * RETURNS
+ * nvram_lid_enum
+ *****************************************************************************/
+nvram_lid_enum nvram_get_total_num_lid(void)
+{
+ return nvram_ptr->ltable.total_LID;
+}
+
+nvram_lid_enum nvram_util_get_IMEISV_LID(void)
+{
+ return NVRAM_EF_IMEI_IMEISV_LID;
+}
+
+kal_uint32 nvram_util_get_IMEISV_size(void)
+{
+ return NVRAM_EF_IMEI_IMEISV_SIZE;
+}
+
+kal_uint32 nvram_util_get_IMEI_size(void)
+{
+ return NVRAM_EF_IMEI_IMEI_SIZE;
+}
+
+void nvram_util_take_mutex(kal_mutexid ext_mutex_id_ptr)
+{
+ if (!INT_QueryExceptionStatus() && !kal_query_systemInit() && ext_mutex_id_ptr)
+ {
+ kal_take_mutex(ext_mutex_id_ptr);
+ }
+}
+
+void nvram_util_give_mutex(kal_mutexid ext_mutex_id_ptr)
+{
+ if (!INT_QueryExceptionStatus() && !kal_query_systemInit() && ext_mutex_id_ptr)
+ {
+ kal_give_mutex(ext_mutex_id_ptr);
+ }
+}
+
+#ifdef __NVRAM_INIT_TIME_UT__
+void nvram_init_time_ut_save(void)
+{
+ kal_uint8 i;
+
+ for(i = 1; i < 9; i++) {
+ if(init_time_tick[i]) {
+ init_time_tick[i] -= init_time_tick[0];
+ }
+ }
+ //init_time_tick[1] = ((init_time_tick[1] & 0x0FFF) | (init_trace << 12));
+ init_time_tick[9] = init_trace;
+ nvram_external_write_data(NVRAM_EF_SYS_CACHE_OCTET_LID,
+ NVRAM_SYS_NVRAM_INIT_TIME_UT,
+ (kal_uint8*)&init_time_tick[1],
+ NVRAM_EF_SYS_CACHE_OCTET_SIZE);
+ nvram_external_write_data(NVRAM_EF_SYS_CACHE_OCTET_LID,
+ NVRAM_SYS_NVRAM_INIT_TIME_UT2,
+ (kal_uint8*)&init_time_tick[5],
+ NVRAM_EF_SYS_CACHE_OCTET_SIZE);
+}
+#endif /* __NVRAM_INIT_TIME_UT__ */
+
+void * nvram_memset(void* dest, kal_int32 value, kal_uint32 size)
+{
+ kal_uint8 *dest_ptr = (kal_uint8*)dest;
+
+ while(size)
+ {
+ if(size > (64*1024)) {
+ kal_mem_set(dest_ptr, value, (64*1024));
+ size -= (64*1024);
+ dest_ptr += (64*1024);
+ }
+ else {
+ return kal_mem_set(dest_ptr, value, size);
+ }
+ }
+ return NULL;
+}
+
+#if defined(__NVRAM_CREATE_FILE_ON_WRITE__)
+#define NVRAM_INFO_FILE_MAGIC_START 0x4F464E49 // "INFO"
+#define NVRAM_INFO_FILE_STAT_READY 0xFDFDFBFB
+#define MD5_CHECKSUM_LEN 16
+#define NVRAM_LID_BITMAP_SIZE ((NVRAM_LID_GRP_MAX-(NVRAM_LID_2ND_GRP_START-NVRAM_LID_1ST_GRP_END)+7)>>3)
+
+typedef struct {
+ kal_uint32 magic_start;
+ kal_uint32 file_stat;
+ kal_uint8 check_sum[MD5_CHECKSUM_LEN];
+} nvram_info_file_hdr_struct;
+
+typedef struct {
+ nvram_info_file_hdr_struct hdr;
+ kal_uint8 bitmap[NVRAM_LID_BITMAP_SIZE];
+ kal_bool changed;
+} nvram_created_file_info_struct;
+
+kal_mutexid nvram_bitmap_mutex = NULL;
+kal_mutexid nvram_pre_write_check_mutex = NULL;
+nvram_created_file_info_struct nvram_created_file_info;
+kal_uint8 *nvram_bitmap_ptr = nvram_created_file_info.bitmap;
+
+static WCHAR *nvram_util_get_info_file_path()
+{
+ static WCHAR fileName[NVRAM_MAX_PATH_LEN];
+
+ NVRAM_FS_MAKE_ROOT_PATH(fileName);
+
+ kal_wstrcat(fileName, L"\\INFO_FILE");
+
+ return fileName;
+}
+
+void nvram_util_lid_bimtap_set(kal_uint8 *bitmap, kal_uint32 lid)
+{
+ kal_uint32 offset;
+ kal_uint32 bit = lid&0x7;
+
+ if(!bitmap) {
+ EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_INVALID, lid);
+ }
+ if (lid < NVRAM_LID_1ST_GRP_END) {
+ offset = lid>>3;
+ } else if (lid >= NVRAM_LID_2ND_GRP_START){
+ offset = (NVRAM_LID_1ST_GRP_END>>3) + ((lid-NVRAM_LID_2ND_GRP_START)>>3);
+ } else {
+ EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_ACCESS_OOR, lid);
+ }
+
+ bitmap[offset] |= (0x1<<bit);
+ nvram_created_file_info.changed = KAL_TRUE;
+}
+
+void nvram_util_lid_bitmap_clr(kal_uint8 *bitmap, kal_uint32 lid)
+{
+ kal_uint32 offset;
+ kal_uint32 bit = lid&0x7;
+
+ if(!bitmap) {
+ EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_INVALID, lid);
+ }
+ if (lid < NVRAM_LID_1ST_GRP_END) {
+ offset = lid>>3;
+ } else if (lid >= NVRAM_LID_2ND_GRP_START){
+ offset = (NVRAM_LID_1ST_GRP_END>>3) + ((lid-NVRAM_LID_2ND_GRP_START)>>3);
+ } else {
+ EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_ACCESS_OOR, lid);
+ }
+
+ bitmap[offset] &= ~(0x1<<bit);
+ nvram_created_file_info.changed = KAL_TRUE;
+}
+
+kal_bool nvram_util_lid_bitmap_check(kal_uint8 *bitmap, kal_uint32 lid)
+{
+ kal_uint32 offset;
+ kal_uint32 bit = lid&0x7;
+
+ if(!bitmap) {
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_INVALID, lid);
+ }
+ if (lid < NVRAM_LID_1ST_GRP_END) {
+ offset = lid>>3;
+ } else if (lid >= NVRAM_LID_2ND_GRP_START){
+ offset = (NVRAM_LID_1ST_GRP_END>>3) + ((lid-NVRAM_LID_2ND_GRP_START)>>3);
+ } else {
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)bitmap, NVRAM_LOC_BITMAP_ACCESS_OOR, lid);
+ }
+
+ return ((bitmap[offset] & (0x1<<bit)) != 0)?KAL_TRUE:KAL_FALSE;
+}
+
+void nvram_utile_reset_lid_bitmap()
+{
+ nvram_created_file_info.hdr.magic_start = NVRAM_INFO_FILE_MAGIC_START;
+ nvram_created_file_info.hdr.file_stat = NVRAM_INFO_FILE_STAT_READY;
+ nvram_created_file_info.changed = KAL_FALSE;
+ kal_mem_set(nvram_created_file_info.bitmap, 0, sizeof(nvram_created_file_info.bitmap));
+}
+
+static void nvram_util_calc_md5_checksum(kal_uint8 *data_buf, kal_uint32 data_buf_len, kal_uint8 *chksum_buf)
+{
+
+ // MD5 of bit map
+ nvram_calculate_checksum(NVRAM_MD5, data_buf, data_buf_len, chksum_buf);
+
+ return;
+}
+
+
+kal_bool nvram_write_bitmap_into_file()
+{
+ kal_uint32 buf_len = 0;
+ kal_uint8 *write_buf = NULL;
+ WCHAR *file_path = NULL;
+ FS_HANDLE file_handle = FS_INVALID_FILE_HANDLE;
+ kal_int32 result = FS_NO_ERROR;
+ kal_uint32 write_len;
+
+ //Reduce the time of nvram init at first bootup by void writing bitmap file many times
+ if (nvram_ptr->state != NVRAM_STATE_READY) //before nvram init done, cann't write bitmap
+ {
+ return KAL_TRUE;
+ }
+ if(!nvram_created_file_info.changed) //Must After nvram init,can write bitmap when first boot or version change
+ {
+ return KAL_TRUE;
+ }
+ file_path = nvram_util_get_info_file_path();
+ NVRAM_FS_START_EX(FS_OP_OPEN,file_path);
+ file_handle = FS_Open(file_path, FS_READ_WRITE | FS_OPEN_NO_DIR | FS_CREATE_ALWAYS);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+ if (file_handle < FS_NO_ERROR) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->FS_Open bitmap fail at %d,file_handle=%d\r\n",__FUNCTION__,__LINE__,file_handle);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)file_handle, NVRAM_LOC_BITMAP_OPEN_FAIL, buf_len);
+ }
+
+ nvram_created_file_info.hdr.file_stat = NVRAM_INFO_FILE_STAT_READY;
+ nvram_util_calc_md5_checksum(nvram_created_file_info.bitmap, sizeof(nvram_created_file_info.bitmap), nvram_created_file_info.hdr.check_sum);
+
+ write_buf = (kal_uint8 *)&nvram_created_file_info;
+ buf_len = sizeof(nvram_created_file_info);
+ NVRAM_FS_START(FS_OP_WRITE);
+ result = FS_Write(file_handle, write_buf, buf_len, &write_len);
+ NVRAM_FS_END(FS_OP_WRITE,result);
+ if (result < FS_NO_ERROR) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->FS_Write fail at %d,result=%d\r\n",__FUNCTION__,__LINE__,result);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)result, NVRAM_LOC_BITMAP_WRITE_FAIL, buf_len, FS_Close(file_handle));
+ }
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ nvram_created_file_info.changed = KAL_FALSE;
+ return KAL_TRUE;
+}
+
+kal_bool nvram_delete_bitmap_file()
+{
+ WCHAR *file_path = NULL;
+ kal_int32 result = FS_NO_ERROR;
+ file_path = nvram_util_get_info_file_path();
+ NVRAM_FS_START_EX(FS_OP_DELETE,file_path);
+ result = FS_Delete(file_path);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s result=%d\r\n",__FUNCTION__,result);
+ return KAL_TRUE;
+}
+kal_taskid pre_write_check_mutex_owner = (kal_taskid)-1; /* to avoid recursive lock */
+void nvram_util_pre_write_lid(nvram_ltable_entry_struct *ldi)
+{
+ if (pre_write_check_mutex_owner != kal_get_current_task()) {
+ nvram_util_take_mutex(nvram_pre_write_check_mutex);
+ pre_write_check_mutex_owner = kal_get_current_task();
+
+ if (!nvram_util_has_file_created(ldi) && !nvram_util_always_gen_default(ldi))
+ {
+ if(NVRAM_IS_ATTR_RAW_DATA(ldi->attr))
+ {
+ // no need reset RAW data file
+ nvram_util_post_reset_gen_default_lid(ldi);
+ }
+ else
+ {
+ // mark always create, then reset the lid
+ ldi->attr |= NVRAM_ATTR_GEN_DEFAULT;
+
+ // reset the LID, bitmap will be set after reset ok
+ nvram_reset_data_items(NVRAM_RESET_CERTAIN, 0, ldi, 1, ldi->total_records);
+ // clear the mark
+ ldi->attr &= ~NVRAM_ATTR_GEN_DEFAULT;
+ }
+ }
+
+ pre_write_check_mutex_owner = (kal_taskid)-1;
+ nvram_util_give_mutex(nvram_pre_write_check_mutex);
+ }
+}
+
+void nvram_util_post_write_lid(nvram_ltable_entry_struct *ldi)
+{
+
+}
+
+void nvram_util_pre_reset_gen_default_lid(nvram_ltable_entry_struct *ldi)
+{
+ if (nvram_util_has_file_created(ldi)) {
+ // do nothing
+ return;
+ }
+
+ // prepare reset
+}
+
+void nvram_util_post_reset_gen_default_lid(nvram_ltable_entry_struct *ldi)
+{
+ nvram_lid_enum lid = ldi->LID;
+
+ if (nvram_util_has_file_created(ldi)) {
+ // do nothing
+ return;
+ }
+
+ // reset lid finish, file generated success fully
+ #ifdef __NVRAM_LID_CACHE__
+ nvram_util_take_mutex(g_nvram_fs_mutex);
+ #endif
+ nvram_util_take_mutex(nvram_bitmap_mutex);
+ nvram_util_lid_bimtap_set(nvram_created_file_info.bitmap, lid);
+ nvram_write_bitmap_into_file();
+ nvram_util_give_mutex(nvram_bitmap_mutex);
+ #ifdef __NVRAM_LID_CACHE__
+ nvram_util_give_mutex(g_nvram_fs_mutex);
+ #endif
+}
+
+kal_bool nvram_util_has_file_created(nvram_ltable_entry_struct *ldi)
+{
+ nvram_lid_enum lid = ldi->LID;
+
+ if (NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category) ||
+ NVRAM_IS_CATEGORY_OTP(ldi->category)) {
+ return KAL_TRUE;
+ }
+#ifdef __NVRAM_READ_RESERVED_FILE__
+ if(ldi->LID == NVRAM_EF_READ_RESERVED_LID) {
+ return KAL_TRUE;
+ }
+#endif
+
+ // read only
+ return nvram_util_lid_bitmap_check(nvram_created_file_info.bitmap, lid);
+}
+
+kal_bool nvram_util_always_gen_default(nvram_ltable_entry_struct *ldi)
+{
+ if ((ldi->attr & (NVRAM_ATTR_GEN_DEFAULT)) != 0) {
+ return KAL_TRUE;
+ }
+
+ return KAL_FALSE;
+}
+
+void nvram_util_mark_file_uncreated(nvram_ltable_entry_struct *ldi)
+{
+ nvram_lid_enum lid = ldi->LID;
+ kal_uint32 idx;
+ kal_int32 result = FS_NO_ERROR;
+ // remove record
+ nvram_util_take_mutex(nvram_bitmap_mutex);
+ if (nvram_util_lid_bitmap_check(nvram_created_file_info.bitmap, lid)) {
+ nvram_util_lid_bitmap_clr(nvram_created_file_info.bitmap, lid);
+
+ // delete the LID's NVRAM File
+ for (idx = 0; idx < 2; idx++) {
+ NVRAM_FILE_NAME nvramname;
+ WCHAR filename[NVRAM_MAX_PATH_LEN];
+ nvram_folder_enum folder_index;
+
+ nvram_util_make_lid_filename(ldi, nvramname, (idx==0));
+ folder_index = nvram_query_folder_index_ex(ldi->category, (idx==0));
+ nvram_query_file_name(folder_index, nvramname, filename);
+ NVRAM_FS_START_EX(FS_OP_DELETE,filename);
+ result = FS_Delete(filename);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s->FS_Delete %s result=%d\r\n",__FUNCTION__,nvramname,result);
+ if (!(ldi->attr & NVRAM_ATTR_MULTIPLE)) {
+ break;
+ }
+ }
+
+ // update info file
+ nvram_write_bitmap_into_file();
+ }
+ nvram_util_give_mutex(nvram_bitmap_mutex);
+}
+
+static kal_bool nvram_util_reconstruct_info_file()
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ FS_FileOpenHint Hint;
+ NVRAM_FILE_NAME nvramname;
+ kal_int32 file_size = 0;
+ kal_wchar filename[NVRAM_MAX_PATH_LEN];
+ nvram_folder_enum folder_index;
+ kal_uint32 i;
+ nvram_ltable_entry_struct *ldi = &logical_data_item_table[0];
+ kal_bool file_exist;
+ nvram_lid_enum lid;
+ kal_int32 result = FS_NO_ERROR;
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ /* Must clear up Hint beforehand */
+ NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
+ kal_mem_set(&Hint, 0, sizeof(Hint));
+ nvram_util_take_mutex(nvram_bitmap_mutex);
+ nvram_utile_reset_lid_bitmap();
+
+ do
+ {
+ file_exist = KAL_FALSE;
+ lid = ldi->LID;
+
+ for (i = 0 ; i < 2; i++)
+ {
+ folder_index = nvram_query_folder_index(ldi->category);
+
+ if (i == 0) // first copy
+ {
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_TRUE);
+ }
+ else // second copy
+ {
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_FALSE);
+
+ #ifdef __NVRAM_BACKUP_DISK_FAT__
+ if (NVRAM_IS_ATTR_BACKUP_FAT(ldi->attr))
+ {
+ folder_index = NVRAM_NVD_BAK;
+ }
+ #endif
+ }
+
+ file_size = nvram_drv_fat_get_record_size(nvramname, &Hint, folder_index);
+
+ if (file_size == 0)
+ {
+ // delete empty file
+ nvram_query_file_name(folder_index, nvramname, filename);
+ NVRAM_FS_START_EX(FS_OP_DELETE,filename);
+ result = FS_Delete(filename);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s->FS_Delete %s result=%d\r\n",__FUNCTION__,nvramname,result);
+ }
+
+ if (file_size > 0) {
+ file_exist = KAL_TRUE;
+ break;
+ }
+
+ if (!NVRAM_IS_ATTR_MULTIPLE(ldi->attr))
+ {
+ break;
+ }
+ }
+
+ if (file_exist == KAL_TRUE) {
+ nvram_util_lid_bimtap_set(nvram_created_file_info.bitmap, lid);
+ }
+ }while(nvram_util_next_data_item(&ldi));
+ nvram_created_file_info.changed = KAL_TRUE;
+ nvram_write_bitmap_into_file();
+ nvram_util_give_mutex(nvram_bitmap_mutex);
+ if(nvram_ee_info != NULL){
+ nvram_ee_info->nvram_init_step = NVRAM_CORE_INIT_FACTORY_BOOT_CONSTRUCT_BITMAP_DONE;
+ }
+ NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
+ return KAL_TRUE;
+}
+
+
+kal_bool nvram_get_created_file_info()
+{
+ WCHAR *file_path = NULL;
+ FS_HANDLE file_handle = FS_INVALID_FILE_HANDLE;
+ kal_uint32 read_len;
+ kal_int32 result = FS_NO_ERROR;
+ nvram_info_file_hdr_struct *hdr = &nvram_created_file_info.hdr;
+ kal_uint8 temp_checksum[MD5_CHECKSUM_LEN];
+
+
+ file_path = nvram_util_get_info_file_path();
+ NVRAM_FS_START_EX(FS_OP_OPEN,file_path);
+ file_handle = FS_Open(file_path, FS_READ_ONLY|FS_OPEN_NO_DIR);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+ if (file_handle < FS_NO_ERROR) {
+ // file not exist, maybe deleted
+ is_nvram_factory_reset = KAL_TRUE;
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s bitmap file is not exist\r\n",__FUNCTION__);
+ return nvram_util_reconstruct_info_file();
+ }
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(file_handle, hdr, sizeof(*hdr), &read_len);
+ NVRAM_FS_END(FS_OP_READ,result);
+
+ if (result < FS_NO_ERROR || read_len != sizeof(*hdr)) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s->FS_Read result=%d,read_len=%d \r\n",__FUNCTION__,result,read_len);
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ return nvram_util_reconstruct_info_file();
+ }
+
+ if (hdr->magic_start != NVRAM_INFO_FILE_MAGIC_START) {
+ // Invalid header
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s bitmap file:Invalid header\r\n",__FUNCTION__);
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ return nvram_util_reconstruct_info_file();
+ }
+
+ if (hdr->file_stat != NVRAM_INFO_FILE_STAT_READY) {
+ // File is updating but power lost
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s bitmap file:data is corruption\r\n",__FUNCTION__);
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ return nvram_util_reconstruct_info_file();
+ }
+
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(file_handle, nvram_created_file_info.bitmap, sizeof(nvram_created_file_info.bitmap), &read_len);
+ NVRAM_FS_END(FS_OP_READ,result);
+ if (result < FS_NO_ERROR || read_len != sizeof(nvram_created_file_info.bitmap)) {
+ // Read Error
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s->FS_Read fail,result=%d\r\n",__FUNCTION__,result);
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ return nvram_util_reconstruct_info_file();
+ }
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+
+ nvram_util_calc_md5_checksum(nvram_created_file_info.bitmap, sizeof(nvram_created_file_info.bitmap), temp_checksum);
+ if (memcmp(nvram_created_file_info.hdr.check_sum, temp_checksum, MD5_CHECKSUM_LEN) != 0) {
+ // checksum check fail
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s bitmap file:checksum error\r\n",__FUNCTION__);
+ return nvram_util_reconstruct_info_file();
+ }
+
+ return KAL_TRUE;
+}
+
+kal_bool nvram_util_init_info_file()
+{
+ // MUST call once @ nvram_init
+ static kal_bool inited = KAL_FALSE;
+
+ if (!inited) {
+ inited = KAL_TRUE;
+
+ nvram_bitmap_mutex = kal_create_mutex("NV_INFO");
+ nvram_pre_write_check_mutex = kal_create_mutex("NV_PREW");
+
+ if (nvram_ptr->sw_status & NVRAM_SW_EMPTY_FAT) {
+ nvram_utile_reset_lid_bitmap();
+ nvram_write_bitmap_into_file();
+ } else {
+ nvram_get_created_file_info();
+ }
+ }
+
+ return KAL_TRUE;
+}
+
+#endif
+
+DECLARE_MIPS32
+static kal_uint16 nvram_data_header_checksum(kal_uint8 *buf, kal_uint32 size)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+ kal_uint32 i;
+ kal_uint16 chksum = *(kal_uint16*)buf;
+ kal_uint8 *byte_chksum = (kal_uint8*)&chksum;
+ kal_uint8 value;
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+
+ for (i = 0; i < size; i++)
+ {
+ value = *(buf + i);
+ while(value) {
+ if(value & 0x1) {
+ #if defined(__MTK_TARGET__)
+ __asm__ __volatile__
+ (
+ "rol %0, %0, 1\r\n"
+ ::"r"(chksum)
+ );
+ #else
+ __asm {ROL [chksum],1};
+ #endif
+ }
+ value >>= 1;
+ }
+ #if defined(__MTK_TARGET__)
+ __asm__ __volatile__
+ (
+ "rol %0, %0, 4\r\n"
+ ::"r"(chksum)
+ );
+ #else
+ __asm {ROL [chksum],4};
+ #endif
+
+ *byte_chksum += *(buf + i);
+ }
+
+ return chksum;
+}
+
+kal_uint32 nvram_appendix_header_offset(nvram_ltable_entry_struct *ldi)
+{
+ kal_uint32 size = 0;
+ kal_uint32 nvram_chksum_size = 0;
+ nvram_lid_chksum_info lid_chksum_info = {0};
+
+ nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
+ nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
+
+ if ((ldi->attr & NVRAM_ATTR_CONFIDENTIAL)
+ #ifdef __NVRAM_BIND_TO_CHIP_CIPHER__
+ || (ldi->attr & NVRAM_ATTR_MSP)
+ #endif
+ )
+ {
+ /* 16 byte alignment */
+ size = NVRAM_MSP_ALIGNMENT_REMAINDER(ldi->size + nvram_chksum_size) + ldi->size + nvram_chksum_size;
+ }
+ else
+ {
+ size = (ldi->size + nvram_chksum_size);
+ }
+ size = size * ldi->total_records;
+ return (NVRAM_LDI_HEADER_SIZE + size);
+}
+
+static __inline kal_bool nvram_prepare_ota_header(nvram_ldi_ota_header *ldi_ota_header, nvram_ltable_entry_struct *ldi)
+{
+ #if defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+ kal_int32 chksum_index;
+ #endif
+
+ memcpy(ldi_ota_header->header, "LDI", 4);
+ ldi_ota_header->LID = ldi->LID;
+ ldi_ota_header->ldi_attr = ldi->attr;
+ ldi_ota_header->ldi_category= ldi->category;
+ ldi_ota_header->record_size = ldi->size;
+ ldi_ota_header->total_records = ldi->total_records;
+ //check appendix header offset
+ if(ldi->attr & NVRAM_ATTR_CHKSUM_INTEGRATE) {
+ ldi->append_offset = nvram_appendix_header_offset(ldi);
+ }
+ #if defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+ chksum_index = nvram_get_defval_chksum_index(ldi->LID);
+ if(-1 != chksum_index)
+ {
+ kal_mem_cpy((char *)(ldi_ota_header->defval_chkrst_h), (const char*)(lid_default_value_chksum[chksum_index].chksum), RST_CHKSUM_SIZE-6);
+ }
+ #endif
+ ldi_ota_header->checksum = nvram_data_header_checksum((kal_uint8*)ldi_ota_header, (NVRAM_LDI_OTA_HEADER_SIZE - sizeof(ldi_ota_header->checksum)));
+ return KAL_TRUE;
+}
+
+static __inline kal_bool nvram_prepare_debug_header(nvram_ldi_debug_header *ldi_debug_header, nvram_ltable_entry_struct *ldi)
+{
+ #if defined(__NVRAM_STRUCTURE_CHANGE_RESET__) || defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+ kal_int32 chksum_index;
+ #endif
+
+ ldi_debug_header->last_write_taskID = kal_get_current_task_index();
+ ldi_debug_header->last_write_time = kal_get_systicks();
+ ldi_debug_header->write_times += 1;
+
+ #if defined(__NVRAM_STRUCTURE_CHANGE_RESET__)
+ chksum_index = nvram_get_structure_chksum_index(ldi->LID);
+ if(-1 != chksum_index)
+ {
+ kal_mem_cpy((char *)(ldi_debug_header->struct_chkrst), (const char*)(lid_structure_chksum[chksum_index].chksum), RST_CHKSUM_SIZE);
+ }
+ #endif
+
+ #if defined(__NVRAM_DEFVAL_CHANGE_RESET__)
+ chksum_index = nvram_get_defval_chksum_index(ldi->LID);
+ if(-1 != chksum_index)
+ {
+ kal_mem_cpy((char *)(ldi_debug_header->defval_chkrst_l),(const char*)(&(lid_default_value_chksum[chksum_index].chksum[RST_CHKSUM_SIZE-6])), 6);
+ }
+ #endif
+
+ return KAL_TRUE;
+}
+
+kal_bool nvram_prepare_data_header(nvram_ltable_entry_struct *ldi,kal_uint8 *ldi_hd_buffer)
+{
+ nvram_ldi_ota_header *ldi_ota_header = (nvram_ldi_ota_header*)ldi_hd_buffer;
+ nvram_ldi_debug_header *ldi_debug_header = (nvram_ldi_debug_header*)(ldi_hd_buffer + NVRAM_LDI_OTA_HEADER_SIZE);
+
+ nvram_prepare_ota_header(ldi_ota_header,ldi);
+ nvram_prepare_debug_header(ldi_debug_header, ldi);
+
+ return KAL_TRUE;
+}
+
+/* =====================================================================
+APDX_hdr1 chksum type data_offset1
+APDX_hdr2 chksum type data_offset2
+data1 ......
+data2 ......
+
+ * FUNCTION
+ * nvram_prepare_appendix_header
+ * DESCRIPTION
+ * This function is used to read the checksum of data item for external module.
+ * Please must check with NVRAM owner before you use this API.
+ * PARAMETERS
+ * type: [IN] header type
+ * ldi_append_header: [IN] header buffer
+ * ldi: [IN] NVRAM LID
+ * data_offset: [IN] current APDX data offset
+ * RETURNS
+ * the next APDX data start offset
+=======================================================================*/
+kal_uint32 nvram_prepare_appendix_header(nvram_appendix_type_enum type, nvram_ldi_appendix_header *ldi_append_header, nvram_ltable_entry_struct *ldi, kal_uint32 data_offset)
+{
+ kal_uint32 nvram_chksum_size = 0;
+ nvram_lid_chksum_info lid_chksum_info = {0};
+
+ nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
+ nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
+
+ memset(ldi_append_header, 0, NVRAM_LDI_APPENDIX_HEADER_SIZE);
+ memcpy(ldi_append_header->header, "APDX", 4);
+
+ if(type == NVRAM_APPEND_TYPE_CHKSUM) {
+ ldi_append_header->type = NVRAM_APPEND_TYPE_CHKSUM;
+ ldi_append_header->data_offset = data_offset;
+ //caculate next data start
+ data_offset = (data_offset + (ldi->total_records * nvram_chksum_size));
+ data_offset = NVRAM_MSP_ALIGNMENT_CEILING(data_offset);
+ }
+ else {
+ ldi_append_header->type = NVRAM_APPEND_TYPE_END;
+ data_offset = 0;
+ }
+ ldi_append_header->checksum = nvram_data_header_checksum((kal_uint8*)ldi_append_header, NVRAM_LDI_APPENDIX_HEADER_SIZE);
+ return data_offset;
+}
+
+kal_bool nvram_write_data_header(nvram_ltable_entry_struct *ldi, nvram_header_section_enum section)
+{
+
+ NVRAM_FILE_NAME nvramname;
+ kal_wchar filename[NVRAM_MAX_PATH_LEN];
+ nvram_folder_enum nvram_folder;
+ FS_HANDLE file_handle = FS_INVALID_FILE_HANDLE;
+ kal_int32 result = FS_NO_ERROR;
+ kal_int32 backup_file_num = 1;
+ kal_bool mulpiple = KAL_FALSE;
+ kal_bool ret_val = KAL_TRUE;
+ nvram_ldi_header nv_header;
+ nvram_ldi_appendix_header nv_appendix_header;
+ nvram_ldi_ota_header *ldi_ota_header = &(nv_header.nv_ota_header);
+ nvram_ldi_debug_header *ldi_debug_header = &(nv_header.nv_dbg_header);
+ nvram_ldi_appendix_header *ldi_append_header = &nv_appendix_header;
+ kal_uint32 ldi_hd_buffer_size = 0;
+ kal_uint32 ldi_hd_offset = 0;
+ kal_uint32 ldi_checksum_hd_offset = 0;
+ #ifdef __NVRAM_LID_CACHE__
+ kal_uint32 cache_offset = 0;
+ kal_uint32 openOption = FS_READ_WRITE | FS_OPEN_NO_DIR | FS_CREATE;
+ #endif
+
+ /* NVRAM GPT timeout assert start timer */
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ start.u2Tick= NVRAM_WRITE_GPT_TIMEOUT;
+ start.pfCallback=nvram_gpt_timeout_callback;
+ start.vPara=NULL;
+ #endif
+
+ kal_mem_set(&nv_header, 0x0, sizeof(nv_header));
+ kal_mem_set(&nv_appendix_header, 0x0, sizeof(nv_appendix_header));
+
+ if(NVRAM_IS_ATTR_MULTIPLE(ldi->attr) || NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category))
+ {
+ mulpiple = KAL_TRUE;
+ backup_file_num = 2;
+ }
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_TRUE);
+ nvram_folder = nvram_query_folder_index(ldi->category);
+ nvram_query_file_name(nvram_folder, nvramname, filename);
+
+ if(section == LDI_HEADER_ALL_SECTION) {
+ nvram_prepare_ota_header(ldi_ota_header,ldi);
+ nvram_prepare_debug_header(ldi_debug_header,ldi);
+ if(ldi->attr & NVRAM_ATTR_CHKSUM_INTEGRATE){
+ nvram_prepare_appendix_header(NVRAM_APPEND_TYPE_CHKSUM, ldi_append_header, ldi, NVRAM_LDI_APPENDIX_HEADER_SIZE);
+ }
+ ldi_hd_buffer_size = NVRAM_LDI_OTA_HEADER_SIZE + NVRAM_LDI_DEBUG_HEADER_SIZE;
+ }
+ else
+ {
+ if(NVRAM_IS_CATEGORY_CALIBRAT(ldi->category) || NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)) {
+ //CALIBRATION and IMPT_L4 need update debug section
+ }
+ else {
+ return KAL_FALSE;
+ }
+ nvram_util_take_mutex(g_nvram_fs_mutex);
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start); //start timer
+ #endif
+ nvram_read_data_header(filename, LDI_HEADER_ALL_SECTION, (void*)&nv_header, NVRAM_LDI_HEADER_SIZE);
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_STOP, (DCL_CTRL_DATA_T*)NULL); //stop timer
+ #endif
+ nvram_util_give_mutex(g_nvram_fs_mutex);
+ }
+ if(section == LDI_HEADER_DBG_SECTION)
+ {
+ if(NVRAM_IS_CATEGORY_CALIBRAT(ldi->category) || NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)) {
+ //CALIBRATION and IMPT_L4 need update debug section
+ }
+ else {
+ return KAL_FALSE;
+ }
+ nvram_prepare_debug_header(ldi_debug_header,ldi);
+ ldi_hd_offset = NVRAM_LDI_OTA_HEADER_SIZE;
+ ldi_hd_buffer_size = NVRAM_LDI_DEBUG_HEADER_SIZE;
+ }
+ else if(section == LDI_HEADER_OTA_SECTION)
+ {
+ nvram_prepare_ota_header(ldi_ota_header,ldi);
+ ldi_hd_offset = 0;
+ ldi_hd_buffer_size = NVRAM_LDI_OTA_HEADER_SIZE;
+ }
+
+ nvram_util_take_mutex(g_nvram_fs_mutex);
+
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start); //start timer
+ #endif
+
+ do{
+ #ifdef __NVRAM_LID_CACHE__
+ if((!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) && NVRAM_WR_WITH_CACHE(ldi->LID))
+ {
+ if(NVRAM_IO_ERRNO_OK != (result = get_lid_cache_base_address(ldi, &cache_offset))) {
+ ret_val = KAL_FALSE;
+ break;
+ }
+ if(NVRAM_IO_ERRNO_OK != (result = nvram_write_data_to_cache(ldi, (void *)(&nv_header), NVRAM_LDI_HEADER_SIZE, cache_offset))){
+ kal_prompt_trace(MOD_NVRAM, "NVRAM write header write fail:0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "section:%d,cache_offset:%d\n\r", section,cache_offset);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[Error]NVRAM write header at %d write fail:%d\n\r", __LINE__,result);
+ if(NVRAM_IS_ATTR_FAULT_ASSERT(ldi->attr)) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "LID:0x%04X, total_records:%d, record_size:%d\r\n", ldi->LID, ldi->total_records, ldi->size);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "section:%d,cache_offset:%d\r\n", section,cache_offset);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)result, NVRAM_ERROR_LOC_NVCACHE_ERRNO_WRITE_HEADER_FAIL, ldi->LID);
+ }
+ ret_val = KAL_FALSE;
+ break;
+ }
+ if(section == LDI_HEADER_ALL_SECTION)
+ {
+ set_reset_flag_by_ltable_entry(ldi);
+ }
+ mask_dirty_bit_by_ltable_entry(ldi, 0, 1);
+ mask_valid_bit_by_ltable_entry(ldi, 0, 1);
+
+ //write appendix header
+ ldi_checksum_hd_offset = nvram_appendix_header_offset(ldi);
+ if((section == LDI_HEADER_ALL_SECTION) && (ldi->attr & NVRAM_ATTR_CHKSUM_INTEGRATE)) {
+ cache_offset = cache_offset + ldi_checksum_hd_offset;
+ if (NVRAM_IO_ERRNO_OK != (result = nvram_write_data_to_cache(ldi, (void *)ldi_append_header, NVRAM_LDI_APPENDIX_HEADER_SIZE, cache_offset))) {
+ kal_prompt_trace(MOD_NVRAM, "NVRAM appendix header write fail:0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "cache_offset:%d\r\n",cache_offset);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[Error]NVRAM appendix header at %d write fail :%d\n\r", __LINE__,result);
+ if(NVRAM_IS_ATTR_FAULT_ASSERT(ldi->attr)) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "LID:0x%04X, total_records:%d, record_size:%d\r\n", ldi->LID, ldi->total_records, ldi->size);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "cache_offset:%d\r\n",cache_offset);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)result, NVRAM_ERROR_LOC_NVCACHE_ERRNO_WRITE_HEADER_FAIL, ldi->LID);
+ }
+ ret_val = KAL_FALSE;
+ break;
+ }
+
+ }
+ nvram_cache_enqueue(ldi, 0, 1, openOption);
+ send_event_to_nvram_cache();
+ }
+ else
+ #endif
+ {
+ NVRAM_FS_START_EX(FS_OP_OPEN,filename);
+ file_handle = FS_Open(filename, FS_READ_WRITE | FS_OPEN_NO_DIR | FS_CREATE);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+ if (file_handle < FS_NO_ERROR) {
+ kal_prompt_trace(MOD_NVRAM, "NVRAM write header open fail:0x%x\n\r", file_handle);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[Error]NVRAM write header at %d open fail:%d\n\r", __LINE__,result);
+ if(NVRAM_IS_ATTR_FAULT_ASSERT(ldi->attr)) {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "LID:0x%04X, total_records:%d, record_size:%d\r\n", ldi->LID, ldi->total_records, ldi->size);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "section:%d\r\n",section);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)file_handle, NVRAM_LOC_OPEN_NV_FOLDER_FAIL_4, ldi->LID);
+ }
+ ret_val = KAL_FALSE;
+ }
+ if(ldi_hd_offset && (file_handle > FS_NO_ERROR)) {
+ NVRAM_FS_START(FS_OP_SEEK);
+ result = FS_Seek(file_handle, ldi_hd_offset, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_SEEK,result);
+ }
+
+ if (file_handle > FS_NO_ERROR){
+ NVRAM_FS_START(FS_OP_WRITE);
+ result = FS_Write(file_handle, (void *)(((kal_uint32)(&nv_header)) + ldi_hd_offset), ldi_hd_buffer_size, &ldi_hd_buffer_size);
+ NVRAM_FS_END(FS_OP_WRITE,result);
+ if (result < FS_NO_ERROR){
+ kal_prompt_trace(MOD_NVRAM, "NVRAM write header write fail:0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[Error]NVRAM write header at %d write fail:%d\n\r", __LINE__,result);
+ if(NVRAM_IS_ATTR_FAULT_ASSERT(ldi->attr)) {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "LID:0x%04X, total_records:%d, record_size:%d\r\n", ldi->LID, ldi->total_records, ldi->size);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "section:%d\r\n",section);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)file_handle, NVRAM_LOC_OPEN_NV_FOLDER_FAIL_5, ldi->LID, result);
+ }
+ ret_val = KAL_FALSE;
+ }
+ #ifdef __NVRAM_LID_CACHE__
+ else
+ {
+ if((!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) && NVRAM_WR_2_FILE_WITH_2_CACHE(ldi->LID))
+ {
+ get_lid_cache_base_address(ldi, &cache_offset);
+ nvram_write_data_to_cache(ldi, (void *)(&nv_header), NVRAM_LDI_HEADER_SIZE, cache_offset);
+ mask_valid_bit_by_ltable_entry(ldi, 0, 1);
+ }
+ }
+ #endif
+ }
+
+ //write appendix header
+ ldi_checksum_hd_offset = nvram_appendix_header_offset(ldi);
+ if((section == LDI_HEADER_ALL_SECTION) && (ldi->attr & NVRAM_ATTR_CHKSUM_INTEGRATE)) {
+ if(file_handle > FS_NO_ERROR){
+ NVRAM_FS_START(FS_OP_WRITE);
+ result = FS_Seek(file_handle, ldi_checksum_hd_offset, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_WRITE,result);
+ NVRAM_FS_START(FS_OP_WRITE);
+ result = FS_Write(file_handle, ldi_append_header, NVRAM_LDI_APPENDIX_HEADER_SIZE, &ldi_hd_buffer_size);
+ NVRAM_FS_END(FS_OP_WRITE,result);
+ }
+ if ((file_handle > FS_NO_ERROR) &&(result < FS_NO_ERROR)) {
+ kal_prompt_trace(MOD_NVRAM, "NVRAM appendix header write fail:0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "[Error]NVRAM appendix header at %d write fail:%d\n\r", __LINE__,result);
+ if(NVRAM_IS_ATTR_FAULT_ASSERT(ldi->attr)) {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "LID:0x%04X, total_records:%d, record_size:%d\r\n", ldi->LID, ldi->total_records, ldi->size);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP, "fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_EXT_ASSERT(KAL_FALSE, (kal_uint32)file_handle, NVRAM_LOC_WRITE_FILE_FAIL_4, ldi->LID, result);
+ }
+ ret_val = KAL_FALSE;
+ }
+ #ifdef __NVRAM_LID_CACHE__
+ else
+ {
+ if((!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) && NVRAM_WR_2_FILE_WITH_2_CACHE(ldi->LID))
+ {
+ get_lid_cache_base_address(ldi, &cache_offset);
+ cache_offset = cache_offset + ldi_checksum_hd_offset;
+ nvram_write_data_to_cache(ldi, ldi_append_header, NVRAM_LDI_APPENDIX_HEADER_SIZE, cache_offset);
+
+ }
+ }
+ #endif
+
+ }
+ if(file_handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ }
+ }
+ backup_file_num --;
+ #if defined(__NVRAM_WRITE_PROTECT_ENABLE__)
+ if (NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)) {
+ // Don't write protect2
+ break;
+ }
+ #endif
+ if(!mulpiple)
+ {
+ break;
+ }
+ nvram_folder = nvram_query_folder_index_ex(ldi->category,KAL_FALSE);
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_FALSE);
+ nvram_query_file_name(nvram_folder, nvramname, filename);
+
+ }while(backup_file_num > 0);
+
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_STOP, (DCL_CTRL_DATA_T*)NULL); //stop timer
+ #endif
+
+ nvram_util_give_mutex(g_nvram_fs_mutex);
+ return ret_val;
+}
+
+kal_bool nvram_read_data_header(const kal_wchar *filename, nvram_header_section_enum section, void* buffer, kal_uint32 buffer_size)
+{
+ kal_char s_filename[NVRAM_MAX_PATH_LEN];
+ FS_HANDLE file_handle = FS_INVALID_FILE_HANDLE;
+ kal_int32 result = FS_NO_ERROR;
+ kal_bool ret_val = KAL_TRUE;
+
+ kal_uint32 ldi_hd_buffer_size = 0;
+ kal_uint32 ldi_hd_buffer_data_size = 0;
+ kal_uint32 ldi_hd_offset = 0;
+ nvram_ldi_ota_header *ldi_ota_header;
+
+ #ifdef __NVRAM_LID_CACHE__
+ nvram_ldi_appendix_header nv_appendix_header;
+ nvram_ldi_appendix_header *ldi_append_header = &nv_appendix_header;
+ kal_uint32 ldi_checksum_hd_offset = 0;
+ kal_uint32 ldi_checksum_hd_buffer_size = NVRAM_LDI_APPENDIX_HEADER_SIZE;
+ kal_uint32 ldi_checksum_hd_data_size = 0;
+ kal_uint32 cache_offset = 0;
+ kal_wchar wcfilename[NVRAM_FILE_LEN + 1];
+ kal_char cfilename[NVRAM_FILE_LEN + 1];
+
+ nvram_ltable_entry_struct *ldi = NULL;
+ #endif
+
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ SGPT_CTRL_START_T start;
+ #endif
+
+ if(section == LDI_HEADER_OTA_SECTION) {
+ //ldi_hd_offset = 0;
+ ldi_hd_buffer_size += NVRAM_LDI_OTA_HEADER_SIZE;
+ }
+ else if(section == LDI_HEADER_DBG_SECTION) {
+ ldi_hd_offset = NVRAM_LDI_OTA_HEADER_SIZE;
+ ldi_hd_buffer_size += NVRAM_LDI_DEBUG_HEADER_SIZE;
+ }
+ else if(section == LDI_HEADER_ALL_SECTION) {
+ //ldi_hd_offset = 0;
+ ldi_hd_buffer_size += (NVRAM_LDI_OTA_HEADER_SIZE + NVRAM_LDI_DEBUG_HEADER_SIZE);
+ }
+ else {
+ kal_prompt_trace(MOD_NVRAM, "nvram_read_data_header:section 0x%x is wrong\n\r", section);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s section 0x%x is wrong\r\n",__FUNCTION__,section);
+ return KAL_FALSE;
+ }
+
+
+ if(!buffer || (buffer_size < ldi_hd_buffer_size)) {
+ return KAL_FALSE;
+ }
+
+ /* NVRAM GPT timeout assert start timer */
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ start.u2Tick= NVRAM_READ_GPT_TIMEOUT;
+ start.pfCallback=nvram_gpt_timeout_callback;
+ start.vPara=NULL;
+ #endif
+
+
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_START, (DCL_CTRL_DATA_T*)&start); //start timer
+ #endif
+
+ #ifdef __NVRAM_LID_CACHE__
+ kal_mem_set(cfilename,0,NVRAM_FILE_LEN + 1);
+ kal_mem_set(wcfilename,0,(NVRAM_FILE_LEN + 1)*sizeof(kal_wchar));
+ nvram_query_file_name_by_path((kal_wchar *)filename, wcfilename);
+ kal_dchar2char((WCHAR *)wcfilename, cfilename);
+
+ nvram_util_get_data_item_by_fileprefix(&ldi, cfilename);
+
+ if(ldi == NULL)
+ {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s Can't find the LID entry at %d,cfilename:%s\r\n",__FUNCTION__,__LINE__,cfilename);
+ if(nvram_ptr->state == NVRAM_STATE_READY)
+ {
+ kal_prompt_trace(MOD_NVRAM, "cfilename:%s\n\r", cfilename);
+ kal_prompt_trace(MOD_NVRAM, "Can not find the LID entry in the LID table:\n\r");
+ NVRAM_EXT_ASSERT(KAL_FALSE,0 , NVRAM_LOC_LID_PTR_IS_NULL_4, ldi);
+ }else
+ {
+ kal_prompt_trace(MOD_NVRAM, "cfilename:%s\n\r", cfilename);
+ goto non_cache_read;
+ }
+ }
+ if(NVRAM_RD_WITH_CACHE(ldi->LID))
+ {
+ if((!(NVRAM_IS_ATTR_RAW_DATA(ldi->attr))) && (check_valid_bit_by_ltable_entry(ldi, 0) || check_dirty_bit_by_ltable_entry(ldi, 0)))
+ {
+ do{
+ get_lid_cache_base_address(ldi, &cache_offset);
+ cache_offset = cache_offset + ldi_hd_offset;
+ if ((result = nvram_read_header_from_cache(ldi, buffer, ldi_hd_buffer_size, cache_offset)) != KAL_TRUE) {
+ kal_dchar2char((WCHAR *)filename, s_filename);
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header read fail: 0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", s_filename);
+ kal_prompt_trace(MOD_NVRAM, "section:%d,cache_offset:%d\n\r", section,cache_offset);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d read fail:%d\r\n", __LINE__,result);
+ NVRAM_DEBUG_DUMP(NVRAM_INFO_DUMP,"category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_INFO_DUMP,"fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_INFO_DUMP,"filename:%s\r\n", s_filename);
+ NVRAM_DEBUG_DUMP(NVRAM_INFO_DUMP,"section:%d,cache_offset:%d\r\n", section,cache_offset);
+ ret_val = KAL_FALSE;
+ break;
+ }
+ }while(0);
+ }else
+ {
+ goto non_cache_read;
+ }
+ }else
+ #endif
+ {
+ #ifdef __NVRAM_LID_CACHE__
+ non_cache_read:
+ #endif
+ #if 0// (defined(__NVRAM_FS_OPERATION_COMPACT__) && defined(__CCCIFS_SUPPORT__) && defined(__MTK_TARGET__)) || defined(__NVRAM_FS_CMPT_SIMULATION__)
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+/* under construction !*/
+ #else
+ NVRAM_FS_START_EX(FS_OP_OPEN,filename);
+ file_handle = FS_Open(filename, FS_READ_ONLY | FS_OPEN_SHARED |FS_OPEN_NO_DIR);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+ if (file_handle < FS_NO_ERROR) {
+ kal_dchar2char((WCHAR *)filename, s_filename);
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header open fail:0x%x\n\r", file_handle);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", s_filename);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d open fail:%d\r\n", __LINE__,file_handle);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"filename:%s\r\n", s_filename);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"section:%d\r\n", section);
+ ret_val = KAL_FALSE;
+ }
+ if(ldi_hd_offset && (file_handle > FS_NO_ERROR)) {
+ NVRAM_FS_START(FS_OP_SEEK);
+ result = FS_Seek(file_handle, ldi_hd_offset, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_SEEK,result);
+ }
+
+ if (file_handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(file_handle, buffer, ldi_hd_buffer_size, &ldi_hd_buffer_data_size);
+ NVRAM_FS_END(FS_OP_READ,result);
+ if((result < FS_NO_ERROR) || (ldi_hd_buffer_size != ldi_hd_buffer_data_size)){
+ kal_dchar2char((WCHAR *)filename, s_filename);
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header read fail:0x%x, 0x%x\n\r", file_handle, result);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", s_filename);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d read fail:%d\r\n", __LINE__,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"filename:%s\r\n", s_filename);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"section:%d\r\n", section);
+ ret_val = KAL_FALSE;
+ }
+ }
+ if(file_handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ }
+ #endif
+
+ #ifdef __NVRAM_LID_CACHE__
+ if((ldi != NULL) && (!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) && NVRAM_RD_WITH_CACHE(ldi->LID))
+ {
+ if(ret_val == KAL_TRUE)
+ {
+ update_cache_header(ldi, buffer, ldi_hd_offset, ldi_hd_buffer_size);
+ mask_valid_bit_by_ltable_entry(ldi, 0, 1);
+
+ //read appendix header
+ if(ldi->attr & NVRAM_ATTR_CHKSUM_INTEGRATE)
+ {
+ ldi_checksum_hd_offset = nvram_appendix_header_offset(ldi);
+ NVRAM_FS_START_EX(FS_OP_OPEN, filename);
+ file_handle = FS_Open(filename, FS_READ_ONLY | FS_OPEN_SHARED |FS_OPEN_NO_DIR);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+
+ if (file_handle < FS_NO_ERROR) {
+ kal_dchar2char((WCHAR *)filename, s_filename);
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header open fail:0x%x\n\r", file_handle);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", s_filename);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d open fail:%d\r\n", __LINE__,file_handle);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"filename:%s\r\n", s_filename);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"section:%d\r\n", section);
+ ret_val = KAL_FALSE;
+ }
+
+ if(file_handle > FS_NO_ERROR)
+ {
+ NVRAM_FS_START(FS_OP_SEEK);
+ result = FS_Seek(file_handle, ldi_checksum_hd_offset, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_SEEK,result);
+ }
+
+ if (file_handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(file_handle, ldi_append_header, ldi_checksum_hd_buffer_size, &ldi_checksum_hd_data_size);
+ NVRAM_FS_END(FS_OP_READ,result);
+ if( (result < FS_NO_ERROR) || (ldi_checksum_hd_buffer_size != ldi_checksum_hd_data_size)){
+ kal_dchar2char((WCHAR *)filename, s_filename);
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header read fail:0x%x, 0x%x\n\r", file_handle, result);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", s_filename);
+ kal_prompt_trace(MOD_NVRAM, "section:%d\n\r", section);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d read fail:%d\r\n", __LINE__,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"filename:%s\r\n", s_filename);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"section:%d\r\n", section);
+ ret_val = KAL_FALSE;
+ }
+ }
+
+ if(file_handle > FS_NO_ERROR)
+ {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ kal_int32 fs_result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,fs_result);
+ }
+ if(ret_val)
+ {
+ update_cache_header(ldi, ldi_append_header, ldi_checksum_hd_offset, ldi_checksum_hd_buffer_size);
+ }
+ }
+ }
+ }
+ #endif
+ }
+
+ #if defined(__NVRAM_ACCESS_TIMEOUT_ASSERT__)
+ DclSGPT_Control(nvram_gpt_handle, SGPT_CMD_STOP, (DCL_CTRL_DATA_T*)NULL); //stop timer
+ #endif
+
+ if((is_nvram_in_ota_flow != KAL_TRUE) && (ret_val != KAL_FALSE) && (section & LDI_HEADER_OTA_SECTION)) {
+ ldi_ota_header = (nvram_ldi_ota_header*)buffer;
+ ldi_hd_offset = nvram_data_header_checksum((kal_uint8*)ldi_ota_header, (NVRAM_LDI_OTA_HEADER_SIZE - sizeof(ldi_ota_header->checksum)));
+ if((ldi_ota_header->checksum != ldi_hd_offset) ||
+ memcmp(ldi_ota_header->header, "LDI", 4)) {
+ ret_val = KAL_FALSE;
+ }
+ }
+
+ return ret_val;
+}
+
+#ifdef __NVRAM_LID_CACHE__
+kal_bool nvram_cache_read_ota_header(const kal_wchar *filename, FS_HANDLE hFile, void* buffer, kal_uint32 buffer_size)
+{
+ kal_uint32 len;
+ nvram_ldi_ota_header *ldi_ota_header;
+ nvram_ldi_header nv_header;
+ kal_uint16 checksum;
+ kal_uint32 cache_offset;
+ kal_wchar wcfilename[NVRAM_FILE_LEN + 1];
+ kal_char cfilename[NVRAM_FILE_LEN + 1];
+ nvram_ltable_entry_struct *ldi = NULL;
+ kal_int32 result = FS_NO_ERROR;
+ kal_bool ret_val = KAL_TRUE;
+ kal_int32 ret = FS_NO_ERROR;
+
+ kal_mem_set(cfilename,0,NVRAM_FILE_LEN + 1);
+ kal_mem_set(wcfilename,0,(NVRAM_FILE_LEN + 1)*sizeof(kal_wchar));
+
+ nvram_query_file_name_by_path((kal_wchar *)filename, wcfilename);
+ kal_dchar2char((WCHAR *)wcfilename, cfilename);
+ nvram_util_get_data_item_by_fileprefix(&ldi, cfilename);
+ if(ldi == NULL)
+ {
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s Can not find the LID entry at %d,cfilename:%s\r\n",__FUNCTION__,__LINE__,cfilename);
+ if(nvram_ptr->state == NVRAM_STATE_READY)
+ {
+ kal_prompt_trace(MOD_NVRAM, "cfilename:%s\n\r", cfilename);
+ kal_prompt_trace(MOD_NVRAM, "Can not find the LID entry in the LID table:\n\r");
+ NVRAM_EXT_ASSERT(KAL_FALSE,0 , NVRAM_LOC_LID_PTR_IS_NULL_5, ldi);
+ }
+ else
+ {
+ kal_prompt_trace(MOD_NVRAM, "cfilename:%s\n\r", cfilename);
+ goto ota_non_cache;
+ }
+ }
+ if(NVRAM_RD_WITH_CACHE(ldi->LID))
+ {
+ if((!(NVRAM_IS_ATTR_RAW_DATA(ldi->attr))) && (check_valid_bit_by_ltable_entry(ldi, 0) || check_dirty_bit_by_ltable_entry(ldi, 0)))
+ {
+ do{
+ if(NVRAM_IO_ERRNO_OK != (result = get_lid_cache_base_address(ldi, &cache_offset))) {
+ ret_val = KAL_FALSE;
+ break;
+ }
+
+ if ((result = nvram_read_header_from_cache(ldi, buffer, buffer_size, cache_offset)) != KAL_TRUE) {
+ kal_prompt_trace(MOD_NVRAM, "NVRAM read header read fail:0x%x\n\r", result);
+ kal_prompt_trace(MOD_NVRAM, "category:0x%x, attr:0x%x\n\r", ldi->category, ldi->attr);
+ kal_prompt_trace(MOD_NVRAM, "fileprefix:%s, fileverno:%s\n\r", ldi->fileprefix, ldi->fileverno);
+ kal_prompt_trace(MOD_NVRAM, "filename:%s\n\r", cfilename);
+
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]NVRAM read header at %d read fail:%d\r\n", __LINE__,result);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"category:0x%08X, attr:0x%08X\r\n", ldi->category, ldi->attr);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"fileprefix:%s, fileverno:%s\r\n", ldi->fileprefix, ldi->fileverno);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"filename:%s\r\n", cfilename);
+ ret_val = KAL_FALSE;
+ break;
+ }
+ }while(0);
+ }else
+ {
+ goto ota_non_cache;
+ }
+ }else
+ {
+ ota_non_cache:
+ kal_mem_set(&nv_header, 0x0, sizeof(nv_header));
+ NVRAM_FS_START(FS_OP_SEEK);
+ ret = FS_Seek(hFile, 0x0, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_SEEK,ret);
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(hFile, (void *)(&nv_header), NVRAM_LDI_HEADER_SIZE, &len);
+ NVRAM_FS_END(FS_OP_READ,result);
+ if((result >= FS_NO_ERROR) && (len == NVRAM_LDI_HEADER_SIZE))
+ {
+ kal_mem_cpy((char *)buffer, (char *)(&nv_header), buffer_size);
+ ret_val = KAL_TRUE;
+ }
+
+ if((ldi != NULL) && NVRAM_RD_WITH_CACHE(ldi->LID))
+ {
+ if(ret_val == KAL_TRUE)
+ {
+ update_cache_header(ldi, (void *)(&nv_header), 0, NVRAM_LDI_HEADER_SIZE);
+ mask_valid_bit_by_ltable_entry(ldi, 0, 1);
+ }
+ }
+
+ }
+
+ ldi_ota_header = (nvram_ldi_ota_header*)buffer;
+ checksum = nvram_data_header_checksum((kal_uint8*)ldi_ota_header, (NVRAM_LDI_OTA_HEADER_SIZE - sizeof(ldi_ota_header->checksum)));
+ if((ldi_ota_header->checksum != checksum) ||
+ memcmp(ldi_ota_header->header, "LDI", 4)) {
+ return KAL_FALSE;
+ }
+
+ return ret_val;
+}
+#endif
+
+kal_bool nvram_read_ota_header(FS_HANDLE hFile, void* buffer, kal_uint32 buffer_size)
+{
+ kal_uint32 len;
+ nvram_ldi_ota_header *ldi_ota_header;
+ kal_uint16 checksum;
+ kal_int32 fs_result = FS_NO_ERROR;
+
+ NVRAM_FS_START(FS_OP_SEEK);
+ fs_result = FS_Seek(hFile, 0x0, FS_FILE_BEGIN);
+ NVRAM_FS_END(FS_OP_SEEK,fs_result);
+ NVRAM_FS_START(FS_OP_READ);
+ fs_result = FS_Read(hFile, buffer, buffer_size, &len);
+ NVRAM_FS_END(FS_OP_READ,fs_result);
+ ldi_ota_header = (nvram_ldi_ota_header*)buffer;
+ checksum = nvram_data_header_checksum((kal_uint8*)ldi_ota_header, (NVRAM_LDI_OTA_HEADER_SIZE - sizeof(ldi_ota_header->checksum)));
+ if((ldi_ota_header->checksum != checksum) ||
+ memcmp(ldi_ota_header->header, "LDI", 4)) {
+ return KAL_FALSE;
+ }
+ return KAL_TRUE;
+}
+
+
+static kal_uint32 nvram_ota_wstrtol(kal_wchar *wstr, kal_uint8 length)
+{
+ kal_uint32 ret = 0;
+ kal_char c;
+
+ for(;length > 0; length--, wstr++) {
+ ret <<= 4;
+ c = (kal_char)*wstr;
+ if(c >= '0' && c <= '9') {
+ c -= '0';
+ }
+ else if(c >= 'a' && c <= 'f') {
+ c -= 'a';
+ c += 10;
+ }
+ else if(c >= 'A' && c <= 'F') {
+ c -= 'A';
+ c += 10;
+ }
+ else {
+ return 0;
+ }
+ ret += (kal_uint8)c;
+ }
+ return ret;
+}
+
+static void nvram_ota_convert_filename(kal_wchar *filename, kal_uint16 *verno, kal_uint32 *size)
+{
+ NVRAM_OTA_FILE_NAME *ota_file = (NVRAM_OTA_FILE_NAME*)filename;
+
+ *verno = nvram_ota_wstrtol(ota_file->fileverno, FILE_VERNO_LEN);
+ *size = nvram_ota_wstrtol(ota_file->record, 8);
+}
+static kal_uint8 nvram_ota_search_overdue_file(NVRAM_FULL_PATH *filenameArry, kal_wchar *filename)
+{
+ kal_uint8 i, ret = 0;
+ kal_uint16 verno[NVRAM_OTA_RESERVE_CNT];
+ kal_uint32 size[NVRAM_OTA_RESERVE_CNT];
+ kal_wchar *s_filename = filename;
+ kal_uint16 val_v;
+ kal_uint32 val_s;
+
+ // remove path
+ filename = kal_wstrrchr(s_filename, '\\');
+ if(filename)
+ filename++;
+
+ // find same filename
+ for(i=0; i<NVRAM_OTA_RESERVE_CNT; i++) {
+ if(!kal_wstrcmp(filenameArry[i], filename)) {
+ return i;
+ }
+ nvram_ota_convert_filename(filenameArry[i], &verno[i], &size[i]);
+ }
+
+ // find the oldest verno
+ val_v = 0xFFFF;
+ for(i=0; i<NVRAM_OTA_RESERVE_CNT; i++) {
+ if(verno[i] < val_v) {
+ val_v = verno[i];
+ ret = i;
+ }
+ }
+
+ // find the smallest record & size
+ val_s = 0xFFFFFFFF;
+ for(i=0; i<NVRAM_OTA_RESERVE_CNT; i++) {
+ if((verno[i] == val_v) && (size[i] < val_s)) {
+ val_s = size[i];
+ ret = i;
+ }
+ }
+
+ return ret;
+}
+
+kal_bool nvram_ota_backup_file(const kal_wchar *s_filename, nvram_ldi_ota_header *ldi_ota_header)
+{
+ NVRAM_FULL_PATH d_filename;
+ NVRAM_FULL_PATH f_filename;
+ kal_wchar *filename;
+ NVRAM_FULL_PATH filenameArry[NVRAM_OTA_RESERVE_CNT];
+ FS_HANDLE handle;
+ FS_DOSDirEntry fileinfo;
+ kal_uint8 cnt = 0;
+ kal_int32 result = FS_NO_ERROR;
+ // create destination filename
+ filename = kal_wstrrchr(s_filename, '\\');
+ if(filename++) {
+ // skip B file
+ if(filename[FILE_PREFIX_LEN] == 'B') {
+ NVRAM_FS_START_EX(FS_OP_DELETE,s_filename);
+ result = FS_Delete(s_filename);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ return KAL_TRUE;
+ }
+ kal_wsprintf(d_filename, "%s\\%w_%04X%04X", NVRAM_FS_OTA_DATAITEM_PATH, filename, ldi_ota_header->total_records, ldi_ota_header->record_size);
+ }
+ else {
+ return KAL_FALSE;
+ }
+
+ // scan backup file
+ kal_wsprintf(f_filename, "%s\\%w", NVRAM_FS_OTA_DATAITEM_PATH, filename);
+ filename = kal_wstrrchr(f_filename, '\\');
+ kal_wstrcpy((filename + (FILE_PREFIX_LEN + 1)), L"*");
+ filename = filenameArry[0];
+ handle = FS_FindFirst(f_filename, 0, FS_ATTR_DIR, &fileinfo, filename, NVRAM_MAX_PATH_LEN);
+ if(handle > FS_NO_ERROR) {
+ for(cnt = 1; cnt < NVRAM_OTA_RESERVE_CNT; cnt++) {
+ filename = filenameArry[cnt];
+ NVRAM_FS_START(FS_OP_FINDNEXT);
+ result = FS_FindNext(handle, &fileinfo, filename, NVRAM_MAX_PATH_LEN);
+ NVRAM_FS_END(FS_OP_FINDNEXT,result);
+ if(result != FS_NO_ERROR) {
+ break;
+ }
+ }
+ NVRAM_FS_START(FS_OP_FINDCLOSE);
+ result = FS_FindClose(handle);
+ NVRAM_FS_END(FS_OP_FINDCLOSE,result);
+ }
+
+ // delete overdue file
+ if(cnt >= NVRAM_OTA_RESERVE_CNT) {
+ cnt = nvram_ota_search_overdue_file(filenameArry,(kal_wchar *)d_filename);
+ kal_wsprintf(f_filename, "%s\\%w", NVRAM_FS_OTA_DATAITEM_PATH, filenameArry[cnt]);
+ NVRAM_FS_START_EX(FS_OP_DELETE,f_filename);
+ result = FS_Delete(f_filename);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ }
+
+ // backup file
+ NVRAM_FS_START_EX(FS_OP_MOVE,d_filename);
+ result = FS_Move(s_filename, d_filename, FS_MOVE_COPY, NULL, NULL, 0);
+ NVRAM_FS_END(FS_OP_MOVE,result);
+ if(result != FS_NO_ERROR) {
+ return KAL_FALSE;
+ }
+ NVRAM_FS_START_EX(FS_OP_DELETE,s_filename);
+ result = FS_Delete(s_filename);
+ NVRAM_FS_END(FS_OP_DELETE,result);
+ return KAL_TRUE;
+}
+
+kal_bool nvram_ota_search_backup_file(const kal_char *s_filename, NVRAM_FULL_PATH *r_filename)
+{
+ FS_HANDLE handle;
+ FS_DOSDirEntry fileinfo;
+ kal_wchar *filename_start;
+ kal_int32 result = FS_NO_ERROR;
+ nvram_query_file_name(NVRAM_NVD_BACKUP, (kal_char *)s_filename, (kal_wchar*)r_filename);
+ filename_start = kal_wstrrchr((const WCHAR*)r_filename, '\\');
+ NVRAM_FS_START_EX(FS_OP_FINDFIRST,r_filename);
+ handle = FS_FindFirst((const WCHAR*)r_filename, 0, FS_ATTR_DIR, &fileinfo, (filename_start + 1), NVRAM_MAX_PATH_LEN);
+ NVRAM_FS_END(FS_OP_FINDFIRST,handle);
+ if(handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_FINDCLOSE);
+ result = FS_FindClose(handle);
+ NVRAM_FS_END(FS_OP_FINDCLOSE,result);
+ return KAL_TRUE;
+ }
+ return KAL_FALSE;
+}
+kal_bool nvram_ota_restore_file(nvram_ltable_entry_struct *ldi)
+{
+ NVRAM_FILE_NAME nvramname;
+ kal_wchar s_filename[NVRAM_MAX_PATH_LEN];
+ kal_wchar d_filename[NVRAM_MAX_PATH_LEN];
+ nvram_folder_enum nvram_folder;
+ nvram_ldi_ota_header ota_hdr;
+ kal_bool hdr_ret;
+ kal_int32 result = FS_NO_ERROR;
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_TRUE);
+ nvram_folder = nvram_query_folder_index(ldi->category);
+ nvram_query_file_name(nvram_folder, nvramname, d_filename);
+
+ kal_wsprintf(s_filename, "%s\\%s_%04X%04X", NVRAM_FS_OTA_DATAITEM_PATH, nvramname, ldi->total_records, ldi->size);
+ hdr_ret = nvram_read_data_header(s_filename, LDI_HEADER_OTA_SECTION, (void*)&ota_hdr, NVRAM_LDI_OTA_HEADER_SIZE);
+ if( (hdr_ret == KAL_TRUE) &&
+ (ota_hdr.LID == ldi->LID) &&
+ (ota_hdr.total_records == ldi->total_records) &&
+ (ota_hdr.record_size == ldi->size) &&
+ (ota_hdr.ldi_category == ldi->category) )
+ {
+ //LDI recover hit
+ NVRAM_FS_START_EX(FS_OP_MOVE,d_filename);
+ result = FS_Move(s_filename, d_filename, FS_MOVE_COPY, NULL, NULL, 0);
+ NVRAM_FS_END(FS_OP_MOVE,result);
+ if(result != FS_NO_ERROR) {
+ return KAL_FALSE;
+ }
+
+ if(NVRAM_IS_ATTR_MULTIPLE(ldi->attr)) {
+ nvram_util_make_lid_filename(ldi, nvramname, KAL_FALSE);
+ nvram_query_file_name(nvram_folder, nvramname, d_filename);
+ NVRAM_FS_START_EX(FS_OP_MOVE,d_filename);
+ result = FS_Move(s_filename, d_filename, FS_MOVE_COPY, NULL, NULL, 0);
+ NVRAM_FS_END(FS_OP_MOVE,result);
+ }
+ return KAL_TRUE;
+ }
+
+ return KAL_FALSE;
+}
+
+kal_uint32 nvram_ota_buffer_size()
+{
+ return NVRAM_LID_BITMAP_SIZE;
+}
+
+#ifdef __NVRAM_INIT_LID_BUFFER__
+void nvram_init_lid_buffer_prepare(void)
+{
+ kal_uint32 size = 0;
+ kal_uint16 i;
+ nvram_ltable_entry_struct *ldi = NULL;
+
+ for(i = 0; i < lid_buffer_list_num; i++) {
+ if(!nvram_util_get_data_item(&ldi, lid_buffer_list[i].LID)) {
+ continue;
+ }
+ lid_buffer_list[i].ldi_ptr = ldi;
+ size += (ldi->size * ldi->total_records);
+ }
+ NVRAM_EXT_ASSERT((size < MAX_NVRAM_RECORD_SIZE), size, NVRAM_LOC_INIT_BUFFER_OVERFLOW, MAX_NVRAM_RECORD_SIZE);
+ nvram_init_lid_buffer = (kal_uint8 *)get_ctrl_buffer(size);
+ for(size = 0, i = 0; i < lid_buffer_list_num; i++) {
+ if(lid_buffer_list[i].ldi_ptr == NULL) {
+ continue;
+ }
+ lid_buffer_list[i].buffer = (nvram_init_lid_buffer + size);
+ size += (lid_buffer_list[i].ldi_ptr->size * lid_buffer_list[i].ldi_ptr->total_records);
+ lid_buffer_list[i].status = NVRAM_INIT_LID_BUF_ENPTY;
+ }
+ nvram_init_lid_buffer_en = KAL_TRUE;
+}
+
+nvram_errno_enum nvram_init_lid_buffer_read(nvram_lid_enum LID, kal_uint32 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
+{
+ kal_uint16 i;
+ kal_uint32 size, offset;
+
+ if(!nvram_init_lid_buffer_en) {
+ return NVRAM_ERRNO_NOT_READY;
+ }
+ for(i = 0; i < lid_buffer_list_num; i++) {
+ if(LID == lid_buffer_list[i].LID) {
+ if(lid_buffer_list[i].ldi_ptr == NULL ||
+ lid_buffer_list[i].status == NVRAM_INIT_LID_BUF_INVALID ||
+ lid_buffer_list[i].status == NVRAM_INIT_LID_BUF_READ ) {
+ return NVRAM_ERRNO_FAIL;
+ }
+ if(lid_buffer_list[i].status == NVRAM_INIT_LID_BUF_ENPTY) {
+ lid_buffer_list[i].status = NVRAM_INIT_LID_BUF_READ;
+ if(NVRAM_ERRNO_SUCCESS != nvram_read_data_item(lid_buffer_list[i].ldi_ptr,
+ 1,
+ lid_buffer_list[i].ldi_ptr->total_records,
+ lid_buffer_list[i].buffer,
+ (lid_buffer_list[i].ldi_ptr->size * lid_buffer_list[i].ldi_ptr->total_records) ))
+ {
+ lid_buffer_list[i].status = NVRAM_INIT_LID_BUF_INVALID;
+ return NVRAM_ERRNO_FAIL;
+ }
+ lid_buffer_list[i].status = NVRAM_INIT_LID_BUF_VALID;
+ }
+ size = (lid_buffer_list[i].ldi_ptr->size * rec_amount);
+ offset = ((rec_index - 1) * lid_buffer_list[i].ldi_ptr->size);
+ if((size > buffer_size) ||
+ ((rec_amount + rec_index - 1) > lid_buffer_list[i].ldi_ptr->total_records) )
+ {
+ return NVRAM_ERRNO_FAIL;
+ }
+ nvram_util_take_mutex(g_nvram_fs_mutex);
+ kal_mem_cpy(buffer, (lid_buffer_list[i].buffer + offset), size);
+ nvram_util_give_mutex(g_nvram_fs_mutex);
+ return NVRAM_ERRNO_SUCCESS;
+ }
+ }
+ return NVRAM_IO_ERRNO_INVALID_LID;
+}
+
+nvram_errno_enum nvram_init_lid_buffer_write(nvram_lid_enum LID, kal_uint32 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
+{
+ kal_uint16 i;
+ kal_uint32 size, offset;
+
+ if(!nvram_init_lid_buffer_en) {
+ return NVRAM_ERRNO_NOT_READY;
+ }
+ for(i = 0; i < lid_buffer_list_num; i++) {
+ if(LID == lid_buffer_list[i].LID) {
+ if(lid_buffer_list[i].ldi_ptr == NULL ||
+ lid_buffer_list[i].status == NVRAM_INIT_LID_BUF_INVALID ||
+ lid_buffer_list[i].status == NVRAM_INIT_LID_BUF_ENPTY)
+ {
+ return NVRAM_ERRNO_FAIL;
+ }
+ size = (lid_buffer_list[i].ldi_ptr->size * rec_amount);
+ offset = ((rec_index - 1) * lid_buffer_list[i].ldi_ptr->size);
+ if((buffer_size > size) ||
+ ((rec_amount + rec_index - 1) > lid_buffer_list[i].ldi_ptr->total_records) )
+ {
+ return NVRAM_ERRNO_FAIL;
+ }
+ nvram_util_take_mutex(g_nvram_fs_mutex);
+ kal_mem_cpy((lid_buffer_list[i].buffer + offset), buffer, size);
+ lid_buffer_list[i].status = NVRAM_INIT_LID_BUF_DIRTY;
+ nvram_util_give_mutex(g_nvram_fs_mutex);
+ return NVRAM_ERRNO_SUCCESS;
+ }
+ }
+ return NVRAM_IO_ERRNO_INVALID_LID;
+}
+
+void nvram_init_lid_buffer_writeback(void)
+{
+ kal_uint16 i,idx;
+ kal_uint32 offset;
+
+ if(!nvram_init_lid_buffer_en) {
+ return;
+ }
+ nvram_init_lid_buffer_en = KAL_FALSE;
+ for(i = 0; i < lid_buffer_list_num; i++) {
+ if((lid_buffer_list[i].ldi_ptr == NULL) || (lid_buffer_list[i].status != NVRAM_INIT_LID_BUF_DIRTY)) {
+ continue;
+ }
+ for(idx = 0; idx < lid_buffer_list[i].ldi_ptr->total_records; idx++) {
+ offset = (idx * lid_buffer_list[i].ldi_ptr->size);
+ nvram_write_data_item(lid_buffer_list[i].ldi_ptr, (idx + 1), (lid_buffer_list[i].buffer + offset), KAL_FALSE);
+ }
+ }
+ free_ctrl_buffer(nvram_init_lid_buffer);
+}
+#endif
+
+void nvram_get_trace_configuration()
+{
+ WCHAR filename[NVRAM_MAX_PATH_LEN];
+ FS_HANDLE file_handle = FS_INVALID_FILE_HANDLE;
+ kal_int32 result = FS_NO_ERROR;
+ kal_char trace_config[4]= {0};
+ kal_uint32 len = 0;
+
+ kal_mem_set(filename,0,NVRAM_MAX_PATH_LEN * sizeof(WCHAR));
+ kal_wsprintf(filename, "%s\\%s", NVRAM_FS_IMPORTNT_DATAITEM_PATH,"md_nv_config.txt");
+
+ kal_mem_set(nvram_trace_filename,0,NVRAM_MAX_PATH_LEN * sizeof(kal_wchar));
+ kal_wsprintf(nvram_trace_filename, "Z:\\%s","nvram_trace_log.log");
+
+ NVRAM_FS_START(FS_OP_OPEN);
+ file_handle = FS_Open(filename, FS_READ_ONLY | FS_OPEN_SHARED |FS_OPEN_NO_DIR);
+ NVRAM_FS_END(FS_OP_OPEN,file_handle);
+ if (file_handle < FS_NO_ERROR) {
+ if(nvram_ee_info != NULL){
+ nvram_ee_info->nvram_trace_setting = 0;
+ nvram_ee_info->nvram_access_trace_setting_file_val = NVRAM_OPEN_TRACE_SETTING_FILE_FAIL;
+ g_access_trace_setting_file_result = NVRAM_OPEN_TRACE_SETTING_FILE_FAIL;
+ g_nvram_trace_setting = 0;
+ }
+ return;
+ }
+ if (file_handle > FS_NO_ERROR ) {
+
+ NVRAM_FS_START(FS_OP_GETFILESIZE);
+ result = FS_GetFileSize(file_handle, &len);
+ NVRAM_FS_END(FS_OP_GETFILESIZE,file_handle);
+
+ kal_mem_set(trace_config,0,4);
+
+ NVRAM_FS_START(FS_OP_READ);
+ result = FS_Read(file_handle, trace_config, len, &len);
+ NVRAM_FS_END(FS_OP_READ,result);
+ if(result < FS_NO_ERROR )
+ {
+ if(nvram_ee_info != NULL){
+ nvram_ee_info->nvram_access_trace_setting_file_val = NVRAM_READ_TRACE_SETTING_FILE_FAIL;
+ g_access_trace_setting_file_result = NVRAM_READ_TRACE_SETTING_FILE_FAIL;
+ g_nvram_trace_setting = 0;
+ }
+ }
+ else
+ {
+ if(nvram_ee_info != NULL){
+ nvram_ee_info->nvram_trace_setting = atoi(trace_config);
+ nvram_ee_info->nvram_access_trace_setting_file_val = NVRAM_READ_TRACE_SETTING_FILE_SUCCESS;
+ g_access_trace_setting_file_result = NVRAM_READ_TRACE_SETTING_FILE_SUCCESS;
+ g_nvram_trace_setting = nvram_ee_info->nvram_trace_setting;
+ }
+ }
+ }
+ if(file_handle > FS_NO_ERROR) {
+ NVRAM_FS_START(FS_OP_CLOSE);
+ result = FS_Close(file_handle);
+ NVRAM_FS_END(FS_OP_CLOSE,result);
+ }
+ if(nvram_ee_info != NULL){
+ nvram_ee_info->nvram_init_step = NVRAM_PRE_INIT_GET_TRACE_SETTING_DONE;
+ }
+ return;
+}
+
+/*****************************************************************************
+ * FUNCTION
+ * nvram_get_lid_chksum_algo_info
+ * DESCRIPTION
+ * get cache LID from cache table
+ * PARAMETERS
+ * ldi [IN]
+ * RETURNS
+ * success or fail
+ *****************************************************************************/
+nvram_errno_enum nvram_get_lid_chksum_algo_info(nvram_ltable_entry_struct *ldi, nvram_lid_chksum_info * lid_chksum_info, kal_bool chksum_only, kal_bool read_2B)
+{
+ /*----------------------------------------------------------------*/
+ /* Local Variables */
+ /*----------------------------------------------------------------*/
+
+ /*----------------------------------------------------------------*/
+ /* Code Body */
+ /*----------------------------------------------------------------*/
+ if((NULL == ldi) || (NULL == lid_chksum_info))
+ {
+ kal_prompt_trace(MOD_NVRAM,"%s->(%d)NVRAM_LOC_BUFFER_PTR_IS_NULL_42 NULL \r\n",__FUNCTION__, __LINE__);
+ NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s()[Error]:NVRAM_LOC_BUFFER_PTR_IS_NULL_42 NULL %d.\r\n", __FUNCTION__,__LINE__);
+ NVRAM_EXT_ASSERT(KAL_FALSE,0 ,NVRAM_LOC_BUFFER_PTR_IS_NULL_42, 0, __LINE__);
+ return NVRAM_ERRNO_FAIL;
+ }
+
+ #ifdef __NV_CHKSUM_ENHANCE__
+ if(NVRAM_IS_ATTR_CHKSUM_ENHANC_ALGRTHM(ldi->attr))
+ {
+ lid_chksum_info->algo_info.chksum_algo_type = chksum_algo_ptr->cur_algo.en_algo_type;
+ if(NVRAM_MD5 == lid_chksum_info->algo_info.chksum_algo_type)
+ {
+ lid_chksum_info->algo_info.chksum_algo_length = read_2B? MD5_CHKSUM_LENGTH_2: MD5_CHKSUM_LENGTH_8;
+ }else
+ {
+ lid_chksum_info->algo_info.chksum_algo_length = chksum_algo_ptr->cur_algo.en_algo_length;
+ }
+ }else
+ {
+ lid_chksum_info->algo_info.chksum_algo_type = chksum_algo_ptr->cur_algo.def_algo_type;
+ if(NVRAM_MD5 == lid_chksum_info->algo_info.chksum_algo_type)
+ {
+ lid_chksum_info->algo_info.chksum_algo_length = read_2B? MD5_CHKSUM_LENGTH_2: MD5_CHKSUM_LENGTH_8;
+ }else
+ {
+ lid_chksum_info->algo_info.chksum_algo_length = chksum_algo_ptr->cur_algo.def_algo_length;
+ }
+ }
+ #else
+ lid_chksum_info->algo_info.chksum_algo_type = NVRAM_MD5;
+ lid_chksum_info->algo_info.chksum_algo_length = read_2B? MD5_CHKSUM_LENGTH_2: MD5_CHKSUM_LENGTH_8;
+ #endif
+
+ if((lid_chksum_info->algo_info.chksum_algo_type == NVRAM_MD5) && (read_2B == KAL_TRUE))
+ {
+ lid_chksum_info->read_chksum_type = (chksum_only? NVRAM_DRV_READ_TYPE_CHKSUM_ONLY_2B: NVRAM_DRV_READ_TYPE_CHKSUM_2B);
+ }
+ else
+ {
+ lid_chksum_info->read_chksum_type = chksum_only? NVRAM_DRV_READ_TYPE_CHKSUM_ONLY: NVRAM_DRV_READ_TYPE_CHKSUM;
+ }
+
+ return NVRAM_IO_ERRNO_OK;
+}
+