Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / 1eb8f53f94c145708b5ea2c6b9b96ea3d613f607 / . / mcu / service / mcf / src / mcf_utfwk.c
blob: 4a6c5b87dda54b7f436125981eb2641b99057289 [file] [log] [blame]
rjw6c1fd8f2022-11-30 14:33:01 +0800[diff] [blame]1#include "kal_public_api.h"
2#include "fs_general_api.h"
3#include <direct.h>
4#include <stdlib.h>
5#include <stdio.h>
6#include <math.h>
7
8#include "em_msgid.h"
9#include "em_l4_common_public_struct.h"
10#include "em_mcf_public_struct.h"
11#include "em_struct.h"
12
13#include "nvram_interface.h"
14#include "nvram_group_def.h"
15#include "mcf_nvram_editor.h"
16
17#include "mcf_msgid.h"
18#include "md_svc_sap.h"
19#include "mcf_if.h"
20#include "mcf_util.h"
21#include "mcf_defs.h"
22#include "mcf_object.h"
23#include "mcf_debug.h"
24#include "mcf_utfwk.h"
25#include "mcf_custom.h"
26#include "mcf_struct.h"
27
28/*------------------------------------------------------------------------------
29 * Constant definition.
30 *----------------------------------------------------------------------------*/
31#define MCF_FS_DUMMY_AP_FILE_PATH "/nvdata/mdota"
32#define MCF_UTFWK_DYN_PTR_NUM 1024
33#define MCF_UT_FWK_OTA_FILE_PREFIX "MTK_UTFWK_OTA"
34#define MCF_UT_FWK_TLVOTA_FILE_PREFIX "MTK_UTFWK_OPOTA_SBPID"
35#define MCF_UT_FWK_GENERAL_TLVOTA_FILE_PREFIX "MTK_UTFWK_GENERAL_OPOTA"
36
37
38/*------------------------------------------------------------------------------
39 * Private Helper macros.
40 *----------------------------------------------------------------------------*/
41
42/*------------------------------------------------------------------------------
43 * Global variables.
44 *----------------------------------------------------------------------------*/
45extern nvram_mcf_lid_info_struct mcf_last_mod_lid_g;
46extern nvram_mcf_lid_info_struct mcf_curr_mod_lid_g;
47kal_bool execute_ota = KAL_FALSE;
48kal_bool execute_op_ota = KAL_FALSE;
49kal_bool execute_gen_op_ota = KAL_FALSE;
50mcf_utfwk_common_t com_buff;
51kal_uint8 mcf_utfwk_dump_buffer[MCF_MAX_DUMP_SIZE + MCF_MAX_RECORD_CNT];
52kal_bool is_ut_fwk = KAL_FALSE;
53
54
55/*------------------------------------------------------------------------------
56 * Private variables.
57 *----------------------------------------------------------------------------*/
58/* OTA test LID value pattern */
59static const nvram_ef_mcf_test_struct mcf_ut_test_lid_value_pattern = {
60 6, // val_byte_11
61 6, // val_byte_12
62 0x6, // val_bit_byte_11
63 0xf0, // val_bit_byte_12
64 6, // val_short_11
65 6, // val_short_12
66 6, // val_int_1
67 6, // val_float_1
68 6, // val_long_1
69 6.6, // val_double_1
70 "MCF Test 66", // val_buffer_1
71 {6, 6, 0x6, 0xf0, 6, 6, 6, 6, 6, 6.6, "MCF Test 66"}, // val_struct_1
72 6, // val_byte_21
73 6, // val_byte_22
74 0x6, // val_bit_byte_21
75 0xf0, // val_bit_byte_22
76 6, // val_short_21
77 6, // val_short_22
78 6, // val_int_2
79 6, // val_float_2
80 6, // val_long_2
81 6.6, // val_double_2
82 "MCF Test 66", // val_buffer_2
83 {6, 6, 0x6, 0xf0, 6, 6, 6, 6, 6, 6.6, "MCF Test 66"}, // val_struct_2
84 {{6, 6, 0x6, 0x6, 6, 6, 6, 6, 6, 6.6, "MCF"}, // val_struct_3[0]
85 {6, 6, 0x6, 0x6, 6, 6, 6, 6, 6, 6.6, "MCF"}, // val_struct_3[1]
86 {6, 6, 0x6, 0x6, 6, 6, 6, 6, 6, 6.6, "MCF"}, // val_struct_3[2]
87 {6, 6, 0x6, 0x6, 6, 6, 6, 6, 6, 6.6, "MCF"}} // val_struct_3[3]
88};
89kal_uint8 mcf_dump_buffer[MCF_MAX_DUMP_SIZE + MCF_MAX_RECORD_CNT * MCF_DUMP_LID_HEADER_SIZE];
90
91/*------------------------------------------------------------------------------
92 * Private fucntions.
93 *----------------------------------------------------------------------------*/
94extern kal_char* release_verno(void);
95extern kal_char* build_date_time(void);
96extern sim_interface_enum l4c_gemini_get_actual_sim_id(sim_interface_enum simId);
97extern kal_bool mcf_set_file_path(l4c_mcf_set_config_req_struct *req);
98extern kal_bool mcf_get_applied_file_path(l4c_mcf_get_config_req_struct *req, l4c_mcf_get_config_cnf_struct *resp);
99extern kal_bool mcf_em_update_req_hdlr(local_para_struct *local_para_ptr);
100extern chmod(const char *_Filename,int _Mode);
101extern mcf_dump_param_struct mcf_dump_param_tbl[];
102extern kal_uint32 mcf_dump_param_tbl_num;
103extern sim_interface_enum l4c_gemini_get_switched_sim_id(sim_interface_enum simId);
104
105#if !defined(__MTK_TARGET__)
106kal_bool mcf_utfwk_open_test_data(kal_char *filename, kal_char *data_buff, kal_uint32 size, kal_char *relative_path_name)
107{
108 kal_char test_data_path[512];
109 FILE *file;
110 kal_char short_filename[512];
111 kal_char *pos;
112
113 kal_sprintf(test_data_path, "%s%c", filename, '\0');
114 file = fopen(test_data_path, "rb");
115
116 pos = strstr(test_data_path, "mcu");
117 kal_sprintf(short_filename, "%s%c", pos + strlen("mcu"), '\0');
118
119 if(file != NULL)
120 {
121 kal_mem_set(data_buff, 0, size);
122 fread(data_buff, size, 1, file);
123 fclose(file);
124 if (strlen(short_filename) < MCF_FILE_MAX_NAME_LEN){
125 strncpy(relative_path_name, short_filename, strlen(short_filename));
126 }
127 } else {
128 return KAL_FALSE;
129 }
130
131 return KAL_TRUE;
132}
133
134
135#endif
136
137kal_bool mcf_utfwk_spilt_tag(kal_char *tag, kal_uint32 *sbp_id, kal_uint8 *mcc, kal_uint8 *mnc)
138{
139 kal_char *saveptr = NULL, *substr = NULL;
140 kal_bool ret = KAL_TRUE;
141
142 substr = kal_strtok_r(tag, "_", &saveptr);
143
144 if (strcmp(substr,"") == 0){
145 ret = KAL_FALSE;
146 MD_TRC_MCF_TR_UTFWK_SPILT_TAG_UNKNOWN_SBP_ID();
147 mcf_utfwk_printf("Unknown sbp_id \r\n");
148 return ret;
149 }else if (strcmp(substr,"NA") == 0){
150 *sbp_id = SBP_ID_INVALID;
151 }else{
152 *sbp_id = mcf_atoi(substr);
153 }
154 substr = kal_strtok_r(NULL, "_",&saveptr);
155 strncpy(mcc, substr, MAX_MCC_STR_LEN);
156 substr = kal_strtok_r(NULL, "_",&saveptr);
157 strncpy(mnc, substr, MAX_MNC_STR_LEN);
158
159 return ret;
160}
161
162kal_bool mcf_utfwk_check_tag_match(
163 mcf_tool_gid_tlvota_file_item_t *pItem,
164 mcf_tlvota_tag_t *tag_entry,
165 kal_uint32 tag_num,
166 kal_uint32 *match_idx)
167{
168 kal_uint32 tag_cnt = 0;
169
170 ASSERT(pItem);
171 ASSERT(tag_entry);
172 ASSERT(tag_num >= 0);
173
174 while(tag_cnt < tag_num) {
175 if ( (pItem->tag_type == tag_entry[tag_cnt].tag_type) && (strncmp(&(pItem->buff_start), tag_entry[tag_cnt].tag, pItem->tag_len) == 0) ) {
176 *match_idx = tag_cnt;
177
178 return KAL_TRUE;
179 }
180
181 tag_cnt++;
182 }
183
184 return KAL_FALSE;
185}
186
187kal_bool mcf_utfwk_check_tag_entry(mcf_tlvota_sbp_tag_t sbp_tag, mcf_tool_gid_tlvota_file_item_t *pItem)
188{
189 mcf_tlvota_tag_t tag_entry[4];
190 kal_uint32 tag_num = 0;
191 kal_char tag[4][MCF_MAX_TAG_LEN];
192 kal_uint32 match_idx;
193 kal_bool ret;
194
195 if(!pItem ){
196 mcf_utfwk_printf("Invalid parameters!! pItem(%x)\r\n", pItem);
197 MD_TRC_MCF_TR_UTFWK_CHECK_TAG_ENTRY_INVALID_PARA(pItem);
198 ASSERT(0);
199 }
200
201 /* Fill tag entry */
202 if (sbp_tag.sbp_id != SBP_ID_INVALID) {
203 if (strcmp((kal_char *)sbp_tag.mcc, "") != 0) {
204 if (strcmp((kal_char *)sbp_tag.mnc, "") != 0) { // sbpid_mcc_mnc case
205 /* NA_mcc_NA and NA_mcc_mnc case should be updated first */
206 /* NA_mcc_NA */
207 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
208 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_NA", (kal_char *)sbp_tag.mcc);
209 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
210 tag_entry[tag_num].tag = tag[tag_num];
211 tag_num++;
212
213 /* NA_mcc_mnc */
214 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
215 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_%s", (kal_char *)sbp_tag.mcc, (kal_char *)sbp_tag.mnc);
216 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
217 tag_entry[tag_num].tag = tag[tag_num];
218 tag_num++;
219
220 if(mcf_utfwk_check_tag_match(pItem, tag_entry, tag_num, &match_idx) == KAL_TRUE){
221 com_buff.is_general = KAL_TRUE;
222 ret = KAL_TRUE;
223 return ret;
224 }
225
226 /* Reuse tag_entry */
227 tag_num = 0;
228 /* NA_NA_NA */
229 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
230 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_NA_NA");
231 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
232 tag_entry[tag_num].tag = tag[tag_num];
233 tag_num++;
234
235 /* sbpid_NA_NA */
236 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
237 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_NA_NA", sbp_tag.sbp_id);
238 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
239 tag_entry[tag_num].tag = tag[tag_num];
240 tag_num++;
241
242 /* sbpid_mcc_NA */
243 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
244 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_%s_NA", sbp_tag.sbp_id, sbp_tag.mcc);
245 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
246 tag_entry[tag_num].tag = tag[tag_num];
247 tag_num++;
248
249 /* sbpid_mcc_mnc */
250 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
251 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_%s_%s", sbp_tag.sbp_id, sbp_tag.mcc, sbp_tag.mnc);
252 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
253 tag_entry[tag_num].tag = tag[tag_num];
254 tag_num++;
255 } else { // sbpid_mcc_NA case
256 /* NA_mcc_NA case should be updated first */
257 /* NA_mcc_NA */
258 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
259 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_NA", (kal_char *)sbp_tag.mcc);
260 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
261 tag_entry[tag_num].tag = tag[tag_num];
262 tag_num++;
263
264 if(mcf_utfwk_check_tag_match(pItem, tag_entry, tag_num, &match_idx) == KAL_TRUE){
265 com_buff.is_general = KAL_TRUE;
266 ret = KAL_TRUE;
267 return ret;
268 }
269
270 /* Reuse tag_entry */
271 tag_num = 0;
272 /* NA_NA_NA */
273 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
274 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_NA_NA");
275 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
276 tag_entry[tag_num].tag = tag[tag_num];
277 tag_num++;
278
279 /* sbpid_NA_NA */
280 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
281 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_NA_NA", sbp_tag.sbp_id);
282 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
283 tag_entry[tag_num].tag = tag[tag_num];
284 tag_num++;
285
286 /* sbpid_mcc_NA */
287 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
288 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_%s_NA", sbp_tag.sbp_id, sbp_tag.mcc);
289 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
290 tag_entry[tag_num].tag = tag[tag_num];
291 tag_num++;
292 }
293 } else {
294 if (strcmp((kal_char *)sbp_tag.mnc, "") == 0) { // sbpid_NA_NA case
295 /* NA_NA_NA */
296 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
297 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_NA_NA");
298 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
299 tag_entry[tag_num].tag = tag[tag_num];
300 tag_num++;
301
302 /* sbpid_NA_NA */
303 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
304 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "%d_NA_NA", sbp_tag.sbp_id);
305 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
306 tag_entry[tag_num].tag = tag[tag_num];
307 tag_num++;
308 } else { // sbpid_NA_mnc case is not allowed!!
309 MD_TRC_MCF_TR_UTFWK_CHECK_TAG_ENTRY_INVALID_SBP_TAG(sbp_tag.sbp_id, sbp_tag.mcc, sbp_tag.mnc);
310 mcf_utfwk_printf("Invalid SBP tag!! sbp_id(%d), mcc(%s), mnc(%d)\r\n", sbp_tag.sbp_id, sbp_tag.mcc, sbp_tag.mnc);
311 ret = KAL_FALSE;
312
313 return ret;
314 }
315 }
316 } else {
317 if (strcmp((kal_char *)sbp_tag.mcc, "") != 0) {
318 if (strcmp((kal_char *)sbp_tag.mnc, "") != 0) { // NA_mcc_mnc case
319 /* NA_mcc_NA and NA_mcc_mnc case should be updated first */
320 /* NA_mcc_NA */
321 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
322 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_NA", (kal_char *)sbp_tag.mcc);
323 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
324 tag_entry[tag_num].tag = tag[tag_num];
325 tag_num++;
326
327 /* NA_mcc_mnc */
328 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
329 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_%s", (kal_char *)sbp_tag.mcc, (kal_char *)sbp_tag.mnc);
330 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
331 tag_entry[tag_num].tag = tag[tag_num];
332 tag_num++;
333
334 if(mcf_utfwk_check_tag_match(pItem, tag_entry, tag_num, &match_idx) == KAL_TRUE){
335 com_buff.is_general = KAL_TRUE;
336 ret = KAL_TRUE;
337 return ret;
338 }
339
340 /* Reuse tag_entry */
341 tag_num = 0;
342 /* NA_NA_NA */
343 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
344 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_NA_NA");
345 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
346 tag_entry[tag_num].tag = tag[tag_num];
347 tag_num++;
348 } else { // NA_mcc_NA case
349 /* NA_mcc_NA and NA_mcc_mnc case should be updated first */
350 /* NA_mcc_NA */
351 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
352 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_%s_NA", (kal_char *)sbp_tag.mcc);
353 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
354 tag_entry[tag_num].tag = tag[tag_num];
355 tag_num++;
356
357 if(mcf_utfwk_check_tag_match(pItem, tag_entry, tag_num, &match_idx) == KAL_TRUE){
358 com_buff.is_general = KAL_TRUE;
359 ret = KAL_TRUE;
360 return ret;
361 }
362
363 /* Reuse tag_entry */
364 tag_num = 0;
365 /* NA_NA_NA */
366 tag_entry[tag_num].tag_type = MCF_TLVOTA_TAG_SBPID;
367 kal_snprintf(tag[tag_num], MCF_MAX_TAG_LEN, "NA_NA_NA");
368 tag_entry[tag_num].tag_len = strlen(tag[tag_num]);
369 tag_entry[tag_num].tag = tag[tag_num];
370 tag_num++;
371 }
372 } else { // NA_NA_mnc cases is not allowed!!
373 MD_TRC_MCF_TR_UTFWK_CHECK_TAG_ENTRY_INVALID_SBP_TAG(sbp_tag.sbp_id, sbp_tag.mcc, sbp_tag.mnc);
374 mcf_utfwk_printf("Invalid SBP tag!! sbp_id(%d), mcc(%s), mnc(%d)\r\n", sbp_tag.sbp_id, sbp_tag.mcc, sbp_tag.mnc);
375 ret = KAL_FALSE;
376
377 return ret;
378 }
379 }
380 ret = mcf_utfwk_check_tag_match(pItem, tag_entry, tag_num, &match_idx);
381 com_buff.is_general = KAL_FALSE;
382 return ret;
383
384}
385
386kal_bool mcf_utfwk_generate_gid_ota_file(kal_uint8 *buff, mcf_utfwk_ota_input_struct ota_input, kal_bool *is_general, kal_uint16 *buff_size)
387{
388 nvram_ltable_entry_struct lid_info = {0};
389 kal_char sw_version[MCF_SW_VERNO_LEN] = {0};
390 kal_char gen_time[MCF_FILE_MAX_GEN_TIME_LEN] = {0};
391 time_t time_sec;
392 struct tm tm;
393 kal_char file_buffer[MCF_SW_VERNO_LEN+MCF_FILE_MAX_GEN_TIME_LEN] = {0};
394 kal_uint16 dump_byte_offset = 0;
395 kal_uint16 dump_bit_offset = 0;
396 kal_uint32 item_size = 0;
397 kal_bool item_is_bit = KAL_FALSE;
398 kal_uint16 item_lid = 0;
399 kal_bool ret = KAL_TRUE;
400 mcf_tool_file_info_t pFile;
401 mcf_tool_gid_ota_file_item_t pItem;
402 mcf_tool_gid_tlvota_file_item_t pItem_op;
403 kal_char tag[MCF_MAX_TAG_LEN];
404 kal_uint8 sbp_len = 0;
405 kal_uint8 array_index[256];
406 kal_uint32 len = 0;
407 kal_uint32 item_num = 0;
408 kal_uint32 align_len = 0;
409 kal_uint16 item_cnt = 0;
410 kal_uint16 offset = 0;
411 kal_uint32 check_sum = 0;
412 kal_char password[MCF_MAX_PASSWORD_LEN] = {0};
413 mcf_utfwk_config_variable_info_struct var_info;
414 kal_bool is_found_lid = KAL_FALSE;
415 kal_uint32 i = 0;
416
417
418 mcf_utfwk_printf("Start! OTA type(%d)\r\n", ota_input.ota_type);
419 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_START(ota_input.ota_type);
420
421
422 kal_mem_set(sw_version, 0, sizeof(kal_char) * MCF_SW_VERNO_LEN);
423 kal_mem_set(gen_time, 0, sizeof(kal_char) * MCF_FILE_MAX_GEN_TIME_LEN);
424 kal_mem_set(file_buffer, 0, sizeof(kal_char) * (MCF_SW_VERNO_LEN+MCF_FILE_MAX_GEN_TIME_LEN));
425 kal_mem_set(array_index, 0, sizeof(kal_uint8) *256);
426 kal_mem_set(&var_info, 0, sizeof(mcf_utfwk_config_variable_info_struct));
427 var_info = ota_input.input_mode.var_info;
428
429 item_cnt = 0;
430
431 switch (ota_input.ota_type)
432 {
433 case MCF_UTFWK_ATTR_OTA:
434 kal_mem_set(&pFile, 0, sizeof(mcf_tool_file_info_t));
435 mcf_utfwk_printf("Start to generate OTA file. number of variable(%d), operation_mask(%d) \r\n", var_info.var_cnt, var_info.operation_mask);
436 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_GEN_OTA_START(var_info.var_cnt, var_info.operation_mask);
437 time(&time_sec);
438 pFile.file_version = 3;
439 strcpy(pFile.file_type, MCF_FILE_TYPE_OTA);
440 pFile.operation_mask = var_info.operation_mask;
441
442 pFile.item_num = var_info.var_cnt;
443
444 strncpy(sw_version, release_verno(), MCF_SW_VERNO_LEN-1);
445 pFile.sw_version_len = strlen(sw_version);
446
447 tm = *localtime(&time_sec);
448
449 sprintf(gen_time,"%04d.%02d.%02d.%02d%02d%02d\0", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
450
451 pFile.gen_time_len = strlen(gen_time);
452
453 strncpy(file_buffer, sw_version, pFile.sw_version_len);
454 strncpy(file_buffer+pFile.sw_version_len, gen_time, pFile.gen_time_len);
455
456 strncpy(&(pFile.buff_start), file_buffer, 1);
457
458
459 pFile.total_len = 43 + pFile.sw_version_len + pFile.gen_time_len;
460 pFile.file_size = pFile.total_len;
461
462 kal_mem_cpy(buff, &pFile, pFile.total_len);
463 strncpy(buff+40, file_buffer, pFile.sw_version_len+pFile.gen_time_len);
464
465 offset = pFile.total_len;
466
467 while (item_cnt < var_info.var_cnt) {
468 dump_byte_offset = 0;
469 dump_bit_offset = 0;
470 item_size = 0;
471 item_lid = 0;
472 align_len = 0;
473 kal_mem_set(&pItem, 0, sizeof(mcf_tool_gid_ota_file_item_t));
474 mcf_toupper((char *)var_info.var[item_cnt].array_index);
475 kal_mem_set(array_index, 0, sizeof(kal_uint8) *256);
476 kal_mem_cpy(array_index, var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
477
478 pItem.global_id = var_info.var[item_cnt].gid;
479 pItem.record_idx = var_info.var[item_cnt].rec_id;
480 pItem.array_index_len = strlen(array_index);
481
482 /* Find GID corresponding LID */
483 item_lid = mcf_find_gid_return_lid_num(pItem.global_id);
484 if (item_lid == 65535){
485 //-1(65535) means not found
486 mcf_utfwk_printf("Can not find this gid(%d)\r\n", pItem.global_id);
487 ret = KAL_FALSE;
488 return ret;
489 }
490
491 is_found_lid = KAL_FALSE;
492 for(i = 0; i < ota_input.lid_cnt; i++){
493 if (item_lid == ota_input.lid[i]){
494 is_found_lid = KAL_TRUE;
495 }
496 }
497 if (is_found_lid == KAL_FALSE){
498 mcf_utfwk_printf("LID(%d) of variable is not match given LID\r\n", item_lid);
499 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_OTA_LID_INVALID(item_lid);
500 ret = KAL_FALSE;
501 return ret;
502 }
503
504 if(mcf_find_gid_offset(pItem.global_id, array_index, &item_lid, &dump_byte_offset, &dump_bit_offset, &item_size, &item_is_bit) == KAL_FALSE){
505 kal_mem_set(array_index, 0, sizeof(kal_uint8) *256);
506 kal_mem_cpy(array_index, var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
507 mcf_utfwk_printf("Can not find this gid(%d), array_index(%s) \r\n", pItem.global_id, array_index);
508 ret = KAL_FALSE;
509 return ret;
510 }
511
512 if (item_is_bit == 0){
513 if(var_info.var[item_cnt].value_len > item_size){
514 mcf_utfwk_printf("Invalid value length! value_len(%d), variable_size(%d) \r\n", var_info.var[item_cnt].value_len, item_size);
515 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_INVALID_VAL_LEN(var_info.var[item_cnt].value_len, item_size);
516 ret = KAL_FALSE;
517 return ret;
518 }
519 }else{
520 if(var_info.var[item_cnt].value_len > 4){
521 mcf_utfwk_printf("Invalid bit_len(%d)!! current bit_value_len(%d) \r\n", var_info.var[item_cnt].value_len, item_size);
522 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_INVALID_BIT_LEN(var_info.var[item_cnt].value_len, item_size);
523 ret = KAL_FALSE;
524 return ret;
525 }
526 }
527
528 pItem.total_len = 16;
529
530 pItem.value_len = var_info.var[item_cnt].value_len;
531 pItem.total_len += pItem.value_len;
532
533 if (item_cnt == var_info.var_cnt -1){
534 if (pFile.file_size % 4 != 0){
535 align_len = (4-(pFile.file_size % 4));
536 pItem.total_len += align_len;
537 }
538 }
539
540 pItem.total_len += pItem.array_index_len;
541
542 if (pItem.array_index_len > 0){
543 strncpy(&(pItem.buff_start), var_info.var[item_cnt].array_index, 1);
544 }else{
545 strncpy(&(pItem.buff_start), var_info.var[item_cnt].value, 1);
546 }
547 pFile.file_size += pItem.total_len;
548
549 if(pFile.file_size > MCF_MAX_OTA_FILE_SIZE){
550 mcf_utfwk_printf("file size(%d) is larger than allocated buffer size(%d)!! \r\n", pFile.file_size, MCF_MAX_OTA_FILE_SIZE);
551 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_FILE_OVERSIZE(pFile.file_size, MCF_MAX_OTA_FILE_SIZE);
552 ret = KAL_FALSE;
553 return ret;
554 }
555
556
557 kal_mem_cpy(buff+offset, &pItem, pItem.total_len);
558 strncpy(buff+offset+16, var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
559 kal_mem_cpy(buff+offset+16+strlen(var_info.var[item_cnt].array_index), var_info.var[item_cnt].value, var_info.var[item_cnt].value_len);
560 kal_mem_set(buff+offset+16+strlen(var_info.var[item_cnt].array_index)+var_info.var[item_cnt].value_len, 0, align_len);
561
562 offset += pItem.total_len;
563 item_cnt++;
564
565 }
566
567 kal_mem_cpy(buff+20, &(pFile.file_size), 4);
568 *buff_size = pFile.file_size;
569
570 if((var_info.operation_mask & MCF_FILE_OP_AES_128) != 0){
571 if ((pFile.file_size - pFile.total_len) % 16 != 0){
572 align_len = (16-((pFile.file_size - pFile.total_len) % 16));
573 kal_mem_set(buff+pFile.file_size, 0, align_len);
574 pFile.file_size += align_len;
575 kal_mem_cpy(buff+20, &(pFile.file_size), 4);
576 *buff_size = pFile.file_size;
577 }
578 }
579
580 if((var_info.operation_mask & MCF_FILE_OP_CHECKSUM) != 0){
581 check_sum = mcf_calc_check_sum((kal_uint32 *)buff, pFile.file_size);
582 pFile.checksum = check_sum;
583 kal_mem_cpy(buff+36, &(pFile.checksum), 4);
584 }
585
586 if((var_info.operation_mask & MCF_FILE_OP_AES_128) != 0){
587 mcf_get_custom_aes_password(password);
588 if (mcf_encrypt_128bit(password, (kal_char *)(buff + pFile.total_len), (pFile.file_size - pFile.total_len) ) != KAL_TRUE) {
589 mcf_utfwk_printf("OTA file encryption FAIL!!\r\n");
590 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_ENCRYPTION_FAIL();
591 return KAL_FALSE;
592 }
593 }
594
595 break;
596
597 case MCF_UTFWK_ATTR_OTA_BY_OP:
598 mcf_utfwk_printf("Start to generate OP-OTA file. number of variable(%d), operation_mask(%d), tag type(%d) \r\n", var_info.var_cnt, var_info.operation_mask, var_info.tag_type);
599 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_GEN_TLVOTA_START(var_info.var_cnt, var_info.operation_mask, var_info.tag_type);
600
601 if(var_info.tag_type == 0){
602 mcf_utfwk_printf("Invalid tag type(%d) \r\n", var_info.tag_type);
603 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_GEN_TLVOTA_INVALID_TAG_TYPE(var_info.tag_type);
604 var_info.tag_type = 1;
605 }
606
607 kal_mem_set(&pFile, 0, sizeof(mcf_tool_file_info_t));
608 *is_general = KAL_FALSE;
609
610 time(&time_sec);
611 pFile.file_version = 3;
612 strcpy(pFile.file_type, MCF_FILE_TYPE_TLVOTA);
613 pFile.operation_mask = 0;
614
615 pFile.item_num = var_info.var_cnt;
616
617 strncpy(sw_version, release_verno(), MCF_SW_VERNO_LEN-1);
618 pFile.sw_version_len = strlen(sw_version);
619
620 tm = *localtime(&time_sec);
621
622 sprintf(gen_time,"%04d.%02d.%02d.%02d%02d%02d\0", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
623
624 pFile.gen_time_len = strlen(gen_time);
625
626 strncpy(file_buffer, sw_version, pFile.sw_version_len);
627 strncpy(file_buffer+pFile.sw_version_len, gen_time, pFile.gen_time_len);
628
629 strncpy(&(pFile.buff_start), file_buffer, 1);
630
631
632 pFile.total_len = 43 + pFile.sw_version_len + pFile.gen_time_len;
633 pFile.file_size = pFile.total_len;
634
635 kal_mem_cpy(buff, &pFile, pFile.total_len);
636 strncpy(buff+40, file_buffer, pFile.sw_version_len+pFile.gen_time_len);
637
638 offset = pFile.total_len;
639 item_cnt = 0;
640
641 while (item_cnt < var_info.var_cnt) {
642 dump_byte_offset = 0;
643 dump_bit_offset = 0;
644 item_size = 0;
645 item_lid = 0;
646 align_len = 0;
647 kal_mem_set(&pItem_op, 0, sizeof(mcf_tool_gid_tlvota_file_item_t));
648 mcf_toupper((char *)var_info.var[item_cnt].array_index);
649 kal_mem_set(array_index, 0, sizeof(kal_uint8) *256);
650 kal_mem_cpy(array_index, var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
651
652 pItem_op.global_id = var_info.var[item_cnt].gid;
653 pItem_op.array_index_len = strlen(array_index);
654 pItem_op.tag_type = var_info.tag_type;
655
656 if(var_info.tag_type == 2){
657 pItem_op.tag_len = strlen(ota_input.iccid);
658 strncpy(tag, ota_input.iccid, 21);
659 *is_general = KAL_TRUE;
660 }else if (ota_input.sbp_id == SBP_ID_INVALID || ota_input.sbp_id == 0){
661 *is_general = KAL_TRUE;
662 }
663
664 /* Find GID corresponding LID */
665 item_lid = mcf_find_gid_return_lid_num(pItem_op.global_id);
666 if (item_lid == 65535){
667 //-1(65535) means not found
668 mcf_utfwk_printf("Can not find this gid(%d)\r\n", pItem_op.global_id);
669 ret = KAL_FALSE;
670 return ret;
671 }
672
673 is_found_lid = KAL_FALSE;
674 for(i = 0; i < ota_input.lid_cnt; i++){
675 if (item_lid == ota_input.lid[i]){
676 is_found_lid = KAL_TRUE;
677 }
678 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_TAKE_TLV_OTA_READ_LOCK_FAIL();
679 }
680 if (is_found_lid == KAL_FALSE){
681 mcf_utfwk_printf("LID(%d) of variable is not match given LID\r\n", item_lid);
682 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_INVALID_LID(item_lid);
683 ret = KAL_FALSE;
684 return ret;
685 }
686
687 if(mcf_find_gid_offset(pItem_op.global_id, array_index, &item_lid, &dump_byte_offset, &dump_bit_offset, &item_size, &item_is_bit) == KAL_FALSE){
688 kal_mem_set(array_index, 0, sizeof(kal_uint8) *256);
689 kal_mem_cpy(array_index, var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
690 mcf_utfwk_printf("Can not find this gid(%d), array_index(%s) \r\n", pItem_op.global_id, array_index);
691 ret = KAL_FALSE;
692 return ret;
693 }
694
695 if (item_is_bit == 0){
696 if(var_info.var[item_cnt].value_len > item_size){
697 mcf_utfwk_printf("Invalid value length! value_len(%d), variable_size(%d) \r\n", var_info.var[item_cnt].value_len, item_size);
698 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_INVALID_VAL_LEN(var_info.var[item_cnt].value_len, item_size);
699 ret = KAL_FALSE;
700 return ret;
701 }
702 }else{
703 if(var_info.var[item_cnt].value_len > 4){
704 mcf_utfwk_printf("Invalid bit_len(%d)!! current bit_value_len(%d) \r\n", var_info.var[item_cnt].value_len, item_size);
705 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_INVALID_BIT_LEN(var_info.var[item_cnt].value_len, item_size);
706 ret = KAL_FALSE;
707 return ret;
708 }
709 }
710
711 pItem_op.total_len = 16;
712
713 pItem_op.value_len = var_info.var[item_cnt].value_len;
714 pItem_op.total_len += pItem_op.value_len;
715 pItem_op.total_len += pItem_op.array_index_len;
716
717 if (pItem_op.tag_type == 1){
718 if (ota_input.sbp_id != SBP_ID_INVALID) {
719 if (strcmp((kal_char *)ota_input.mcc, "") != 0) {
720 if (strcmp((kal_char *)ota_input.mnc, "") != 0){
721 kal_snprintf(tag, MCF_MAX_TAG_LEN, "%d_%s_%s%c", ota_input.sbp_id, (kal_char *)ota_input.mcc, (kal_char *)ota_input.mnc, '\0');
722 }else{
723 kal_snprintf(tag, MCF_MAX_TAG_LEN, "%d_%s_NA%c", ota_input.sbp_id, (kal_char *)ota_input.mcc, '\0');
724 }
725 }else{
726 if (strcmp((kal_char *)ota_input.mnc, "") != 0){
727 kal_snprintf(tag, MCF_MAX_TAG_LEN, "%d_NA_%s%c", ota_input.sbp_id, (kal_char *)ota_input.mnc, '\0');
728 }else{
729 kal_snprintf(tag, MCF_MAX_TAG_LEN, "%d_NA_NA%c", ota_input.sbp_id, '\0');
730 }
731 }
732 }else{
733 if (strcmp((kal_char *)ota_input.mcc, "") != 0) {
734 if (strcmp((kal_char *)ota_input.mnc, "") != 0){
735 kal_snprintf(tag, MCF_MAX_TAG_LEN, "NA_%s_%s%c", (kal_char *)ota_input.mcc, (kal_char *)ota_input.mnc, '\0');
736 }else{
737 kal_snprintf(tag, MCF_MAX_TAG_LEN, "NA_%s_NA%c", (kal_char *)ota_input.mcc, '\0');
738 }
739 }else{
740 if (strcmp((kal_char *)ota_input.mnc, "") != 0){
741 kal_snprintf(tag, MCF_MAX_TAG_LEN, "NA_NA_%s%c", (kal_char *)ota_input.mnc, '\0');
742 }else{
743 *is_general = KAL_FALSE;
744 kal_snprintf(tag, MCF_MAX_TAG_LEN, "NA_NA_NA%c", '\0');
745 }
746 }
747 }
748
749 pItem_op.tag_len = strlen(tag);
750 }else if (pItem_op.tag_type == 2){
751 *is_general = KAL_TRUE;
752 if (strcmp(ota_input.iccid,"") != 0){
753 kal_snprintf(tag, MCF_MAX_TAG_LEN, "%s%c", ota_input.iccid, '\0');
754 }
755
756 pItem_op.tag_len = strlen(tag);
757 }
758
759 pItem_op.total_len += pItem_op.tag_len;
760
761 strncpy(&(pItem_op.buff_start), tag, 1);
762
763 if (item_cnt == var_info.var_cnt -1){
764 if (pFile.file_size % 4 != 0){
765 align_len = (4-(pFile.file_size % 4));
766 pItem_op.total_len += align_len;
767 }
768 }
769
770 pFile.file_size += pItem_op.total_len;
771
772 if(pFile.file_size > MCF_MAX_TLVOTA_FILE_SIZE){
773 mcf_utfwk_printf("file size(%d) is larger than allocated buffer size(%d)!! \r\n", pFile.file_size, MCF_MAX_TLVOTA_FILE_SIZE);
774 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_FILE_OVERSIZE(pFile.file_size, MCF_MAX_TLVOTA_FILE_SIZE);
775 ret = KAL_FALSE;
776 return ret;
777 }
778
779 kal_mem_cpy(buff+offset, &pItem_op, pItem_op.total_len);
780 strncpy(buff+offset+16, tag, strlen(tag));
781 strncpy(buff+offset+16+strlen(tag), var_info.var[item_cnt].array_index, strlen(var_info.var[item_cnt].array_index));
782 kal_mem_cpy(buff+offset+16+strlen(tag)+strlen(var_info.var[item_cnt].array_index), var_info.var[item_cnt].value, var_info.var[item_cnt].value_len);
783 kal_mem_set(buff+offset+16+strlen(tag)+strlen(var_info.var[item_cnt].array_index)+var_info.var[item_cnt].value_len, 0, align_len);
784
785 offset += pItem_op.total_len;
786 item_cnt++;
787
788 }
789
790 kal_mem_cpy(buff+20, &(pFile.file_size), 4);
791 *buff_size = pFile.file_size;
792
793 if((var_info.operation_mask & MCF_FILE_OP_AES_128) != 0){
794 if ((pFile.file_size - pFile.total_len) % 16 != 0){
795 align_len = (16-((pFile.file_size - pFile.total_len) % 16));
796 kal_mem_set(buff+pFile.file_size, 0, align_len);
797 pFile.file_size += align_len;
798 kal_mem_cpy(buff+20, &(pFile.file_size), 4);
799 *buff_size = pFile.file_size;
800 }
801 }
802
803 if(var_info.operation_mask & MCF_FILE_OP_CHECKSUM != 0){
804 check_sum = mcf_calc_check_sum((kal_uint32 *)buff, pFile.file_size);
805 pFile.checksum = check_sum;
806 kal_mem_cpy(buff+36, &(pFile.checksum), 4);
807 }
808
809 if(var_info.operation_mask & MCF_FILE_OP_AES_128 != 0){
810 mcf_get_custom_aes_password(password);
811 if (mcf_encrypt_128bit(password, (kal_char *)(buff + pFile.total_len), (pFile.file_size - pFile.total_len) ) != KAL_TRUE) {
812 mcf_utfwk_printf("OTA file encryption FAIL!!\r\n");
813 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_ENCRYPTION_FAIL();
814 return KAL_FALSE;
815 }
816 }
817
818
819 break;
820
821 default:
822 MD_TRC_MCF_TR_UTFWK_GENERATE_OTA_FILE_UNKNOWN_OTA_TYPE(ota_input.ota_type);
823 mcf_utfwk_printf("Unknown ota type(%d) \r\n", ota_input.ota_type);
824 break;
825 }
826
827
828 return ret;
829}
830
831kal_bool mcf_utfwk_is_working_status()
832{
833 return is_ut_fwk;
834}
835kal_bool mcf_utfwk_initial_env(mcf_utfwk_ota_input_struct ota_input)
836{
837 mcf_t *pMcf = mcf_get_instance();
838 mcf_ota_file_t *ota_file = &(pMcf->ota_file);
839 mcf_tlvota_file_t *tlvota_file;
840 kal_uint8 *lid_buffer;
841 kal_uint32 i;
842 mcf_tool_file_info_t *pFile;
843 mcf_tool_gid_ota_file_item_t *pItem;
844 mcf_tool_gid_tlvota_file_item_t *pItem_op;
845 kal_char tag[MCF_MAX_TAG_LEN];
846 kal_uint32 sbp_id;
847 kal_uint8 mcc[MAX_MCC_STR_LEN];
848 kal_uint8 mnc[MAX_MNC_STR_LEN];
849 kal_uint8 iccid[21];
850 kal_uint32 item_cnt = 0;
851 nvram_errno_enum nvram_api_ret;
852 nvram_ltable_entry_struct lid_info = {0};
853 kal_char password[MCF_MAX_PASSWORD_LEN] = {0};
854 mcf_tlvota_sbp_tag_t sbp_tag;
855 kal_uint16 item_byte_offset;
856 kal_uint16 item_bit_offset;
857 kal_uint32 item_size;
858 kal_char array_tag[MCF_FILE_MAX_ARRAY_TAG_LEN]={0};
859 kal_bool item_is_bit = KAL_FALSE;
860 kal_uint16 item_lid;
861 kal_bool is_found_lid = KAL_FALSE;
862 kal_uint16 buff_size = 0;
863
864 mcf_utfwk_printf("Start! OTA type(%d), Operation(%d), SIM(%d)\r\n", ota_input.ota_type, ota_input.input_op, ota_input.sim_id);
865 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_START(ota_input.ota_type, ota_input.input_op, ota_input.sim_id);
866 kal_take_enh_mutex(mcf_utfwk_enhmutex_g);
867
868 if (execute_ota == KAL_FALSE && execute_op_ota == KAL_FALSE && execute_gen_op_ota == KAL_FALSE){
869 kal_mem_set(pMcf, 0, sizeof(mcf_t));
870
871 /* Object init */
872 MCF_INIT_OBJECT_BEGIN(ota_file, mcf_enhmutex_g);
873 MCF_INIT_OBJECT_END(ota_file, mcf_enhmutex_g);
874
875 for (i = 0; i < MAX_SIM_NUM; i++) {
876 tlvota_file = &(pMcf->tlvota_file[i]);
877 MCF_INIT_OBJECT_BEGIN(tlvota_file, mcf_enhmutex_g);
878 MCF_INIT_OBJECT_END(tlvota_file, mcf_enhmutex_g);
879 }
880
881 tlvota_file = &(pMcf->general_tlvota_file);
882 MCF_INIT_OBJECT_BEGIN(tlvota_file, mcf_enhmutex_g);
883 MCF_INIT_OBJECT_END(tlvota_file, mcf_enhmutex_g);
884
885
886 kal_mem_set(&com_buff, 0, sizeof(mcf_utfwk_common_t));
887 com_buff.initial_ret = KAL_TRUE;
888 com_buff.ota_input = ota_input;
889
890 /* UT FWK is working, need to use fread to read file */
891 is_ut_fwk = KAL_TRUE;
892
893 /* Reset NVRAM_EF_MCF_OTA_FILE_LID */
894 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_ota_file_info_struct));
895 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_ota_file_info_struct));
896 for(i = 0; i < NVRAM_EF_MCF_OTA_FILE_TOTAL; i++) {
897 if ( !nvram_external_write_data(NVRAM_EF_MCF_OTA_FILE_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_ota_file_info_struct)) ) {
898 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_OTA_FILE_LID!!\r\n");
899 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_OTA_FILE_LID_FAIL();
900 com_buff.initial_ret = KAL_FALSE;
901 free_ctrl_buffer_set_null(lid_buffer);
902 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
903 return com_buff.initial_ret;
904 }
905 }
906 free_ctrl_buffer_set_null(lid_buffer);
907
908 /* Reset NVRAM_EF_MCF_TLVOTA_FILE_LID */
909 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_tlvota_file_info_struct));
910 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_tlvota_file_info_struct));
911 for(i = 0; i < NVRAM_EF_MCF_TLVOTA_FILE_TOTAL; i++) {
912 if ( !nvram_external_write_data(NVRAM_EF_MCF_TLVOTA_FILE_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_tlvota_file_info_struct)) ) {
913 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_TLVOTA_FILE_LID!!\r\n");
914 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_TLVOTA_FILE_LID_FAIL();
915 com_buff.initial_ret = KAL_FALSE;
916 free_ctrl_buffer_set_null(lid_buffer);
917 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
918 return com_buff.initial_ret;
919 }
920 }
921 free_ctrl_buffer_set_null(lid_buffer);
922
923 /* Reset NVRAM_EF_MCF_TEST_OTA_LID */
924 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_test_struct));
925 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_test_struct));
926 for(i = 0; i < NVRAM_EF_MCF_TEST_OTA_TOTAL; i++) {
927 if ( !nvram_external_write_data(NVRAM_EF_MCF_TEST_OTA_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_test_struct)) ) {
928 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_TEST_OTA_LID!!\r\n");
929 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_TEST_OTA_LID_FAIL();
930 com_buff.initial_ret = KAL_FALSE;
931 free_ctrl_buffer_set_null(lid_buffer);
932 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
933 return com_buff.initial_ret;
934 }
935 }
936 free_ctrl_buffer_set_null(lid_buffer);
937
938 /* Reset NVRAM_EF_MCF_TEST_OTA_QUERY_LID */
939 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_test_struct));
940 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_test_struct));
941 for(i = 0; i < NVRAM_EF_MCF_TEST_OTA_QUERY_TOTAL; i++) {
942 if ( !nvram_external_write_data(NVRAM_EF_MCF_TEST_OTA_QUERY_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_test_struct)) ) {
943 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_TEST_OTA_QUERY_LID!!\r\n");
944 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_TEST_OTA_QUERY_LID_FAIL();
945 com_buff.initial_ret = KAL_FALSE;
946 free_ctrl_buffer_set_null(lid_buffer);
947 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
948 return com_buff.initial_ret;
949 }
950 }
951 free_ctrl_buffer_set_null(lid_buffer);
952
953 /* Reset NVRAM_EF_MCF_SW_INFO_LID */
954 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_sw_info_struct));
955 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_sw_info_struct));
956 for(i = 0; i < NVRAM_EF_MCF_SW_INFO_TOTAL; i++) {
957 if ( !nvram_external_write_data(NVRAM_EF_MCF_SW_INFO_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_sw_info_struct)) ) {
958 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_SW_INFO_LID!!\r\n");
959 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_SW_INFO_LID_FAIL();
960 com_buff.initial_ret = KAL_FALSE;
961 free_ctrl_buffer_set_null(lid_buffer);
962 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
963 return com_buff.initial_ret;
964 }
965 }
966 free_ctrl_buffer_set_null(lid_buffer);
967
968 /* Reset NVRAM_EF_MCF_INTERNAL_INFO_LID */
969 lid_buffer = (kal_uint8 *)get_ctrl_buffer(sizeof(nvram_ef_mcf_internal_info_struct));
970 kal_mem_set(lid_buffer, 0, sizeof(nvram_ef_mcf_internal_info_struct));
971 for(i = 0; i < NVRAM_EF_MCF_INTERNAL_INFO_TOTAL; i++) {
972 if ( !nvram_external_write_data(NVRAM_EF_MCF_INTERNAL_INFO_LID, i+1, lid_buffer, sizeof(nvram_ef_mcf_internal_info_struct)) ) {
973 mcf_utfwk_printf("Fail to reset NVRAM_EF_MCF_INTERNAL_INFO_LID!!\r\n");
974 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_INTERNAL_INFO_LID_FAIL();
975 com_buff.initial_ret = KAL_FALSE;
976 free_ctrl_buffer_set_null(lid_buffer);
977 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
978 return com_buff.initial_ret;
979 }
980 }
981 free_ctrl_buffer_set_null(lid_buffer);
982
983
984
985 for (i = 0; i < com_buff.ota_input.lid_cnt; i++){
986 kal_mem_set(&lid_info, 0, sizeof(nvram_ltable_entry_struct));
987 nvram_api_ret = nvram_external_get_lid_info(com_buff.ota_input.lid[i], &lid_info);
988 if (nvram_api_ret != NVRAM_ERRNO_SUCCESS) {
989 mcf_utfwk_printf("Fail to get LID information!! LID(%d), nvram_api_ret(%d) \r\n", com_buff.ota_input.lid[i], nvram_api_ret);
990 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_GET_LID_INFO_FAIL(com_buff.ota_input.lid[i], nvram_api_ret);
991 com_buff.initial_ret = KAL_FALSE;
992 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
993 return com_buff.initial_ret;
994 }
995 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
996 if ( (lid_info.attr & NVRAM_ATTR_MCF_OTA) == 0 && (lid_info.attr & NVRAM_ATTR_MCF_OTA_FOR_QUERY) == 0) {
997 mcf_utfwk_printf("Invalid OTA type!! LID(%d), LID attribute(%x), ota_type(%d) \r\n", com_buff.ota_input.lid[i], lid_info.attr, com_buff.ota_input.ota_type);
998 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_INVALID_OTA_TYPE(com_buff.ota_input.lid[i], lid_info.attr, com_buff.ota_input.ota_type);
999 com_buff.initial_ret = KAL_FALSE;
1000 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1001 return com_buff.initial_ret;
1002 }
1003
1004 }else if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1005 if (com_buff.ota_input.sim_id >= MAX_SIM_NUM){
1006 mcf_utfwk_printf("Invalid Parameters! SIM(%d)\r\n", com_buff.ota_input.sim_id);
1007 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_INVALID_SIM_ID(com_buff.ota_input.sim_id);
1008 com_buff.initial_ret = KAL_FALSE;
1009 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1010 return com_buff.initial_ret;
1011 }
1012 if ( (lid_info.attr & NVRAM_ATTR_MCF_OTA_BY_OP) == 0 ) {
1013 mcf_utfwk_printf("Invalid OP-OTA type!! LID(%d), LID attribute(%x), ota_type(%d) \r\n", com_buff.ota_input.lid[i], lid_info.attr, com_buff.ota_input.ota_type);
1014 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_INVALID_TLVOTA_TYPE(com_buff.ota_input.lid[i], lid_info.attr, com_buff.ota_input.ota_type);
1015 com_buff.initial_ret = KAL_FALSE;
1016 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1017 return com_buff.initial_ret;
1018 }
1019 }
1020 if((lid_info.attr & NVRAM_ATTR_MCF_OTA) != 0) {
1021 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_LID(com_buff.ota_input.lid[i]);
1022 if ( !nvram_external_reset_data(com_buff.ota_input.lid[i], 1, lid_info.total_records) ) {
1023 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_RESET_LID_FAIL(com_buff.ota_input.lid[i], lid_info.total_records);
1024 mcf_utfwk_printf("Fail to reset LID!! LID(%d), total_record(%d) \r\n", com_buff.ota_input.lid, lid_info.total_records);
1025 com_buff.initial_ret = KAL_FALSE;
1026 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1027 return com_buff.initial_ret;
1028 }
1029
1030 }
1031 }
1032
1033
1034 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1035 for (i = 0; i < MAX_SIM_NUM; i++) {
1036 tlvota_file = &(pMcf->tlvota_file[i]);
1037 tlvota_file->sbp_id = SBP_ID_INVALID;
1038 }
1039
1040 tlvota_file = &(pMcf->tlvota_file[com_buff.ota_input.sim_id]);
1041 tlvota_file->sbp_id = com_buff.ota_input.sbp_id;
1042 if (com_buff.ota_input.sbp_id == SBP_ID_INVALID || com_buff.ota_input.sbp_id == 0){
1043 if (strcmp(com_buff.ota_input.iccid,"") == 0){
1044 mcf_utfwk_printf("Invalid SBP ID! SBP_ID(%d)\r\n", com_buff.ota_input.sbp_id);
1045 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_INVALID_SBP_ID(com_buff.ota_input.sbp_id);
1046 com_buff.initial_ret = KAL_FALSE;
1047 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1048 return com_buff.initial_ret;
1049 }
1050 }
1051 strncpy(tlvota_file->mcc, com_buff.ota_input.mcc, MAX_MCC_STR_LEN);
1052 strncpy(tlvota_file->mnc, com_buff.ota_input.mnc, MAX_MNC_STR_LEN);
1053 strncpy(tlvota_file->iccid, com_buff.ota_input.iccid, 21);
1054
1055 }
1056 }
1057
1058 if (com_buff.ota_input.input_op == MCF_UTFWK_OTA_FILE_PATH){
1059 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
1060 MCF_W_LOCK_OBJECT(ota_file, mcf_enhmutex_g);
1061 if (ota_file) {
1062 com_buff.initial_ret = mcf_utfwk_open_test_data(com_buff.ota_input.input_mode.file_path_name, (kal_char *)(ota_file->buff), MCF_MAX_OTA_FILE_SIZE, ota_file->relative_path_name);
1063 if (com_buff.initial_ret == KAL_FALSE) {
1064 mcf_utfwk_printf("Open OTA test data(%s) FAIL!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1065 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_OPEN_OTA_FAIL(com_buff.ota_input.input_mode.file_path_name);
1066 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1067 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1068 com_buff.initial_ret = KAL_FALSE;
1069 return com_buff.initial_ret;
1070 }
1071 pFile = (mcf_tool_file_info_t *)(ota_file->buff);
1072 pItem = (mcf_tool_gid_ota_file_item_t *)(ota_file->buff + pFile->total_len);
1073 if (pFile->file_size > MCF_MAX_OTA_FILE_SIZE) {
1074 mcf_utfwk_printf("file size(%d) is larger than allocated buffer size(%d)!! \r\n", pFile->file_size, MCF_MAX_OTA_FILE_SIZE);
1075 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_OVERSIZE(pFile->file_size, MCF_MAX_OTA_FILE_SIZE);
1076 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1077 com_buff.initial_ret = KAL_FALSE;
1078 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1079 return com_buff.initial_ret;
1080 }
1081 if (pFile->file_version == 3) {
1082 /*
1083 * If file is encrypted and has checksum.
1084 * Decrypt file before checking checksum.
1085 */
1086 if ( (pFile->operation_mask & MCF_FILE_OP_AES_128) != 0) {
1087 mcf_get_custom_aes_password(password);
1088
1089 if (mcf_decrypt_128bit(password, (kal_char *)(ota_file->buff + pFile->total_len), (pFile->file_size - pFile->total_len) ) != KAL_TRUE) {
1090 kal_mem_set(ota_file->buff, 0, MCF_MAX_OTA_FILE_SIZE);
1091 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1092 mcf_utfwk_printf("file(%s) decryption FAIL!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1093 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_DECRYPTION_FAIL(com_buff.ota_input.input_mode.file_path_name);
1094 com_buff.initial_ret = KAL_FALSE;
1095 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1096 return com_buff.initial_ret;
1097 }
1098 }
1099
1100 if ( (pFile->operation_mask & MCF_FILE_OP_CHECKSUM) != 0) {
1101 if (mcf_check_check_sum((kal_uint32 *)(ota_file->buff), pFile->file_size) != 0) {
1102 kal_mem_set(ota_file->buff, 0, MCF_MAX_OTA_FILE_SIZE);
1103 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1104 mcf_utfwk_printf("file(%s) checksum ERROR!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1105 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_CHECKSUM_ERROR(com_buff.ota_input.input_mode.file_path_name);
1106 com_buff.initial_ret = KAL_FALSE;
1107 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1108 return com_buff.initial_ret;
1109 }
1110 }
1111 } else {
1112 mcf_utfwk_printf("file version(%d) is INVALID!! \r\n", pFile->file_version);
1113 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_INVALID_FILE_VERSION(pFile->file_version);
1114 kal_mem_set(ota_file->buff, 0, MCF_MAX_OTA_FILE_SIZE);
1115 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1116 com_buff.initial_ret = KAL_FALSE;
1117 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1118 return com_buff.initial_ret;
1119 }
1120 item_cnt = 0;
1121 while (item_cnt < pFile->item_num) {
1122 if ( (pItem->array_index_len < 0) || (pItem->array_index_len >= MCF_FILE_MAX_ARRAY_TAG_LEN-1) ) {
1123 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAG_INVALID_ARRAY_INDEX_LEN(pItem->array_index_len, MCF_FILE_MAX_ARRAY_TAG_LEN);
1124 mcf_utfwk_printf("Invalid array_index_len(%d)!! max array_index_len(%d)", pItem->array_index_len, MCF_FILE_MAX_ARRAY_TAG_LEN);
1125 goto next;
1126 }
1127 strncpy(array_tag, &(pItem->buff_start), pItem->array_index_len);
1128 array_tag[pItem->array_index_len] = '\0';
1129
1130 if(mcf_find_gid_offset(pItem->global_id, array_tag, &item_lid, &item_byte_offset, &item_bit_offset, &item_size, &item_is_bit) == KAL_FALSE){
1131 goto next;
1132 }
1133 is_found_lid = KAL_FALSE;
1134 for(i = 0; i <com_buff.ota_input.lid_cnt; i++){
1135 if (item_lid == com_buff.ota_input.lid[i]){
1136 is_found_lid = KAL_TRUE;
1137 }
1138 }
1139 if (is_found_lid == KAL_FALSE){
1140 mcf_utfwk_printf("LID(%d) in OTA file is not match given LID\r\n", item_lid);
1141 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_OTA_LID_INVALID(item_lid);
1142 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1143 com_buff.initial_ret = KAL_FALSE;
1144 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1145 return com_buff.initial_ret;
1146 }
1147
1148next:
1149 pItem = (mcf_tool_gid_ota_file_item_t *)((kal_uint8 *)pItem + pItem->total_len);
1150 item_cnt++;
1151 }
1152 execute_ota = KAL_TRUE;
1153 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1154 } else {
1155 mcf_utfwk_printf("Read OTA test data FAIL!! Fail to take read lock! \r\n");
1156 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAKE_OTA_READ_LOCK_FAIL();
1157 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1158 com_buff.initial_ret = KAL_FALSE;
1159 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1160 return com_buff.initial_ret;
1161 }
1162 execute_ota = KAL_TRUE;
1163 }else if(com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1164 tlvota_file = &(pMcf->tlvota_file[com_buff.ota_input.sim_id]);
1165 kal_mem_set(tag, 0, sizeof(kal_char) * MCF_MAX_TAG_LEN);
1166 kal_mem_set(iccid, 0, 21);
1167 MCF_W_LOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1168 if (tlvota_file) {
1169 com_buff.initial_ret = mcf_utfwk_open_test_data(com_buff.ota_input.input_mode.file_path_name, (kal_char *)(tlvota_file->buff), MCF_MAX_TLVOTA_FILE_SIZE, tlvota_file->relative_path_name);
1170 if (com_buff.initial_ret == KAL_FALSE) {
1171 mcf_utfwk_printf("Open OP-OTA test data(%s) FAIL!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1172 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_OPEN_TLVOTA_FAIL(com_buff.ota_input.input_mode.file_path_name);
1173 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1174 com_buff.initial_ret = KAL_FALSE;
1175 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1176 return com_buff.initial_ret;
1177 }
1178
1179 pFile = (mcf_tool_file_info_t *)(tlvota_file->buff);
1180 pItem_op = (mcf_tool_gid_tlvota_file_item_t *)(tlvota_file->buff + pFile->total_len);
1181
1182 if (pFile->file_size > MCF_MAX_TLVOTA_FILE_SIZE) {
1183 mcf_utfwk_printf("file size(%d) is larger than allocated buffer size(%d)!! \r\n", pFile->file_size, MCF_MAX_TLVOTA_FILE_SIZE);
1184 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_OVERSIZE(pFile->file_size, MCF_MAX_TLVOTA_FILE_SIZE);
1185 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1186 com_buff.initial_ret = KAL_FALSE;
1187 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1188 return com_buff.initial_ret;
1189 }
1190 if (pFile->file_version == 3) {
1191 if (pItem_op->tag_type == 1){
1192 strncpy(tag, &(pItem_op->buff_start), pItem_op->tag_len);
1193 com_buff.initial_ret = mcf_utfwk_spilt_tag(tag, &sbp_id, mcc, mnc);
1194 if (sbp_id == SBP_ID_INVALID){
1195 com_buff.is_general = KAL_TRUE;
1196 }
1197 sbp_tag.sbp_id = com_buff.ota_input.sbp_id;
1198 strncpy(sbp_tag.mcc, com_buff.ota_input.mcc, MAX_MCC_STR_LEN);
1199 strncpy(sbp_tag.mnc, com_buff.ota_input.mnc, MAX_MNC_STR_LEN);
1200
1201 if(mcf_utfwk_check_tag_entry(sbp_tag, pItem_op) != KAL_TRUE){
1202 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAG_IS_NOT_MATCH(com_buff.ota_input.sbp_id, com_buff.ota_input.mcc, com_buff.ota_input.mnc, sbp_id, mcc, mnc);
1203 mcf_utfwk_printf("Tag(%d_%s_%s) in OP-OTA file is not match given tag(%d_%s_%s)\r\n", com_buff.ota_input.sbp_id, com_buff.ota_input.mcc, com_buff.ota_input.mnc, sbp_id, mcc, mnc);
1204 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1205 com_buff.initial_ret = KAL_FALSE;
1206 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1207 return com_buff.initial_ret;
1208 }
1209
1210
1211 }else if(pItem_op->tag_type == 2){
1212 strncpy(iccid, &(pItem_op->buff_start), pItem_op->tag_len);
1213 strncpy(tlvota_file->iccid, iccid, 21);
1214 com_buff.is_general = KAL_TRUE;
1215 }
1216
1217
1218 /*
1219 * If file is encrypted and has checksum.
1220 * Decrypt file before checking checksum.
1221 */
1222 if ( (pFile->operation_mask & MCF_FILE_OP_AES_128) != 0) {
1223 mcf_get_custom_aes_password(password);
1224
1225 if (mcf_decrypt_128bit(password, (kal_char *)(tlvota_file->buff + pFile->total_len), (pFile->file_size - pFile->total_len) ) != KAL_TRUE) {
1226 kal_mem_set(tlvota_file->buff, 0, MCF_MAX_TLVOTA_FILE_SIZE);
1227 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1228 mcf_utfwk_printf("file(%s) decryption FAIL!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1229 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_DECRYPTION_FAIL(com_buff.ota_input.input_mode.file_path_name);
1230 com_buff.initial_ret = KAL_FALSE;
1231 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1232 return com_buff.initial_ret;
1233 }
1234 }
1235
1236 if ( (pFile->operation_mask & MCF_FILE_OP_CHECKSUM) != 0) {
1237 if (mcf_check_check_sum((kal_uint32 *)(tlvota_file->buff), pFile->file_size) != 0) {
1238 kal_mem_set(tlvota_file->buff, 0, MCF_MAX_TLVOTA_FILE_SIZE);
1239 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1240 mcf_utfwk_printf("file(%s) checksum ERROR!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1241 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_CHECKSUM_ERROR(com_buff.ota_input.input_mode.file_path_name);
1242 com_buff.initial_ret = KAL_FALSE;
1243 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1244 return com_buff.initial_ret;
1245 }
1246 }
1247 } else {
1248 mcf_utfwk_printf("file version(%d) is INVALID!! \r\n", pFile->file_version);
1249 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_FILE_INVALID_FILE_VERSION(pFile->file_version);
1250 kal_mem_set(tlvota_file->buff, 0, MCF_MAX_TLVOTA_FILE_SIZE);
1251 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1252 com_buff.initial_ret = KAL_FALSE;
1253 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1254 return com_buff.initial_ret;
1255 }
1256
1257 item_cnt = 0;
1258 while (item_cnt < pFile->item_num) {
1259 if ( (pItem_op->array_index_len < 0) || (pItem_op->array_index_len >= MCF_FILE_MAX_ARRAY_TAG_LEN-1) ) {
1260 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAG_INVALID_ARRAY_INDEX_LEN(pItem_op->array_index_len, MCF_FILE_MAX_ARRAY_TAG_LEN);
1261 mcf_utfwk_printf("Invalid array_index_len(%d)!! max array_index_len(%d)", pItem_op->array_index_len, MCF_FILE_MAX_ARRAY_TAG_LEN);
1262 goto next1;
1263 }
1264 strncpy(array_tag, &(pItem_op->buff_start), pItem_op->array_index_len);
1265 array_tag[pItem_op->array_index_len] = '\0';
1266
1267 if(mcf_find_gid_offset(pItem_op->global_id, array_tag, &item_lid, &item_byte_offset, &item_bit_offset, &item_size, &item_is_bit) == KAL_FALSE){
1268 goto next1;
1269 }
1270 is_found_lid = KAL_FALSE;
1271 for(i = 0; i <com_buff.ota_input.lid_cnt; i++){
1272 if (item_lid == com_buff.ota_input.lid[i]){
1273 is_found_lid = KAL_TRUE;
1274 }
1275 }
1276 if (is_found_lid == KAL_FALSE){
1277 mcf_utfwk_printf("LID(%d) in OP-OTA file is not match given\r\n", item_lid);
1278 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TLVOTA_LID_INVALID(item_lid);
1279 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1280 com_buff.initial_ret = KAL_FALSE;
1281 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1282 return com_buff.initial_ret;
1283 }
1284next1:
1285 pItem_op = (mcf_tool_gid_tlvota_file_item_t *)((kal_uint8 *)pItem_op + pItem_op->total_len);
1286 item_cnt++;
1287 }
1288 execute_op_ota = KAL_TRUE;
1289 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1290
1291 }else {
1292 mcf_utfwk_printf("Read OP-OTA test data FAIL!! Fail to take read lock! \r\n");
1293 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAKE_TLV_OTA_READ_LOCK_FAIL();
1294 MCF_R_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1295 com_buff.initial_ret = KAL_FALSE;
1296 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1297 return com_buff.initial_ret;
1298 }
1299 /* General OP-OTA */
1300 if (com_buff.is_general == KAL_TRUE){
1301 tlvota_file = &(pMcf->general_tlvota_file);
1302 kal_mem_set(tag, 0, sizeof(kal_char) * MCF_MAX_TAG_LEN);
1303 kal_mem_set(iccid, 0, 21);
1304 MCF_W_LOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1305 if (tlvota_file) {
1306 com_buff.initial_ret = mcf_utfwk_open_test_data(com_buff.ota_input.input_mode.file_path_name, (kal_char *)(tlvota_file->buff), MCF_MAX_TLVOTA_FILE_SIZE, tlvota_file->relative_path_name);
1307 if (com_buff.initial_ret == KAL_FALSE) {
1308 mcf_utfwk_printf("Open OP-OTA test data(%s) FAIL!! \r\n", com_buff.ota_input.input_mode.file_path_name);
1309 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_OPEN_TLVOTA_FAIL(com_buff.ota_input.input_mode.file_path_name);
1310 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1311 com_buff.initial_ret = KAL_FALSE;
1312 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1313 return com_buff.initial_ret;
1314 }
1315 pFile = (mcf_tool_file_info_t *)(tlvota_file->buff);
1316 pItem_op = (mcf_tool_gid_tlvota_file_item_t *)(tlvota_file->buff + pFile->total_len);
1317
1318 if (pItem_op->tag_type == 1){
1319 strncpy(tag, &(pItem_op->buff_start), pItem_op->tag_len);
1320 com_buff.initial_ret = mcf_utfwk_spilt_tag(tag, &sbp_id, mcc, mnc);
1321 if (sbp_id == SBP_ID_INVALID){
1322 com_buff.is_general = KAL_TRUE;
1323 }
1324 tlvota_file->sbp_id = com_buff.ota_input.sbp_id;
1325 strncpy(tlvota_file->mcc, com_buff.ota_input.mcc, MAX_MCC_STR_LEN);
1326 strncpy(tlvota_file->mnc, com_buff.ota_input.mnc, MAX_MNC_STR_LEN);
1327 }else if(pItem_op->tag_type == 2){
1328 strncpy(iccid, &(pItem_op->buff_start), pItem_op->tag_len);
1329 strncpy(tlvota_file->iccid, iccid, 21);
1330 }
1331 execute_gen_op_ota = KAL_TRUE;
1332 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1333 }else{
1334 mcf_utfwk_printf("Read OP-OTA test data FAIL!! Fail to take read lock! \r\n");
1335 MD_TRC_MCF_TR_UTFWK_INITIAL_ENV_TAKE_TLV_OTA_READ_LOCK_FAIL();
1336 MCF_R_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1337 com_buff.initial_ret = KAL_FALSE;
1338 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1339 return com_buff.initial_ret;
1340 }
1341 }
1342 }
1343 }else if (com_buff.ota_input.input_op == MCF_UTFWK_OTA_VARIABLE_CONFIG){
1344 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
1345 MCF_W_LOCK_OBJECT(ota_file, mcf_enhmutex_g);
1346 com_buff.initial_ret = mcf_utfwk_generate_gid_ota_file(ota_file->buff, com_buff.ota_input, &(com_buff.is_general), &buff_size);
1347 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1348 if (com_buff.initial_ret == KAL_FALSE){
1349 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1350 }
1351 }else if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1352 MCF_W_LOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1353 com_buff.initial_ret = mcf_utfwk_generate_gid_ota_file(tlvota_file->buff, com_buff.ota_input, &(com_buff.is_general), &buff_size);
1354 MCF_W_UNLOCK_OBJECT(tlvota_file, mcf_enhmutex_g);
1355 if (com_buff.initial_ret == KAL_FALSE){
1356 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1357 }
1358 }
1359 }
1360
1361
1362 return com_buff.initial_ret;
1363}
1364
1365void mcf_utfwk_initial_dsbp_callback(MCF_UTFWK_DSBP_FUNC dsbp_func_ptr)
1366{
1367 mcf_utfwk_printf("Start!!\r\n");
1368 MD_TRC_MCF_TR_UTFWK_INITIAL_DSBP_CALLBACK_START();
1369 com_buff.utfwk_dsbp_func_ptr = dsbp_func_ptr;
1370}
1371
1372void mcf_utfwk_execute()
1373{
1374 nvram_ltable_entry_struct lid_info = {0};
1375 sbp_reconfig_custom_param_struct sbp_reconfig_custom_param;
1376 mcf_ota_result_e mcf_ret;
1377
1378 mcf_utfwk_printf("Start! OTA type(%d), SIM(%d)\r\n", com_buff.ota_input.ota_type, com_buff.ota_input.sim_id);
1379 MD_TRC_MCF_TR_UTFWK_EXECUTE_START(com_buff.ota_input.ota_type, com_buff.ota_input.sim_id);
1380 if (com_buff.initial_ret == KAL_FALSE){
1381 mcf_utfwk_printf("Initial env is fail, ret(%d)\r\n", com_buff.initial_ret);
1382 MD_TRC_MCF_TR_UTFWK_EXECUTE_INITIAL_ENV_FAIL(com_buff.initial_ret);
1383 ASSERT(0);
1384 }
1385
1386 if(com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
1387 mcf_ret = mcf_do_ota_full();
1388 if (mcf_ret != MCF_OTA_R_SUCCESS) {
1389 mcf_utfwk_printf("Update default OTA FAIL!! ret(%d) \r\n", mcf_ret);
1390 MD_TRC_MCF_TR_UTFWK_EXECUTE_UPDATE_DEFAULT_OTA_FAIL(mcf_ret);
1391 ASSERT(0);
1392 }else{
1393 execute_ota = KAL_FALSE;
1394 return;
1395 }
1396
1397 }else if(com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1398 if (!(com_buff.utfwk_dsbp_func_ptr)){
1399 MD_TRC_MCF_TR_UTFWK_EXECUTE_NOT_REGISTER_DSBP_CALLBACK();
1400 mcf_utfwk_printf("Not register DSBP callback function!!! \r\n");
1401 return;
1402 }
1403 sbp_reconfig_custom_param.sbp_id = com_buff.ota_input.sbp_id;
1404 sbp_reconfig_custom_param.is_in_dynamic_sbp = KAL_TRUE;
1405 sbp_reconfig_custom_param.sbp_sub_id = 0;
1406 sbp_reconfig_custom_param.is_boot_up = KAL_FALSE;
1407 sbp_reconfig_custom_param.trans_id = 250;
1408 sbp_reconfig_custom_param.ps_id = l4c_gemini_get_switched_sim_id(com_buff.ota_input.sim_id);
1409 kal_mem_set(sbp_reconfig_custom_param.mcc, 0, MAX_MCC_STR_LEN);
1410 kal_mem_set(sbp_reconfig_custom_param.mnc, 0, MAX_MNC_STR_LEN);
1411 kal_mem_set(sbp_reconfig_custom_param.iccid, 0, 21);
1412 kal_mem_cpy(sbp_reconfig_custom_param.mcc, com_buff.ota_input.mcc, MAX_MCC_STR_LEN);
1413 kal_mem_cpy(sbp_reconfig_custom_param.mnc, com_buff.ota_input.mnc, MAX_MNC_STR_LEN);
1414 kal_mem_cpy(sbp_reconfig_custom_param.iccid, com_buff.ota_input.iccid, 21);
1415
1416 if (com_buff.utfwk_dsbp_func_ptr(&sbp_reconfig_custom_param) == KAL_FALSE){
1417 MD_TRC_MCF_TR_UTFWK_EXECUTE_UPDATE_OP_OTA_FAIL(KAL_FALSE);
1418 mcf_utfwk_printf("Update OP-OTA FAIL!! ret(%d) \r\n", KAL_FALSE);
1419 ASSERT(0);
1420 }
1421 execute_op_ota = KAL_TRUE;
1422 execute_gen_op_ota = KAL_TRUE;
1423 }
1424
1425}
1426kal_bool mcf_utfwk_dump_result(kal_uint16 lid, kal_uint16 rec_id, mcf_utfwk_dump_type_enum dump_type, void *dump_buffer, kal_uint32 size, kal_uint16 gid, kal_char* array_index)
1427{
1428 nvram_ltable_entry_struct lid_info = {0};
1429 nvram_errno_enum nvram_api_ret;
1430 kal_uint16 item_byte_offset;
1431 kal_uint16 item_bit_offset;
1432 kal_uint32 item_size;
1433 mcf_custom_dump_param_struct dump_para;
1434 kal_uint32 lid_size;
1435 kal_uint32 i;
1436 kal_uint32 j = 0;
1437 kal_uint32 n = 1;
1438 kal_uint32 read_len = 0;
1439 kal_bool invalid_arr_size = KAL_FALSE;
1440 kal_bool next_level_array = KAL_FALSE;
1441 kal_bool is_found = KAL_FALSE;
1442 kal_bool ret = KAL_TRUE;
1443 kal_uint8 *buffer = (kal_uint8*)dump_buffer;
1444 kal_char array_tag[MCF_FILE_MAX_ARRAY_TAG_LEN]={0};
1445 kal_bool item_is_bit = KAL_FALSE;
1446 kal_uint16 item_lid;
1447
1448 if ((!(buffer && (size > 0))) && rec_id == 0) {
1449 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_INVALID_PARA(lid, buffer, size);
1450 mcf_utfwk_printf("Invalid parameters!! LID(%d), buffer(%x), size(%d) \r\n", lid, buffer, size);
1451 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1452 ret = KAL_FALSE;
1453 return ret;
1454 }
1455
1456 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_START(dump_type, com_buff.ota_input.ota_type, lid, rec_id, com_buff.ota_input.sim_id);
1457 mcf_utfwk_printf("Start! dump type(%d), OTA type(%d), LID(%d), Record(%d), SIM(%d)\r\n", dump_type, com_buff.ota_input.ota_type, lid, rec_id, com_buff.ota_input.sim_id);
1458
1459 kal_mem_set(&dump_para, 0, sizeof(mcf_custom_dump_param_struct));
1460
1461
1462 nvram_api_ret = nvram_external_get_lid_info(lid, &lid_info);
1463 if (nvram_api_ret != NVRAM_ERRNO_SUCCESS) {
1464 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_GET_LID_INFO_FAIL(lid, nvram_api_ret);
1465 mcf_utfwk_printf("Get LID information FAIL!! lid(%d), nvram_ret(%d) \r\n", lid, nvram_api_ret);
1466 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1467 ret = KAL_FALSE;
1468 return ret;
1469 }
1470
1471 kal_mem_set(mcf_dump_buffer, 0, lid_info.size);
1472
1473 dump_para.sbp_id = com_buff.ota_input.sbp_id;
1474 kal_mem_cpy(&(dump_para.mcc), &(com_buff.ota_input.mcc), MAX_MCC_STR_LEN);
1475 kal_mem_cpy(&(dump_para.mnc), &(com_buff.ota_input.mnc), MAX_MNC_STR_LEN);
1476 kal_mem_cpy(&(dump_para.iccid), &(com_buff.ota_input.iccid), 21);
1477 dump_para.size = &lid_size;
1478
1479 for (i = 0; i < mcf_dump_param_tbl_num; i++) {
1480 if ( (mcf_dump_param_tbl[i].lid == lid) ) {
1481 is_found = KAL_TRUE;
1482 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
1483
1484 dump_para.type = MCF_TYPE_OTA;
1485 dump_para.record_idx = rec_id;
1486
1487 if ((mcf_dump_param_tbl[i].ntfy_type & MCF_DUMP_NTFY_TYPE_OTA) != 0) {
1488
1489 dump_para.lid = mcf_dump_param_tbl[i].lid;
1490 dump_para.buffer = mcf_dump_buffer;
1491 *(dump_para.size) = 0;
1492
1493 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_CALLBACK(dump_para.lid, mcf_dump_param_tbl[i].ntfy_type, dump_para.record_idx);
1494 mcf_utfwk_printf("Read default OTA by callback. LID(%d), type(%d), record_id(%d) \r\n", dump_para.lid, mcf_dump_param_tbl[i].ntfy_type, dump_para.record_idx);
1495
1496 ret = mcf_dump_param_tbl[i].dump_func_ptr(&dump_para);
1497 if ( (ret == KAL_FALSE) || (*(dump_para.size) != lid_info.size) ) {
1498 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_DUMP_ERROR(mcf_dump_param_tbl[i].lid, ret, lid_info.size, *(dump_para.size));
1499 mcf_utfwk_printf("Read OTA dump LID(%d) FAIL!! ret(%d), lid_size(%d), return_size(%d) \r\n", mcf_dump_param_tbl[i].lid, ret, lid_info.size, *(dump_para.size));
1500 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1501 ret = KAL_FALSE;
1502 return ret;
1503 }
1504 } else {
1505 /* If not register callback */
1506 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_NVRAM(lid_info.LID, mcf_dump_param_tbl[i].ntfy_type, dump_para.record_idx);
1507 mcf_utfwk_printf("Read default OTA by NVRAM. LID(%d), type(%d), record_id(%d) \r\n", lid_info.LID, mcf_dump_param_tbl[i].ntfy_type, dump_para.record_idx);
1508 dump_para.buffer = mcf_dump_buffer;
1509 if ( !nvram_external_read_data(lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size) ) {
1510 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_NVRAM_FAIL(mcf_dump_param_tbl[i].lid, dump_para.record_idx, dump_para.buffer, lid_info.size);
1511 mcf_utfwk_printf("Read default OTA by NVRAM FAIL!! LID(%d), record_idx(%d), buffer(0x%x), size(%d) \r\n", mcf_dump_param_tbl[i].lid, dump_para.record_idx, dump_para.buffer, lid_info.size);
1512 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1513 ret = KAL_FALSE;
1514 return ret;
1515 }
1516 }
1517 }else if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1518 dump_para.type = MCF_TYPE_OTA_BY_OP;
1519 dump_para.record_idx = 1;
1520 dump_para.ps_id = l4c_gemini_get_switched_sim_id(com_buff.ota_input.sim_id);
1521
1522 mcf_utfwk_printf("Read OP OTA. LID(%d), record_id(%d), ps_id(%d), sbp_id(%d), mcc(%s), mnc(%s), iccid(%s) \r\n", dump_para.lid, dump_para.record_idx, dump_para.ps_id, dump_para.sbp_id, dump_para.mnc, dump_para.mcc, dump_para.iccid);
1523 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_USIR(dump_para.lid, dump_para.record_idx, dump_para.ps_id, dump_para.sbp_id, dump_para.mnc, dump_para.mcc, dump_para.iccid);
1524
1525 if ((mcf_dump_param_tbl[i].ntfy_type & MCF_DUMP_NTFY_TYPE_OTA_BY_OP) != 0) {
1526 dump_para.lid = mcf_dump_param_tbl[i].lid;
1527 dump_para.buffer = mcf_dump_buffer;
1528 *(dump_para.size) = 0;
1529
1530 mcf_utfwk_printf("Read OP OTA by callback. LID(%d), type(%d), record_id(%d), sbp_id(%d), mnc(%s), mcc(%s), iccid(%s) \r\n", dump_para.lid, dump_para.type, dump_para.record_idx, dump_para.sbp_id, dump_para.mnc, dump_para.mcc, dump_para.iccid);
1531 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_CALLBACK_USIR(dump_para.lid, dump_para.type, dump_para.record_idx, dump_para.sbp_id, dump_para.mnc, dump_para.mcc, dump_para.iccid);
1532
1533 ret = mcf_dump_param_tbl[i].dump_func_ptr(&dump_para);
1534 if ( (ret == KAL_FALSE) || (*(dump_para.size) != lid_info.size) ) {
1535 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_DUMP_FAIL(mcf_dump_param_tbl[i].lid, ret, lid_info.size, *(dump_para.size));
1536 mcf_utfwk_printf("Read OP OTA dump LID(%d) FAIL!! ret(%d), lid_size(%d), return_size(%d) \r\n", mcf_dump_param_tbl[i].lid, ret, lid_info.size, *(dump_para.size));
1537 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1538 ret = KAL_FALSE;
1539 return ret;
1540 }
1541 } else {
1542 /* If not register callback */
1543 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_NVRAM(dump_para.lid, mcf_dump_param_tbl[i].ntfy_type);
1544 mcf_utfwk_printf("Read OP OTA by NVRAM. LID(%d), type(%d) \r\n", dump_para.lid, mcf_dump_param_tbl[i].ntfy_type);
1545 dump_para.buffer = mcf_dump_buffer;
1546 if ( !nvram_external_read_data(lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size) ) {
1547 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_NVRAM_FAIL(mcf_dump_param_tbl[i].lid, dump_para.record_idx, dump_para.buffer, lid_info.size);
1548 mcf_utfwk_printf("Read OP OTA by NVRAM FAIL!! LID(%d), record_idx(%d), buffer(0x%x), size(%d) \r\n", mcf_dump_param_tbl[i].lid, dump_para.record_idx, dump_para.buffer, lid_info.size);
1549 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1550 ret = KAL_FALSE;
1551 return ret;
1552 }
1553 }
1554 }
1555 break;
1556 }
1557 }
1558
1559 if (is_found == KAL_FALSE){
1560 /* If not register callback */
1561 if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA){
1562
1563 dump_para.type = MCF_TYPE_OTA;
1564 dump_para.record_idx = rec_id;
1565
1566 mcf_utfwk_printf("Read default OTA by NVRAM (non-register callback). LID(%d), record_id(%d) \r\n", lid, rec_id);
1567 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_NVRAM_NOT_CALLBACK(lid, rec_id);
1568 dump_para.buffer = mcf_dump_buffer;
1569 if ( !nvram_external_read_data(lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size) ) {
1570 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OTA_NVRAM_NOT_CALLBACK_FAIL(lid, rec_id, dump_para.buffer, lid_info.size);
1571 mcf_utfwk_printf("Read default OTA by NVRAM FAIL (non-register callback)!!. LID(%d), record_idx(%d), buffer(0x%x), size(%d) \r\n", com_buff.ota_input.lid, rec_id, dump_para.buffer, lid_info.size);
1572 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1573 ret = KAL_FALSE;
1574 return ret;
1575 }
1576
1577 }else if (com_buff.ota_input.ota_type == MCF_UTFWK_ATTR_OTA_BY_OP){
1578 dump_para.type = MCF_TYPE_OTA_BY_OP;
1579 dump_para.record_idx = 1;
1580 dump_para.ps_id = l4c_gemini_get_switched_sim_id(com_buff.ota_input.sim_id);
1581
1582 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_NVRAM_NOT_CALLBACK_USIR(lid, dump_para.ps_id, dump_para.sbp_id, dump_para.mnc, dump_para.mcc, dump_para.iccid);
1583 mcf_utfwk_printf("Read OP OTA by NVRAM (non-register callback). LID(%d) ps_id(%d), sbp_id(%d), mcc(%s), mnc(%s), iccid(%s) \r\n", lid, dump_para.ps_id, dump_para.sbp_id, dump_para.mcc, dump_para.mnc, dump_para.iccid);
1584 dump_para.buffer = mcf_dump_buffer;
1585 if ( !nvram_external_read_data(lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size) ) {
1586 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_OPOTA_NVRAM_NOT_CALLBACK_FAIL(lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size);
1587 mcf_utfwk_printf("Read OP OTA by NVRAM FAIL (non-register callback)!! LID(%d), record_idx(%d), buffer(0x%x), size(%d) \r\n", lid_info.LID, dump_para.record_idx, dump_para.buffer, lid_info.size);
1588 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1589 ret = KAL_FALSE;
1590 return ret;
1591 }
1592
1593 }
1594
1595 }
1596
1597
1598 if(dump_type == MCF_UTFWK_DUMP_LID){
1599 if (size != lid_info.size) {
1600 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_INVALID_SIZE(size, lid_info.size);
1601 mcf_utfwk_printf("Invalid buffer_size(%d)!! record_size(%d) \r\n", size, lid_info.size);
1602 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1603 ret = KAL_FALSE;
1604 return ret;
1605 }
1606 kal_mem_cpy(buffer, mcf_dump_buffer, size);
1607 return ret;
1608 }else if (dump_type == MCF_UTFWK_DUMP_ONE_VARIABLE){
1609 kal_mem_set(array_tag, 0, MCF_FILE_MAX_ARRAY_TAG_LEN);
1610 if (gid == 0){
1611 mcf_utfwk_printf("Dump one variable, Invalid GID(%d)!!! \r\n", gid);
1612 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_INVALID_GID(gid);
1613 ret = KAL_FALSE;
1614 return ret;
1615 }else{
1616 if (array_index != NULL){
1617 mcf_utfwk_printf("GID(%d), array index(%s) \r\n", gid, array_index);
1618 strcpy(array_tag, array_index);
1619 }else{
1620 mcf_utfwk_printf("GID(%d) \r\n", gid);
1621 strcpy(array_tag, "");
1622 }
1623 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_DUMP_ONE_VARIABLE_START(gid, array_tag);
1624 }
1625
1626 /* Find GID corresponding LID */
1627 item_lid = mcf_find_gid_return_lid_num(gid);
1628 if (item_lid == 65535){
1629 //-1(65535) means not found
1630 mcf_utfwk_printf("Can not find this gid(%d) \r\n", gid);
1631 ret = KAL_FALSE;
1632 return ret;
1633 }
1634
1635 if (item_lid != lid){
1636 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_INVALID_LID(item_lid, gid, lid);
1637 mcf_utfwk_printf("LID(%d) of GID(%d) item is not match given LID(%d) \r\n", item_lid, gid, lid);
1638 ret = KAL_FALSE;
1639 return ret;
1640 }
1641
1642 if(mcf_find_gid_offset(gid, array_tag, &item_lid, &item_byte_offset, &item_bit_offset, &item_size, &item_is_bit) == KAL_FALSE){
1643 //Cannot find the tag
1644 kal_mem_set(array_tag, 0, sizeof(kal_uint8) *256);
1645 strcpy(array_tag, array_index);
1646 mcf_utfwk_printf("Can not find this gid(%d), array_index(%s) \r\n", gid, array_tag);
1647 ret = KAL_FALSE;
1648 return ret;
1649 }
1650
1651 if (item_size > size){
1652 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_INVALID_SIZE(size, item_size);
1653 mcf_utfwk_printf("Invalid buffer_size(%d)!! record_size(%d) \r\n", size, item_size);
1654 ret = KAL_FALSE;
1655 return ret;
1656 }
1657
1658 kal_mem_set(buffer, 0, lid_info.size);
1659
1660 if (item_is_bit == KAL_FALSE){
1661 kal_mem_cpy(buffer, (mcf_dump_buffer + item_byte_offset), item_size);
1662 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_VARIABLE_BYTE(buffer, item_size);
1663 mcf_utfwk_printf("Read variable by byte. value(%s), len(%d) \r\n", buffer, item_size);
1664 }else{
1665 if (item_size <= 8){
1666 kal_uint8 bit_value = *(mcf_dump_buffer + item_byte_offset);
1667 kal_uint8 bit_mask = (kal_uint8)MCF_GEN_BIT_MASK(item_size);
1668 bit_value &= (bit_mask << item_bit_offset);
1669 bit_value = ((kal_uint8)bit_value >> item_bit_offset);
1670
1671 size = 1;
1672 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_VARIABLE_BIT(bit_value, size);
1673 mcf_utfwk_printf("Read variable by bit. value(%d), len(%d) \r\n", bit_value, size);
1674 kal_mem_cpy(buffer, &bit_value, size);
1675 }else if (item_size > 8 && item_size <= 16){
1676 kal_uint16 bit_value = *(mcf_dump_buffer + item_byte_offset);
1677 kal_uint16 bit_mask = (kal_uint8)MCF_GEN_BIT_MASK(item_size);
1678 bit_value &= (bit_mask << item_bit_offset);
1679 bit_value = ((kal_uint8)bit_value >> item_bit_offset);
1680
1681 size = 2;
1682 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_VARIABLE_BIT(bit_value, size);
1683
1684 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_VARIABLE_BIT(bit_value, size);
1685 mcf_utfwk_printf("Read variable by bit. value(%d), len(%d) \r\n", bit_value, size);
1686 kal_mem_cpy(buffer, &bit_value, size);
1687 }else if (item_size > 16 && item_size <= 32){
1688 kal_uint32 bit_value = *(mcf_dump_buffer + item_byte_offset);
1689 kal_uint32 bit_mask = (kal_uint8)MCF_GEN_BIT_MASK(item_size);
1690 bit_value &= (bit_mask << item_bit_offset);
1691 bit_value = ((kal_uint8)bit_value >> item_bit_offset);
1692 size = 4;
1693 MD_TRC_MCF_TR_UTFWK_DUMP_RESULT_READ_VARIABLE_BIT(bit_value, size);
1694 mcf_utfwk_printf("Read variable by bit. value(%d), len(%d) \r\n", bit_value, size);
1695 kal_mem_cpy(buffer, &bit_value, size);
1696 }
1697 }
1698 }
1699
1700 return ret;
1701
1702}
1703void mcf_utfwk_reset()
1704{
1705 mcf_t *pMcf = mcf_get_instance();
1706 nvram_errno_enum nvram_api_ret;
1707 nvram_ltable_entry_struct lid_info = {0};
1708 mcf_ota_file_t *ota_file = &(pMcf->ota_file);
1709 kal_uint32 i;
1710
1711 MD_TRC_MCF_TR_UTFWK_RESET_START();
1712 mcf_utfwk_printf("Reset Start!!\r\n");
1713
1714 MCF_W_LOCK_OBJECT(ota_file, mcf_enhmutex_g);
1715 if (ota_file) {
1716 kal_mem_set(ota_file->buff, 0, sizeof(kal_uint8) * MCF_MAX_OTA_FILE_SIZE);
1717 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1718 } else {
1719 MD_TRC_MCF_TR_UTFWK_RESET_TAKE_WRITE_LOCK_FAIL();
1720 mcf_utfwk_printf("Take write lock FAIL!!\r\n");
1721 MCF_W_UNLOCK_OBJECT(ota_file, mcf_enhmutex_g);
1722 ASSERT(0);
1723 }
1724
1725 for(i = 0; i < com_buff.ota_input.lid_cnt; i++){
1726 kal_mem_set(&lid_info, 0, sizeof(nvram_ltable_entry_struct));
1727 nvram_api_ret = nvram_external_get_lid_info(com_buff.ota_input.lid[i], &lid_info);
1728 if (nvram_api_ret != NVRAM_ERRNO_SUCCESS) {
1729 mcf_utfwk_printf("Fail to get LID information!! LID(%d), nvram_api_ret(%d) \r\n", com_buff.ota_input.lid[i], nvram_api_ret);
1730 MD_TRC_MCF_TR_UTFWK_RESET_GET_LID_INFO_FAIL(com_buff.ota_input.lid[i], nvram_api_ret);
1731 ASSERT(0);
1732
1733 }
1734 /* Reset LID to default value */
1735 if((lid_info.attr & NVRAM_ATTR_MCF_OTA) != 0) {
1736 MD_TRC_MCF_TR_UTFWK_RESET_RESET_LID(com_buff.ota_input.lid[i]);
1737 if ( !nvram_external_reset_data(com_buff.ota_input.lid[i], 1, lid_info.total_records) ) {
1738 MD_TRC_MCF_TR_UTFWK_RESET_RESET_LID_FAIL(com_buff.ota_input.lid[i], lid_info.total_records);
1739 mcf_utfwk_printf("Fail to reset LID!! LID(%d), total_record(%d) \r\n", com_buff.ota_input.lid[i], lid_info.total_records);
1740 ASSERT(0);
1741 }
1742
1743 }
1744 }
1745 kal_mem_set(&com_buff, 0, sizeof(mcf_utfwk_common_t));
1746 execute_ota = KAL_FALSE;
1747 execute_op_ota = KAL_FALSE;
1748 execute_gen_op_ota = KAL_FALSE;
1749
1750 /* UT FWK is done */
1751 is_ut_fwk = KAL_FALSE;
1752 kal_give_enh_mutex(mcf_utfwk_enhmutex_g);
1753
1754}
1755
1756void mcf_utfwk_ilm_initial_env(ilm_struct *ilm)
1757{
1758 mcf_utfwk_initial_env_req_struct *req = (mcf_utfwk_initial_env_req_struct *)ilm->local_para_ptr;
1759 mcf_utfwk_initial_env_resp_struct *resp;
1760
1761 resp = (mcf_utfwk_initial_env_resp_struct *)construct_local_para(sizeof(mcf_utfwk_initial_env_resp_struct), TD_RESET);
1762 if (!resp) {
1763 ASSERT(0);
1764 }
1765
1766 resp->result = mcf_utfwk_initial_env(req->ota_input);
1767
1768
1769 /* Send process result to ATCI */
1770 msg_send6(MOD_MCF, /* src_mod_id */
1771 ilm->src_mod_id, /* dest_mod_id */
1772 MCF_UTFWK_SAP, /* sap_id */
1773 MSG_ID_MCF_UTFWK_INITIAL_ENV_RESP, /* msg_id */
1774 (local_para_struct*)resp, /* local_para_ptr */
1775 NULL); /* peer_buff_ptr */
1776
1777}
1778
1779void mcf_utfwk_ilm_initial_dsbp_callback(ilm_struct *ilm)
1780{
1781 mcf_utfwk_initial_dsbp_callback_req_struct *req = (mcf_utfwk_initial_dsbp_callback_req_struct *)ilm->local_para_ptr;
1782
1783 mcf_utfwk_initial_dsbp_callback(req->utfwk_dsbp_func_ptr);
1784
1785
1786 /* Send process result to ATCI */
1787 msg_send6(MOD_MCF, /* src_mod_id */
1788 ilm->src_mod_id, /* dest_mod_id */
1789 MCF_UTFWK_SAP, /* sap_id */
1790 MSG_ID_MCF_UTFWK_INITIAL_DSBP_CALLBACK_RESP, /* msg_id */
1791 NULL, /* local_para_ptr */
1792 NULL); /* peer_buff_ptr */
1793
1794}
1795
1796void mcf_utfwk_ilm_execute(ilm_struct *ilm)
1797{
1798 mcf_utfwk_execute();
1799
1800 /* Send process result to ATCI */
1801 msg_send6(MOD_MCF, /* src_mod_id */
1802 ilm->src_mod_id, /* dest_mod_id */
1803 MCF_UTFWK_SAP, /* sap_id */
1804 MSG_ID_MCF_UTFWK_EXECUTE_RESP, /* msg_id */
1805 NULL, /* local_para_ptr */
1806 NULL); /* peer_buff_ptr */
1807
1808}
1809
1810void mcf_utfwk_ilm_dump_result(ilm_struct *ilm)
1811{
1812 mcf_utfwk_dump_result_req_struct *req = (mcf_utfwk_dump_result_req_struct *)ilm->local_para_ptr;
1813 mcf_utfwk_dump_result_resp_struct *resp;
1814
1815 resp = (mcf_utfwk_dump_result_resp_struct *)construct_local_para(sizeof(mcf_utfwk_dump_result_resp_struct), TD_RESET);
1816 if (!resp) {
1817 ASSERT(0);
1818 }
1819
1820 resp->result = mcf_utfwk_dump_result(req->lid, req->rec_id, req->dump_type, req->buffer, req->size, req->gid, req->array_index);
1821
1822 /* Send process result to ATCI */
1823 msg_send6(MOD_MCF, /* src_mod_id */
1824 ilm->src_mod_id, /* dest_mod_id */
1825 MCF_UTFWK_SAP, /* sap_id */
1826 MSG_ID_MCF_UTFWK_DUMP_RESULT_RESP, /* msg_id */
1827 (local_para_struct*)resp, /* local_para_ptr */
1828 NULL); /* peer_buff_ptr */
1829
1830}
1831
1832void mcf_utfwk_ilm_reset(ilm_struct *ilm)
1833{
1834 mcf_utfwk_reset();
1835
1836 /* Send process result to ATCI */
1837 msg_send6(MOD_MCF, /* src_mod_id */
1838 ilm->src_mod_id, /* dest_mod_id */
1839 MCF_UTFWK_SAP, /* sap_id */
1840 MSG_ID_MCF_UTFWK_RESET_RESP, /* msg_id */
1841 NULL, /* local_para_ptr */
1842 NULL); /* peer_buff_ptr */
1843
1844}