Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / 1eb8f53f94c145708b5ea2c6b9b96ea3d613f607 / . / mcu / service / nvram / src / nvram_pseudo_merge.c
blob: c4ba1be173b686812ab6368aa9b90ec6d2215b80 [file] [log] [blame]
rjw6c1fd8f2022-11-30 14:33:01 +0800[diff] [blame]1/*****************************************************************************
2* Copyright Statement:
3* --------------------
4* This software is protected by Copyright and the information contained
5* herein is confidential. The software may not be copied and the information
6* contained herein may not be used or disclosed except with the written
7* permission of MediaTek Inc. (C) 2005
8*
9* BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
10* THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
11* RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
12* AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
13* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
14* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
15* NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
16* SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
17* SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
18* THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
19* NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
20* SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
21*
22* BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
23* LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
24* AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
25* OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
26* MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
27*
28* THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
29* WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
30* LAWS PRINCIPLES. ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
31* RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
32* THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
33*
34*****************************************************************************/
35
36/*****************************************************************************
37 *
38 * Filename:
39 * ---------
40 * nvram_pseudo_merge.c
41 *
42 * Project:
43 * --------
44 * MAUI
45 *
46 * Description:
47 * ------------
48 * NVRAM feature: pseudo merge
49 *
50 * Author:
51 * -------
52 * -------
53 *
54 *============================================================================
55 * HISTORY
56 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
57 *------------------------------------------------------------------------------
58 * removed!
59 *
60 * removed!
61 * removed!
62 * removed!
63 *
64 * removed!
65 * removed!
66 * removed!
67 *
68 * removed!
69 * removed!
70 * removed!
71 *
72 * removed!
73 * removed!
74 *
75 * removed!
76 * removed!
77 *
78 * removed!
79 * removed!
80 * removed!
81 *
82 * removed!
83 * removed!
84 * removed!
85 *
86 * removed!
87 * removed!
88 * removed!
89 *
90 * removed!
91 * removed!
92 * removed!
93 * removed!
94 * removed!
95 * removed!
96 * removed!
97 *
98 * removed!
99 * removed!
100 * removed!
101 *
102 * removed!
103 * removed!
104 * removed!
105 *
106 * removed!
107 * removed!
108 * removed!
109 *
110 * removed!
111 * removed!
112 * removed!
113 *
114 * removed!
115 * removed!
116 * removed!
117 *
118 * removed!
119 * removed!
120 * removed!
121 *
122 * removed!
123 * removed!
124 * removed!
125 *
126 * removed!
127 * removed!
128 * removed!
129 *
130 * removed!
131 * removed!
132 * removed!
133 *
134 * removed!
135 * removed!
136 * removed!
137 *
138 * removed!
139 * removed!
140 * removed!
141 *
142 * removed!
143 * removed!
144 * removed!
145 *
146 * removed!
147 * removed!
148 * removed!
149 *
150 * removed!
151 * removed!
152 * removed!
153 *
154 * removed!
155 * removed!
156 * removed!
157 *
158 * removed!
159 * removed!
160 * removed!
161 *
162 * removed!
163 * removed!
164 * removed!
165 *
166 * removed!
167 * removed!
168 * removed!
169 *
170 * removed!
171 * removed!
172 * removed!
173 *
174 * removed!
175 * removed!
176 * removed!
177 *
178 * removed!
179 * removed!
180 * removed!
181 *
182 * removed!
183 * removed!
184 * removed!
185 *
186 * removed!
187 * removed!
188 * removed!
189 *
190 * removed!
191 * removed!
192 * removed!
193 *
194 * removed!
195 * removed!
196 * removed!
197 *
198 * removed!
199 * removed!
200 * removed!
201 *
202 * removed!
203 * removed!
204 * removed!
205 *
206 * removed!
207 * removed!
208 * removed!
209 *
210 * removed!
211 * removed!
212 * removed!
213 * removed!
214 *
215 * removed!
216 * removed!
217 * removed!
218 *
219 * removed!
220 *------------------------------------------------------------------------------
221 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
222 *============================================================================
223 ****************************************************************************/
224
225/*****************************************************************************
226 * Include
227 *****************************************************************************/
228#ifdef __NVRAM_PSEUDO_MERGE__
229
230#include "string.h"
231#include "kal_general_types.h"
232#include "kal_public_api.h"
233#include "kal_trace.h"
234#include "nvram_pseudo_merge.h"
235
236
237/*
238 * FS head file
239 */
240#include "fs_type.h"
241#include "fs_func.h"
242#include "fs_errcode.h"
243
244#include "nvram_main.h"
245
246/***********************************************************
247 * Static Declaration
248 ***********************************************************/
249/*
250 * Define local variable here
251 */
252static head_info_entry *g_nvram_move_package_lid;
253static kal_bool is_need_move = KAL_FALSE;
254static kal_uint16 total_package_lid = 0;
255static head_info_struct g_head_info_file;
256
257/***********************************************************
258 * Global Variable
259 **********************************************************/
260
261/***********************************************************
262 * Global Function
263 **********************************************************/
264extern void *kal_tmp_mem_alloc(kal_uint32 size);
265extern void kal_tmp_mem_free(void *mem_ptr);
266
267/*****************************************************************************
268 * FUNCTION
269 * nvram_make_filename_compare
270 * DESCRIPTION
271 * PARAMETERS
272 * RETURNS
273 *****************************************************************************/
274void nvram_make_filename_compare(kal_char* buf, kal_char* prefix, kal_char* verno)
275{
276 buf[0] = prefix[0];
277 buf[1] = prefix[1];
278 buf[2] = prefix[2];
279 buf[3] = prefix[3];
280 buf[4] = verno[0];
281 buf[5] = verno[1];
282 buf[6] = verno[2];
283 buf[7] = '\0';
284};
285/*****************************************************************************
286 * FUNCTION
287 * nvram_make_package_filename
288 * DESCRIPTION
289 * PARAMETERS
290 * RETURNS
291 *****************************************************************************/
292void nvram_make_package_filename(kal_char* buf, kal_char M)
293{
294 buf[0] = 'P';
295 buf[1] = 'A';
296 buf[2] = 'C';
297 buf[3] = 'K';
298 buf[4] = M;
299 buf[5] = 'L';
300 buf[6] = 'I';
301 buf[7] = 'D';
302 buf[8] = '\0';
303};
304
305/*****************************************************************************
306 * FUNCTION
307 * nvram_make_package_info_filename
308 * DESCRIPTION
309 * PARAMETERS
310 * RETURNS
311 *****************************************************************************/
312void nvram_make_package_info_filename(kal_char* buf, kal_char M)
313{
314 buf[0] = 'I';
315 buf[1] = 'N';
316 buf[2] = 'F';
317 buf[3] = 'O';
318 buf[4] = M;
319 buf[5] = 'L';
320 buf[6] = 'I';
321 buf[7] = 'D';
322 buf[8] = '\0';
323};
324
325/*****************************************************************************
326 * FUNCTION
327 * naram_make_temp_filename
328 * DESCRIPTION
329 * PARAMETERS
330 * RETURNS
331 *****************************************************************************/
332void naram_make_temp_filename(kal_char* buf, kal_char M)
333{
334 buf[0] = 'T';
335 buf[1] = 'E';
336 buf[2] = 'M';
337 buf[3] = 'P';
338 buf[4] = M;
339 buf[5] = 'L';
340 buf[6] = 'I';
341 buf[7] = 'D';
342 buf[8] = '\0';
343};
344
345/*****************************************************************************
346 * FUNCTION
347 * nvram_sort_order_head_info
348 * DESCRIPTION
349 *
350 * PARAMETERS
351 * lid_info [?]
352 * info_index [IN] info_index [0, total_num - 1], <==> loop_index
353 * file_index [IN]
354 * RETURNS
355 *
356 *****************************************************************************/
357static kal_bool nvram_sort_order_head_info(LID_info_struct *lid_info, kal_uint16 info_index, nvram_lid_enum file_index)
358{
359 /*----------------------------------------------------------------*/
360 /* Local Variables */
361 /*----------------------------------------------------------------*/
362 head_info_entry headinfo_temp;
363 kal_uint32 temp;
364
365 /*----------------------------------------------------------------*/
366 /* Code Body */
367 /*----------------------------------------------------------------*/
368 headinfo_temp.file_offset = lid_info->file_offset;
369 headinfo_temp.record_size = lid_info->record_size;
370 headinfo_temp.total_records = lid_info->total_records;
371 headinfo_temp.area = lid_info->area;
372 headinfo_temp.LID = file_index;
373
374// NVRAM_BLOCKING_ASSERT(info_index <= total_package_lid, 0, 0, 0);
375
376 if (info_index == 0)
377 {
378 g_nvram_move_package_lid[0] = headinfo_temp;
379 }
380 else
381 {
382 for (temp = (kal_uint32)info_index; temp > 0; temp--)
383 {
384 if (headinfo_temp.file_offset < g_nvram_move_package_lid[temp - 1].file_offset) /* last one */
385 {
386 g_nvram_move_package_lid[temp] = headinfo_temp;
387 break;
388 }
389 else
390 {
391 g_nvram_move_package_lid[temp] = g_nvram_move_package_lid[temp - 1];
392 g_nvram_move_package_lid[temp - 1] = headinfo_temp;
393 }
394 }
395 }
396 return KAL_TRUE;
397}
398
399/*****************************************************************************
400 * FUNCTION
401 * nvram_compare_filename_chksum
402 * DESCRIPTION
403 * To judge which table (core/comm/cust) has been changed (add LID or del LID)
404 * By compare filename's chksum.
405 * PARAMETERS
406 * void
407 * RETURNS
408 * Success or Fail
409 *****************************************************************************/
410 static kal_bool nvram_compare_filename_chksum(head_info_struct *head_info)
411 {
412 /*----------------------------------------------------------------*/
413 /* Local Variables */
414 /*----------------------------------------------------------------*/
415
416 /*----------------------------------------------------------------*/
417 /* Code Body */
418 /*----------------------------------------------------------------*/
419
420 //for compatible with 10A & 11A, only use CORE variable after 11B
421 head_info->chksum_core += (head_info->chksum_comm + head_info->chksum_cust);
422 head_info->total_size_core += (head_info->total_size_comm + head_info->total_size_cust);
423
424 //for compatible with 10A & 11A, only use CORE variable after 11B
425 if ((head_info->chksum_core != g_head_info_file.chksum_core) ||
426 (head_info->total_size_core != g_head_info_file.total_size_core))
427 {
428 nvram_ptr->sw_status |= NVRAM_SW_PACKAGE_CHANGE;
429 if(nvram_ee_info != NULL){
430 nvram_ee_info->nvram_init_context.sw_status = nvram_ptr->sw_status;
431 }
432 }
433
434 return KAL_TRUE;
435 }
436
437/*****************************************************************************
438 * FUNCTION
439 * nvram_create_package_file
440 * DESCRIPTION
441 * To create package_file and information_package_file.
442 * PARAMETERS
443 * M_name [IN]
444 * RETURNS
445 * Success or Fail
446 *****************************************************************************/
447kal_bool nvram_create_package_file(kal_char M_name)
448{
449 /*----------------------------------------------------------------*/
450 /* Local Variables */
451 /*----------------------------------------------------------------*/
452 NVRAM_FILE_NAME nvramname;
453
454 nvram_drv_status_enum drv_status;
455
456 /*----------------------------------------------------------------*/
457 /* Code Body */
458 /*----------------------------------------------------------------*/
459 /* open package file/backup file,if no exist, create it */
460 nvram_make_package_filename(nvramname, M_name);
461
462 drv_status = nvram_drv_fat_write(
463 nvramname,
464 NVRAM_NVD_DATA,
465 0,
466 1,
467 1,
468 sizeof(head_info_struct),
469 (kal_uint8*) &g_head_info_file,
470 NVRAM_ATTR_AVERAGE,
471 KAL_TRUE);
472 if (drv_status != NVRAM_DRV_OK)
473 {
474 return KAL_FALSE;
475 }
476
477 /* open information file/backup file,if no exist, create it */
478 nvram_make_package_info_filename(nvramname, M_name);
479
480 drv_status = nvram_drv_fat_write(
481 nvramname,
482 NVRAM_NVD_DATA,
483 0,
484 1,
485 1,
486 sizeof(head_info_struct),
487 (kal_uint8*) &g_head_info_file,
488 NVRAM_ATTR_AVERAGE,
489 KAL_TRUE);
490 if (drv_status != NVRAM_DRV_OK)
491 {
492 return KAL_FALSE;
493 }
494
495 return KAL_TRUE;
496}
497
498
499/*****************************************************************************
500 * FUNCTION
501 * nvram_open_package_file
502 * DESCRIPTION
503 * To open package_file and backup_package_file.
504 * PARAMETERS
505 * nvramname [IN]
506 * openOption [IN]
507 * RETURNS
508 * Success or Fail
509 *****************************************************************************/
510static kal_bool nvram_open_package_file(kal_char *nvramname, kal_uint32 openOption)
511{
512 /*----------------------------------------------------------------*/
513 /* Local Variables */
514 /*----------------------------------------------------------------*/
515 kal_wchar filename[NVRAM_MAX_PATH_LEN];
516
517 FS_HANDLE hFile = 0;
518 kal_int32 result = FS_NO_ERROR;
519 /*----------------------------------------------------------------*/
520 /* Code Body */
521 /*----------------------------------------------------------------*/
522 nvram_query_file_name(NVRAM_NVD_DATA, nvramname, filename);
523 NVRAM_FS_START_EX(FS_OP_OPEN,filename);
524 hFile = FS_Open((const kal_wchar*)filename, openOption);
525 NVRAM_FS_END(FS_OP_OPEN,hFile);
526
527 if (hFile <= FS_NO_ERROR)
528 {
529 MD_TRC_MERGE_OPEN_PKG_FILE_RESULT(hFile);
530 return KAL_FALSE;
531 }
532 NVRAM_FS_START(FS_OP_OPEN);
533 result = FS_Close(hFile);
534 NVRAM_FS_END(FS_OP_OPEN,result);
535
536 return KAL_TRUE;
537}
538
539
540/*****************************************************************************
541 * FUNCTION
542 * nvram_check_data_item
543 * DESCRIPTION
544 * To check which data item valid. 1.Write back to file. OR 2. Create big array ?????
545 * PARAMETERS
546 * total_num [IN]
547 * data_offset [IN/OUT]
548 * sw_change [IN]
549 * RETURNS
550 * Success or Fail
551 *****************************************************************************/
552static kal_bool nvram_check_data_item(kal_bool sw_change)
553{
554 /*----------------------------------------------------------------*/
555 /* Local Variables */
556 /*----------------------------------------------------------------*/
557 nvram_lid_enum temp;
558 kal_uint32 package_temp;
559 nvram_ltable_entry_struct *ldi = NULL;
560
561 kal_uint32 Offset;
562
563 LID_info_struct lid_info;
564 kal_char filename_compare[8];
565 NVRAM_FILE_NAME nvramname;
566 nvram_drv_status_enum drv_status;
567 kal_bool lid_is_valid; /* can find in logical table, means lid is still valid */
568 kal_uint16 info_index = 0;
569
570
571 /*----------------------------------------------------------------*/
572 /* Code Body */
573 /*----------------------------------------------------------------*/
574 nvram_make_package_info_filename(nvramname, 'A');
575
576 for (package_temp = (kal_uint32)total_package_lid; package_temp > 0; package_temp--)
577 {
578 /* 1. Read LID information */
579
580 /* seek to the record start,from top to bottom */
581 Offset = (sizeof(head_info_struct) + NVRAM_CHKSUM_SIZE) +
582 (package_temp - 1) * (sizeof(LID_info_struct) + NVRAM_CHKSUM_SIZE);
583
584 lid_is_valid = KAL_FALSE; /* first, Assume every lid is invalid */
585
586 drv_status = nvram_drv_fat_read(
587 nvramname,
588 NVRAM_NVD_DATA,
589 Offset,
590 1,
591 1,
592 sizeof(LID_info_struct),
593 (kal_uint8*) &lid_info,
594 NVRAM_DRV_READ_TYPE_DATA,
595 NVRAM_ATTR_AVERAGE);
596 /* Success!! Great!! */
597 if (drv_status == NVRAM_DRV_OK)
598 {
599 if (lid_info.area != NVRAM_AREA_INVALID)
600 {
601 /* Step 1: try to find out corresponding LID */
602 ldi = &logical_data_item_table[0];
603 do
604 {
605
606 if (NVRAM_IS_ATTR_PACKAGE(ldi->attr))
607 {
608 nvram_make_filename_compare(filename_compare, ldi->fileprefix, ldi->fileverno);
609 if (!strcmp(filename_compare, lid_info.itemname)) /* Compatible */
610 {
611 if (lid_info.record_size * lid_info.total_records == ldi->size * ldi->total_records)
612 {
613 lid_is_valid = KAL_TRUE; /* means current LID is valid */
614 }
615 break; /* break out for loop */
616 }
617 }
618 }while(nvram_util_next_data_item(&ldi));
619
620 /* Step 2: if software change,
621 * case a: item is invalid, set it as invalid and register it into g_nvram_move_package_lid
622 * case b: item is valid, set the offset into ltable.
623 */
624
625 if (sw_change)
626 {
627 if (!lid_is_valid)
628 {
629 is_need_move = KAL_TRUE;
630 lid_info.area = NVRAM_AREA_INVALID;
631
632 drv_status = nvram_drv_fat_write(
633 nvramname,
634 NVRAM_NVD_DATA,
635 Offset,
636 1,
637 1,
638 sizeof(LID_info_struct),
639 (kal_uint8*) &lid_info,
640 NVRAM_ATTR_AVERAGE,
641 KAL_FALSE);
642 if (drv_status != NVRAM_DRV_OK)
643 {
644 }
645 }
646
647 //nvram_sort_order_head_info(&lid_info, info_index, temp);
648 nvram_sort_order_head_info(&lid_info, info_index, ldi->LID);
649 info_index++;
650 }
651 else
652 {
653 if (lid_is_valid)
654 {
655 ldi->description = (kal_char *)(lid_info.file_offset);
656 }
657 else
658 {
659 NVRAM_EXT_ASSERT(KAL_FALSE,lid_info.file_offset,NVRAM_LOC_INVALID_LID_4 , lid_info.record_size);
660 return KAL_FALSE;
661 }
662 }
663 }
664 else
665 {
666 if (sw_change)
667 {
668 is_need_move = KAL_TRUE;
669 /*
670 * If in the previous three cases, before write action poweroff suddenly happened,
671 * when next power-on, it will run into this case. this LID will be invalid and
672 * will be truncated in movement action.
673 */
674 temp = 0xFF;
675 nvram_sort_order_head_info(&lid_info, info_index, temp);
676 info_index++;
677 }
678 }
679 }
680 else /* Sigh. Failed..... */
681 {
682 //NVRAM_BLOCKING_ASSERT(KAL_FALSE, 0, 0, 0);
683 return KAL_FALSE;
684 }
685
686 }
687 return KAL_TRUE;
688}
689
690/*****************************************************************************
691 * FUNCTION
692 * nvram_set_offset_to_ltable
693 * DESCRIPTION
694 * Read out file offset from file, and set it to ltable
695 * PARAMETERS
696 * void
697 * RETURNS
698 * Success or Fail
699 *****************************************************************************/
700static kal_bool nvram_set_offset_to_ltable(void)
701{
702 /*----------------------------------------------------------------*/
703 /* Local Variables */
704 /*----------------------------------------------------------------*/
705
706 /*----------------------------------------------------------------*/
707 /* Code Body */
708 /*----------------------------------------------------------------*/
709 return nvram_check_data_item(KAL_FALSE);
710}
711
712
713
714/*****************************************************************************
715 * FUNCTION
716 * nvram_read_head_information
717 * DESCRIPTION
718 *
719 * PARAMETERS
720 * head_info [IN/OUT]
721 * openOption [IN]
722 * RETURNS
723 *
724 *****************************************************************************/
725static kal_bool nvram_read_head_information(head_info_struct *head_info, kal_uint32 openOption)
726{
727 /*----------------------------------------------------------------*/
728 /* Local Variables */
729 /*----------------------------------------------------------------*/
730 NVRAM_FILE_NAME nvramname;
731 nvram_drv_status_enum drv_status;
732
733 /*----------------------------------------------------------------*/
734 /* Code Body */
735 /*----------------------------------------------------------------*/
736 nvram_make_package_info_filename(nvramname, 'A');
737
738 drv_status = nvram_drv_fat_read(
739 nvramname,
740 NVRAM_NVD_DATA,
741 0,
742 1,
743 1,
744 sizeof(head_info_struct),
745 (kal_uint8*) head_info,
746 NVRAM_DRV_READ_TYPE_DATA,
747 NVRAM_ATTR_AVERAGE);
748
749 if (drv_status != NVRAM_DRV_OK)
750 {
751 return KAL_FALSE;
752 }
753 return KAL_TRUE;
754}
755
756
757/*****************************************************************************
758 * FUNCTION
759 * nvram_calculate_write_data_offset
760 * DESCRIPTION
761 * 1. Fill in all offset to ldi->description.
762 * 2. Update the header in package file
763 * 3. Update the info file
764 * 4. return the maximum offset of the package file now. All new item will be added
765 * after this offset.
766 * PARAMETERS
767 * offset_for_add_lid [OUT] the offset to add new lid
768 * is_init [IN] is init or not
769 * RETURNS
770 * KAL_FALSE: fail
771 * KAL_TRUE: successful
772 *****************************************************************************/
773kal_bool nvram_calculate_write_data_offset(kal_uint32 *offset_for_add_lid, kal_bool is_init)
774{
775 /*----------------------------------------------------------------*/
776 /* Local Variables */
777 /*----------------------------------------------------------------*/
778 NVRAM_FILE_NAME nvramname;
779 nvram_ltable_entry_struct *ldi;
780 LID_info_struct lid_info_temp;
781 kal_uint32 file_idx;
782 nvram_drv_status_enum drv_status;
783 kal_uint32 info_offset = 0;
784 kal_uint16 info_index = 0;
785 kal_uint32 file_offset = 0;
786
787
788
789 /*----------------------------------------------------------------*/
790 /* Code Body */
791 /*----------------------------------------------------------------*/
792
793 if (is_init) /* write Init */
794 {
795 nvram_make_package_info_filename(nvramname, 'A');
796 nvram_create_package_file('A');
797 file_offset = sizeof(head_info_struct) + NVRAM_CHKSUM_SIZE;
798 }
799 else /* write backup information file */
800 {
801 nvram_make_package_info_filename(nvramname, 'B'); /* 1. need move 2. add new lid */
802 nvram_create_package_file('B');
803
804 if (is_need_move) /* 1. need move, has invalid lid */
805 {
806 file_offset = sizeof(head_info_struct) + NVRAM_CHKSUM_SIZE;
807 }
808
809 for (file_idx = 0; file_idx < total_package_lid; file_idx++)
810 {
811
812 if (g_nvram_move_package_lid[file_idx].area != NVRAM_AREA_INVALID)
813 {
814 nvram_util_get_data_item(&ldi, g_nvram_move_package_lid[file_idx].LID);
815
816 if (is_need_move) /* 1. need move, has invalid lid */
817 {
818 ldi->description = (kal_char *)(file_offset);
819 file_offset += (ldi->size + NVRAM_CHKSUM_SIZE) * ldi->total_records;
820 }
821 else
822 {
823 ldi->description = (kal_char *)(g_nvram_move_package_lid[file_idx].file_offset);
824 }
825 }
826 }
827
828
829 if (!is_need_move) /* 2. No need move, only add new lid */
830 {
831 nvram_util_get_data_item(&ldi, g_nvram_move_package_lid[0].LID);
832 file_offset = g_nvram_move_package_lid[0].file_offset + (ldi->size + NVRAM_CHKSUM_SIZE) * ldi->total_records;
833 }
834
835 }
836
837 if (offset_for_add_lid)
838 {
839 /* Assign file_offset for add new lid */
840 *offset_for_add_lid = file_offset;
841 }
842
843 /* 2.write package LID information */
844 ldi = &logical_data_item_table[0];
845 do
846 {
847// if (ltable_entry)
848// {
849// nvram_util_get_data_item(&ldi, file_idx);
850 if (!NVRAM_IS_ATTR_PACKAGE(ldi->attr))
851 {
852 continue;
853 }
854
855 info_offset = (sizeof(head_info_struct) + NVRAM_CHKSUM_SIZE) + info_index * (sizeof(lid_info_temp) + NVRAM_CHKSUM_SIZE);
856 info_index++;
857
858 lid_info_temp.record_size = ldi->size;
859 lid_info_temp.total_records = ldi->total_records;
860 nvram_make_filename_compare(lid_info_temp.itemname, ldi->fileprefix, ldi->fileverno);
861
862 if (ldi->description) /* already in package file */
863 {
864 lid_info_temp.file_offset = (kal_uint32) (ldi->description);
865 }
866 else /* newly add [do not set file_offset in ltable, because add_new_package_lid need this information] */
867 {
868 ldi->description = (kal_char*) file_offset;
869 lid_info_temp.file_offset = file_offset;
870 file_offset += ((ldi->size + NVRAM_CHKSUM_SIZE) * (ldi->total_records));
871 }
872
873 drv_status = nvram_drv_fat_write(
874 nvramname,
875 NVRAM_NVD_DATA,
876 info_offset,
877 1,
878 1,
879 sizeof(LID_info_struct),
880 (kal_uint8*) &lid_info_temp,
881 NVRAM_ATTR_AVERAGE,
882 KAL_FALSE);
883 if (drv_status != NVRAM_DRV_OK)
884 {
885 return KAL_FALSE;
886 }
887
888// }
889
890 }while(nvram_util_next_data_item(&ldi));
891
892 return KAL_TRUE;
893}
894
895
896/*****************************************************************************
897 * FUNCTION
898 * nvram_init_all_package_lid
899 * DESCRIPTION
900 *
901 * PARAMETERS
902 * void
903 * RETURNS
904 *
905 *****************************************************************************/
906static kal_bool nvram_init_all_package_lid(void)
907{
908 /*----------------------------------------------------------------*/
909 /* Local Variables */
910 /*----------------------------------------------------------------*/
911
912 /*----------------------------------------------------------------*/
913 /* Code Body */
914 /*----------------------------------------------------------------*/
915 nvram_reset_data_items(NVRAM_RESET_PACKAGE, NVRAM_APP_RESERVED, 0, 0, 0);
916 return KAL_TRUE;
917}
918
919
920/*****************************************************************************
921 * FUNCTION
922 * nvram_construct_head_info_table
923 * DESCRIPTION
924 *
925 * PARAMETERS
926 * total_num [IN]
927 * RETURNS
928 *
929 *****************************************************************************/
930static kal_bool nvram_construct_head_info_table(kal_uint32 total_num)
931{
932 /*----------------------------------------------------------------*/
933 /* Local Variables */
934 /*----------------------------------------------------------------*/
935
936 /*----------------------------------------------------------------*/
937 /* Code Body */
938 /*----------------------------------------------------------------*/
939 g_nvram_move_package_lid = (head_info_entry *)kal_tmp_mem_alloc(sizeof(head_info_entry) * total_num);
940
941 if (!g_nvram_move_package_lid)
942 {
943 return KAL_FALSE;
944 }
945
946 kal_mem_set(g_nvram_move_package_lid, 0, total_num * sizeof(head_info_entry));
947
948 return KAL_TRUE;
949}
950
951
952/*****************************************************************************
953 * FUNCTION
954 * nvram_destruct_head_info_table
955 * DESCRIPTION
956 *
957 * PARAMETERS
958 * void
959 * RETURNS
960 *
961 *****************************************************************************/
962static kal_bool nvram_destruct_head_info_table(void)
963{
964 /*----------------------------------------------------------------*/
965 /* Local Variables */
966 /*----------------------------------------------------------------*/
967
968 /*----------------------------------------------------------------*/
969 /* Code Body */
970 /*----------------------------------------------------------------*/
971 if (g_nvram_move_package_lid)
972 {
973 kal_tmp_mem_free(g_nvram_move_package_lid);
974 g_nvram_move_package_lid = NULL;
975 }
976
977 return KAL_TRUE;
978}
979
980
981
982
983
984
985
986/*****************************************************************************
987 * FUNCTION
988 * nvram_del_rename_package_file
989 * DESCRIPTION
990 *
991 * PARAMETERS
992 * void
993 * RETURNS
994 *
995 *****************************************************************************/
996static kal_bool nvram_del_rename_package_file(kal_bool is_exist_package_file)
997{
998 /*----------------------------------------------------------------*/
999 /* Local Variables */
1000 /*----------------------------------------------------------------*/
1001 NVRAM_FILE_NAME packagename;
1002 NVRAM_FILE_NAME backupname;
1003 kal_wchar pack_filename[NVRAM_MAX_PATH_LEN];
1004 kal_wchar back_filename[NVRAM_MAX_PATH_LEN];
1005 kal_int32 ret;
1006 /*----------------------------------------------------------------*/
1007 /* Code Body */
1008 /*----------------------------------------------------------------*/
1009 /* package file */
1010 if (is_exist_package_file)
1011 {
1012 nvram_make_package_filename(packagename, 'A');
1013 nvram_make_package_filename(backupname, 'B');
1014 nvram_query_file_name(NVRAM_NVD_DATA, packagename, pack_filename);
1015 nvram_query_file_name(NVRAM_NVD_DATA, backupname, back_filename);
1016 NVRAM_FS_START_EX(FS_OP_DELETE,pack_filename);
1017 ret = FS_Delete(pack_filename);
1018 NVRAM_FS_END(FS_OP_DELETE,ret);
1019 if (ret < 0)
1020 {
1021 return KAL_FALSE;
1022 }
1023
1024 NVRAM_FS_START_EX(FS_OP_RENAME,back_filename);
1025 ret = FS_Rename(back_filename, pack_filename);
1026 NVRAM_FS_END(FS_OP_RENAME,ret);
1027 if (ret < 0)
1028 {
1029 return KAL_FALSE;
1030 }
1031 }
1032
1033 /* information file */
1034 nvram_make_package_info_filename(packagename, 'A');
1035 nvram_make_package_info_filename(backupname, 'B');
1036 nvram_query_file_name(NVRAM_NVD_DATA, packagename, pack_filename);
1037 nvram_query_file_name(NVRAM_NVD_DATA, backupname, back_filename);
1038
1039 NVRAM_FS_START_EX(FS_OP_DELETE,pack_filename);
1040 ret = FS_Delete(pack_filename);
1041 NVRAM_FS_END(FS_OP_DELETE,ret);
1042 if (ret < 0)
1043 {
1044 return KAL_FALSE;
1045 }
1046
1047 NVRAM_FS_START_EX(FS_OP_RENAME,back_filename);
1048 ret = FS_Rename(back_filename, pack_filename);
1049 NVRAM_FS_END(FS_OP_RENAME,ret);
1050 if (ret < 0)
1051 {
1052 return KAL_FALSE;
1053 }
1054
1055 return KAL_TRUE;
1056}
1057
1058
1059/*****************************************************************************
1060 * FUNCTION
1061 * nvram_del_temporary_file
1062 * DESCRIPTION
1063 *
1064 * PARAMETERS
1065 * void
1066 * RETURNS
1067 *
1068 *****************************************************************************/
1069static kal_bool nvram_del_temporary_file(void)
1070{
1071 /*----------------------------------------------------------------*/
1072 /* Local Variables */
1073 /*----------------------------------------------------------------*/
1074 NVRAM_FILE_NAME tempname;
1075 kal_wchar temp_filename[NVRAM_MAX_PATH_LEN];
1076 kal_int32 ret;
1077
1078 /*----------------------------------------------------------------*/
1079 /* Code Body */
1080 /*----------------------------------------------------------------*/
1081 naram_make_temp_filename(tempname, 'A');
1082 nvram_query_file_name(NVRAM_NVD_DATA, tempname, temp_filename);
1083
1084 NVRAM_FS_START_EX(FS_OP_DELETE,temp_filename);
1085 ret = FS_Delete(temp_filename);
1086 NVRAM_FS_END(FS_OP_DELETE,ret);
1087 if (ret < 0)
1088 {
1089 return KAL_FALSE;
1090 }
1091
1092 return KAL_TRUE;
1093}
1094
1095
1096/*****************************************************************************
1097 * FUNCTION
1098 * nvram_write_temporary_record
1099 * DESCRIPTION
1100 *
1101 * PARAMETERS
1102 * loopindex [IN] moving index of g_nvram_move_package_lid[index]
1103 * adding index of logical table[index]
1104 * Is_moving [IN] KAL_TRUE: Now is moving, loopindex is moving index
1105 * KAL_FALSE: Now is adding new LID, loopindex is adding index
1106 * RETURNS
1107 *
1108 *****************************************************************************/
1109static kal_bool nvram_write_temporary_record(kal_uint16 loopindex, kal_bool Is_moving)
1110{
1111 /*----------------------------------------------------------------*/
1112 /* Local Variables */
1113 /*----------------------------------------------------------------*/
1114 NVRAM_FILE_NAME tempname;
1115 temp_info_struct temp_info;
1116 nvram_drv_status_enum drv_status;
1117
1118 /*----------------------------------------------------------------*/
1119 /* Code Body */
1120 /*----------------------------------------------------------------*/
1121 naram_make_temp_filename(tempname, 'A');
1122
1123 if (Is_moving)
1124 {
1125 temp_info.lid_moving_index = loopindex + 1;
1126 temp_info.lid_adding_index = 0;
1127 }
1128 else
1129 {
1130 temp_info.lid_moving_index = 0;
1131 temp_info.lid_adding_index = loopindex + 1;
1132 }
1133
1134 drv_status = nvram_drv_fat_write(
1135 tempname,
1136 NVRAM_NVD_DATA,
1137 0,
1138 1,
1139 1,
1140 sizeof(temp_info_struct),
1141 (kal_uint8 *)(&temp_info),
1142 NVRAM_ATTR_AVERAGE,
1143 KAL_FALSE);
1144
1145 if (drv_status != NVRAM_DRV_OK)
1146 {
1147 MD_TRC_MERGE_WRITE_TEMP_RESULT(
1148 temp_info.lid_moving_index,
1149 temp_info.lid_adding_index,
1150 nvram_drv_fat_get_last_err(),
1151 __LINE__);
1152 return KAL_FALSE;
1153 }
1154
1155 return KAL_TRUE;
1156}
1157
1158
1159/*****************************************************************************
1160 * FUNCTION
1161 * nvram_add_package_lid
1162 * DESCRIPTION
1163 *
1164 * PARAMETERS
1165 * Is_moving [IN]
1166 * RETURNS
1167 *
1168 *****************************************************************************/
1169static kal_bool nvram_add_package_lid(kal_uint32 *file_offset, kal_bool Is_moving)
1170{
1171 /*----------------------------------------------------------------*/
1172 /* Local Variables */
1173 /*----------------------------------------------------------------*/
1174 nvram_drv_status_enum drv_status;
1175 nvram_ltable_entry_struct *ldi;
1176
1177 NVRAM_FILE_NAME backupname;
1178 kal_uint32 default_value_buffer_size;
1179 kal_uint8 *default_value_buffer;
1180
1181 kal_uint32 record_index;
1182
1183 /*----------------------------------------------------------------*/
1184 /* Code Body */
1185 /*----------------------------------------------------------------*/
1186 /* Cannot allocate memory! */
1187 if ((default_value_buffer_size = MAX_NVRAM_RECORD_SIZE) & 1)
1188 {
1189 default_value_buffer_size += 1;
1190 }
1191
1192 default_value_buffer = (kal_uint8*) get_ctrl_buffer(default_value_buffer_size);
1193
1194 if (Is_moving)
1195 {
1196 nvram_make_package_filename(backupname, 'B');
1197 }
1198 else
1199 {
1200 nvram_make_package_filename(backupname, 'A');
1201 }
1202
1203 ldi = &logical_data_item_table[0];
1204 do
1205 {
1206
1207 if (!NVRAM_IS_ATTR_PACKAGE(ldi->attr))
1208 {
1209 continue;
1210 }
1211
1212 if ((kal_uint32)ldi->description < (*file_offset)) /* Already in package file */
1213 {
1214 continue;
1215 }
1216
1217
1218 for (record_index = ldi->total_records; record_index > 0; record_index--)
1219 {
1220 nvram_get_default_value_to_write(ldi, (kal_uint16)record_index, default_value_buffer, default_value_buffer_size);
1221
1222 drv_status = nvram_drv_fat_write(
1223 backupname,
1224 NVRAM_NVD_DATA,
1225 (kal_uint32)(ldi->description),
1226 (kal_uint16)(record_index),
1227 1,
1228 ldi->size,
1229 default_value_buffer,
1230 //NVRAM_ATTR_AVERAGE,
1231 ldi->attr,
1232 KAL_FALSE);
1233 if (drv_status == NVRAM_DRV_OK)
1234 {
1235 }
1236 else
1237 {
1238 return KAL_FALSE;
1239 }
1240 }
1241 /* write temp record, only when need moving, if just add LID, don't write temp record */
1242 if (Is_moving)
1243 {
1244 nvram_write_temporary_record(ldi->LID, KAL_FALSE);
1245 }
1246 }while(nvram_util_next_data_item(&ldi));
1247
1248 return KAL_TRUE;
1249}
1250
1251
1252/*****************************************************************************
1253 * FUNCTION
1254 * nvram_truncate_file
1255 * DESCRIPTION
1256 *
1257 * PARAMETERS
1258 * loopindex [IN]
1259 * RETURNS
1260 *
1261 *****************************************************************************/
1262static kal_bool nvram_truncate_file(kal_uint16 loopindex)
1263{
1264 /*----------------------------------------------------------------*/
1265 /* Local Variables */
1266 /*----------------------------------------------------------------*/
1267 FS_HANDLE hFileSrc = 0;
1268 NVRAM_FILE_NAME packagename;
1269 kal_wchar filename[NVRAM_MAX_PATH_LEN];
1270 kal_int32 result = FS_NO_ERROR;
1271 /*----------------------------------------------------------------*/
1272 /* Code Body */
1273 /*----------------------------------------------------------------*/
1274 nvram_make_package_filename(packagename, 'A');
1275 nvram_query_file_name(NVRAM_NVD_DATA, packagename, filename);
1276
1277 NVRAM_FS_START_EX(FS_OP_OPEN,filename);
1278 hFileSrc = FS_Open(filename, FS_OPEN_NO_DIR | FS_READ_WRITE | FS_PROTECTION_MODE);
1279 NVRAM_FS_END(FS_OP_OPEN,hFileSrc);
1280 if (hFileSrc <= FS_NO_ERROR)
1281 {
1282 MD_TRC_MERGE_TRUNK_STATUS(hFileSrc);
1283 NVRAM_FS_START(FS_OP_CLOSE);
1284 result = FS_Close(hFileSrc);
1285 NVRAM_FS_END(FS_OP_CLOSE,result);
1286 return KAL_FALSE;
1287 }
1288
1289 NVRAM_FS_START(FS_OP_SEEK);
1290 result = FS_Seek(hFileSrc, g_nvram_move_package_lid[loopindex].file_offset, FS_FILE_BEGIN);
1291 NVRAM_FS_END(FS_OP_SEEK,result);
1292 #if !(defined(__CCCIFS_SUPPORT__) && defined(__MTK_TARGET__))
1293 result = FS_Truncate(hFileSrc);
1294 #endif
1295 NVRAM_FS_START(FS_OP_CLOSE);
1296 result = FS_Close(hFileSrc);
1297 NVRAM_FS_END(FS_OP_CLOSE,result);
1298
1299 return KAL_TRUE;
1300}
1301
1302/*****************************************************************************
1303 * FUNCTION
1304 * nvram_move_certain_date_item
1305 * DESCRIPTION
1306 * This is nvram_move_certain_date_item() function of NVRAM module.
1307 * This function will copy certain valid data from src file to dest.
1308 * PARAMETERS
1309 * loopindex [IN]
1310 * RETURNS
1311 * KAL_TRUE if move (copy, write) successfully.
1312 * KAL_FALSE if move (copy, write) failure.
1313 *****************************************************************************/
1314static kal_bool nvram_move_certain_date_item(kal_uint16 loopindex)
1315{
1316 /*----------------------------------------------------------------*/
1317 /* Local Variables */
1318 /*----------------------------------------------------------------*/
1319 kal_uint32 record_index;
1320 NVRAM_FILE_NAME packagename;
1321 NVRAM_FILE_NAME backupname;
1322 nvram_ltable_entry_struct *ldi;
1323 kal_uint8 *buffer = NULL;
1324 nvram_drv_status_enum drv_status;
1325
1326 /*----------------------------------------------------------------*/
1327 /* Code Body */
1328 /*----------------------------------------------------------------*/
1329 nvram_make_package_filename(packagename, 'A');
1330 nvram_make_package_filename(backupname, 'B');
1331
1332 nvram_util_get_data_item(&ldi, g_nvram_move_package_lid[loopindex].LID);
1333
1334 buffer = (kal_uint8 *) get_ctrl_buffer(ldi->size);
1335
1336 /* g_nvram_move_package_lid[loopindex].total_records */
1337 for (record_index = 0; record_index < ldi->total_records; record_index++)
1338 {
1339 drv_status = nvram_drv_fat_read(
1340 packagename,
1341 NVRAM_NVD_DATA,
1342 g_nvram_move_package_lid[loopindex].file_offset,
1343 (kal_uint16)(record_index + 1),
1344// (kal_uint16)(record_index),
1345 (kal_uint16)1,
1346 ldi->size,
1347 buffer,
1348 NVRAM_DRV_READ_TYPE_DATA,
1349 NVRAM_ATTR_AVERAGE);
1350
1351 if (drv_status != NVRAM_DRV_OK)
1352 {
1353 NVRAM_EXT_ASSERT(0, DISPLAY_ERROR(drv_status), NVRAM_LOC_READ_PACKED_FILE_FAIL, ldi->LID);
1354 return KAL_FALSE;
1355 }
1356
1357 /* Write to Dest file */
1358 drv_status = nvram_drv_fat_write(
1359 backupname,
1360 NVRAM_NVD_DATA,
1361 (kal_uint32)(ldi->description),
1362 (kal_uint16)(record_index + 1),
1363 1,
1364// (kal_uint16)(record_index),
1365 ldi->size,
1366 buffer,
1367 NVRAM_ATTR_AVERAGE,
1368 //ldi->attr,
1369 KAL_FALSE);
1370
1371 if (drv_status != NVRAM_DRV_OK)
1372 {
1373 return KAL_FALSE;
1374 }
1375 }
1376
1377 if (buffer)
1378 free_ctrl_buffer(buffer);
1379
1380 return KAL_TRUE;
1381}
1382
1383
1384/*****************************************************************************
1385 * FUNCTION
1386 * nvram_move_date_item
1387 * DESCRIPTION
1388 * This is nvram_move_date_item() function of NVRAM module.
1389 * This function will copy valid data from src file to dest.
1390 * PARAMETERS
1391 * temp_info [IN]
1392 * total_package_lid [IN]
1393 * init_move [IN]
1394 * RETURNS
1395 * KAL_TRUE if move (copy, write) successfully.
1396 * KAL_FALSE if move (copy, write) failure.
1397 *****************************************************************************/
1398static kal_bool nvram_move_data_item(temp_info_struct *temp_info, kal_bool init_move)
1399{
1400 /*----------------------------------------------------------------*/
1401 /* Local Variables */
1402 /*----------------------------------------------------------------*/
1403 NVRAM_FILE_NAME packagename;
1404 NVRAM_FILE_NAME backupname;
1405 NVRAM_FILE_NAME tempname;
1406 kal_wchar filename[NVRAM_MAX_PATH_LEN];
1407 kal_int32 openOption = FS_OPEN_NO_DIR | FS_READ_WRITE | FS_PROTECTION_MODE;
1408
1409 kal_uint16 loopindex;
1410 kal_uint16 loopstart;
1411 kal_uint16 loopend = total_package_lid;
1412 kal_int32 result = FS_NO_ERROR;
1413 /*----------------------------------------------------------------*/
1414 /* Code Body */
1415 /*----------------------------------------------------------------*/
1416
1417 nvram_make_package_filename(packagename, 'A');
1418 nvram_make_package_filename(backupname, 'B');
1419 naram_make_temp_filename(tempname, 'A');
1420
1421 if (init_move) /* first time, move valid data *//* logical error */
1422 {
1423 loopstart = 0;
1424 }
1425 else
1426 {
1427 loopstart = temp_info->lid_moving_index;
1428 }
1429 /* step 1: open src file, if failed, reset all package lid */
1430 if (nvram_open_package_file(packagename, openOption))
1431 {
1432 /* step 2: open/create dest file, if failed, delete src file and reset all package lid */
1433 if (nvram_open_package_file(backupname, openOption))
1434 {
1435 /* Move valid LID package file */
1436 for (loopindex = loopstart; loopindex < loopend; loopindex++)
1437 {
1438 if (g_nvram_move_package_lid[loopindex].area == NVRAM_AREA_INVALID)
1439 {
1440
1441 /* May be suddenly power off between this two function */
1442 /* 1. truncate file
1443 * nvram_truncate_file(loopindex);
1444 * 2. write index to file
1445 * nvram_write_temporary_record(loopindex, KAL_TRUE);
1446 */
1447
1448 /* 1. write index to file */
1449 nvram_write_temporary_record(loopindex, KAL_TRUE);
1450 /* 2. truncate file */
1451 nvram_truncate_file(loopindex);
1452 }
1453 else
1454 {
1455 if (nvram_move_certain_date_item(loopindex))
1456 {
1457 /* 1. write index to file */
1458 nvram_write_temporary_record(loopindex, KAL_TRUE);
1459 /* 2. truncate file */
1460 nvram_truncate_file(loopindex);
1461 }
1462 else
1463 {
1464 /* if move certain data item failure, return KAL_FALSE, and All pachage LID will be reset */
1465 return KAL_FALSE;
1466 }
1467 }
1468 }
1469 }
1470 else
1471 {
1472 nvram_query_file_name(NVRAM_NVD_DATA, packagename, filename);
1473 NVRAM_FS_START_EX(FS_OP_DELETE,filename);
1474 result = FS_Delete(filename);
1475 NVRAM_FS_END(FS_OP_DELETE,result);
1476 /* return KAL_FALSE, and All pachage LID will be reset */
1477 return KAL_FALSE;
1478 }
1479 }
1480 else
1481 {
1482 /* return KAL_FALSE, and All pachage LID will be reset */
1483 return KAL_FALSE;
1484 }
1485/* */
1486
1487 return KAL_TRUE;
1488}
1489
1490/*****************************************************************************
1491 * FUNCTION
1492 * nvram_deal_with_exception
1493 * DESCRIPTION
1494 *
1495 * PARAMETERS
1496 * void
1497 * RETURNS
1498 *
1499 *****************************************************************************/
1500static kal_bool nvram_deal_with_exception(void)
1501{
1502 /*----------------------------------------------------------------*/
1503 /* Local Variables */
1504 /*----------------------------------------------------------------*/
1505 NVRAM_FILE_NAME temp_file;
1506 temp_info_struct temp_info;
1507 head_info_struct head_info;
1508 kal_int32 openOption = FS_OPEN_NO_DIR | FS_READ_ONLY;
1509 kal_uint32 data_offset = 0;
1510
1511 /*----------------------------------------------------------------*/
1512 /* Code Body */
1513 /*----------------------------------------------------------------*/
1514 naram_make_temp_filename(temp_file, 'A');
1515
1516 nvram_drv_fat_read(
1517 temp_file,
1518 NVRAM_NVD_DATA,
1519 0,
1520 1,
1521 1,
1522 sizeof(temp_info_struct),
1523 (kal_uint8*) &temp_info,
1524 NVRAM_DRV_READ_TYPE_DATA,
1525 NVRAM_ATTR_AVERAGE);
1526
1527 if (nvram_read_head_information(&head_info, openOption))
1528 {
1529 total_package_lid = head_info.total_pack_lid;
1530
1531 /* maybe have bug */
1532 nvram_compare_filename_chksum(&head_info);
1533
1534 if (nvram_construct_head_info_table(total_package_lid))
1535 {
1536 nvram_check_data_item(KAL_TRUE);
1537
1538 nvram_calculate_write_data_offset(&data_offset, KAL_FALSE);
1539
1540 if (temp_info.lid_moving_index) /* moving */
1541 {
1542 if (nvram_move_data_item(&temp_info, KAL_FALSE))
1543 {
1544 /* 1. Add new LID */
1545 if (nvram_add_package_lid(&data_offset, KAL_TRUE))
1546 {
1547 /* 2. Delete Src file and Rename Dest file*/
1548 nvram_del_rename_package_file(KAL_TRUE);
1549 /* 3. Delete temp file */
1550 nvram_del_temporary_file();
1551 }
1552 }
1553 else
1554 {
1555 /* What should i do */
1556 nvram_init_all_package_lid();
1557 }
1558 }
1559 else /* moved, add new lid */
1560 {
1561 if (nvram_add_package_lid(&data_offset, KAL_TRUE)) /* need move-->package file B */
1562 {
1563 nvram_del_rename_package_file(KAL_TRUE);
1564 nvram_del_temporary_file();
1565 }
1566 }
1567 }
1568 else /* else of nvram_construct_head_info_table */
1569 {
1570 nvram_init_all_package_lid();
1571 } /* end of nvram_construct_head_info_table */
1572
1573 nvram_destruct_head_info_table();
1574 }
1575 else
1576 {
1577 nvram_init_all_package_lid();
1578 } /* end of nvram_read_head_information */
1579
1580 return KAL_TRUE;
1581}
1582
1583/*****************************************************************************
1584 * FUNCTION
1585 * nvram_compare_filename_chksum
1586 * DESCRIPTION
1587 * To perform filename's chksum incompatible.(1. add LID 2. del LID)
1588 * PARAMETERS
1589 * void
1590 * RETURNS
1591 * Success or Fail
1592 *****************************************************************************/
1593static kal_bool nvram_chksum_conflict_resolve(void)
1594{
1595 /*----------------------------------------------------------------*/
1596 /* Local Variables */
1597 /*----------------------------------------------------------------*/
1598 kal_uint32 offset_for_add_lid = 0;
1599 kal_bool result=KAL_TRUE;
1600
1601 /*----------------------------------------------------------------*/
1602 /* Code Body */
1603 /*----------------------------------------------------------------*/
1604 if (nvram_construct_head_info_table(total_package_lid))
1605 {
1606 if (!nvram_check_data_item(KAL_TRUE))
1607 {
1608 result=KAL_FALSE;
1609 goto out;
1610 }
1611
1612 /* After check out all valid LID, need moving or not */
1613 if (is_need_move)
1614 {
1615 if (nvram_create_package_file('B'))
1616 {
1617 temp_info_struct temp_info;
1618
1619 nvram_calculate_write_data_offset(&offset_for_add_lid, KAL_FALSE);
1620 if (nvram_move_data_item(&temp_info, KAL_TRUE))
1621 {
1622 /* 1.Add new LID */
1623 if (nvram_add_package_lid(&offset_for_add_lid, is_need_move)) /* is_need_move =KAL_TRUE */
1624 {
1625 /* 2.Delete Src file and Rename Dest file */
1626 nvram_del_rename_package_file(KAL_TRUE);
1627 /* 3.Delete temp file */
1628 nvram_del_temporary_file();
1629 }
1630 }
1631 else
1632 {
1633 nvram_init_all_package_lid();
1634 }
1635 }
1636 else /* Create back file failure */
1637 {
1638 nvram_init_all_package_lid();
1639 } /* end of nvram_create_package_file */
1640 } /* is_need_move */
1641 else
1642 {
1643 nvram_calculate_write_data_offset(&offset_for_add_lid, KAL_FALSE);
1644 if (nvram_add_package_lid(&offset_for_add_lid, is_need_move)) /* is_need_move =KAL_FALSE */
1645 {
1646 nvram_del_rename_package_file(KAL_FALSE);
1647 /* nvram_del_temporary_file(); *//* in this case, not have temp file */
1648 }
1649 } /* is_need_move = KAL_FALSE */
1650 }
1651 else
1652 {
1653 /* What should i do */
1654 //NVRAM_BLOCKING_ASSERT(0, total_package_lid, 0, 0);
1655 NVRAM_EXT_ASSERT(KAL_FALSE,(kal_uint32)g_nvram_move_package_lid,NVRAM_LOC_BUFFER_PTR_IS_NULL_7 , 0);
1656 return KAL_FALSE;
1657 } /* nvram_construct_head_info_table(&head_info) */
1658
1659out:
1660
1661 nvram_destruct_head_info_table();
1662
1663 return result;
1664}
1665
1666#define NVRAM_PSEUDO_MERGE_EXTERN_FUNCTION
1667/*****************************************************************************
1668 * FUNCTION
1669 * nvram_calculate_filename_chksum
1670 * DESCRIPTION
1671 * Calculate chksum, and turn off attr multiple, turn on attr package
1672 * PARAMETERS
1673 * chksum [IN/OUT]
1674 * ldi [IN/OUT]
1675 * RETURNS
1676 * void
1677 *****************************************************************************/
1678kal_uint32 nvram_calculate_filename_chksum(nvram_ltable_entry_struct *ldi)
1679{
1680 /*----------------------------------------------------------------*/
1681 /* Local Variables */
1682 /*----------------------------------------------------------------*/
1683 kal_uint32 chksum = 0;
1684 kal_uint16 *word_chksum = (kal_uint16 *) &chksum;
1685 kal_uint8 checksum_buf[8];
1686
1687 /*----------------------------------------------------------------*/
1688 /* Code Body */
1689 /*----------------------------------------------------------------*/
1690
1691 *(word_chksum + 1) = nvram_util_caculate_checksum((kal_uint8 *)ldi->fileverno, 3, checksum_buf);
1692 *word_chksum = nvram_util_caculate_checksum((kal_uint8 *)ldi->fileprefix, 4, checksum_buf);
1693
1694 return chksum;
1695}
1696
1697
1698/*****************************************************************************
1699 * FUNCTION
1700 * nvram_query_lid_merge
1701 * DESCRIPTION
1702 * Query certain data item should be merge or not
1703 * PARAMETERS
1704 * ldi [IN]
1705 * lid_size [OUT]
1706 * RETURNS
1707 * KAL_TRUE : merge
1708 * KAL_FALSE : not merge
1709 *****************************************************************************/
1710kal_bool nvram_query_lid_merge(nvram_ltable_entry_struct *ldi)
1711{
1712 /*----------------------------------------------------------------*/
1713 /* Local Variables */
1714 /*----------------------------------------------------------------*/
1715 kal_uint32 lid_size;
1716
1717 /*----------------------------------------------------------------*/
1718 /* Code Body */
1719 /*----------------------------------------------------------------*/
1720
1721 lid_size = (ldi->size + NVRAM_CHKSUM_SIZE) * ldi->total_records;
1722
1723 if (!NVRAM_IS_CATEGORY_INTERNAL(ldi->category) &&
1724 !NVRAM_IS_CATEGORY_SECUPACK(ldi->category) &&
1725 !NVRAM_IS_CATEGORY_IMPORTANT(ldi->category) &&
1726 !NVRAM_IS_CATEGORY_CALIBRAT(ldi->category) &&
1727 #ifdef __NVRAM_CUSTOM_SENSITIVE__
1728 !NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) &&
1729 #endif
1730 #ifdef __NVRAM_CUSTOM_DISK__
1731 !NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category) &&
1732 #endif
1733 lid_size < NVRAM_CLUSTER_SIZE)
1734 {
1735 return KAL_TRUE;
1736 }
1737 else
1738 {
1739 return KAL_FALSE;
1740 }
1741}
1742
1743/*****************************************************************************
1744 * FUNCTION
1745 * nvram_assign_package_entry
1746 * DESCRIPTION
1747 * calculate the checksum and setup the attribute
1748 * PARAMETERS
1749 * area [IN] in MT/MP/Custom table
1750 * ldi [IN] data item
1751 * RETURNS
1752 * void
1753 *****************************************************************************/
1754void nvram_assign_package_entry(nvram_ltable_entry_struct *ldi)
1755{
1756 /*----------------------------------------------------------------*/
1757 /* Local Variables */
1758 /*----------------------------------------------------------------*/
1759 kal_uint32 ldi_size;
1760
1761 /*----------------------------------------------------------------*/
1762 /* Code Body */
1763 /*----------------------------------------------------------------*/
1764
1765 g_head_info_file.total_pack_lid++;
1766
1767 ldi_size = (ldi->size + NVRAM_CHKSUM_SIZE) * ldi->total_records;
1768
1769 //for compatible with 10A & 11A, only use CORE variable after 11B
1770 g_head_info_file.total_size_core += ldi_size;
1771 g_head_info_file.chksum_core += nvram_calculate_filename_chksum(ldi);
1772
1773 //for compatible with 10A & 11A, only use CORE variable after 11B
1774 g_head_info_file.total_size_comm = 0;
1775 g_head_info_file.chksum_comm = 0;
1776
1777 g_head_info_file.total_size_cust = 0;
1778 g_head_info_file.chksum_cust = 0;
1779
1780
1781 ldi->attr |= NVRAM_ATTR_PACKAGE;
1782}
1783
1784/*****************************************************************************
1785 * FUNCTION
1786 * nvram_pseudo_merge
1787 * DESCRIPTION
1788 * pseudo merge init function
1789 * PARAMETERS
1790 * void
1791 * RETURNS
1792 * Success or Fail
1793 *****************************************************************************/
1794kal_bool nvram_pseudo_merge(void)
1795{
1796 /*----------------------------------------------------------------*/
1797 /* Local Variables */
1798 /*----------------------------------------------------------------*/
1799 kal_int32 openOption = FS_OPEN_NO_DIR | FS_READ_ONLY;
1800 NVRAM_FILE_NAME pack_file;
1801 head_info_struct head_info;
1802 kal_wchar filename[NVRAM_MAX_PATH_LEN];
1803 kal_int32 result = FS_NO_ERROR;
1804 /*----------------------------------------------------------------*/
1805 /* Code Body */
1806 /*----------------------------------------------------------------*/
1807
1808 naram_make_temp_filename(pack_file, 'A');
1809 nvram_query_file_name(NVRAM_NVD_DATA, pack_file, filename);
1810 NVRAM_FS_START_EX(FS_OP_GETATTRIBUTES,filename);
1811 result = FS_GetAttributes(filename);
1812 NVRAM_FS_END(FS_OP_GETATTRIBUTES,result);
1813 if (result >= FS_NO_ERROR) /* can find backup file, indicate suddenly power off last time */
1814 {
1815 nvram_deal_with_exception();
1816 }
1817 else /* no find, last time is OK */
1818 {
1819 nvram_make_package_filename(pack_file, 'A'); /* 'A' means package file */
1820 nvram_query_file_name(NVRAM_NVD_DATA, pack_file, filename);
1821 NVRAM_FS_START_EX(FS_OP_GETATTRIBUTES,filename);
1822 result = FS_GetAttributes(filename);
1823 NVRAM_FS_END(FS_OP_GETATTRIBUTES,result);
1824 if (result >= FS_NO_ERROR)
1825 {
1826 /* 1. Read out head information */
1827 /* 2. Compare three chksum */
1828
1829 if (nvram_read_head_information(&head_info, openOption))
1830 {
1831 total_package_lid = head_info.total_pack_lid;
1832 nvram_compare_filename_chksum(&head_info);
1833
1834 if (nvram_ptr->sw_status)
1835 {
1836 /* chksum error, deal with it */
1837 return nvram_chksum_conflict_resolve();
1838 }
1839 else /* No change, but also need know file offset */
1840 {
1841 return nvram_set_offset_to_ltable();
1842 } /* end of nvram_ptr->sw_status */
1843 }
1844 else
1845 {
1846 /* Read fail,Assume all chksum error */
1847 nvram_ptr->sw_status |= NVRAM_SW_PACKAGE_CHANGE;
1848 if(nvram_ee_info != NULL){
1849 nvram_ee_info->nvram_init_context.sw_status = nvram_ptr->sw_status;
1850 }
1851 /* nvram should init all package LID */
1852 nvram_init_all_package_lid();
1853 } /* end of read head information */
1854 }
1855 else /* can not find package file, indicate first power on */
1856 {
1857 /* nvram should init all package LID */
1858 nvram_init_all_package_lid();
1859 }
1860 }
1861
1862 return KAL_TRUE;
1863}
1864
1865#endif /* __NVRAM_PSEUDO_MERGE__ */
1866