Gitiles
Code Review Sign In
192.168.1.100 / T800_MD / 1eb8f53f94c145708b5ea2c6b9b96ea3d613f607 / . / mcu / service / nvram / src / nvram_interface.c
blob: 73a667f65a4c51634ed2fd2aaf0c1d11f5b4a96a [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 * Filename:
38 * ---------
39 * nvram_interface.c
40 *
41 * Project:
42 * --------
43 * MAUI
44 *
45 * Description:
46 * ------------
47 * These are interface functions of NVRAM module.
48 *
49 * Author:
50 * -------
51 * -------
52 *
53 *============================================================================
54 * HISTORY
55 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
56 *------------------------------------------------------------------------------
57 * removed!
58 *
59 * removed!
60 * removed!
61 * removed!
62 * removed!
63 *
64 * removed!
65 * removed!
66 * removed!
67 * removed!
68 *
69 * removed!
70 * removed!
71 * removed!
72 * removed!
73 *
74 * removed!
75 * removed!
76 * removed!
77 * removed!
78 *
79 * removed!
80 * removed!
81 * removed!
82 * removed!
83 *
84 * removed!
85 * removed!
86 * removed!
87 * removed!
88 *
89 * removed!
90 * removed!
91 * removed!
92 *
93 * removed!
94 * removed!
95 * removed!
96 * removed!
97 *
98 * removed!
99 * removed!
100 * removed!
101 *
102 * removed!
103 * removed!
104 * removed!
105 * removed!
106 * removed!
107 *
108 * removed!
109 * removed!
110 * removed!
111 * removed!
112 * removed!
113 * removed!
114 * removed!
115 * removed!
116 *
117 * removed!
118 * removed!
119 * removed!
120 *
121 * removed!
122 * removed!
123 * removed!
124 *
125 * removed!
126 * removed!
127 * removed!
128 *
129 * removed!
130 * removed!
131 *
132 * removed!
133 * removed!
134 * removed!
135 *
136 * removed!
137 * removed!
138 *
139 * removed!
140 * removed!
141 *
142 * removed!
143 * removed!
144 * removed!
145 *
146 * removed!
147 * removed!
148 * removed!
149 * removed!
150 *
151 * removed!
152 * removed!
153 * removed!
154 *
155 * removed!
156 * removed!
157 * removed!
158 *
159 * removed!
160 * removed!
161 * removed!
162 *
163 * removed!
164 * removed!
165 *
166 * removed!
167 * removed!
168 * removed!
169 *
170 * removed!
171 * removed!
172 * removed!
173 *
174 * removed!
175 * removed!
176 *
177 * removed!
178 * removed!
179 * removed!
180 *
181 * removed!
182 *
183 * removed!
184 *
185 * removed!
186 * removed!
187 * removed!
188 *
189 * removed!
190 * removed!
191 * removed!
192 *
193 * removed!
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 *
214 * removed!
215 * removed!
216 * removed!
217 *
218 * removed!
219 * removed!
220 * removed!
221 *
222 * removed!
223 * removed!
224 * removed!
225 *
226 * removed!
227 * removed!
228 * removed!
229 *
230 * removed!
231 * removed!
232 * removed!
233 *
234 * removed!
235 * removed!
236 * removed!
237 *
238 * removed!
239 * removed!
240 * removed!
241 * removed!
242 * removed!
243 * removed!
244 * removed!
245 * removed!
246 * removed!
247 * removed!
248 * removed!
249 * removed!
250 * removed!
251 * removed!
252 * removed!
253 *
254 * removed!
255 * removed!
256 * removed!
257 *
258 * removed!
259 * removed!
260 * removed!
261 *
262 * removed!
263 * removed!
264 * removed!
265 *
266 * removed!
267 * removed!
268 * removed!
269 *
270 * removed!
271 * removed!
272 * removed!
273 *
274 * removed!
275 * removed!
276 * removed!
277 *
278 * removed!
279 * removed!
280 * removed!
281 *
282 * removed!
283 * removed!
284 * removed!
285 *
286 * removed!
287 * removed!
288 * removed!
289 *
290 * removed!
291 * removed!
292 * removed!
293 *
294 * removed!
295 * removed!
296 * removed!
297 *
298 * removed!
299 * removed!
300 * removed!
301 *
302 * removed!
303 * removed!
304 * removed!
305 *
306 * removed!
307 * removed!
308 * removed!
309 *
310 * removed!
311 * removed!
312 * removed!
313 *
314 * removed!
315 * removed!
316 * removed!
317 *
318 * removed!
319 * removed!
320 * removed!
321 *
322 * removed!
323 * removed!
324 * removed!
325 *
326 * removed!
327 * removed!
328 * removed!
329 *
330 * removed!
331 * removed!
332 * removed!
333 *
334 * removed!
335 * removed!
336 * removed!
337 *
338 * removed!
339 * removed!
340 * removed!
341 *
342 * removed!
343 * removed!
344 * removed!
345 *
346 * removed!
347 * removed!
348 * removed!
349 *
350 * removed!
351 * removed!
352 * removed!
353 *
354 * removed!
355 * removed!
356 * removed!
357 *
358 * removed!
359 * removed!
360 * removed!
361 *
362 * removed!
363 * removed!
364 * removed!
365 *
366 * removed!
367 * removed!
368 * removed!
369 *
370 * removed!
371 * removed!
372 * removed!
373 *
374 * removed!
375 * removed!
376 * removed!
377 *
378 * removed!
379 * removed!
380 * removed!
381 *
382 * removed!
383 * removed!
384 * removed!
385 *
386 * removed!
387 * removed!
388 * removed!
389 *
390 * removed!
391 * removed!
392 * removed!
393 *
394 * removed!
395 * removed!
396 *
397 *
398 * removed!
399 * removed!
400 *
401 *
402 * removed!
403 * removed!
404 *
405 *
406 * removed!
407 * removed!
408 *
409 *
410 * removed!
411 * removed!
412 *
413 *
414 * removed!
415 * removed!
416 *
417 *
418 * removed!
419 * removed!
420 *
421 *
422 * removed!
423 * removed!
424 *
425 *
426 * removed!
427 * removed!
428 *
429 *
430 * removed!
431 * removed!
432 *
433 *
434 * removed!
435 * removed!
436 * removed!
437 *
438 * removed!
439 * removed!
440 * removed!
441 *
442 * removed!
443 * removed!
444 *
445 *
446 * removed!
447 * removed!
448 *
449 *
450 * removed!
451 * removed!
452 *
453 *
454 * removed!
455 * removed!
456 *
457 *
458 * removed!
459 * removed!
460 *
461 *
462 * removed!
463 * removed!
464 *
465 *
466 * removed!
467 * removed!
468 *
469 *
470 * removed!
471 * removed!
472 *
473 *
474 * removed!
475 * removed!
476 *
477 *
478 * removed!
479 * removed!
480 *
481 *
482 * removed!
483 * removed!
484 *
485 *
486 * removed!
487 * removed!
488 *
489 *
490 * removed!
491 * removed!
492 *
493 *
494 * removed!
495 * removed!
496 *
497 *
498 * removed!
499 * removed!
500 *
501 *
502 * removed!
503 * removed!
504 *
505 *
506 * removed!
507 * removed!
508 *
509 *
510 * removed!
511 * removed!
512 *
513 *
514 * removed!
515 * removed!
516 *
517 *
518 * removed!
519 * removed!
520 *
521 *
522 * removed!
523 * removed!
524 *
525 *
526 * removed!
527 * removed!
528 *
529 *
530 * removed!
531 * removed!
532 *
533 *
534 * removed!
535 * removed!
536 *
537 *
538 * removed!
539 * removed!
540 *
541 *
542 * removed!
543 * removed!
544 *
545 *
546 * removed!
547 * removed!
548 *
549 *
550 * removed!
551 * removed!
552 *
553 *
554 * removed!
555 * removed!
556 *
557 *
558 * removed!
559 * removed!
560 *
561 *
562 * removed!
563 * removed!
564 *
565 *
566 * removed!
567 * removed!
568 *
569 *
570 * removed!
571 * removed!
572 *
573 *
574 * removed!
575 * removed!
576 * removed!
577 *
578 * removed!
579 * removed!
580 * removed!
581 *
582 * removed!
583 * removed!
584 *
585 *
586 * removed!
587 * removed!
588 *
589 *
590 * removed!
591 * removed!
592 *
593 *
594 * removed!
595 * removed!
596 * removed!
597 *
598 * removed!
599 * removed!
600 * removed!
601 *
602 * removed!
603 * removed!
604 *
605 *
606 * removed!
607 * removed!
608 *
609 *
610 * removed!
611 * removed!
612 *
613 *
614 * removed!
615 * removed!
616 *
617 *
618 * removed!
619 * removed!
620 *
621 *
622 * removed!
623 * removed!
624 *
625 *
626 * removed!
627 * removed!
628 *
629 *
630 * removed!
631 * removed!
632 *
633 *
634 * removed!
635 * removed!
636 *
637 *
638 * removed!
639 * removed!
640 *
641 *
642 * removed!
643 * removed!
644 *
645 *
646 * removed!
647 * removed!
648 *
649 *
650 * removed!
651 * removed!
652 *
653 *
654 * removed!
655 * removed!
656 *
657 *
658 * removed!
659 * removed!
660 * removed!
661 *
662 * removed!
663 * removed!
664 * removed!
665 *
666 * removed!
667 * removed!
668 * removed!
669 *
670 * removed!
671 * removed!
672 * removed!
673 *
674 * removed!
675 * removed!
676 *
677 *
678 * removed!
679 * removed!
680 *
681 *
682 *------------------------------------------------------------------------------
683 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
684 *============================================================================
685 ****************************************************************************/
686
687/*
688 * Include
689 */
690#include "string.h"
691#include "kal_general_types.h"
692#include "kal_public_api.h"
693#include "kal_public_defs.h"
694#include "kal_trace.h"
695
696
697#include "kal_public_defs.h" //MSBB change #include "stack_config.h"
698#include "ex_item.h"
699#include "ex_public.h"
700#include "sysconf_statistics.h"
701
702#include "fs_type.h"
703#include "fs_errcode.h"
704#include "fs_func.h"
705//MSBB remove #include "fctycomp_config.h"
706
707#include "nvram_data_items.h"
708#include "nvram_group_def.h" //add for break group files from header file
709#include "nvram_main.h"
710#include "nvram_interface.h"
711
712#include "ul1_nvram_def.h"
713#include "audio_nvram_def.h"
714#include "ex_nvram_def.h"
715#include "nvram_msgid.h"
716
717#include "SST_secure.h"
718#include "svc_sap.h"
719#include "us_timer.h"
720#include "mcf_if.h"
721#include "cc_ex_item.h"
722#include "ex_public.h"
723
724/*
725 * Macro
726 */
727#define NVRAM_SPACE_MARGIN 10
728
729/*
730* used to check nvram ee memory info
731*/
732kal_bool g_nvram_emm_query_info_result = KAL_TRUE;
733kal_uint32 g_nvram_emm_size = 0;
734kal_uint32 g_nvram_emm_addr = 0;
735
736/*
737 * Local Variable
738 */
739#if defined(__MTK_TARGET__) || defined(__OFFLINE_EX_LOG_PARSER__)
740static EX_FULLLOG_T exception_full_log;
741#endif
742
743static kal_uint8 nvram_exception_buffer[NVRAM_EF_SYS_EXCEPTION_SIZE];
744extern kal_uint32 BytesPerCluster; /* will be set to exact value in nvram_get_disk_file_info */
745extern kal_bool stack_update_sys_statistics(stack_statistics_struct *prev_stats);
746
747extern nvram_shutdown_cb_struct nvram_shutdown_cb_table[];
748extern nvram_access_trace_information nvram_access_trace;
749extern kal_mutexid g_nvram_trace_mutex;
750extern module_type stack_get_active_module_id( void );
751
752extern nvram_ee_info_type* nvram_ee_info;
753extern kal_char nvram_trace_dump_temp_buffer[];
754extern kal_char nvram_trace_dump_buffer[];
755extern kal_mutexid g_nvram_dump_trace_mutex;
756extern kal_wchar nvram_trace_filename[];
757extern FS_HANDLE nvram_trace_file_hdl;
758extern kal_uint32 nvram_trace_dump_buffer_offset;
759
760
761
762/*****************************************************************************
763 * FUNCTION
764 * nvram_get_info
765 * DESCRIPTION
766 * This is nvram_get_info() function of NVRAM module.
767 * PARAMETERS
768 * LID [IN]
769 * total [?]
770 * size [?]
771 * RETURNS
772 * NVRAM_ERRNO_SUCCESS if succeed, NVRAM_ERRNO_INVALID otherwise (ie, invalid LID).
773 *****************************************************************************/
774nvram_errno_enum nvram_get_info(nvram_lid_enum LID, kal_uint16 *total, kal_uint16 *size)
775{
776 /*----------------------------------------------------------------*/
777 /* Local Variables */
778 /*----------------------------------------------------------------*/
779 nvram_ltable_entry_struct *ldi;
780
781 /*----------------------------------------------------------------*/
782 /* Code Body */
783 /*----------------------------------------------------------------*/
784 if ((nvram_ptr->state != NVRAM_STATE_READY) && !nvram_util_is_usbboot())
785 {
786 return NVRAM_ERRNO_FAIL;
787 }
788
789 nvram_pre_init();
790
791 if (!NVRAM_IS_LID_VALID(LID))
792 {
793 return NVRAM_IO_ERRNO_INVALID_LID;
794 }
795
796 nvram_util_get_data_item(&ldi, LID);
797
798 *total = ldi->total_records;
799 *size = ldi->size;
800
801 return NVRAM_ERRNO_SUCCESS;
802} /* end of nvram_get_info function */
803
804
805/*****************************************************************************
806 * FUNCTION
807 * nvram_log_ota_info
808 * DESCRIPTION
809 * show OTA version info in ELT log
810 *
811 * PARAMETERS
812 * void
813 * RETURNS
814 * void
815 *****************************************************************************/
816void nvram_log_ota_info(void)
817{
818 kal_wchar filename[NVRAM_MAX_PATH_LEN];
819 FS_HANDLE handle;
820 kal_char info[256];
821 kal_uint32 len = 0;
822 kal_int32 result = FS_NO_ERROR;
823 /*----------------------------------------------------------------*/
824 /* Code Body */
825 /*----------------------------------------------------------------*/
826 kal_wsprintf(filename, "%s", NVRAM_SWCHANGE_REPORT_FILE_TXT);
827
828 NVRAM_FS_START_EX(FS_OP_OPEN,filename);
829 handle = FS_Open(filename, FS_READ_ONLY);
830 NVRAM_FS_END(FS_OP_OPEN,result);
831 if (handle < FS_NO_ERROR) {
832 return;
833 }
834 NVRAM_FS_START(FS_OP_READ);
835 result = FS_Read(handle, info, sizeof(info)-1, &len);
836 NVRAM_FS_END(FS_OP_READ,result);
837 NVRAM_FS_START(FS_OP_CLOSE);
838 result = FS_Close(handle);
839 NVRAM_FS_END(FS_OP_CLOSE,result);
840 if (len > 0) {
841 info[len] = '\0';
842 dhl_print(TRACE_INFO, DHL_USER_FLAG_NONE, MOD_NIL, "[NVRAM] %s", info); /* MOD_NIL will log to System trace */
843 }
844}
845
846
847/*****************************************************************************
848 * FUNCTION
849 * nvram_write_exception
850 * DESCRIPTION
851 *
852 * PARAMETERS
853 * length: [IN] buffer length
854 * ex_data: [IN] ex_data
855 * ex_log: [IN] ex_log
856 * RETURNS
857 * void
858 *****************************************************************************/
859void nvram_write_exception(kal_uint16 length, long *ex_data, long *ex_log)
860{
861 #if defined(__MTK_TARGET__) || defined(__OFFLINE_EX_LOG_PARSER__)
862 /*----------------------------------------------------------------*/
863 /* Local Variables */
864 /*----------------------------------------------------------------*/
865 kal_uint16 i;
866 kal_uint16 prev_num = 0;
867
868 nvram_drv_status_enum result;
869 nvram_ltable_entry_struct *ldi;
870
871 EX_LOG_T *exception_ptr = (EX_LOG_T*) nvram_exception_buffer;
872 EX_FULLLOG_T* exception_fulllog_ptr = (EX_FULLLOG_T*)ex_data;
873
874 /*----------------------------------------------------------------*/
875 /* Code Body */
876 /*----------------------------------------------------------------*/
877 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s ====>\r\n",__FUNCTION__);
878 nvram_log_ota_info();
879
880 if (ex_data == NULL)
881 {
882 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s \r\n",__FUNCTION__);
883 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
884 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION1();
885 return;
886 }
887 if (ex_log == NULL)
888 {
889 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
890 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION1();
891 return;
892 }
893
894 /* Length must be equal to NVRAM_EF_SYS_EXCEPTION_SIZE */
895 if (length != NVRAM_EF_SYS_EXCEPTION_SIZE)
896 {
897 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
898 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(length, NVRAM_EF_SYS_EXCEPTION_SIZE);
899 return;
900 }
901
902 /* Exception could happen even when no task is initialized */
903 if (nvram_ptr->state == NVRAM_STATE_NULL)
904 {
905 //nvram_init(INDX_NIL);
906 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
907 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(NVRAM_STATE_NULL, 1);
908 return;
909 }
910
911 /**
912 * Now linear searching for a free record such that ex_data could be
913 * written.
914 *
915 * Note that if value of ex_nvram field of a exception record
916 * is NOT 0xFF, then it is a valid record; otherwise it is a free
917 * record.
918 * Furthermore, update of exception records cannot exceeds
919 * the capacity, ie, number of exception records defined in NVRAM.
920 * Once the storage is full, no more exception record can be dumped.
921 * Hence, as long as a free record is found, then that record and
922 * other records after it could be all assumed to be free.
923 */
924
925 nvram_util_get_data_item(&ldi, NVRAM_EF_SYS_EXCEPTION_LID);
926
927 for (i = 1; i <= NVRAM_EF_SYS_EXCEPTION_TOTAL; ++i)
928 {
929 memset(&exception_full_log,0,sizeof(exception_full_log));
930 result = nvram_read_exception_data_item(ldi, i, (kal_uint8*) & exception_full_log, sizeof(exception_full_log));
931 /* Ok, now determine whether it is a free record */
932
933 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(i, result);
934 if ((result == NVRAM_DRV_OK))
935 {
936 if ((exception_full_log.mcu.ex_log.header.ex_nvram != KAL_TRUE) && (exception_full_log.mcu.ex_log.header.ex_serial_num < prev_num)) /* Found! */
937 {
938 break;
939 }
940 else
941 {
942 prev_num = exception_full_log.mcu.ex_log.header.ex_serial_num;
943 }
944 }
945 else if(result == NVRAM_DRV_EMPTY_RECORD)
946 {
947 if ((exception_full_log.mcu.ex_log.header.ex_nvram != KAL_TRUE)) /* Found! */
948 {
949 break;
950 }
951 }
952 else /* Error, read fail!? How come?.....Dunno what to do.. */
953 {
954 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(i, result);
955 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
956 return;
957 }
958 }
959
960 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(0, 255);
961 if (i >= NVRAM_EF_SYS_EXCEPTION_TOTAL + 1)
962 {
963 i = 1;
964 }
965
966 prev_num += 1;
967 if (prev_num == 0xFFFF)
968 {
969 prev_num = 1; /* wrap around to 1 if it reaches 65535 */
970 }
971
972 /**
973 *
974 * Hence the first record is the free record. Increment the serial number
975 * of the last record and take it as the new serial number for free record.
976 */
977 exception_ptr = (EX_LOG_T*) ex_log;
978 exception_ptr->header.ex_nvram = KAL_TRUE;
979 exception_ptr->header.ex_serial_num = prev_num;
980
981 exception_fulllog_ptr->mcu.ex_log.header.ex_nvram = KAL_TRUE;
982 exception_fulllog_ptr->mcu.ex_log.header.ex_serial_num = prev_num;
983
984 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(1, prev_num);
985
986 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(ldi->LID, i);
987
988 nvram_write_exception_data_item(ldi, i, (kal_uint8*) ex_data);
989
990 MD_TRC_FUNC_NVRAM_WRITE_EXCEPTION2(1, __LINE__);
991 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s <====\r\n",__FUNCTION__);
992 #else
993 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
994 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s <====\r\n",__FUNCTION__);
995 return;
996 #endif
997} /* end of nvram_write_exception function */
998
999
1000/*****************************************************************************
1001 * FUNCTION
1002 * nvram_get_lid_num
1003 * DESCRIPTION
1004 * To get the maxium LID
1005 * PARAMETERS
1006 * void
1007 * RETURNS
1008 * nvram_ptr->ltable.total_LID
1009 *****************************************************************************/
1010nvram_lid_enum nvram_get_lid_num(void)
1011{
1012 /*----------------------------------------------------------------*/
1013 /* Local Variables */
1014 /*----------------------------------------------------------------*/
1015
1016 /*----------------------------------------------------------------*/
1017 /* Code Body */
1018 /*----------------------------------------------------------------*/
1019 return nvram_ptr->ltable.total_LID;
1020
1021}
1022
1023
1024/*****************************************************************************
1025 * FUNCTION
1026 * nvram_check_backup
1027 * DESCRIPTION
1028 * To tell given LID needs to backup or not
1029 * PARAMETERS
1030 * LID [IN] LID of the file
1031 * prefix [IN] file prefix
1032 * RETURNS
1033 * NVRAM_IO_ERRNO_OK: need to backup
1034 * NVRAM_IO_ERRNO_INVALID_LID: LID out of range or don't need to backup
1035 *****************************************************************************/
1036kal_uint8 nvram_check_backup(nvram_lid_enum LID, kal_char **prefix, kal_char **verno)
1037{
1038 /*----------------------------------------------------------------*/
1039 /* Local Variables */
1040 /*----------------------------------------------------------------*/
1041 nvram_ltable_entry_struct *ldi = NULL;
1042
1043 /*----------------------------------------------------------------*/
1044 /* Code Body */
1045 /*----------------------------------------------------------------*/
1046 if (!NVRAM_IS_LID_VALID(LID) || prefix == NULL)
1047 {
1048 return NVRAM_IO_ERRNO_INVALID_LID;
1049 }
1050
1051 nvram_util_get_data_item(&ldi, LID);
1052
1053 if ((NVRAM_IS_CATEGORY_CALIBRAT(ldi->category) ||
1054 NVRAM_IS_CATEGORY_IMPORTANT(ldi->category)||
1055 NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)) &&
1056 !NVRAM_IS_CATEGORY_OTP(ldi->category))
1057 {
1058 #ifdef __NVRAM_PSEUDO_MERGE__
1059 if (NVRAM_IS_ATTR_PACKAGE(ldi->attr))
1060 {
1061 *prefix = "PACK";
1062 *verno = "LID";
1063 }
1064 else
1065 #endif
1066 {
1067 *prefix = ldi->fileprefix;
1068 *verno = ldi->fileverno;
1069 }
1070 return NVRAM_IO_ERRNO_OK;
1071 }
1072 else
1073 {
1074 *prefix = NULL;
1075 *verno = NULL;
1076 return NVRAM_IO_ERRNO_INVALID_LID;
1077 }
1078
1079
1080}
1081
1082
1083/*****************************************************************************
1084 * FUNCTION
1085 * nvram_validate_file
1086 * DESCRIPTION
1087 * To validate integrity of the given file
1088 * PARAMETERS
1089 * LID [IN] LID of the file
1090 * path [IN] path to validate
1091 * RETURNS
1092 * NVRAM_IO_ERRNO_OK: valid
1093 * NVRAM_IO_ERRNO_INVALID_LID: LID out of range
1094 * others: invalid
1095 *****************************************************************************/
1096nvram_errno_enum nvram_validate_file(nvram_lid_enum LID, kal_wchar *path)
1097{
1098 /*----------------------------------------------------------------*/
1099 /* Local Variables */
1100 /*----------------------------------------------------------------*/
1101 nvram_ltable_entry_struct *ldi = NULL;
1102 kal_uint8 *buffer = NULL;
1103 kal_int32 result;
1104 FS_HANDLE hFile = 0;
1105 kal_uint32 nvram_chksum_size = 0;
1106 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM;
1107 nvram_lid_chksum_info lid_chksum_info = {0};
1108
1109#ifdef __NVRAM_PSEUDO_MERGE__
1110 kal_uint32 file_offset;
1111#endif
1112
1113 /*----------------------------------------------------------------*/
1114 /* Code Body */
1115 /*----------------------------------------------------------------*/
1116 if (!NVRAM_IS_LID_VALID(LID))
1117 {
1118 return NVRAM_IO_ERRNO_INVALID_LID;
1119 }
1120
1121 nvram_util_get_data_item(&ldi, LID);
1122
1123
1124#ifdef __NVRAM_PSEUDO_MERGE__
1125 if (NVRAM_IS_ATTR_PACKAGE(ldi->attr))
1126 {
1127 file_offset = (kal_uint32) (ldi->description);
1128 }
1129 else
1130 {
1131 file_offset = (kal_uint32) 0;
1132 }
1133#endif
1134
1135 /* open NV_RCD.(RCD#) file */
1136 NVRAM_FS_START_EX(FS_OP_OPEN,path);
1137 hFile = FS_Open((const kal_wchar*)path, FS_READ_ONLY | FS_OPEN_NO_DIR | FS_OPEN_SHARED);
1138 NVRAM_FS_END(FS_OP_OPEN,hFile);
1139 if (FS_NO_ERROR > hFile)
1140 {
1141 return NVRAM_IO_ERRNO_INVALID_LID;
1142 }
1143
1144#ifdef __NVRAM_PSEUDO_MERGE__
1145 NVRAM_FS_START(FS_OP_SEEK);
1146 result = FS_Seek(hFile, file_offset, FS_FILE_BEGIN);
1147 NVRAM_FS_END(FS_OP_SEEK,result);
1148 if (file_offset && FS_NO_ERROR > result)
1149 {
1150 NVRAM_FS_START(FS_OP_CLOSE);
1151 result = FS_Close(hFile);
1152 NVRAM_FS_END(FS_OP_CLOSE,result);
1153 return NVRAM_IO_ERRNO_INVALID_LID;
1154 }
1155#endif
1156
1157 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
1158 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
1159 read_chksum_type = lid_chksum_info.read_chksum_type;
1160
1161
1162 buffer = (kal_uint8 *)get_ctrl_buffer(nvram_chksum_size * ldi->total_records);
1163
1164 result = nvram_drv_fat_read_section(hFile, 1, ldi->total_records, ldi->size, buffer, read_chksum_type, ldi);
1165
1166 free_ctrl_buffer(buffer);
1167
1168 NVRAM_FS_START(FS_OP_CLOSE);
1169 result = FS_Close(hFile);
1170 NVRAM_FS_END(FS_OP_CLOSE,result);
1171
1172 if (result != NVRAM_DRV_OK)
1173 {
1174 return NVRAM_IO_ERRNO_INVALID_LID;
1175 }
1176
1177 return NVRAM_IO_ERRNO_OK;
1178}
1179
1180
1181/*****************************************************************************
1182 * FUNCTION
1183 * nvram_external_read_multi_record
1184 * DESCRIPTION
1185 * This function is used to get data items for external modules.
1186 * PARAMETERS
1187 * LID [IN]
1188 * rec_index [IN]
1189 * rec_amount [IN]
1190 * buffer [?]
1191 * buffer_size [IN]
1192 * .(?)
1193 * RETURNS
1194 * NVRAM_ERRNO_SUCCESS if succeed, NVRAM_ERRNO_INVALID otherwise (ie, invalid LID).
1195 *****************************************************************************/
1196kal_bool nvram_external_read_multi_record(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
1197{
1198 /*----------------------------------------------------------------*/
1199 /* Local Variables */
1200 /*----------------------------------------------------------------*/
1201 nvram_ltable_entry_struct *ldi = NULL;
1202 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1203 kal_uint32 nvram_trace_index = 0;
1204 /*----------------------------------------------------------------*/
1205 /* Code Body */
1206 /*----------------------------------------------------------------*/
1207
1208 /*record nvram msg read access information to global struct*/
1209 nvram_util_take_mutex(g_nvram_trace_mutex);
1210 nvram_trace_index = nvram_access_trace.read_trace_index;
1211 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1212 nvram_util_give_mutex(g_nvram_trace_mutex);
1213
1214 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1215 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
1216 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1217 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1218
1219 if (nvram_ptr->state != NVRAM_STATE_READY)
1220 {
1221 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1222 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1223 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1224 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1225 return KAL_FALSE;
1226 }
1227
1228// nvram_pre_init();
1229
1230 /**
1231 * Invalid input paramters.
1232 */
1233 if (!NVRAM_IS_LID_VALID(LID))
1234 {
1235 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1236 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
1237 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1238 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1239 return KAL_FALSE;
1240 }
1241
1242 nvram_util_get_data_item(&ldi, LID);
1243 if(NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
1244 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1245 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
1246 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
1247 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
1248 return KAL_FALSE;
1249 }
1250
1251 if(SST_NVRAM_Data_Access_Check(LID, 0, KAL_FALSE, NULL))
1252 {
1253 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1254 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1255 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1256 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1257 return KAL_FALSE;
1258 }
1259#ifdef __NVRAM_READ_RESERVED_FILE__
1260 if(ldi->LID == NVRAM_EF_READ_RESERVED_LID) {
1261 nvram_ltable_entry_struct *ldi_r = (nvram_ltable_entry_struct*)ldi->default_value;
1262 if(SST_NVRAM_Data_Access_Check(ldi_r->LID, 0, KAL_FALSE, NULL))
1263 {
1264 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1265 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1266 kal_prompt_trace(MOD_NVRAM,"%s->Reserve LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,ldi_r->LID);
1267 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Reserve LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,ldi_r->LID);
1268 return KAL_FALSE;
1269 }
1270 }
1271#endif
1272
1273#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1274 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1275 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1276 {
1277 #ifdef __TC01__
1278 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1279 #else
1280 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1281 #endif
1282 {
1283 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1284 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1285 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1286 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1287 return KAL_FALSE;
1288 }
1289 }
1290#endif
1291
1292 if ((rec_index < 1) ||(rec_index > ldi->total_records))
1293 {
1294 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1295 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
1296 kal_prompt_trace(MOD_NVRAM,"[Error]%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
1297 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD\r\n",__FUNCTION__,LID);
1298 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
1299 return KAL_FALSE;
1300 }
1301
1302 if (rec_index+rec_amount-1 > ldi->total_records)
1303 {
1304 rec_amount = ldi->total_records-rec_index+1;
1305 }
1306
1307
1308 /* handle by nvram_io layer */
1309 result = nvram_read_data_item(ldi, rec_index, rec_amount, buffer, buffer_size);
1310 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1311 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
1312
1313 if (result != NVRAM_IO_ERRNO_OK)
1314 {
1315 kal_prompt_trace(MOD_NVRAM,"%s->LID(0x%x) nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1316 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1317 return KAL_FALSE;
1318 }
1319 else
1320 {
1321 return KAL_TRUE;
1322 }
1323
1324}
1325
1326
1327
1328/*****************************************************************************
1329 * FUNCTION
1330 * nvram_external_read_data
1331 * DESCRIPTION
1332 * This function is used to get data items for external modules.
1333 * PARAMETERS
1334 * LID [IN]
1335 * rec_index [IN]
1336 * buffer [?]
1337 * buffer_size [IN]
1338 * .(?)
1339 * RETURNS
1340 * NVRAM_ERRNO_SUCCESS if succeed, NVRAM_ERRNO_INVALID otherwise (ie, invalid LID).
1341 *****************************************************************************/
1342kal_bool nvram_external_read_data(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint8 *buffer, kal_uint32 buffer_size)
1343{
1344 return nvram_external_read_multi_record(LID, rec_index, 1, buffer, buffer_size);
1345}
1346
1347
1348/*****************************************************************************
1349 * FUNCTION
1350 * nvram_external_read_raw_data
1351 * DESCRIPTION
1352 * This function is used to get data items for external modules.
1353 * PARAMETERS
1354 * LID [IN]
1355 * offset [IN]
1356 * buffer [OUT]
1357 * buffer_size [IN]
1358 * .(?)
1359 * RETURNS
1360 * NVRAM_ERRNO_SUCCESS if succeed, NVRAM_ERRNO_INVALID otherwise (ie, invalid LID).
1361 *****************************************************************************/
1362kal_bool nvram_external_read_raw_data(nvram_lid_enum LID, kal_uint32 offset, kal_uint8 *buffer, kal_uint32 buffer_size)
1363{
1364 /*----------------------------------------------------------------*/
1365 /* Local Variables */
1366 /*----------------------------------------------------------------*/
1367 nvram_ltable_entry_struct *ldi = NULL;
1368 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1369 kal_uint32 nvram_trace_index = 0;
1370 /*----------------------------------------------------------------*/
1371 /* Code Body */
1372 /*----------------------------------------------------------------*/
1373
1374 /*record nvram msg read access information to global struct*/
1375 nvram_util_take_mutex(g_nvram_trace_mutex);
1376 nvram_trace_index = nvram_access_trace.read_trace_index;
1377 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1378 nvram_util_give_mutex(g_nvram_trace_mutex);
1379
1380 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1381 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
1382 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1383 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1384
1385 if (nvram_ptr->state != NVRAM_STATE_READY) {
1386 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1387 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1388
1389 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1390 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1391 return KAL_FALSE;
1392 }
1393
1394 /**
1395 * Invalid input paramters.
1396 */
1397 if(!nvram_util_get_data_item(&ldi, LID)) {
1398 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1399 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
1400 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID \r\n",__FUNCTION__,LID);
1401 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID \r\n",__FUNCTION__,LID);
1402 return KAL_FALSE;
1403 }
1404 if(!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
1405 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1406 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
1407 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n\r\n",__FUNCTION__,LID);
1408 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
1409 return KAL_FALSE;
1410 }
1411
1412 if(SST_NVRAM_Data_Access_Check(LID, 0, KAL_FALSE, NULL))
1413 {
1414 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1415 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1416 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1417 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1418 return KAL_FALSE;
1419 }
1420
1421#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1422 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1423 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1424 {
1425 #ifdef __TC01__
1426 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1427 #else
1428 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1429 #endif
1430 {
1431 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1432 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1433 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1434 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1435 return KAL_FALSE;
1436 }
1437 }
1438#endif
1439
1440 /* handle by nvram_io layer */
1441 result = nvram_read_data_item(ldi, offset, 1, buffer, buffer_size);
1442 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1443 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
1444 if (result != NVRAM_IO_ERRNO_OK)
1445 {
1446 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1447 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1448 return KAL_FALSE;
1449 }
1450 else
1451 {
1452 return KAL_TRUE;
1453 }
1454
1455}
1456/*****************************************************************************
1457 * FUNCTION
1458 * nvram_external_secure_read_data
1459 * DESCRIPTION
1460 * This function is used to get data items for external modules with secure check.
1461 * PARAMETERS
1462 * LID [IN]
1463 * rec_index [IN]
1464 * buffer [?]
1465 * buffer_size [IN]
1466 * .(?)
1467 * RETURNS
1468 * NVRAM_ERRNO_SUCCESS if succeed, NVRAM_ERRNO_INVALID otherwise (ie, invalid LID).
1469 *****************************************************************************/
1470nvram_errno_enum nvram_external_secure_read_data(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint8 *buffer, kal_uint32 buffer_size, void* reserved_ptr)
1471{
1472 /*----------------------------------------------------------------*/
1473 /* Local Variables */
1474 /*----------------------------------------------------------------*/
1475 nvram_ltable_entry_struct *ldi = NULL;
1476 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1477 kal_uint32 nvram_trace_index;
1478 /*----------------------------------------------------------------*/
1479 /* Code Body */
1480 /*----------------------------------------------------------------*/
1481
1482 /*record nvram msg read access information to global struct*/
1483 nvram_util_take_mutex(g_nvram_trace_mutex);
1484 nvram_trace_index = nvram_access_trace.read_trace_index;
1485 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1486 nvram_util_give_mutex(g_nvram_trace_mutex);
1487
1488 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1489 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_SECURE_API;
1490 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1491 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1492
1493 if (nvram_ptr->state != NVRAM_STATE_READY)
1494 {
1495 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1496 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1497 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__);
1498 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1499 return NVRAM_ERRNO_NOT_READY;
1500 }
1501
1502// nvram_pre_init();
1503
1504 /**
1505 * Invalid input paramters.
1506 */
1507 if (!NVRAM_IS_LID_VALID(LID))
1508 {
1509 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1510 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
1511 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID \r\n",__FUNCTION__,LID);
1512 return NVRAM_IO_ERRNO_INVALID_LID;
1513 }
1514
1515 nvram_util_get_data_item(&ldi, LID);
1516 if(NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
1517 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1518 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
1519 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
1520 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
1521 return KAL_FALSE;
1522 }
1523
1524 if(SST_NVRAM_Data_Access_Check(LID, 0, KAL_TRUE, reserved_ptr))
1525 {
1526 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1527 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1528 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1529 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1530 return NVRAM_IO_ERRNO_ACCESS_DENIED;
1531 }
1532#ifdef __NVRAM_READ_RESERVED_FILE__
1533 if(ldi->LID == NVRAM_EF_READ_RESERVED_LID) {
1534 nvram_ltable_entry_struct *ldi_r = (nvram_ltable_entry_struct*)ldi->default_value;
1535 if(SST_NVRAM_Data_Access_Check(ldi_r->LID, 0, KAL_FALSE, NULL))
1536 {
1537 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1538 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1539 kal_prompt_trace(MOD_NVRAM,"%s->Reserve LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1540 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Reserve LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
1541 return KAL_FALSE;
1542 }
1543 }
1544#endif
1545
1546#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1547 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1548 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1549 {
1550 #ifdef __TC01__
1551 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1552 #else
1553 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1554 #endif
1555 {
1556 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1557 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1558 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta mode\r\n",__FUNCTION__,ldi->LID);
1559 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta mode\r\n",__FUNCTION__,ldi->LID);
1560 return NVRAM_IO_ERRNO_ACCESS_DENIED;
1561 }
1562 }
1563#endif
1564
1565 if ((rec_index < 1) ||(rec_index > ldi->total_records))
1566 {
1567 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1568 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
1569 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
1570 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
1571 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
1572 return NVRAM_IO_ERRNO_INVALID_RECORD;
1573 }
1574
1575
1576 /* handle by nvram_io layer */
1577 result = nvram_read_data_item(ldi, rec_index, 1, buffer, buffer_size);
1578 if (result != NVRAM_IO_ERRNO_OK)
1579 {
1580 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1581 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item return %d\r\n",__FUNCTION__,LID,result);
1582 }
1583 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1584 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
1585 return result;
1586}
1587
1588nvram_errno_enum nvram_external_get_lid_chksum_algo_info(nvram_lid_enum LID, nvram_lid_chksum_algo_info* lid_chksum_algo_info)
1589{
1590 /*----------------------------------------------------------------*/
1591 /* Local Variables */
1592 /*----------------------------------------------------------------*/
1593 nvram_ltable_entry_struct *ldi = NULL;
1594 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1595 kal_bool state = KAL_TRUE;
1596 nvram_lid_chksum_info lid_chksum_info = {0};
1597 /*----------------------------------------------------------------*/
1598 /* Code Body */
1599 /*----------------------------------------------------------------*/
1600
1601 if(NULL == lid_chksum_algo_info)
1602 {
1603 return NVRAM_ERRNO_FAIL;
1604 }
1605
1606 if (nvram_ptr->state != NVRAM_STATE_READY)
1607 {
1608 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1609 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1610 return NVRAM_ERRNO_NOT_READY;
1611 }
1612
1613 state = nvram_util_get_data_item(&ldi, LID);
1614 if (!state)
1615 {
1616 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1617 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1618 return NVRAM_ERRNO_INVALID;
1619 }
1620
1621 result = nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
1622 if(result != NVRAM_IO_ERRNO_OK)
1623 {
1624 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO.\r\n",__FUNCTION__,LID);
1625 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO.\r\n",__FUNCTION__,LID);
1626 return NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO;
1627 }
1628
1629 lid_chksum_algo_info->chksum_algo_length = lid_chksum_info.algo_info.chksum_algo_length;
1630 lid_chksum_algo_info->chksum_algo_type = lid_chksum_info.algo_info.chksum_algo_type;
1631
1632 return NVRAM_IO_ERRNO_OK;
1633}
1634
1635/*****************************************************************************
1636 * FUNCTION
1637 * nvram_external_read_chksum_value
1638 * DESCRIPTION
1639 * This function is used to read the checksum of data item for external module.
1640 * Please must check with NVRAM owner before you use this API.
1641 * PARAMETERS
1642 * LID: [IN] NVRAM LID
1643 * rec_index: [IN] record index
1644 * rec_amount: [IN] read how many record
1645 * buffer: [OUT] buffer pointer
1646 * buffer_size: [IN] buffer size
1647 * RETURNS
1648 * a boolean value
1649 * RETURN VALUES
1650 * KAL_FALSE: fail
1651 * KAL_TRUE: success
1652 *****************************************************************************/
1653nvram_errno_enum nvram_external_read_chksum_value(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size, nvram_lid_read_type_enum read_chksum_type)
1654{
1655 /*----------------------------------------------------------------*/
1656 /* Local Variables */
1657 /*----------------------------------------------------------------*/
1658 nvram_ltable_entry_struct *ldi = NULL;
1659 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1660 kal_bool state = KAL_TRUE;
1661 kal_uint32 nvram_trace_index = 0;
1662 kal_bool chksum_only = KAL_FALSE;
1663 nvram_lid_chksum_info lid_chksum_info = {0};
1664 /*----------------------------------------------------------------*/
1665 /* Code Body */
1666 /*----------------------------------------------------------------*/
1667
1668 /*record nvram msg read access information to global struct*/
1669 nvram_util_take_mutex(g_nvram_trace_mutex);
1670 nvram_trace_index = nvram_access_trace.read_trace_index;
1671 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1672 nvram_util_give_mutex(g_nvram_trace_mutex);
1673
1674 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1675 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
1676 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1677 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1678
1679 if (nvram_ptr->state != NVRAM_STATE_READY)
1680 {
1681 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1682 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1683 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1684 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1685 return NVRAM_ERRNO_NOT_READY;
1686 }
1687
1688// nvram_pre_init();
1689
1690 /**
1691 * Invalid input paramters.
1692 */
1693 state = nvram_util_get_data_item(&ldi, LID);
1694 if (!state)
1695 {
1696 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1697 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1698 return NVRAM_ERRNO_INVALID;
1699 }
1700
1701 if(((read_chksum_type == NVRAM_READ_TYPE_CHKSUM) || (read_chksum_type == NVRAM_READ_TYPE_CHKSUM_ONLY)))
1702 {
1703 chksum_only = (read_chksum_type == NVRAM_READ_TYPE_CHKSUM_ONLY)? KAL_TRUE : KAL_FALSE;
1704 result = nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, chksum_only, KAL_FALSE);
1705 }else
1706 {
1707 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1708 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_CHKSUM_TYPE_PARM;
1709 kal_prompt_trace(MOD_NVRAM, "[Error][NVRAM_ERRNO_CHKSUM_TYPE_PARM]%s->LID 0x%x, chceksum_type(%d)\r\n",__FUNCTION__,LID, read_chksum_type);
1710 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error][NVRAM_ERRNO_CHKSUM_TYPE_PARM]%s->LID 0x%04X, chceksum_type(%d)\r\n",__FUNCTION__,LID, read_chksum_type);
1711 return NVRAM_ERRNO_CHKSUM_TYPE_PARM;
1712 }
1713
1714 if (result != NVRAM_IO_ERRNO_OK)
1715 {
1716 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO return %d\r\n",__FUNCTION__,LID,result);
1717 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO return %d\r\n",__FUNCTION__,LID,result);
1718 return NVRAM_ERRNO_GET_CHKSUM_ALGO_INGO;
1719 }
1720
1721 if (buffer_size < (lid_chksum_info.algo_info.chksum_algo_length * rec_amount))
1722 {
1723 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1724 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
1725 kal_prompt_trace(MOD_NVRAM, "[Error][NVRAM_IO_ERRNO_INVALID_SIZE]%s->LID 0x%x.\r\n",__FUNCTION__,LID);
1726 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error][NVRAM_IO_ERRNO_INVALID_SIZE]%s->chksum_algo_type 0x%04X.\r\n",__FUNCTION__, lid_chksum_info.algo_info.chksum_algo_type);
1727 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error][NVRAM_IO_ERRNO_INVALID_SIZE]buffer_size(%d) < (chksum_algo_length*rec_amount: %d)\r\n",buffer_size,(lid_chksum_info.algo_info.chksum_algo_length * rec_amount));
1728 return NVRAM_IO_ERRNO_INVALID_SIZE;
1729 }
1730#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1731 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1732 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1733 {
1734 #ifdef __TC01__
1735 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1736 #else
1737 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1738 #endif
1739 {
1740 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1741 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1742 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1743 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1744 return NVRAM_IO_ERRNO_ACCESS_DENIED;
1745 }
1746 }
1747#endif
1748
1749 if ((rec_index < 1) ||(rec_index > ldi->total_records))
1750 {
1751 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1752 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
1753 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
1754 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
1755 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
1756 return NVRAM_IO_ERRNO_INVALID_RECORD;
1757 }
1758
1759
1760 /* handle by nvram_io layer */
1761 result = nvram_read_data_item_chksum(ldi, rec_index, rec_amount, buffer, buffer_size, lid_chksum_info.read_chksum_type);
1762 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1763 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
1764
1765 if (result != NVRAM_IO_ERRNO_OK)
1766 {
1767 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
1768 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
1769 return result;
1770 }
1771
1772 return NVRAM_IO_ERRNO_OK;
1773}
1774
1775/*****************************************************************************
1776 * FUNCTION
1777 * nvram_external_read_chksum
1778 * DESCRIPTION
1779 * This function is used to read the checksum of data item for external module.
1780 * Please must check with NVRAM owner before you use this API.
1781 * PARAMETERS
1782 * LID: [IN] NVRAM LID
1783 * rec_index: [IN] record index
1784 * rec_amount: [IN] read how many record
1785 * buffer: [OUT] buffer pointer
1786 * buffer_size: [IN] buffer size
1787 * RETURNS
1788 * a boolean value
1789 * RETURN VALUES
1790 * KAL_FALSE: fail
1791 * KAL_TRUE: success
1792 *****************************************************************************/
1793kal_bool nvram_external_read_chksum(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
1794{
1795 /*----------------------------------------------------------------*/
1796 /* Local Variables */
1797 /*----------------------------------------------------------------*/
1798 nvram_ltable_entry_struct *ldi = NULL;
1799 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1800 kal_uint32 nvram_trace_index = 0;
1801 kal_uint32 nvram_chksum_size = 0;
1802 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM_2B;
1803 nvram_lid_chksum_info lid_chksum_info = {0};
1804
1805 /*----------------------------------------------------------------*/
1806 /* Code Body */
1807 /*----------------------------------------------------------------*/
1808
1809 /*record nvram msg read access information to global struct*/
1810 nvram_util_take_mutex(g_nvram_trace_mutex);
1811 nvram_trace_index = nvram_access_trace.read_trace_index;
1812 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1813 nvram_util_give_mutex(g_nvram_trace_mutex);
1814
1815 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1816 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
1817 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1818 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1819
1820 if (nvram_ptr->state != NVRAM_STATE_READY)
1821 {
1822 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1823 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1824 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1825 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
1826 return KAL_FALSE;
1827 }
1828
1829// nvram_pre_init();
1830
1831 /**
1832 * Invalid input paramters.
1833 */
1834 if (!NVRAM_IS_LID_VALID(LID))
1835 {
1836 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1837 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
1838 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1839 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1840 return KAL_FALSE;
1841 }
1842
1843 nvram_util_get_data_item(&ldi, LID);
1844 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_TRUE);
1845 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
1846 read_chksum_type = lid_chksum_info.read_chksum_type;
1847
1848 if (buffer_size < (nvram_chksum_size * rec_amount))
1849 {
1850 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1851 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
1852 kal_prompt_trace(MOD_NVRAM, "[Error]%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE\r\n",__FUNCTION__,LID);
1853 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE\r\n",__FUNCTION__,LID);
1854 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",buffer_size,(nvram_chksum_size * rec_amount));
1855 return KAL_FALSE;
1856 }
1857
1858#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1859 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1860 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1861 {
1862 #ifdef __TC01__
1863 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1864 #else
1865 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1866 #endif
1867 {
1868 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1869 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
1870 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1871 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
1872 return KAL_FALSE;
1873 }
1874 }
1875#endif
1876
1877 if ((rec_index < 1) ||(rec_index > ldi->total_records))
1878 {
1879 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1880 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
1881 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
1882 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
1883 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
1884 return KAL_FALSE;
1885 }
1886
1887
1888 /* handle by nvram_io layer */
1889 result = nvram_read_data_item_chksum(ldi, rec_index, rec_amount, buffer, buffer_size, read_chksum_type);
1890 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1891 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
1892
1893 if (result != NVRAM_IO_ERRNO_OK)
1894 {
1895 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
1896 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
1897 return KAL_FALSE;
1898 }
1899 else
1900 {
1901 return KAL_TRUE;
1902 }
1903
1904}
1905
1906/*****************************************************************************
1907 * FUNCTION
1908 * nvram_external_read_chksum_only
1909 * DESCRIPTION
1910 * This function is used to read the checksum of data item for external module.
1911 * Please must check with NVRAM owner before you use this API.
1912 * PARAMETERS
1913 * LID: [IN] NVRAM LID
1914 * rec_index: [IN] record index
1915 * rec_amount: [IN] read how many record
1916 * buffer: [OUT] buffer pointer
1917 * buffer_size: [IN] buffer size
1918 * RETURNS
1919 * a boolean value
1920 * RETURN VALUES
1921 * KAL_FALSE: fail
1922 * KAL_TRUE: success
1923 *****************************************************************************/
1924kal_bool nvram_external_read_chksum_only(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
1925{
1926 /*----------------------------------------------------------------*/
1927 /* Local Variables */
1928 /*----------------------------------------------------------------*/
1929 nvram_ltable_entry_struct *ldi = NULL;
1930 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
1931 kal_uint32 nvram_trace_index;
1932 kal_uint32 nvram_chksum_size = 0;
1933 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM_ONLY_2B;
1934 nvram_lid_chksum_info lid_chksum_info = {0};
1935
1936 /*----------------------------------------------------------------*/
1937 /* Code Body */
1938 /*----------------------------------------------------------------*/
1939
1940 /*record nvram msg read access information to global struct*/
1941 nvram_util_take_mutex(g_nvram_trace_mutex);
1942 nvram_trace_index = nvram_access_trace.read_trace_index;
1943 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
1944 nvram_util_give_mutex(g_nvram_trace_mutex);
1945
1946 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
1947 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
1948 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
1949 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
1950
1951 if (nvram_ptr->state != NVRAM_STATE_READY)
1952 {
1953 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1954 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
1955 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__);
1956 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__,LID);
1957 return KAL_FALSE;
1958 }
1959
1960// nvram_pre_init();
1961
1962 /**
1963 * Invalid input paramters.
1964 */
1965
1966
1967 if (!NVRAM_IS_LID_VALID(LID))
1968 {
1969 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1970 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
1971 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1972 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
1973 return KAL_FALSE;
1974 }
1975
1976 nvram_util_get_data_item(&ldi, LID);
1977 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_TRUE, KAL_TRUE);
1978 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
1979 read_chksum_type = lid_chksum_info.read_chksum_type;
1980
1981 if (buffer_size < (nvram_chksum_size * rec_amount))
1982 {
1983 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
1984 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
1985 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",__FUNCTION__,LID,buffer_size,(nvram_chksum_size * rec_amount));
1986 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE:\r\n",__FUNCTION__,LID);
1987 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",buffer_size,(nvram_chksum_size * rec_amount));
1988 return KAL_FALSE;
1989 }
1990
1991#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
1992 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
1993 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
1994 {
1995 #ifdef __TC01__
1996 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1997 #else
1998 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
1999 #endif
2000 {
2001 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2002 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2003 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2004 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2005 return KAL_FALSE;
2006 }
2007 }
2008#endif
2009
2010 if ((rec_index < 1) ||(rec_index > ldi->total_records))
2011 {
2012 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2013 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
2014 kal_prompt_trace(MOD_NVRAM,"[Error]%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
2015 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2016 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2017 return KAL_FALSE;
2018 }
2019
2020
2021 /* handle by nvram_io layer */
2022 result = nvram_read_data_item_chksum(ldi, rec_index, rec_amount, buffer, buffer_size, read_chksum_type);
2023 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2024 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
2025 if (result != NVRAM_IO_ERRNO_OK)
2026 {
2027 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
2028 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item_chksum return %d\r\n",__FUNCTION__,LID,result);
2029 return KAL_FALSE;
2030 }
2031 else
2032 {
2033 return KAL_TRUE;
2034 }
2035
2036}
2037
2038
2039/*****************************************************************************
2040 * FUNCTION
2041 * nvram_external_read_chksum_8b
2042 * DESCRIPTION
2043 * This function is used to read the checksum of data item for external module.
2044 * Please must check with NVRAM owner before you use this API.
2045 * PARAMETERS
2046 * LID: [IN] NVRAM LID
2047 * rec_index: [IN] record index
2048 * rec_amount: [IN] read how many record
2049 * buffer: [OUT] md5 buffer pointer
2050 * buffer_size: [IN] md5 buffer size: must be 8-bytes length.
2051 * RETURNS
2052 * a boolean value
2053 * RETURN VALUES
2054 * KAL_FALSE: fail
2055 * KAL_TRUE: success
2056 *****************************************************************************/
2057kal_bool nvram_external_read_chksum_8b(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
2058{
2059 /*----------------------------------------------------------------*/
2060 /* Local Variables */
2061 /*----------------------------------------------------------------*/
2062 nvram_ltable_entry_struct *ldi = NULL;
2063 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
2064 kal_uint32 nvram_trace_index;
2065 kal_uint32 nvram_chksum_size = 0;
2066 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM;
2067 nvram_lid_chksum_info lid_chksum_info = {0};
2068
2069 /*----------------------------------------------------------------*/
2070 /* Code Body */
2071 /*----------------------------------------------------------------*/
2072
2073 /*record nvram msg read access information to global struct*/
2074 nvram_util_take_mutex(g_nvram_trace_mutex);
2075 nvram_trace_index = nvram_access_trace.read_trace_index;
2076 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
2077 nvram_util_give_mutex(g_nvram_trace_mutex);
2078
2079 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
2080 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
2081 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
2082 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
2083
2084 if (nvram_ptr->state != NVRAM_STATE_READY)
2085 {
2086 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2087 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2088 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__);
2089 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__,LID);
2090 return KAL_FALSE;
2091 }
2092
2093// nvram_pre_init();
2094
2095 /**
2096 * Invalid input paramters.
2097 */
2098 if (!NVRAM_IS_LID_VALID(LID))
2099 {
2100 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2101 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2102 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2103 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2104 return KAL_FALSE;
2105 }
2106
2107 nvram_util_get_data_item(&ldi, LID);
2108 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
2109 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
2110 read_chksum_type = lid_chksum_info.read_chksum_type;
2111
2112 if (buffer_size < (nvram_chksum_size * rec_amount))
2113 {
2114 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2115 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
2116 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE: buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",__FUNCTION__,LID,buffer_size,(nvram_chksum_size * rec_amount));
2117 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE:\r\n",__FUNCTION__,LID);
2118 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",buffer_size,(nvram_chksum_size * rec_amount));
2119 return KAL_FALSE;
2120 }
2121
2122#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2123 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
2124 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
2125 {
2126 #ifdef __TC01__
2127 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2128 #else
2129 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2130 #endif
2131 {
2132 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2133 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2134 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2135 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2136 return KAL_FALSE;
2137 }
2138 }
2139#endif
2140
2141 if ((rec_index < 1) ||(rec_index > ldi->total_records))
2142 {
2143 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2144 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
2145 kal_prompt_trace(MOD_NVRAM,"[Error]%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
2146 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2147 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2148 return KAL_FALSE;
2149 }
2150
2151
2152 /* handle by nvram_io layer */
2153 result = nvram_read_data_item_chksum_8b(ldi, rec_index, rec_amount, (kal_uint8*)buffer, buffer_size, read_chksum_type);
2154 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2155 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
2156 if (result != NVRAM_IO_ERRNO_OK)
2157 {
2158 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item_chksum_8b return %d\r\n",__FUNCTION__,LID,result);
2159 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item_chksum_8b return %d\r\n",__FUNCTION__,LID,result);
2160 return KAL_FALSE;
2161 }
2162 else
2163 {
2164 return KAL_TRUE;
2165 }
2166
2167}
2168
2169/*****************************************************************************
2170 * FUNCTION
2171 * nvram_external_read_chksum_only_8b
2172 * DESCRIPTION
2173 * This function is used to read the checksum of data item for external module.
2174 * Please must check with NVRAM owner before you use this API.
2175 * PARAMETERS
2176 * LID: [IN] NVRAM LID
2177 * rec_index: [IN] record index
2178 * rec_amount: [IN] read how many record
2179 * buffer: [OUT] md5 buffer pointer
2180 * buffer_size: [IN] md5 buffer size: must be 8-bytes length.
2181 * RETURNS
2182 * a boolean value
2183 * RETURN VALUES
2184 * KAL_FALSE: fail
2185 * KAL_TRUE: success
2186 *****************************************************************************/
2187kal_bool nvram_external_read_chksum_only_8b(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount, kal_uint8 *buffer, kal_uint32 buffer_size)
2188{
2189 /*----------------------------------------------------------------*/
2190 /* Local Variables */
2191 /*----------------------------------------------------------------*/
2192 nvram_ltable_entry_struct *ldi = NULL;
2193 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
2194 kal_uint32 nvram_trace_index = 0;
2195 kal_uint32 nvram_chksum_size = 0;
2196 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM_ONLY;
2197 nvram_lid_chksum_info lid_chksum_info = {0};
2198
2199 /*----------------------------------------------------------------*/
2200 /* Code Body */
2201 /*----------------------------------------------------------------*/
2202
2203 /*record nvram msg read access information to global struct*/
2204 nvram_util_take_mutex(g_nvram_trace_mutex);
2205 nvram_trace_index = nvram_access_trace.read_trace_index;
2206 nvram_access_trace.read_trace_index = (nvram_access_trace.read_trace_index + 1) % MAX_TRACE_NUM;
2207 nvram_util_give_mutex(g_nvram_trace_mutex);
2208
2209 kal_mem_set((void *)&(nvram_access_trace.read_trace[nvram_trace_index]), 0, sizeof(trace_info));
2210 nvram_access_trace.read_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
2211 nvram_access_trace.read_trace[nvram_trace_index].LID = LID;
2212 nvram_access_trace.read_trace[nvram_trace_index].start_time = ust_get_current_time();
2213
2214 if (nvram_ptr->state != NVRAM_STATE_READY)
2215 {
2216 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2217 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2218 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__);
2219 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__,LID);
2220 return KAL_FALSE;
2221 }
2222
2223// nvram_pre_init();
2224
2225 /**
2226 * Invalid input paramters.
2227 */
2228 if (!NVRAM_IS_LID_VALID(LID))
2229 {
2230 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2231 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2232 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2233 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2234 return KAL_FALSE;
2235 }
2236
2237 nvram_util_get_data_item(&ldi, LID);
2238 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_TRUE, KAL_FALSE);
2239 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
2240 read_chksum_type = lid_chksum_info.read_chksum_type;
2241
2242 if (buffer_size < (nvram_chksum_size * rec_amount))
2243 {
2244 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2245 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
2246 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE: buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",__FUNCTION__,LID,buffer_size,(nvram_chksum_size * rec_amount));
2247 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE:\r\n",__FUNCTION__,LID);
2248 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer_size(%d) < (nvram_chksum_size * rec_amount: %d)\r\n",buffer_size,(nvram_chksum_size * rec_amount));
2249 return KAL_FALSE;
2250 }
2251
2252#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2253 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
2254 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
2255 {
2256 #ifdef __TC01__
2257 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2258 #else
2259 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2260 #endif
2261 {
2262 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2263 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2264 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2265 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2266 return KAL_FALSE;
2267 }
2268 }
2269#endif
2270
2271 if ((rec_index < 1) ||(rec_index > ldi->total_records))
2272 {
2273 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2274 nvram_access_trace.read_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
2275 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
2276 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2277 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2278 return KAL_FALSE;
2279 }
2280
2281
2282 /* handle by nvram_io layer */
2283 result = nvram_read_data_item_chksum_8b(ldi, rec_index, rec_amount, (kal_uint8*)buffer, buffer_size, read_chksum_type);
2284 nvram_access_trace.read_trace[nvram_trace_index].end_time = ust_get_current_time();
2285 nvram_access_trace.read_trace[nvram_trace_index].ret_value = result;
2286 if (result != NVRAM_IO_ERRNO_OK)
2287 {
2288 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_read_data_item_chksum_8b return %d\r\n",__FUNCTION__,LID,result);
2289 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_read_data_item_chksum_8b return %d\r\n",__FUNCTION__,LID,result);
2290 return KAL_FALSE;
2291 }
2292 else
2293 {
2294 return KAL_TRUE;
2295 }
2296
2297}
2298
2299/*****************************************************************************
2300 * FUNCTION
2301 * nvram_external_write_data
2302 * DESCRIPTION
2303 * This function is used to write data items for external modules.
2304 * PARAMETERS
2305 * LID: [IN] NVRAM LID
2306 * rec_index: [IN] record index
2307 * buffer: [IN] buffer pointer
2308 * buffer_size: [IN] buffer size
2309 * RETURNS
2310 * a boolean value
2311 * RETURN VALUES
2312 * KAL_FALSE: fail
2313 * KAL_TRUE: success
2314 *****************************************************************************/
2315kal_bool nvram_external_write_data(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint8 *buffer, kal_uint32 buffer_size)
2316{
2317 /*----------------------------------------------------------------*/
2318 /* Local Variables */
2319 /*----------------------------------------------------------------*/
2320 nvram_ltable_entry_struct *ldi = NULL;
2321 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
2322 kal_uint32 nvram_trace_index = 0;
2323 /*----------------------------------------------------------------*/
2324 /* Code Body */
2325 /*----------------------------------------------------------------*/
2326
2327 /*record nvram msg read access information to global struct*/
2328 nvram_util_take_mutex(g_nvram_trace_mutex);
2329 nvram_trace_index = nvram_access_trace.write_trace_index;
2330 nvram_access_trace.write_trace_index = (nvram_access_trace.write_trace_index + 1) % MAX_TRACE_NUM;
2331 nvram_util_give_mutex(g_nvram_trace_mutex);
2332
2333 kal_mem_set((void *)&(nvram_access_trace.write_trace[nvram_trace_index]), 0, sizeof(trace_info));
2334 nvram_access_trace.write_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
2335 nvram_access_trace.write_trace[nvram_trace_index].LID = LID;
2336 nvram_access_trace.write_trace[nvram_trace_index].start_time = ust_get_current_time();
2337
2338 if (nvram_ptr->state != NVRAM_STATE_READY)
2339 {
2340 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2341 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2342 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
2343 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
2344 return KAL_FALSE;
2345 }
2346
2347// nvram_pre_init();
2348
2349 if (!NVRAM_IS_LID_VALID(LID))
2350 {
2351 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2352 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2353 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2354 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2355 return KAL_FALSE;
2356 }
2357
2358 nvram_util_get_data_item(&ldi, LID);
2359 if(NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
2360 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2361 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
2362 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2363 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2364 return KAL_FALSE;
2365 }
2366
2367 if(SST_NVRAM_Data_Access_Check(LID, 1, KAL_FALSE, NULL))
2368 {
2369 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2370 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2371 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2372 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2373 return KAL_FALSE;
2374 }
2375
2376#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2377 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
2378 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
2379 {
2380 #ifdef __TC01__
2381 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2382 #else
2383 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2384 #endif
2385 {
2386 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2387 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2388 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2389 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2390 return KAL_FALSE;
2391 }
2392 }
2393#endif
2394
2395 if ((rec_index < 1) ||
2396 (rec_index > ldi->total_records))
2397 {
2398 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2399 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
2400 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
2401 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2402 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2403 return KAL_FALSE;
2404 }
2405
2406 if (buffer_size < ldi->size)
2407 {
2408 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2409 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
2410 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE:buffer size(%d)< record_size(%d)\r\n",__FUNCTION__,LID,buffer_size,ldi->size);
2411 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE:\r\n",__FUNCTION__,LID);
2412 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer size(%d)< record_size(%d)\r\n",buffer_size,ldi->size);
2413 return KAL_FALSE;
2414 }
2415
2416 result = nvram_write_data_item(ldi, rec_index, buffer, KAL_FALSE);
2417 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2418 nvram_access_trace.write_trace[nvram_trace_index].ret_value = result;
2419
2420 if (result != NVRAM_IO_ERRNO_OK)
2421 {
2422 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2423 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2424 return KAL_FALSE;
2425 }
2426 else
2427 {
2428 return KAL_TRUE;
2429 }
2430}
2431
2432
2433/*****************************************************************************
2434 * FUNCTION
2435 * nvram_external_write_raw_data
2436 * DESCRIPTION
2437 * This function is used to write data items for external modules.
2438 * PARAMETERS
2439 * LID: [IN] NVRAM LID
2440 * offset: [IN] file offset
2441 * buffer: [IN] buffer pointer
2442 * buffer_size: [IN] buffer size
2443 * RETURNS
2444 * a boolean value
2445 * RETURN VALUES
2446 * KAL_FALSE: fail
2447 * KAL_TRUE: success
2448 *****************************************************************************/
2449kal_bool nvram_external_write_raw_data(nvram_lid_enum LID, kal_uint32 offset, kal_uint8 *buffer, kal_uint32 buffer_size)
2450{
2451 /*----------------------------------------------------------------*/
2452 /* Local Variables */
2453 /*----------------------------------------------------------------*/
2454 nvram_ltable_entry_struct *ldi = NULL;
2455 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
2456 kal_uint32 nvram_trace_index = 0;
2457 /*----------------------------------------------------------------*/
2458 /* Code Body */
2459 /*----------------------------------------------------------------*/
2460
2461 /*record nvram msg read access information to global struct*/
2462 nvram_util_take_mutex(g_nvram_trace_mutex);
2463 nvram_trace_index = nvram_access_trace.write_trace_index;
2464 nvram_access_trace.write_trace_index = (nvram_access_trace.write_trace_index + 1) % MAX_TRACE_NUM;
2465 nvram_util_give_mutex(g_nvram_trace_mutex);
2466
2467 kal_mem_set((void *)&(nvram_access_trace.write_trace[nvram_trace_index]), 0, sizeof(trace_info));
2468 nvram_access_trace.write_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
2469 nvram_access_trace.write_trace[nvram_trace_index].LID = LID;
2470 nvram_access_trace.write_trace[nvram_trace_index].start_time = ust_get_current_time();
2471
2472 if (nvram_ptr->state != NVRAM_STATE_READY)
2473 {
2474 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2475 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2476 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__);
2477 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY \r\n",__FUNCTION__,LID);
2478 return KAL_FALSE;
2479 }
2480
2481 /**
2482 * Invalid input paramters.
2483 */
2484 if(!nvram_util_get_data_item(&ldi, LID)) {
2485 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2486 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2487 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2488 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2489 return KAL_FALSE;
2490 }
2491 if(!NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
2492 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2493 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
2494 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2495 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2496 return KAL_FALSE;
2497 }
2498
2499 if(SST_NVRAM_Data_Access_Check(LID, 1, KAL_FALSE, NULL))
2500 {
2501 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2502 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2503 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2504 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2505 return KAL_FALSE;
2506 }
2507
2508#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2509 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
2510 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
2511 {
2512 #ifdef __TC01__
2513 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2514 #else
2515 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2516 #endif
2517 {
2518 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2519 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2520 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2521 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2522 return KAL_FALSE;
2523 }
2524 }
2525#endif
2526
2527 ldi->size = buffer_size;
2528 result = nvram_write_data_item(ldi, offset, buffer, KAL_FALSE);
2529 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2530 nvram_access_trace.write_trace[nvram_trace_index].ret_value = result;
2531 if (result != NVRAM_IO_ERRNO_OK)
2532 {
2533 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2534 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2535 return KAL_FALSE;
2536 }
2537 else
2538 {
2539 return KAL_TRUE;
2540 }
2541}
2542
2543
2544
2545/*****************************************************************************
2546 * FUNCTION
2547 * nvram_external_secure_write_data
2548 * DESCRIPTION
2549 * This function is used to write data items for external modules with secure check.
2550 * PARAMETERS
2551 * LID: [IN] NVRAM LID
2552 * rec_index: [IN] record index
2553 * buffer: [IN] buffer pointer
2554 * buffer_size: [IN] buffer size
2555 * RETURNS
2556 * a boolean value
2557 * RETURN VALUES
2558 * KAL_FALSE: fail
2559 * KAL_TRUE: success
2560 *****************************************************************************/
2561nvram_errno_enum nvram_external_secure_write_data(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint8 *buffer, kal_uint32 buffer_size, void* reserved_ptr)
2562{
2563 /*----------------------------------------------------------------*/
2564 /* Local Variables */
2565 /*----------------------------------------------------------------*/
2566 nvram_ltable_entry_struct *ldi = NULL;
2567 nvram_errno_enum result = NVRAM_IO_ERRNO_OK;
2568 kal_uint32 nvram_trace_index = 0;
2569 /*----------------------------------------------------------------*/
2570 /* Code Body */
2571 /*----------------------------------------------------------------*/
2572
2573 /*record nvram msg read access information to global struct*/
2574 nvram_util_take_mutex(g_nvram_trace_mutex);
2575 nvram_trace_index = nvram_access_trace.write_trace_index;
2576 nvram_access_trace.write_trace_index = (nvram_access_trace.write_trace_index + 1) % MAX_TRACE_NUM;
2577 nvram_util_give_mutex(g_nvram_trace_mutex);
2578
2579 kal_mem_set((void *)&(nvram_access_trace.write_trace[nvram_trace_index]), 0, sizeof(trace_info));
2580 nvram_access_trace.write_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_SECURE_API;
2581 nvram_access_trace.write_trace[nvram_trace_index].LID = LID;
2582 nvram_access_trace.write_trace[nvram_trace_index].start_time = ust_get_current_time();
2583
2584 if (nvram_ptr->state != NVRAM_STATE_READY)
2585 {
2586 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2587 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2588 kal_prompt_trace(MOD_NVRAM, "%s->LID 0x%x NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
2589 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
2590 return NVRAM_ERRNO_NOT_READY;
2591 }
2592
2593// nvram_pre_init();
2594
2595 if (!NVRAM_IS_LID_VALID(LID))
2596 {
2597 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2598 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2599 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2600 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2601 return NVRAM_IO_ERRNO_INVALID_LID;
2602 }
2603
2604 nvram_util_get_data_item(&ldi, LID);
2605 if(NVRAM_IS_ATTR_RAW_DATA(ldi->attr)) {
2606 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2607 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_WRONG_API_USE;
2608 kal_prompt_trace(MOD_NVRAM,"%s->Raw LID 0x%x NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2609 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Raw LID 0x%04X NVRAM_ERRNO_WRONG_API_USE\r\n",__FUNCTION__,LID);
2610 return KAL_FALSE;
2611 }
2612
2613 if(SST_NVRAM_Data_Access_Check(LID, 1, KAL_TRUE, reserved_ptr))
2614 {
2615 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2616 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2617 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2618 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED\r\n",__FUNCTION__,LID);
2619 return NVRAM_IO_ERRNO_ACCESS_DENIED;
2620 }
2621
2622#if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2623 /* In Meta mode, we cannot access the data belongs to custom sensitve area */
2624 if (NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category) || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category))
2625 {
2626 #ifdef __TC01__
2627 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2628 #else
2629 if (FACTORY_BOOT == stack_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2630 #endif
2631 {
2632 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2633 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2634 kal_prompt_trace(MOD_NVRAM,"%s->Custom LID 0x%x NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2635 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->Custom LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2636 return NVRAM_IO_ERRNO_ACCESS_DENIED;
2637 }
2638 }
2639#endif
2640
2641 if ((rec_index < 1) ||
2642 (rec_index > ldi->total_records))
2643 {
2644 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2645 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_RECORD;
2646 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_RECORD:rec_index(%d) total_records(%d)\r\n",__FUNCTION__,LID,rec_index,ldi->total_records);
2647 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2648 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2649 return NVRAM_IO_ERRNO_INVALID_RECORD;
2650 }
2651
2652 if (buffer_size < ldi->size)
2653 {
2654 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2655 nvram_access_trace.write_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_SIZE;
2656 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x NVRAM_IO_ERRNO_INVALID_SIZE:buffer size(%d)< record_size(%d)\r\n",__FUNCTION__,LID,buffer_size,ldi->size);
2657 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_SIZE:\r\n",__FUNCTION__,LID);
2658 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]buffer size(%d)< record_size(%d)\r\n",buffer_size,ldi->size);
2659 return NVRAM_IO_ERRNO_INVALID_SIZE;
2660 }
2661
2662 result = nvram_write_data_item(ldi, rec_index, buffer, KAL_FALSE);
2663 nvram_access_trace.write_trace[nvram_trace_index].end_time = ust_get_current_time();
2664 nvram_access_trace.write_trace[nvram_trace_index].ret_value = result;
2665 if (result != NVRAM_IO_ERRNO_OK)
2666 {
2667 kal_prompt_trace(MOD_NVRAM,"%s->LID 0x%x nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2668 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X nvram_write_data_item return %d\r\n",__FUNCTION__,LID,result);
2669 return KAL_FALSE;
2670 }
2671 return result;
2672}
2673
2674/*****************************************************************************
2675 * FUNCTION
2676 * nvram_external_reset_data
2677 * DESCRIPTION
2678 * This function is used to reset data items for external modules.
2679 * PARAMETERS
2680 * LID: [IN] NVRAM LID
2681 * rec_index: [IN] record index
2682 * buffer: [IN] buffer pointer
2683 * RETURNS
2684 * a boolean value
2685 * RETURN VALUES
2686 * KAL_FALSE: fail
2687 * KAL_TRUE: success
2688 *****************************************************************************/
2689kal_bool nvram_external_reset_data(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint16 rec_amount)
2690{
2691 /*----------------------------------------------------------------*/
2692 /* Local Variables */
2693 /*----------------------------------------------------------------*/
2694 nvram_ltable_entry_struct *ldi = NULL;
2695 nvram_ltable_entry_struct tmp_ldi = {0};
2696 kal_bool result = KAL_FALSE;
2697 kal_uint32 nvram_trace_index = 0;
2698 /*----------------------------------------------------------------*/
2699 /* Code Body */
2700 /*----------------------------------------------------------------*/
2701 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s ====>\r\n",__FUNCTION__);
2702 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"LID:0x%04X rec_index=%d,rec_amount=%d\r\n",LID,rec_index,rec_amount);
2703 /*record nvram msg read access information to global struct*/
2704 nvram_util_take_mutex(g_nvram_trace_mutex);
2705 nvram_trace_index = nvram_access_trace.reset_trace_index;
2706 nvram_access_trace.reset_trace_index = (nvram_access_trace.reset_trace_index + 1) % MAX_TRACE_NUM;
2707 nvram_util_give_mutex(g_nvram_trace_mutex);
2708
2709 kal_mem_set((void *)&(nvram_access_trace.reset_trace[nvram_trace_index]), 0, sizeof(trace_info));
2710 nvram_access_trace.reset_trace[nvram_trace_index].access_way = NVRAM_ACCESS_BY_NORMAL_API;
2711 nvram_access_trace.reset_trace[nvram_trace_index].LID = LID;
2712 nvram_access_trace.reset_trace[nvram_trace_index].start_time = ust_get_current_time();
2713
2714 if (nvram_ptr->state != NVRAM_STATE_READY)
2715 {
2716 nvram_access_trace.reset_trace[nvram_trace_index].end_time = ust_get_current_time();
2717 nvram_access_trace.reset_trace[nvram_trace_index].ret_value = NVRAM_ERRNO_NOT_READY;
2718 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_ERRNO_NOT_READY\r\n",__FUNCTION__,LID);
2719 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
2720 return KAL_FALSE;
2721 }
2722
2723// nvram_pre_init();
2724
2725 if (!NVRAM_IS_LID_VALID(LID))
2726 {
2727 nvram_access_trace.reset_trace[nvram_trace_index].end_time = ust_get_current_time();
2728 nvram_access_trace.reset_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_INVALID_LID;
2729 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2730 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
2731 return KAL_FALSE;
2732 }
2733
2734 nvram_util_get_data_item(&ldi, LID);
2735
2736 /* In Meta mode, we cannot access the data belongs to custom sensitve area
2737 we also cannot reset the important data to prevent security problem */
2738 if (NVRAM_IS_CATEGORY_IMPORTANT(ldi->category)
2739 || NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category)
2740 #if defined(__NVRAM_CUSTOM_SENSITIVE__) || defined(__NVRAM_CUSTOM_DISK__)
2741 || NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category)
2742 || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category)
2743 #endif
2744 )
2745 {
2746 #ifdef __TC01__
2747 if (FACTORY_BOOT == kal_query_boot_mode() && stack_get_active_module_id() == MOD_FT)
2748 #else
2749 if (FACTORY_BOOT == kal_query_boot_mode() && kal_get_active_module_id() == MOD_FT)
2750 #endif
2751 {
2752 nvram_access_trace.reset_trace[nvram_trace_index].end_time = ust_get_current_time();
2753 nvram_access_trace.reset_trace[nvram_trace_index].ret_value = NVRAM_IO_ERRNO_ACCESS_DENIED;
2754 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_ACCESS_DENIED for Meta Mode\r\n",__FUNCTION__,LID);
2755 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s <====\r\n",__FUNCTION__);
2756 return KAL_FALSE;
2757 }
2758 }
2759
2760 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[collection]%s -> LID:0x%04X index=%d\r\n",__FUNCTION__, ldi->LID, ldi->size);
2761 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[collection]rec_amount=%d,rec_index=%d\r\n", rec_amount, rec_index);
2762
2763 result = nvram_reset_data_items(NVRAM_RESET_CERTAIN, NVRAM_APP_RESERVED, ldi, rec_index, rec_amount);
2764 memcpy(&tmp_ldi,ldi,sizeof(nvram_ltable_entry_struct));
2765 mcf_do_ota_by_lid(LID,rec_index, rec_amount,&tmp_ldi);
2766
2767 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"%s <====\r\n",__FUNCTION__);
2768 nvram_access_trace.reset_trace[nvram_trace_index].end_time = ust_get_current_time();
2769 nvram_access_trace.reset_trace[nvram_trace_index].ret_value = result;
2770
2771 return result;
2772}
2773
2774/*****************************************************************************
2775 * FUNCTION
2776 * nvram_get_default_value
2777 * DESCRIPTION
2778 * This function is used to get default value for external modules.
2779 * PARAMETERS
2780 * LID [IN]
2781 * rec_index [IN]
2782 * p_buffer [IN/OUT]
2783 *
2784 * RETURNS
2785 * NVRAM_DEFAULT_VALUE_FAIL : get default value fail
2786 * NVRAM_DEFAULT_VALUE_FF : p_buffer is invalid, default value is FF
2787 * NVRAM_DEFAULT_VALUE_ZERO : p_buffer is invalid, default value is zero
2788 * NVRAM_DEFAULT_VALUE_POINT: p_buffer is valid, use p_buffer to get default value
2789 *****************************************************************************/
2790nvram_default_value_enum nvram_get_default_value(nvram_lid_enum LID, kal_uint16 rec_index, kal_uint8 **p_buffer)
2791{
2792 /*----------------------------------------------------------------*/
2793 /* Local Variables */
2794 /*----------------------------------------------------------------*/
2795 nvram_ltable_entry_struct *ldi = NULL;
2796 nvram_default_value_enum result = NVRAM_DEFAULT_VALUE_SUCCESS;
2797 /*----------------------------------------------------------------*/
2798 /* Code Body */
2799 /*----------------------------------------------------------------*/
2800
2801 if (!NVRAM_IS_LID_VALID(LID))
2802 {
2803 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_LID\r\n",__FUNCTION__,LID);
2804 return NVRAM_DEFAULT_VALUE_FAIL;
2805 }
2806
2807 nvram_util_get_data_item(&ldi, LID);
2808
2809 if ((rec_index < 1) || (rec_index > ldi->total_records))
2810 {
2811 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]%s->LID 0x%04X NVRAM_IO_ERRNO_INVALID_RECORD:\r\n",__FUNCTION__,LID);
2812 NVRAM_DEBUG_DUMP(NVRAM_CRITICAL_DUMP,"[Error]rec_index(%d) total_records(%d)\r\n",rec_index,ldi->total_records);
2813 return NVRAM_DEFAULT_VALUE_FAIL;
2814 }
2815
2816
2817 /* Multi default value */
2818 if ((ldi->attr & NVRAM_ATTR_MULTI_DEFAULT))
2819 {
2820 rec_index--;
2821 }
2822 else
2823 {
2824 rec_index = 0;
2825 }
2826
2827 if ((ldi->LID >= NVRAM_EF_L1_START && ldi->LID <= NVRAM_EF_L1_END)
2828 || (ldi->LID >= NVRAM_EF_UL1_START && ldi->LID <= NVRAM_EF_UL1_END)
2829 #if defined(__WIFI_SUPPORT__)&&(__CUSTOM_WIFI_FEATURES_SWITCH__)
2830 || (ldi->LID >= NVRAM_EF_WNDRV_START && ldi->LID <= NVRAM_EF_WNDRV_END)
2831 #endif
2832#if !defined(MED_NOT_PRESENT)
2833#ifdef __AMRWB_LINK_SUPPORT__
2834 || (ldi->LID == NVRAM_EF_AUDIO_WB_SPEECH_INPUT_FIR_LID) || (ldi->LID == NVRAM_EF_AUDIO_WB_SPEECH_OUTPUT_FIR_LID) || (ldi->LID == NVRAM_EF_AUDIO_WB_SPEECH_MODE_PARAM_LID)
2835#endif
2836#ifdef __AUDIO_COMPENSATION_SW_VERSION__
2837 || (ldi->LID == NVRAM_EF_AUDIO_SWFIR_LID)
2838#endif
2839#ifdef __BES_LOUDNESS_SUPPORT__
2840 || (ldi->LID == NVRAM_EF_AUDIO_BESLOUDNESS_LID)
2841#endif
2842 || (ldi->LID == NVRAM_EF_AUDIO_DC_CALIBRATION_LID)
2843
2844 || (ldi->LID == NVRAM_EF_AUDIO_PARAM_LID)
2845#endif
2846 )
2847 {
2848 result = NVRAM_DEFAULT_VALUE_APPLICATION;
2849 }
2850#ifdef __NVRAM_COMPRESS_SUPPORT__
2851 else if (NVRAM_IS_ATTR_ZIP_DEFAULT(ldi->attr))
2852 {
2853 result = NVRAM_DEFAULT_VALUE_FF;
2854 }
2855#endif
2856 else
2857 {
2858 /* No default value supplied. Fill the buffer with 0xFF. */
2859 if (ldi->default_value == NULL || ldi->default_value == (kal_uint8 const*)NVRAM_EF_FF_DEFAULT)
2860 {
2861 result = NVRAM_DEFAULT_VALUE_FF;
2862 } /* Default value is all the same value (0x00) Fill it as well. */
2863 else if (ldi->default_value == (kal_uint8 const*)NVRAM_EF_ZERO_DEFAULT)
2864 {
2865 result = NVRAM_DEFAULT_VALUE_ZERO;
2866 }
2867 else
2868 {
2869 *p_buffer = (void*)(ldi->default_value + ldi->size * rec_index);
2870 result = NVRAM_DEFAULT_VALUE_POINT;
2871 }
2872 }
2873//#ifdef __NVRAM_PSEUDO_MERGE__
2874 MD_TRC_FUNC_NVRAM_GET_DEFAULT_VALUE(ldi->LID, result, ldi->size, ldi->fileprefix);
2875//#else
2876// nvram_trace(TRACE_FUNC, FUNC_NVRAM_GET_DEFAULT_VALUE, ldi->LID, result, ldi->size);
2877//#endif
2878 return result;
2879}
2880
2881
2882
2883
2884/*****************************************************************************
2885 * FUNCTION
2886 * nvram_shutdown_handler
2887 * DESCRIPTION
2888 * Disable all interrupts, change NVRAM state, change FS command mode, and flush
2889 * PARAMETERS
2890 * void
2891 * RETURNS
2892 * void
2893 *****************************************************************************/
2894void nvram_shutdown_handler(void)
2895{
2896
2897#ifdef __MMI_FMI__
2898#if !defined(__L1_STANDALONE__)
2899
2900 /*----------------------------------------------------------------*/
2901 /* Local Variables */
2902 /*----------------------------------------------------------------*/
2903 kal_uint32 i;
2904
2905 /*----------------------------------------------------------------*/
2906 /* Code Body */
2907 /*----------------------------------------------------------------*/
2908 /* to handle shutdown callback */
2909 for (i = 0; ;i++)
2910 {
2911 if (nvram_shutdown_cb_table[i].LID == 0 && nvram_shutdown_cb_table[i].get_data == NULL)
2912 {
2913 break;
2914 }
2915
2916 if (NVRAM_IS_LID_VALID(nvram_shutdown_cb_table[i].LID) && nvram_shutdown_cb_table[i].get_data)
2917 {
2918 kal_uint8 *data;
2919 nvram_ltable_entry_struct *ldi;
2920
2921 nvram_util_get_data_item(&ldi, nvram_shutdown_cb_table[i].LID);
2922 data = (kal_uint8 *)get_ctrl_buffer(ldi->size);
2923 if (nvram_shutdown_cb_table[i].get_data(data, ldi->size))
2924 {
2925 /* doesn't support linear-fix */
2926 nvram_write_data_item(ldi, 1, data, KAL_FALSE);
2927 }
2928 free_ctrl_buffer(data);
2929 }
2930 }
2931#endif /* !__L1_STANDALONE__ */
2932#endif /* __MMI_FMI__ */
2933}
2934
2935#ifdef __NVRAM_DISK_SIZE_CHECK__
2936/*****************************************************************************
2937 * FUNCTION
2938 * nvram_space_reserve
2939 * DESCRIPTION
2940 * To perform software upgrade.
2941 * PARAMETERS
2942 * SpecialName [?]
2943 * StillNeed [?]
2944 * sysrecord(?) [IN] Sysrecord
2945 * RETURNS
2946 * Success or Fail(?)
2947 *****************************************************************************/
2948void nvram_space_reserve(kal_uint32 *size_from_code)
2949{
2950 /*----------------------------------------------------------------*/
2951 /* Local Variables */
2952 /*----------------------------------------------------------------*/
2953 kal_uint32 CodeFileSize;
2954 kal_uint32 clusterSize;
2955
2956 /*----------------------------------------------------------------*/
2957 /* Code Body */
2958 /*----------------------------------------------------------------*/
2959 NVRAM_FS_START_EX(FS_OP_GETCLUSTERSIZE,'Z');
2960 clusterSize = FS_GetClusterSize('Z');
2961 NVRAM_FS_END(FS_OP_GETCLUSTERSIZE,clusterSize);
2962
2963 nvram_pre_init();
2964
2965 nvram_get_code_file_size(&CodeFileSize);
2966
2967 *size_from_code = (CodeFileSize / clusterSize) + ((CodeFileSize / clusterSize)? 1 : 0) + NVRAM_SPACE_MARGIN;
2968}
2969#endif
2970
2971/*****************************************************************************
2972 * FUNCTION
2973 * nvram_get_folder_name
2974 * DESCRIPTION
2975 * To get NVRAM folder name.
2976 * PARAMETERS
2977 * void
2978 * RETURNS
2979 * NVRAM folder name.
2980 *****************************************************************************/
2981void nvram_get_folder_name(WCHAR *nvram_folder_name)
2982{
2983 /*----------------------------------------------------------------*/
2984 /* Local Variables */
2985 /*----------------------------------------------------------------*/
2986
2987 /*----------------------------------------------------------------*/
2988 /* Code Body */
2989 /*----------------------------------------------------------------*/
2990 kal_wstrcpy(nvram_folder_name, NVRAM_FS_FOLDER_NAME);
2991}
2992
2993
2994/*****************************************************************************
2995 * FUNCTION
2996 * nvram_get_work_path
2997 * DESCRIPTION
2998 * To get NVRAM working directory.
2999 * PARAMETERS
3000 * folder_idx : Which folder
3001 * RETURNS
3002 * NVRAM working directory.
3003 *****************************************************************************/
3004kal_char *nvram_get_work_path(kal_uint8 folder_idx)
3005{
3006 /*----------------------------------------------------------------*/
3007 /* Local Variables */
3008 /*----------------------------------------------------------------*/
3009
3010 /*----------------------------------------------------------------*/
3011 /* Code Body */
3012 /*----------------------------------------------------------------*/
3013
3014 return nvram_query_work_path((nvram_folder_enum)folder_idx);
3015}
3016
3017
3018/*****************************************************************************
3019 * FUNCTION
3020 * nvram_get_folder_idx
3021 * DESCRIPTION
3022 * To get the index of nvram folder.
3023 * PARAMETERS
3024 * LID :
3025 * RETURNS
3026 * index of folder.
3027 *****************************************************************************/
3028kal_uint8 nvram_get_folder_idx(nvram_lid_enum LID)
3029{
3030 /*----------------------------------------------------------------*/
3031 /* Local Variables */
3032 /*----------------------------------------------------------------*/
3033 nvram_ltable_entry_struct *ldi;
3034
3035 /*----------------------------------------------------------------*/
3036 /* Code Body */
3037 /*----------------------------------------------------------------*/
3038 if (!NVRAM_IS_LID_VALID(LID))
3039 {
3040 return NVRAM_IO_ERRNO_INVALID_LID;
3041 }
3042
3043 nvram_util_get_data_item(&ldi, LID);
3044
3045 return nvram_query_folder_index(ldi->category);
3046}
3047
3048
3049/*****************************************************************************
3050 * FUNCTION
3051 * nvram_get_file_fullname
3052 * DESCRIPTION
3053 * To get the full name of nvram file.
3054 * PARAMETERS
3055 * folder_idx : [In]
3056 * nvramname : [In]
3057 * filename : [Out]
3058 * RETURNS
3059 * index of folder.
3060 *****************************************************************************/
3061kal_wchar * nvram_get_file_fullname(kal_uint8 folder_idx, kal_char *nvramname, kal_wchar *filename)
3062{
3063 /*----------------------------------------------------------------*/
3064 /* Local Variables */
3065 /*----------------------------------------------------------------*/
3066
3067 /*----------------------------------------------------------------*/
3068 /* Code Body */
3069 /*----------------------------------------------------------------*/
3070
3071 return nvram_query_file_name((nvram_folder_enum)folder_idx, nvramname, filename);
3072}
3073
3074
3075/*****************************************************************************
3076 * FUNCTION
3077 * nvram_get_folder_total_amount
3078 * DESCRIPTION
3079 * To get the full name of nvram file.
3080 * PARAMETERS
3081 * void
3082 * RETURNS
3083 * number of folders
3084 *****************************************************************************/
3085kal_uint8 nvram_get_folder_total_amount(void)
3086{
3087 /*----------------------------------------------------------------*/
3088 /* Local Variables */
3089 /*----------------------------------------------------------------*/
3090
3091 /*----------------------------------------------------------------*/
3092 /* Code Body */
3093 /*----------------------------------------------------------------*/
3094
3095 return NVRAM_FOLDER_TOTAL;
3096}
3097
3098/*****************************************************************************
3099 * FUNCTION
3100 * nvram_check_hidden_files
3101 * DESCRIPTION
3102 * Check if the files or folder is hidden or not in Meta FAT Editor.
3103 * 1. Any LID with NVRAM_CATEGORY_IMPORTANT will not appear in meta FAT Editor. ex: IMEI and SML
3104 * 2. Important Folder will not appear in meta FAT Editor.
3105 * 3. Customer sensitive data.
3106 * Exception 1: During backup/restore, we can see IMEI and SML
3107 * Exception 2: When NVRAM is locked. All the files and folder are hidden.
3108 *
3109 * PARAMETERS
3110 * filename [IN] the filename
3111 * backup [IN] During backup/restore the hidden file is different from normal
3112 * Please set this as true during backup/restore
3113 * RETURNS
3114 * a boolean value
3115 * RETURN VALUES
3116 * KAL_TRUE: hidden
3117 * KAL_FALSE: not hidden
3118 *****************************************************************************/
3119kal_bool nvram_check_hidden_file(const kal_wchar* filename, kal_bool backup)
3120{
3121 /*----------------------------------------------------------------*/
3122 /* Local Variables */
3123 /*----------------------------------------------------------------*/
3124 kal_wchar buf[NVRAM_MAX_PATH_LEN];
3125 nvram_ltable_entry_struct *ldi;
3126#ifdef __NVRAM_MULTI_FOLDERS__
3127 nvram_folder_enum i;
3128#endif
3129 kal_wchar *starter;
3130 kal_char *temp_strrchr = NULL;
3131
3132
3133 /*----------------------------------------------------------------*/
3134 /* Code Body */
3135 /*----------------------------------------------------------------*/
3136
3137 starter = kal_wstrchr(filename, '\\');
3138
3139 if (starter == NULL)
3140 {
3141 return KAL_FALSE;
3142 }
3143
3144 if (kal_wstrncmp(starter + 1, NVRAM_FS_FOLDER_NAME, kal_wstrlen(NVRAM_FS_FOLDER_NAME)) !=0 )
3145 {
3146 /* Not belongs to NVRAM folder */
3147 return KAL_FALSE;
3148 }
3149
3150 if (nvram_test_lock() && backup == KAL_FALSE)
3151 {
3152 return KAL_TRUE;
3153 }
3154
3155 starter = kal_wstrrchr(filename, '\\') + 1;
3156
3157#ifdef __NVRAM_MULTI_FOLDERS__
3158 for (i = NVRAM_FOLDER_BEGIN; i < NVRAM_FOLDER_TOTAL ; i++)
3159 {
3160 temp_strrchr = strrchr(nvram_query_work_path(i), '\\');
3161 if(temp_strrchr == NULL)
3162 {
3163 continue;
3164 }
3165 kal_wsprintf(buf, "%s", temp_strrchr+1);
3166 if (kal_wstrcmp(buf, starter) == 0)
3167 {
3168 if ((i == NVRAM_NVD_IMPT && backup == KAL_FALSE)
3169 #ifdef __NVRAM_CUSTOM_SENSITIVE__
3170 || i == NVRAM_NVD_CUST
3171 #endif
3172 )
3173 {
3174 return KAL_TRUE;
3175 }
3176 else
3177 {
3178 return KAL_FALSE;
3179 }
3180 }
3181 }
3182#endif
3183
3184 ldi = &logical_data_item_table[0];
3185 do
3186 {
3187
3188 if (( NVRAM_IS_CATEGORY_IMPORTANT(ldi->category) && backup == KAL_FALSE)
3189 || (NVRAM_IS_CATEGORY_IMPORTANT_L4(ldi->category) && backup == KAL_FALSE)
3190 #ifdef __NVRAM_CUSTOM_SENSITIVE__
3191 || NVRAM_IS_CATEGORY_CUSTOM_SENSITIVE(ldi->category)
3192 #endif
3193 #ifdef __NVRAM_CUSTOM_DISK__
3194 || NVRAM_IS_CATEGORY_CUSTOM_DISK(ldi->category)
3195 #endif
3196 )
3197 {
3198
3199 kal_wsprintf(buf, "%s", ldi->fileprefix);
3200
3201 if (kal_wstrncmp(buf, starter, FILE_PREFIX_LEN)== 0)
3202 {
3203 return KAL_TRUE;
3204 }
3205 }
3206 }while(nvram_util_next_data_item(&ldi));
3207
3208 return KAL_FALSE;
3209}
3210
3211
3212
3213
3214/*****************************************************************************
3215 * FUNCTION
3216 * nvram_compare_to_default_value
3217 * DESCRIPTION
3218 * This function is used to compare the value in nvram file to default value
3219 * PARAMETERS
3220 * LID: [IN] NVRAM LID
3221 * rec_index: [IN] record index, start from 1, but if the value is 0,
3222 * this function will compare all record to default value
3223 * RETURNS
3224 * nvram_errno_enum
3225 * RETURN VALUES
3226 * NVRAM_ERRNO_SUCCESS: no error
3227 * NVRAM_ERRNO_FAIL: at least one record is different to default value
3228 *****************************************************************************/
3229kal_int32 nvram_compare_to_default_value(nvram_lid_enum LID, kal_uint16 rec_index)
3230{
3231 /*----------------------------------------------------------------*/
3232 /* Local Variables */
3233 /*----------------------------------------------------------------*/
3234 nvram_ltable_entry_struct *ldi;
3235 int i;
3236 kal_uint8 *default_value = NULL;
3237 kal_uint8 *buffer = NULL;
3238 kal_int32 compare_result = 1;
3239 /*----------------------------------------------------------------*/
3240 /* Code Body */
3241 /*----------------------------------------------------------------*/
3242
3243 nvram_util_get_data_item(&ldi, LID);
3244
3245 if (!NVRAM_IS_LID_VALID(LID))
3246 {
3247 return NVRAM_IO_ERRNO_INVALID_LID;
3248 }
3249
3250 if (rec_index > ldi->total_records)
3251 {
3252 return NVRAM_IO_ERRNO_INVALID_RECORD;
3253 }
3254
3255 if (ldi->size <= MAX_NVRAM_RECORD_SIZE)
3256 {
3257 /* this function doesn't support the size over 2K now */
3258 buffer = (kal_uint8*) get_ctrl_buffer(ldi->size);
3259
3260
3261 for (i = (rec_index == 0?0:rec_index-1); i < ldi->total_records ; i++)
3262 {
3263 nvram_read_data_item(ldi, i + 1, 1, buffer, ldi->size);
3264
3265 default_value = (kal_uint8 *)nvram_get_default_value_to_write(ldi, i + 1, NULL, 0);
3266
3267 if (default_value == NULL || default_value == NVRAM_EF_FF_DEFAULT || default_value == NVRAM_EF_ZERO_DEFAULT)
3268 {
3269 default_value = (kal_uint8*)get_ctrl_buffer(ldi->size);
3270 nvram_get_default_value_to_write(ldi, i + 1, default_value, ldi->size);
3271 compare_result = memcmp(default_value, buffer, ldi->size);
3272 free_ctrl_buffer(default_value);
3273 }
3274 else
3275 {
3276 compare_result = memcmp(default_value, buffer, ldi->size);
3277 }
3278
3279 if (rec_index != 0)
3280 {
3281 break;
3282 }
3283 }
3284
3285 free_ctrl_buffer(buffer);
3286 }
3287 else
3288 {
3289 kal_uint8 *chksum2 = NULL;
3290 kal_uint8 *chksum1 = NULL;
3291 kal_uint32 nvram_chksum_size = 0;
3292 nvram_drv_read_type_enum read_chksum_type = NVRAM_DRV_READ_TYPE_CHKSUM;
3293 nvram_lid_chksum_info lid_chksum_info = {0};
3294
3295 nvram_get_lid_chksum_algo_info(ldi, &lid_chksum_info, KAL_FALSE, KAL_FALSE);
3296 nvram_chksum_size = lid_chksum_info.algo_info.chksum_algo_length;
3297 read_chksum_type = lid_chksum_info.read_chksum_type;
3298
3299 buffer = (kal_uint8*) get_ctrl_buffer(ldi->total_records * nvram_chksum_size);
3300 chksum1 = (kal_uint8*) get_ctrl_buffer(nvram_chksum_size);
3301
3302 /* this is temp solution, should implement full solution in drv layer in the future */
3303 nvram_read_data_item_chksum(ldi, 1, ldi->total_records, buffer, ldi->total_records * nvram_chksum_size, read_chksum_type);
3304
3305 for (i = (rec_index == 0?0:rec_index-1); i < ldi->total_records ; i++)
3306 {
3307 default_value = (kal_uint8 *)nvram_get_default_value_to_write(ldi, i + 1, NULL, 0);
3308
3309 /* not support special default_value now */
3310 if(default_value == NULL)
3311 {
3312 if(buffer)
3313 {
3314 free_ctrl_buffer(buffer);
3315 buffer = NULL;
3316 }
3317 if (chksum1)
3318 {
3319 free_ctrl_buffer(chksum1);
3320 chksum1 = NULL;
3321 }
3322 NVRAM_EXT_ASSERT(KAL_FALSE,0, NVRAM_LOC_GET_DEFAULT_VALUE_IS_NULL_1, 0, __LINE__);
3323 }
3324
3325 kal_mem_set(chksum1, 0, nvram_chksum_size);
3326 nvram_util_caculate_checksum(ldi, default_value, ldi->size, chksum1);
3327 chksum2 = buffer + (nvram_chksum_size * i);
3328
3329 compare_result = memcmp(chksum1, chksum2, nvram_chksum_size);
3330 if(compare_result != 0)
3331 {
3332 compare_result = 1;
3333 }
3334
3335 if (rec_index != 0)
3336 {
3337 break;
3338 }
3339 }
3340
3341 if(buffer)
3342 {
3343 free_ctrl_buffer(buffer);
3344 buffer = NULL;
3345 }
3346 if (chksum1)
3347 {
3348 free_ctrl_buffer(chksum1);
3349 chksum1 = NULL;
3350 }
3351 }
3352
3353 if (compare_result == 0)
3354 {
3355 return NVRAM_ERRNO_SUCCESS;
3356 }
3357 else
3358 {
3359 return NVRAM_ERRNO_FAIL;
3360 }
3361}
3362
3363kal_uint8 *nvram_get_custpack_version(void)
3364{
3365 return nvram_ptr->custpack_version;
3366}
3367void nvram_dummy(void)
3368{
3369}
3370/*****************************************************************************
3371 * FUNCTION
3372 * nvram_set_restore_factory_flag
3373 * DESCRIPTION
3374 * PARAMETERS
3375 * RETURNS
3376 *****************************************************************************/
3377kal_bool nvram_set_restore_factory_flag(nvram_restore_flag_enum restore_flag)
3378{
3379 /*----------------------------------------------------------------*/
3380 /* Local Variables */
3381 /*----------------------------------------------------------------*/
3382 nvram_ltable_entry_struct *ldi;
3383 kal_uint8 sys_cache[NVRAM_EF_SYS_CACHE_OCTET_SIZE];
3384
3385 /*----------------------------------------------------------------*/
3386 /* Code Body */
3387 /*----------------------------------------------------------------*/
3388 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3389 nvram_util_get_data_item(&ldi, NVRAM_EF_SYS_CACHE_OCTET_LID);
3390
3391 /*
3392 * if current record just record NVRAM_SYS_FACTORY_FLAG
3393 * 1. please use memory set
3394 * 2. else read out first.
3395 */
3396 memset(sys_cache, 0, NVRAM_EF_SYS_CACHE_OCTET_SIZE);
3397
3398 sys_cache[0] = (kal_uint8) restore_flag;
3399
3400 nvram_write_data_item(ldi, NVRAM_SYS_FACTORY_FLAG, sys_cache, KAL_FALSE);
3401 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3402 return KAL_TRUE;
3403}
3404
3405/*****************************************************************************
3406 * FUNCTION
3407 * nvram_check_restore_factory_flag
3408 * DESCRIPTION
3409 * PARAMETERS
3410 * RETURNS
3411 *****************************************************************************/
3412kal_bool nvram_check_restore_factory_flag(void)
3413{
3414 /*----------------------------------------------------------------*/
3415 /* Local Variables */
3416 /*----------------------------------------------------------------*/
3417 nvram_ltable_entry_struct *ldi;
3418 kal_uint8 sys_cache[NVRAM_EF_SYS_CACHE_OCTET_SIZE];
3419
3420 /*----------------------------------------------------------------*/
3421 /* Code Body */
3422 /*----------------------------------------------------------------*/
3423 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3424 nvram_util_get_data_item(&ldi, NVRAM_EF_SYS_CACHE_OCTET_LID);
3425
3426 nvram_read_data_item(ldi, NVRAM_SYS_FACTORY_FLAG, 1, sys_cache, NVRAM_EF_SYS_CACHE_OCTET_SIZE);
3427
3428 if (NVRAM_RESTORE_TRUE == sys_cache[0])
3429 {
3430 return KAL_TRUE;
3431 }
3432 else
3433 {
3434 return KAL_FALSE;
3435 }
3436 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3437}
3438
3439
3440/*****************************************************************************
3441 * FUNCTION
3442 * nvram_external_msg_read_req
3443 * DESCRIPTION
3444 * This function issues MSG_ID_NVRAM_READ_REQ to nvram.
3445 * PARAMETERS
3446 * file_idx [IN]
3447 * record_index [IN]
3448 * access_id [IN]
3449 * rec_amount [IN]
3450 * RETURNS
3451 * void
3452 *****************************************************************************/
3453void nvram_external_msg_read_req(
3454 kal_uint16 file_idx,
3455 kal_uint16 record_index,
3456 kal_uint8 access_id,
3457 kal_uint16 rec_amount)
3458{
3459
3460 nvram_read_req_struct *nvram_read_req;
3461 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3462 nvram_read_req = (nvram_read_req_struct*) construct_local_para(sizeof(nvram_read_req_struct), TD_CTRL);
3463 nvram_read_req->file_idx = (nvram_lid_enum) file_idx;
3464 nvram_read_req->para = record_index;
3465 nvram_read_req->access_id = (kal_uint16) access_id;
3466 nvram_read_req->rec_amount = rec_amount;
3467
3468 msg_send6(stack_get_active_module_id(), MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_READ_REQ, (local_para_struct *)nvram_read_req,NULL);
3469 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3470} /* end of nvram_msg_read_req */
3471
3472/*****************************************************************************
3473 * FUNCTION
3474 * nvram_external_msg_write_req
3475 * DESCRIPTION
3476 * This function issues NVRAM_WRITE_REQ to nvram.
3477 * PARAMETERS
3478 * file_idx [IN]
3479 * record_index [IN]
3480 * access_id [IN]
3481 * peer_buf_ptr [?]
3482 * ilm_ptr(?) [IN] The primitives
3483 * RETURNS
3484 * void
3485 *****************************************************************************/
3486void nvram_external_msg_write_req(
3487 kal_uint16 file_idx,
3488 kal_uint16 record_index,
3489 kal_uint8 access_id,
3490 peer_buff_struct *peer_buf_ptr)
3491{
3492
3493 nvram_write_req_struct *nvram_write_req;
3494 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3495
3496 nvram_write_req = (nvram_write_req_struct*) construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
3497 nvram_write_req->file_idx = (nvram_lid_enum) file_idx;
3498 nvram_write_req->para = record_index;
3499 nvram_write_req->access_id = (kal_uint16) access_id;
3500
3501 msg_send6(stack_get_active_module_id(), MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_WRITE_REQ, (local_para_struct *)nvram_write_req, peer_buf_ptr);
3502 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3503} /* end of nvram_msg_write_req */
3504
3505/*****************************************************************************
3506 * FUNCTION
3507 * nvram_external_msg_reset_req
3508 * DESCRIPTION
3509 *
3510 * PARAMETERS
3511 * src_id [IN]
3512 * reset_category [IN]
3513 * lid [IN]
3514 * rec_index [IN]
3515 * rec_amount [IN]
3516 * RETURNS
3517 * void
3518 *****************************************************************************/
3519void nvram_external_msg_reset_req(
3520 kal_uint16 file_idx,
3521 kal_uint16 record_index,
3522 kal_uint16 rec_amount,
3523 kal_uint8 access_id)
3524{
3525 nvram_reset_req_struct *nvram_reset_req;
3526 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3527
3528 nvram_reset_req = (nvram_reset_req_struct*) construct_local_para((kal_uint16) sizeof(nvram_reset_req_struct), TD_RESET);
3529
3530 nvram_reset_req->reset_category = NVRAM_RESET_CERTAIN;
3531 nvram_reset_req->LID = file_idx;
3532 nvram_reset_req->access_id = access_id;
3533 nvram_reset_req->rec_index = record_index;
3534 nvram_reset_req->rec_amount = rec_amount;
3535
3536 msg_send6(stack_get_active_module_id(), MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_RESET_REQ, (local_para_struct *)nvram_reset_req, NULL);
3537 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3538}
3539
3540
3541extern void nvram_set_ltable(nvram_ltable_entry_struct *table);
3542extern nvram_ltable_entry_struct *nvram_get_ltable(void);
3543
3544/*****************************************************************************
3545 * FUNCTION
3546 * nvram_ltable_register
3547 * DESCRIPTION
3548 * PARAMETERS
3549 * RETURNS
3550 *****************************************************************************/
3551void nvram_ltable_register(nvram_ltable_entry_struct *table)
3552{
3553 /*----------------------------------------------------------------*/
3554 /* Local Variables */
3555 /*----------------------------------------------------------------*/
3556
3557
3558 /*----------------------------------------------------------------*/
3559 /* Code Body */
3560 /*----------------------------------------------------------------*/
3561
3562
3563 nvram_set_ltable(table);
3564}
3565
3566// The return value not used now, always return KAL_TRUE
3567kal_bool nvram_register_read_req(nvram_read_callback_struct *entry)
3568{
3569 nvram_callback_req_struct *local_data;
3570 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3571
3572 entry->processed = KAL_FALSE;
3573 /*send a message to NVRAM to wakeup NVRAM task*/
3574 local_data = (nvram_callback_req_struct*) construct_local_para(sizeof(nvram_callback_req_struct), TD_CTRL);
3575 local_data->ref_count = 1;
3576 local_data->access_id = 0;
3577 local_data->cfun_addr = (void*)(entry->callback);
3578 nvram_send_ilm(MOD_NVRAM, MSG_ID_NVRAM_CALLBACK_REQ, local_data, NULL);
3579 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3580 return KAL_TRUE;
3581}
3582
3583/*****************************************************************************
3584 * FUNCTION
3585 * nvram_external_msg_reg_req
3586 * DESCRIPTION
3587 * file_idx [IN]
3588 * rec_index [IN]
3589 * rec_amount [IN]
3590 * RETURNS
3591 * void
3592 *****************************************************************************/
3593void nvram_external_msg_reg_req(
3594 kal_uint16 file_idx,
3595 kal_uint16 record_index,
3596 kal_uint16 rec_amount)
3597{
3598 nvram_reg_notify_req_struct *nvram_read_req;
3599 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3600
3601 nvram_read_req = (nvram_reg_notify_req_struct*) construct_local_para(sizeof(nvram_reg_notify_req_struct), TD_CTRL);
3602 nvram_read_req->file_idx = (nvram_lid_enum) file_idx;
3603 nvram_read_req->para = record_index;
3604 nvram_read_req->access_id = 0;
3605 nvram_read_req->rec_amount = rec_amount;
3606
3607 msg_send6(stack_get_active_module_id(), MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_REG_NOTIFY_REQ, (local_para_struct *)nvram_read_req,NULL);
3608}
3609
3610void nvram_external_msg_dereg_req(
3611 kal_uint16 file_idx,
3612 kal_uint16 record_index,
3613 kal_uint16 rec_amount)
3614{
3615 nvram_dereg_notify_req_struct *nvram_read_req;
3616 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3617
3618 nvram_read_req = (nvram_dereg_notify_req_struct*) construct_local_para(sizeof(nvram_dereg_notify_req_struct), TD_CTRL);
3619 nvram_read_req->file_idx = (nvram_lid_enum) file_idx;
3620 nvram_read_req->para = record_index;
3621 nvram_read_req->access_id = 0;
3622 nvram_read_req->rec_amount = rec_amount;
3623
3624 msg_send6(stack_get_active_module_id(), MOD_NVRAM, PS_NVRAM_SAP, MSG_ID_NVRAM_DEREG_NOTIFY_REQ, (local_para_struct *)nvram_read_req,NULL);
3625 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3626}
3627
3628#ifdef __NVRAM_READ_RESERVED_FILE__
3629kal_bool nvram_external_search_reserved_lid(nvram_lid_enum LID, kal_char *verno, kal_uint16 total_records, kal_uint16 size)
3630{
3631 nvram_ltable_entry_struct *ldi, *ldi_r;
3632 kal_char filename[NVRAM_MAX_PATH_LEN];
3633 NVRAM_FULL_PATH r_filename;
3634 nvram_ldi_ota_header ota_hdr;
3635 kal_int32 result = 0;
3636
3637 nvram_util_get_data_item(&ldi, LID);
3638 if (!ldi) {
3639 return KAL_FALSE;
3640 }
3641
3642 //search file
3643 sprintf(filename, "%s?%s_", ldi->fileprefix, verno);
3644 if(total_records) {
3645 sprintf((filename + NVRAM_FILE_LEN + 1), "%04X", total_records);
3646 }
3647 else {
3648 strcat(filename, "????");
3649 }
3650
3651 if(size) {
3652 result = sprintf((filename + NVRAM_FILE_LEN + 5), "%04X", size);
3653 if(result < 0)
3654 {
3655 return KAL_FALSE;
3656 }
3657 }
3658 else {
3659 strcat(filename, "????");
3660 }
3661
3662 if(!nvram_ota_search_backup_file(filename, (NVRAM_FULL_PATH *)r_filename)) {
3663 return KAL_FALSE;
3664 }
3665
3666 //check file header
3667 if(!nvram_read_data_header(r_filename, LDI_HEADER_OTA_SECTION, (void*)&ota_hdr, NVRAM_LDI_OTA_HEADER_SIZE)) {
3668 return KAL_FALSE;
3669 }
3670
3671 //Prepare NVRAM_EF_READ_RESERVED_LID_VERNO
3672 nvram_util_get_data_item(&ldi_r, NVRAM_EF_READ_RESERVED_LID);
3673 if (!ldi_r) {
3674 return KAL_FALSE;
3675 }
3676 ldi_r->attr = ota_hdr.ldi_attr;
3677 ldi_r->total_records = ota_hdr.total_records;
3678 ldi_r->size = ota_hdr.record_size;
3679 ldi_r->default_value = (kal_uint8*)ldi;
3680 strncpy(ldi_r->fileprefix, ldi->fileprefix, FILE_PREFIX_LEN);
3681 ldi_r->fileprefix[FILE_PREFIX_LEN] = '\0';
3682 strncpy(ldi_r->fileverno, verno, FILE_VERNO_LEN);
3683 ldi_r->fileverno[FILE_VERNO_LEN] = '\0';
3684
3685 return KAL_TRUE;
3686}
3687#endif
3688
3689/*****************************************************************************
3690 * FUNCTION
3691 * nvram_external_get_lid_info
3692 * DESCRIPTION
3693 * This function is used to get the LID info
3694 * PARAMETERS
3695 * LID: [IN] NVRAM LID
3696 * ldi: [OUT] LID info buffer pointer,store the LID info
3697 * RETURNS
3698 * nvram_errno_enum
3699 * RETURN VALUES
3700 * NVRAM_ERRNO_SUCCESS: no error
3701 * NVRAM_IO_ERRNO_INVALID_LID: invalid LID
3702 * NVRAM_ERRNO_INVALID: lid pointer is NULL
3703 *****************************************************************************/
3704
3705
3706nvram_errno_enum nvram_external_get_lid_info(nvram_lid_enum LID,nvram_ltable_entry_struct *ldi)
3707{
3708 /*----------------------------------------------------------------*/
3709 /* Local Variables */
3710 /*----------------------------------------------------------------*/
3711 nvram_ltable_entry_struct *tmp_ldi = NULL;
3712 kal_bool ret = KAL_TRUE;
3713 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s ====>\r\n",__FUNCTION__);
3714
3715 if(ldi == NULL)
3716 {
3717 return NVRAM_ERRNO_INVALID;
3718 }
3719 ret = nvram_util_get_data_item(&tmp_ldi, LID);
3720
3721 if (!ret)
3722 {
3723 return NVRAM_IO_ERRNO_INVALID_LID;
3724 }
3725 memcpy(ldi,tmp_ldi,sizeof(nvram_ltable_entry_struct));
3726 NVRAM_DEBUG_DUMP(NVRAM_WARNING_DUMP,"%s <====\r\n",__FUNCTION__);
3727 return NVRAM_ERRNO_SUCCESS;
3728}
3729
3730kal_bool nvram_debug_info_init(kal_uint32 **share_mem,kal_uint32 *length_ptr)
3731{
3732 #if defined(__CCCIFS_SUPPORT__) && defined(__MTK_TARGET__)
3733 if(nvram_ee_info == NULL)
3734 {
3735 g_nvram_emm_query_info_result = EMM_DirInfo_Query(EMM_DIRECT_WRITE_NVRAM, &g_nvram_emm_addr, &g_nvram_emm_size);
3736 if((g_nvram_emm_size < sizeof(nvram_ee_info_type)) || !g_nvram_emm_query_info_result)
3737 {
3738 share_mem = NULL;
3739 nvram_ee_info = NULL;
3740 *length_ptr = 0;
3741 return KAL_FALSE;
3742 }
3743 nvram_ee_info = (nvram_ee_info_type *)g_nvram_emm_addr;
3744 kal_mem_set(nvram_ee_info,0,sizeof(nvram_ee_info_type));
3745 *share_mem =(kal_uint32 *)(&(nvram_ee_info->md_ccci_debug_info[0]));
3746 *length_ptr = MD_CCCI_INFO_SIZE * sizeof(nvram_ee_info->md_ccci_debug_info[0]);
3747 }
3748 return KAL_TRUE;
3749 #else
3750 return KAL_FALSE;
3751 #endif
3752}
3753