开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
NvramInterface.c
资源名称：mmi.rar　[点击查看]
上传用户：lqx1163
上传日期：2014-08-13
资源大小：9183k
文件大小：72k
源码类别：

MTK

开发平台：

C/C++

NvramInterface.c：源码内容
  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. *****************************************************************************/
  36. /*****************************************************************************
  37.  *
  38.  * Filename:
  39.  * ---------
  40.  * NVRAMINTERFACE.C
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for nvram read write data interface.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  *
  54.  *============================================================================
  55.  *             HISTORY
  56.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  57.  *------------------------------------------------------------------------------
  58.  * removed!
  59.  *
  60.  * removed!
  61.  * removed!
  62.  * removed!
  63.  *
  64.  * removed!
  65.  * removed!
  66.  * removed!
  67.  * removed!
  68.  *
  69.  * removed!
  70.  * removed!
  71.  * removed!
  72.  *
  73.  * removed!
  74.  * removed!
  75.  * removed!
  76.  *
  77.  * removed!
  78.  * removed!
  79.  * removed!
  80.  *
  81.  * removed!
  82.  * removed!
  83.  * removed!
  84.  *
  85.  * removed!
  86.  * removed!
  87.  * removed!
  88.  *
  89.  * removed!
  90.  * removed!
  91.  * removed!
  92.  *
  93.  * removed!
  94.  * removed!
  95.  * removed!
  96.  *
  97.  * removed!
  98.  * removed!
  99.  * removed!
  100.  *
  101.  * removed!
  102.  * removed!
  103.  * removed!
  104.  *
  105.  * removed!
  106.  * removed!
  107.  * removed!
  108.  *
  109.  * removed!
  110.  * removed!
  111.  * removed!
  112.  *
  113.  * removed!
  114.  * removed!
  115.  * removed!
  116.  *
  117.  * removed!
  118.  * removed!
  119.  * removed!
  120.  *
  121.  * removed!
  122.  * removed!
  123.  * removed!
  124.  * removed!
  125.  *
  126.  * removed!
  127.  * removed!
  128.  * removed!
  129.  *
  130.  * removed!
  131.  * removed!
  132.  * removed!
  133.  *
  134.  * removed!
  135.  * removed!
  136.  * removed!
  137.  *
  138.  * removed!
  139.  * removed!
  140.  * removed!
  141.  *
  142.  * removed!
  143.  * removed!
  144.  * removed!
  145.  *
  146.  * removed!
  147.  * removed!
  148.  * removed!
  149.  *
  150.  * removed!
  151.  * removed!
  152.  * removed!
  153.  *
  154.  * removed!
  155.  * removed!
  156.  * removed!
  157.  *
  158.  * removed!
  159.  * removed!
  160.  * removed!
  161.  *
  162.  * removed!
  163.  * removed!
  164.  * removed!
  165.  *
  166.  * removed!
  167.  * removed!
  168.  * removed!
  169.  *
  170.  * removed!
  171.  * removed!
  172.  * removed!
  173.  *
  174.  * removed!
  175.  * removed!
  176.  * removed!
  177.  *
  178.  * removed!
  179.  * removed!
  180.  * removed!
  181.  *
  182.  * removed!
  183.  * removed!
  184.  * removed!
  185.  *
  186.  * removed!
  187.  * removed!
  188.  * removed!
  189.  *
  190.  * removed!
  191.  * removed!
  192.  * removed!
  193.  *
  194.  * removed!
  195.  * removed!
  196.  * removed!
  197.  *
  198.  * removed!
  199.  * removed!
  200.  * removed!
  201.  *
  202.  * removed!
  203.  * removed!
  204.  * removed!
  205.  *
  206.  * removed!
  207.  * removed!
  208.  * removed!
  209.  *
  210.  *------------------------------------------------------------------------------
  211.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  212.  *============================================================================
  213.  ****************************************************************************/
  214. #ifndef MMI_ON_WIN32
  215. #include "kal_release.h"        /* Basic data type */
  216. #include "stack_common.h"
  217. #include "stack_msgs.h"
  218. #include "app_ltlcom.h" /* Task message communiction */
  219. #include "syscomp_config.h"
  220. #include "task_config.h"        /* Task creation */
  221. #include "stacklib.h"   /* Basic type for dll, evshed, stacktimer */
  222. #include "event_shed.h" /* Event scheduler */
  223. #include "stack_timer.h"        /* Stack timer */
  224. #include "l4dr.h"
  225. #include "MMI_trc.h"
  226. #include "lcddr.h"
  227. #include "PixtelDataTypes.h"
  228. #include "OslMemory.h"
  229. #endif /* MMI_ON_WIN32 */ 
  230. #include "nvram_user_defs.h"
  232. #include "StdC.h"
  233. #include "QueueGprot.h"
  234. #include "NVRAMEnum.h"
  235. #include "NVRAMProt.h"
  236. #include "NVRAMHwMapFile.h"
  237. #include "NVRAMType.h"
  238. #include "DebugInitDef.h"
  239. #include "TaskInit.h"   /* For MMITaskProt.h */
  240. #include "MMITaskProt.h"        /* For ProtocolEventHandler() prototype */
  241. #include "keyBrd.h"
  242. #ifdef MMI_ON_WIN32
  243. #include "windows.h"
  244. #include "Fat_fs.h"
  245. #endif /* MMI_ON_WIN32 */ 
  246. #include "ucs2prot.h"
  248. #include "TimerEvents.h"
  249. #include "SimDetectionGexdcl.h" /* for g_pwr_context */
  250. #include "SimDetectionGprot.h"
  251. #define __ONLY_FOR_AUTO_RESGEN__
  252. #include "PhoneSetup.h"
  253. #undef __ONLY_FOR_AUTO_RESGEN__
  256. extern void EvshedMMITimerHandler(void *dataPtr);
  257. extern void KeyHandleBeforePWRON(void *paraBuff);
  259. extern oslMsgqid mmi_ext_qid;
  261. #ifndef MMI_ON_WIN32
  262. #include "Stack_timer.h"
  263. extern MMI_BOOL g_keypad_flag;
  264. extern drv_get_key_func keypad_ptr;
  265. #endif /* MMI_ON_WIN32 */ 
  267. static U8 in_nvram_procedure = 0;
  269. static oslMsgqid nvramQID;
  270. static U8 byte_data[NVRAM_CACHE_SIZE];
  271. static U8 uint_data[NVRAM_CACHE_SIZE];
  272. static U8 double_data[NVRAM_CACHE_SIZE];
  274. static U8 byteDataReadFlag = 0;
  275. static U8 uintDataReadFlag = 0;
  276. static U8 doubleDataReadFlag = 0;
  278. static U8 byteDataWriteFlashFlag = 0;
  279. static U8 uintDataWriteFlashFlag = 0;
  280. static U8 doubleDataWriteFlashFlag = 0;
  282. #if defined(__NEW_NVRAMINTERFACE__) && !defined(MMI_ON_WIN32)
  284. /* only for internal read/write value */
  285. #define WriteRecordInt(nFileId,nRecordId,pBuffer,nBufferSize,pError, fileName,lineNumber)
  286.    AccessRecordInt(nFileId,nRecordId,pBuffer,nBufferSize, 1, pError, MMI_TRUE, MMI_TRUE, fileName,lineNumber)
  288. /* only for internal read/write value */
  289. #define ReadRecordInt(nFileId,nRecordId,pBuffer,nBufferSize,pError,fileName,lineNumber)
  290.    AccessRecordInt(nFileId,nRecordId,pBuffer,nBufferSize, 1, pError, MMI_FALSE, MMI_TRUE, fileName,lineNumber)
  292. #endif /* defined(__NEW_NVRAMINTERFACE__) && !defined(MMI_ON_WIN32) */
  295. /*****************************************************************************
  296.  * FUNCTION
  297.  *  SendNVRAMReadReq
  298.  * DESCRIPTION
  299.  *  Send Read NVRAM request to L4
  300.  * PARAMETERS
  301.  *  nFileId             [IN]        File LID
  302.  *  nRecordId           [IN]        Record Index
  303.  *  nRecordAmount       [IN]        
  304.  * RETURNS
  305.  *  void
  306.  *****************************************************************************/
  307. static void SendNVRAMReadReq(U16 nFileId, U16 nRecordId, U16 nRecordAmount)
  308. {
  309.     /*----------------------------------------------------------------*/
  310.     /* Local Variables                                                */
  311.     /*----------------------------------------------------------------*/
  313. #ifndef MMI_ON_WIN32
  315.     MYQUEUE Message;
  316.     mmi_eq_nvram_read_req_struct *local_data;
  318.     /*----------------------------------------------------------------*/
  319.     /* Code Body                                                      */
  320.     /*----------------------------------------------------------------*/
  321.     Message.oslSrcId = MOD_MMI;
  322.     Message.oslDestId = MOD_L4C;
  323.     Message.oslMsgId = MSG_ID_MMI_EQ_NVRAM_READ_REQ;
  325.     local_data = (mmi_eq_nvram_read_req_struct*) OslConstructDataPtr(sizeof(mmi_eq_nvram_read_req_struct));
  327.     /* since we truncate U16 to U8, make sure the value is in U8 range here */
  328.     MMI_ASSERT(nFileId <= 0xFF);
  329.     
  330.     local_data->file_idx = (U8) nFileId;
  331.     local_data->para = nRecordId;
  332.     local_data->rec_amount = nRecordAmount;
  333.     if (local_data->rec_amount == 0)
  334.     {
  336.         local_data->rec_amount = 1;
  338.     }
  340.     Message.oslDataPtr = (oslParaType*) local_data;
  341.     Message.oslPeerBuffPtr = NULL;
  342.     OslMsgSendExtQueue(&Message);
  344. #endif /* MMI_ON_WIN32 */ 
  346. }
  349. /*****************************************************************************
  350.  * FUNCTION
  351.  *  SendNVRAMWriteReq
  352.  * DESCRIPTION
  353.  *  Send Write NVRAM request to L4
  354.  *  
  355.  *  Size should be an even number
  356.  * PARAMETERS
  357.  *  nFileId         [IN]        File ID
  358.  *  nRecordId       [IN]        Record Index
  359.  *  pBuffer         [IN]        Data to be writen
  360.  *  nBufferSize     [IN]        Size of data to be writen
  361.  * RETURNS
  362.  *  void
  363.  *****************************************************************************/
  364. static void SendNVRAMWriteReq(U16 nFileId, U16 nRecordId, void *pBuffer, U16 nBufferSize)
  365. {
  366.     /*----------------------------------------------------------------*/
  367.     /* Local Variables                                                */
  368.     /*----------------------------------------------------------------*/
  370. #ifndef MMI_ON_WIN32
  371.     MYQUEUE Message;
  372.     mmi_eq_nvram_write_req_struct *local_data;
  374.     /*----------------------------------------------------------------*/
  375.     /* Code Body                                                      */
  376.     /*----------------------------------------------------------------*/
  377.     Message.oslSrcId = MOD_MMI;
  378.     Message.oslDestId = MOD_L4C;
  379.     Message.oslMsgId = MSG_ID_MMI_EQ_NVRAM_WRITE_REQ;
  380.     local_data = (mmi_eq_nvram_write_req_struct*) OslConstructDataPtr(sizeof(mmi_eq_nvram_write_req_struct) + nBufferSize);
  382.     /* since we truncate U16 to U8, make sure the value is in U8 range here */
  383.     MMI_ASSERT(nFileId <= 0xFF);
  385.     local_data->file_idx = (U8) nFileId;
  387.     local_data->length = nBufferSize;
  389.     memcpy(local_data->data, pBuffer, nBufferSize);
  391.     local_data->para = nRecordId;
  393.     Message.oslDataPtr = (oslParaType*) local_data;
  394.     Message.oslPeerBuffPtr = NULL;
  395.     OslMsgSendExtQueue(&Message);
  397.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_HDLR));
  399. #endif /* MMI_ON_WIN32 */ 
  401. }
  403. #ifndef MMI_ON_WIN32
  405. #ifdef __NEW_NVRAMINTERFACE__
  406. #define CIRCQ_NODE_SIZE sizeof(MYQUEUE)
  407. #define CIRCQ_NO_OF_NODES 65
  409. typedef enum
  410. {
  411.     circularQ_check_never_check,
  412.     circularQ_check_not_found,
  413.     circularQ_check_found
  414. } circularQ_check_enum;
  416. #ifdef __MMI_TEST_NEW_NVRAMINTERFACE__
  419. /*****************************************************************************
  420.  * FUNCTION
  421.  *  NVRAMDummyTestRW
  422.  * DESCRIPTION
  423.  *  
  424.  * PARAMETERS
  425.  *  void
  426.  * RETURNS
  427.  *  void
  428.  *****************************************************************************/
  429. void NVRAMDummyTestRW(void)
  430. {
  431.     /*----------------------------------------------------------------*/
  432.     /* Local Variables                                                */
  433.     /*----------------------------------------------------------------*/
  434.     static pBOOL isRead = MMI_TRUE;
  435.     static kal_uint8 settingBuffer[NVRAM_SETTING_SIZE] = {0};
  436.     S16 error;
  438.     /*----------------------------------------------------------------*/
  439.     /* Code Body                                                      */
  440.     /*----------------------------------------------------------------*/
  441.     StartTimer(AT_TEST_TIMER, 3000, NVRAMDummyTestRW);
  443.     if (isRead)
  444.     {
  445.         ReadRecord(NVRAM_EF_SETTING_LID, 1, settingBuffer, NVRAM_SETTING_SIZE, &error);
  446.         isRead = MMI_FALSE;
  447.     }
  448.     else
  449.     {
  450.         WriteRecord(NVRAM_EF_SETTING_LID, 1, settingBuffer, NVRAM_SETTING_SIZE, &error);
  451.         isRead = MMI_TRUE;
  452.     }
  454. }
  455. #endif /* __MMI_TEST_NEW_NVRAMINTERFACE__ */ 
  458. /*****************************************************************************
  459.  * FUNCTION
  460.  *  NVRAMCheckCircularQ
  461.  * DESCRIPTION
  462.  *  check if there is nvram access response
  463.  *  in the circular queue; if there is,
  464.  *  retrieve it and put a dummy one in the
  465.  *  same position
  466.  * PARAMETERS
  467.  *  msgPtr          [?]         
  468.  *  nFileId         [IN]        The LID currently waiting
  469.  *  memory(?)       [OUT]       For this.
  470.  *  pBuffer(?)      [OUT]       Buffer in which data need to
  471.  *  be(?)           [OUT]       Retrieved,caller will allocate
  472.  * RETURNS
  473.  *  circularQ_check_enum
  474.  *****************************************************************************/
  475. circularQ_check_enum NVRAMCheckCircularQ(void *msgPtr, U16 nFileId)
  476. {
  477.     /*----------------------------------------------------------------*/
  478.     /* Local Variables                                                */
  479.     /*----------------------------------------------------------------*/
  480.     U8 i;
  481.     extern U8 circq_array[];
  482.     MYQUEUE *tempQueueNode;
  484. #ifdef __MMI_TEST_NEW_NVRAMINTERFACE__
  485.     static pBOOL testFlag = MMI_TRUE;
  487.     /*----------------------------------------------------------------*/
  488.     /* Code Body                                                      */
  489.     /*----------------------------------------------------------------*/
  490.     if (testFlag)
  491.     {
  492.         NVRAMDummyTestRW();
  493.         testFlag = MMI_FALSE;
  494.     }
  495. #endif /* __MMI_TEST_NEW_NVRAMINTERFACE__ */ 
  497.     for (i = 0; i < CIRCQ_NO_OF_NODES; i++)
  498.     {
  499.         tempQueueNode = ((MYQUEUE*) (circq_array + i * CIRCQ_NODE_SIZE));
  501.         switch (tempQueueNode->msg_id)
  502.         {
  503.             case MSG_ID_MMI_EQ_NVRAM_READ_RSP:
  504.             case MSG_ID_MMI_EQ_NVRAM_WRITE_RSP:
  505.             {
  506.                 ilm_struct ilm_ptr; /* DUMMY message */
  508.                 if (((mmi_eq_nvram_read_rsp_struct*) (tempQueueNode->local_para_ptr))->file_idx == nFileId
  509.                     || ((mmi_eq_nvram_write_rsp_struct*) (tempQueueNode->local_para_ptr))->file_idx == nFileId)
  510.                 {
  511.                     memcpy(msgPtr, circq_array + (i * CIRCQ_NODE_SIZE), CIRCQ_NODE_SIZE);
  513.                     ilm_ptr.src_mod_id = MOD_NIL;
  514.                     ilm_ptr.dest_mod_id = MOD_NIL;
  515.                     ilm_ptr.msg_id = MSG_ID_MMI_EQ_NVRAM_READY_IND;
  516.                     ilm_ptr.sap_id = INVALID_SAP;
  517.                     ilm_ptr.local_para_ptr = NULL;
  518.                     ilm_ptr.peer_buff_ptr = NULL;
  519.                     memcpy(circq_array + (i * CIRCQ_NODE_SIZE), &ilm_ptr, CIRCQ_NODE_SIZE);
  520.                     return circularQ_check_found;
  521.                 }
  523.             }
  524.             default:
  525.                 break;
  526.         }
  527.     }
  528.     return circularQ_check_not_found;
  529. }
  532. /*****************************************************************************
  533.  * FUNCTION
  534.  *  AccessRecordInt
  535.  * DESCRIPTION
  536.  *  MMI level API to access NVRAM
  537.  * PARAMETERS
  538.  *  nFileId             [IN]        NVRAM data item id
  539.  *  nRecordId           [IN]        Record index in a data item
  540.  *  pBuffer             [OUT]       Buffer in which data need to
  541.  *  nBufferSize         [IN]        Size of record to be read
  542.  *  nRecordAmount       [IN]        
  543.  *  pError              [OUT]       Error returned from PS
  544.  *  isWrite             [IN]        True =write, false=read
  545.  *  isValue             [IN]        True = from read/write Value
  546.  *                                  False = from read/write Record
  547.  *  filename            [IN]         
  548.  *  lineNumber          [IN]        
  549.  * RETURNS
  550.  *  S32
  551.  *****************************************************************************/
  552. S32 AccessRecordInt
  553.     (U16 nFileId,
  554.      U16 nRecordId,
  555.      void *pBuffer, 
  556.      U16 nBufferSize, 
  557.      U16 nRecordAmount, 
  558.      S16 *pError, 
  559.      pBOOL isWrite, 
  560.      pBOOL isValue,
  561.      S8 *filename, 
  562.      S32 lineNumber)
  563. {
  564.     /*----------------------------------------------------------------*/
  565.     /* Local Variables                                                */
  566.     /*----------------------------------------------------------------*/
  568.     MYQUEUE queueNode;
  569.     S32 status = -1;
  570.     U32 my_index;
  571.     circularQ_check_enum circularQ_check_result = circularQ_check_never_check;
  572.     static U8 nvram_req_count = 0;
  573.     MMI_BOOL toPush;
  575.     /*----------------------------------------------------------------*/
  576.     /* Code Body                                                      */
  577.     /*----------------------------------------------------------------*/
  578.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_REC_INT_HDLR, nFileId, nRecordId));
  580.     if (isWrite)
  581.     {
  582.         SendNVRAMWriteReq(nFileId, nRecordId, pBuffer, nBufferSize);
  584.         if (!isValue)   /* call from read/write Record */
  585.         {
  586.             /* reset BYTE/SHORT/DOUBLE cache */
  587.             /*   since others may access these LIDs directly */
  588.             if (nFileId == NVRAM_EF_CACHE_BYTE_LID)
  589.             {
  590.                 byteDataReadFlag = 0;
  591.             }
  592.             else if (nFileId == NVRAM_EF_CACHE_SHORT_LID)
  593.             {
  594.                 uintDataReadFlag = 0;
  595.             }
  596.             else if (nFileId == NVRAM_EF_CACHE_DOUBLE_LID)
  597.             {
  598.                 doubleDataReadFlag = 0;
  599.             }
  600.         }    
  601.     }
  602.     else
  603.     {
  604.         SendNVRAMReadReq(nFileId, nRecordId, nRecordAmount);
  605.     }
  607.     in_nvram_procedure++;
  608.     while (1)
  609.     {
  610.         /* if more than 1 access request exist, go through the circular Q */
  611.         if ((nvram_req_count > 0) && (circularQ_check_result == circularQ_check_never_check))
  612.         {
  613.             circularQ_check_result = NVRAMCheckCircularQ(&queueNode, nFileId);
  614.         }
  616.         if (circularQ_check_result != circularQ_check_found)
  617.         {
  618.             OslReceiveMsgExtQ(mmi_ext_qid, &queueNode);
  619.             OslGetMyTaskIndex(&my_index);
  620.             OslStackSetActiveModuleID(my_index, MOD_MMI);
  621.         }
  623.         toPush = MMI_FALSE;
  624.         switch (queueNode.msg_id)
  625.         {
  626.             case MSG_ID_MMI_EQ_PLAY_AUDIO_RSP:
  627.             case MSG_ID_MMI_EQ_STOP_AUDIO_RSP:
  628.             case MSG_ID_MMI_EQ_EXE_GPIO_LEVEL_RSP:
  629.             case MSG_ID_MMI_EQ_SET_VOLUME_RSP:
  630.                 OslFreeInterTaskMsg(&queueNode);
  631.                 break;
  632.             case MSG_ID_MMI_EQ_KEYPAD_DETECT_IND:
  633.             {
  634.   /* special handling before entering stable stable state.
  635.      But for charger and USB case, need to treat them as stable state */
  636.   if ((mmi_bootup_is_power_on_animation_complete() == MMI_FALSE) &&
  637.   (g_pwr_context.PowerOnMode != POWER_ON_PRECHARGE) &&
  638.       (g_pwr_context.PowerOnMode != POWER_ON_CHARGER_IN) &&
  639.       (g_pwr_context.PowerOnMode != POWER_ON_USB))
  640.                 {
  641.                     KeyHandleBeforePWRON((void*)queueNode.oslDataPtr);
  642.                 }
  643.                 else
  644.                 {
  645.                     mmi_eq_keypad_detect_ind_struct *p;
  647.                     p = (mmi_eq_keypad_detect_ind_struct*) queueNode.local_para_ptr;
  648.                     if (p->func != keypad_ptr)
  649.                     {
  650.                         ClearKeyEvents();
  651.                     }
  652.                     g_keypad_flag = MMI_TRUE;
  653.                     keypad_ptr = p->func;
  654.                 }
  655.                 OslFreeInterTaskMsg(&queueNode);
  656.                 break;
  657.             }
  658.             /* We don't need to handle MSG_ID_MMI_EQ_GET_RTC_TIME_RSP in special condition */
  659.             case MSG_ID_TIMER_EXPIRY:
  660.             {
  661.                 /* only process non-alignment timer during power-up */
  662.                 if ( (mmi_bootup_is_searching_or_idle_reached() == MMI_FALSE) &&
  663.                      !mmi_frm_is_align_base_timer(queueNode.oslDataPtr))
  664.                 {
  665.                     kal_uint16 msg_len;
  667.                     EvshedMMITimerHandler(get_local_para_ptr(queueNode.oslDataPtr, &msg_len));
  668.                     OslFreeInterTaskMsg(&queueNode);
  669.                     break;
  670.                 }
  671.                 else
  672.                 {
  673.                     stack_timer_struct *stack_timer_ptr;
  675.                     stack_timer_ptr = (stack_timer_struct*) queueNode.oslDataPtr;
  676.                     if (!stack_is_time_out_valid(stack_timer_ptr))
  677.                     {
  678.                         PRINT_INFORMATION(("==========Time out is not valid=========="));
  679.                         OslFreeInterTaskMsg(&queueNode);
  680.                         break;
  681.                     }
  682.                 }
  683.                 toPush = MMI_TRUE;
  684.                 break;
  685.             }
  686.             case MSG_ID_MMI_EQ_NVRAM_READ_RSP:
  687.             {
  688.                 mmi_eq_nvram_read_rsp_struct *readMessage;
  690.                 readMessage = (mmi_eq_nvram_read_rsp_struct *)queueNode.oslDataPtr;
  692.                 if (readMessage->file_idx != nFileId)
  693.                 {
  694.                     nvram_req_count++;
  695.                 }
  696.                 else
  697.                 {
  698.                     if (readMessage->result.flag == MMI_OK)
  699.                     {
  700.                         PRINT_INFORMATION((" NVRAM Read Success"));
  701.                         if (readMessage->length > nBufferSize)
  702.                         {
  703.                             memcpy(pBuffer, readMessage->data, nBufferSize);
  704.                             *pError = NVRAM_ERROR_ACTUAL_READ_GREATER_THAN_REQUESTED_READ;
  705.                         }
  706.                         else if (readMessage->length < nBufferSize)
  707.                         {
  708.                             memcpy(pBuffer, readMessage->data, readMessage->length);
  709.                             *pError = NVRAM_ERROR_ACTUAL_READ_LESS_THAN_REQUESTED_READ;
  710.                         }
  711.                         else
  712.                         {
  713.                             memcpy(pBuffer, readMessage->data, readMessage->length);
  714.                             *pError = NVRAM_READ_SUCCESS;
  715.                         }
  717.                         status = readMessage->length;
  718.                     }
  719.                     else
  720.                     {
  721.                         PRINT_INFORMATION((" NVRAM Read Failed. Cause: %d", readMessage->result.cause));
  722.                         ASSERT(readMessage->result.flag == MMI_OK);
  723.                         *pError = NVRAM_READ_FAIL;
  724.                     }
  726.                     OslFreeInterTaskMsg(&queueNode);
  727.                     PRINT_INFORMATION((" Exiting Reading record status = %dn", status));
  728.                     if (nvram_req_count && circularQ_check_result == circularQ_check_found)
  729.                     {
  730.                         nvram_req_count--;
  731.                     }
  733.                     in_nvram_procedure--;
  734.                     return status;
  735.                 }
  736.                 toPush = MMI_TRUE;
  737.                 break;
  738.             }
  739.             case MSG_ID_MMI_EQ_NVRAM_WRITE_RSP:
  740.             {
  742.                 mmi_eq_nvram_write_rsp_struct *writeMessage;
  744.                 writeMessage = (mmi_eq_nvram_write_rsp_struct*) queueNode.oslDataPtr;
  746.                 if (writeMessage->file_idx != nFileId)
  747.                 {
  748.                     nvram_req_count++;
  749.                 }
  750.                 else
  751.                 {
  752.                     if (writeMessage->result.flag == MMI_OK)
  753.                     {
  754.                         PRINT_INFORMATION((" NVRAM Write Success"));
  755.                         *pError = NVRAM_WRITE_SUCCESS;
  756.                         status = nBufferSize;
  757.                     }
  758.                     else
  759.                     {
  760.                         PRINT_INFORMATION((" NVRAM Write Failed. Cause: %d", writeMessage->result.cause));
  761.                         ASSERT(writeMessage->result.flag == MMI_OK);
  762.                         *pError = NVRAM_WRITE_FAIL;
  763.                     }
  765.                     OslFreeInterTaskMsg(&queueNode);
  766.                     PRINT_INFORMATION((" Exiting Wriring record"));
  767.                     if (nvram_req_count && circularQ_check_result == circularQ_check_found)
  768.                     {
  769.                         nvram_req_count--;
  770.                     }
  772.                     in_nvram_procedure--;
  773.                     return status;
  774.                 }
  775.                 toPush = MMI_TRUE;
  776.                 break;
  777.             }
  779.             default:
  780.             {
  781.                 toPush = MMI_TRUE;
  782.                 break;
  783.             }
  784.         }
  786.         if (toPush == MMI_TRUE)
  787.         {
  788.             ilm_struct ilm_ptr;
  789.             U8 flag = 0;
  791.             ilm_ptr.src_mod_id = queueNode.src_mod_id;
  792.             ilm_ptr.dest_mod_id = queueNode.dest_mod_id;
  793.             ilm_ptr.msg_id = queueNode.msg_id;
  794.             ilm_ptr.sap_id = queueNode.sap_id;
  795.             ilm_ptr.local_para_ptr = queueNode.local_para_ptr;
  796.             ilm_ptr.peer_buff_ptr = queueNode.peer_buff_ptr;
  797.             flag = OslWriteCircularQ(&ilm_ptr);
  798.             /* TIMER use special data in the local_para_ptr field. Can NOT treat as general ILM */
  799.             if ((queueNode.src_mod_id != MOD_TIMER) && (flag == 1))
  800.             {
  801.                 hold_local_para(ilm_ptr.local_para_ptr);
  802.                 hold_peer_buff(ilm_ptr.peer_buff_ptr);
  803.             }
  804.             OslFreeInterTaskMsg(&queueNode);
  805.         }
  807.     }
  808. }
  810. #else /* __NEW_NVRAMINTERFACE__ */ 
  811. #if 0
  812. /* under construction !*/
  813. /* under construction !*/
  814. /* under construction !*/
  815. /* under construction !*/
  816. /* under construction !*/
  817. /* under construction !*/
  818. /* under construction !*/
  819. /* under construction !*/
  820. /* under construction !*/
  821. /* under construction !*/
  822. /* under construction !*/
  823. /* under construction !*/
  824. /* under construction !*/
  825. /* under construction !*/
  826. /* under construction !*/
  827. /* under construction !*/
  828. /* under construction !*/
  829. /* under construction !*/
  830. /* under construction !*/
  831. /* under construction !*/
  832. /* under construction !*/
  833. /* under construction !*/
  834. /* under construction !*/
  835. /* under construction !*/
  836. /* under construction !*/
  837. /* under construction !*/
  838. /* under construction !*/
  839. /* under construction !*/
  840. /* under construction !*/
  841. /* under construction !*/
  842. /* under construction !*/
  843. /* under construction !*/
  844. /* under construction !*/
  845. /* under construction !*/
  846. /* under construction !*/
  847. /* under construction !*/
  848. /* under construction !*/
  849. /* under construction !*/
  850. /* under construction !*/
  851. /* under construction !*/
  852. /* under construction !*/
  853. /* under construction !*/
  854. /* under construction !*/
  855. /* under construction !*/
  856. /* under construction !*/
  857. /* under construction !*/
  858. /* under construction !*/
  859. /* under construction !*/
  860. /* under construction !*/
  861. /* under construction !*/
  862. /* under construction !*/
  863. /* under construction !*/
  864. /* under construction !*/
  865. /* under construction !*/
  866. /* under construction !*/
  867. /* under construction !*/
  868. /* under construction !*/
  869. /* under construction !*/
  870. /* under construction !*/
  871. /* under construction !*/
  872. /* under construction !*/
  873. /* under construction !*/
  874. /* under construction !*/
  875. /* under construction !*/
  876. /* under construction !*/
  877. /* under construction !*/
  878. /* under construction !*/
  879. /* under construction !*/
  880. /* under construction !*/
  881. /* under construction !*/
  882. /* under construction !*/
  883. /* under construction !*/
  884. /* under construction !*/
  885. /* under construction !*/
  886. /* under construction !*/
  887. /* under construction !*/
  888. /* under construction !*/
  889. /* under construction !*/
  890. /* under construction !*/
  891. /* under construction !*/
  892. /* under construction !*/
  893. /* under construction !*/
  894. /* under construction !*/
  895.                #ifdef __MTK_TARGET__
  896. /* under construction !*/
  897.                #endif
  898. /* under construction !*/
  899. /* under construction !*/
  900. /* under construction !*/
  901. /* under construction !*/
  902. /* under construction !*/
  903. /* under construction !*/
  904. /* under construction !*/
  905. /* under construction !*/
  906. /* under construction !*/
  907. /* under construction !*/
  908. /* under construction !*/
  909. /* under construction !*/
  910. /* under construction !*/
  911. /* under construction !*/
  912. /* under construction !*/
  913. /* under construction !*/
  914. /* under construction !*/
  915. /* under construction !*/
  916. /* under construction !*/
  917. /* under construction !*/
  918. /* under construction !*/
  919. /* under construction !*/
  920. /* under construction !*/
  921. /* under construction !*/
  922. /* under construction !*/
  923. /* under construction !*/
  924. /* under construction !*/
  925. /* under construction !*/
  926. /* under construction !*/
  927. /* under construction !*/
  928. /* under construction !*/
  929. /* under construction !*/
  930. /* under construction !*/
  931. /* under construction !*/
  932. /* under construction !*/
  933. /* under construction !*/
  934. /* under construction !*/
  935. /* under construction !*/
  936. /* under construction !*/
  937. /* under construction !*/
  938. /* under construction !*/
  939. /* under construction !*/
  940. /* under construction !*/
  941. /* under construction !*/
  942. /* under construction !*/
  943. /* under construction !*/
  944. /* under construction !*/
  945. /* under construction !*/
  946. /* under construction !*/
  947. /* under construction !*/
  948. /* under construction !*/
  949. /* under construction !*/
  950. /* under construction !*/
  951. /* under construction !*/
  952. /* under construction !*/
  953. /* under construction !*/
  954. /* under construction !*/
  955. /* under construction !*/
  956. /* under construction !*/
  957. /* under construction !*/
  958. /* under construction !*/
  959. /* under construction !*/
  960. /* under construction !*/
  961. /* under construction !*/
  962. /* under construction !*/
  963. /* under construction !*/
  964. /* under construction !*/
  965. /* under construction !*/
  966. /* under construction !*/
  967. /* under construction !*/
  968. /* under construction !*/
  969. /* under construction !*/
  970. /* under construction !*/
  971. /* under construction !*/
  972. /* under construction !*/
  973. /* under construction !*/
  974. /* under construction !*/
  975. /* under construction !*/
  976. /* under construction !*/
  977. /* under construction !*/
  978. /* under construction !*/
  979. /* under construction !*/
  980. /* under construction !*/
  981. /* under construction !*/
  982. /* under construction !*/
  983. /* under construction !*/
  984. /* under construction !*/
  985. /* under construction !*/
  986. /* under construction !*/
  987. /* under construction !*/
  988. /* under construction !*/
  989. /* under construction !*/
  990. /* under construction !*/
  991. /* under construction !*/
  992. /* under construction !*/
  993. /* under construction !*/
  994. /* under construction !*/
  995. /* under construction !*/
  996. /* under construction !*/
  997. /* under construction !*/
  998. /* under construction !*/
  999. /* under construction !*/
  1000. /* under construction !*/
  1001. /* under construction !*/
  1002. /* under construction !*/
  1003. /* under construction !*/
  1004. /* under construction !*/
  1005. /* under construction !*/
  1006. /* under construction !*/
  1007. /* under construction !*/
  1008. /* under construction !*/
  1009. /* under construction !*/
  1010. /* under construction !*/
  1011. /* under construction !*/
  1012. /* under construction !*/
  1013. /* under construction !*/
  1014. /* under construction !*/
  1015. /* under construction !*/
  1016. /* under construction !*/
  1017. /* under construction !*/
  1018. /* under construction !*/
  1019. /* under construction !*/
  1020. /* under construction !*/
  1021. /* under construction !*/
  1022. /* under construction !*/
  1023. /* under construction !*/
  1024. /* under construction !*/
  1025. /* under construction !*/
  1026. /* under construction !*/
  1027. /* under construction !*/
  1028. /* under construction !*/
  1029. /* under construction !*/
  1030. /* under construction !*/
  1031. /* under construction !*/
  1032. /* under construction !*/
  1033. /* under construction !*/
  1034. /* under construction !*/
  1035. /* under construction !*/
  1036. /* under construction !*/
  1037. /* under construction !*/
  1038. /* under construction !*/
  1039. /* under construction !*/
  1040. /* under construction !*/
  1041. /* under construction !*/
  1042. /* under construction !*/
  1043. /* under construction !*/
  1044. /* under construction !*/
  1045. /* under construction !*/
  1046. /* under construction !*/
  1047. /* under construction !*/
  1048. /* under construction !*/
  1049.          #ifdef __MTK_TARGET__
  1050. /* under construction !*/
  1051.          #endif
  1052. /* under construction !*/
  1053. /* under construction !*/
  1054. /* under construction !*/
  1055. /* under construction !*/
  1056. /* under construction !*/
  1057. /* under construction !*/
  1058. /* under construction !*/
  1059. /* under construction !*/
  1060. /* under construction !*/
  1061. /* under construction !*/
  1062. /* under construction !*/
  1063. /* under construction !*/
  1064. /* under construction !*/
  1065. /* under construction !*/
  1066. /* under construction !*/
  1067. /* under construction !*/
  1068. /* under construction !*/
  1069. /* under construction !*/
  1070. /* under construction !*/
  1071. /* under construction !*/
  1072. /* under construction !*/
  1073. /* under construction !*/
  1074. /* under construction !*/
  1075. /* under construction !*/
  1076. /* under construction !*/
  1077. /* under construction !*/
  1078. /* under construction !*/
  1079. /* under construction !*/
  1080. /* under construction !*/
  1081. /* under construction !*/
  1082. /* under construction !*/
  1083. /* under construction !*/
  1084. /* under construction !*/
  1085. /* under construction !*/
  1086. /* under construction !*/
  1087. /* under construction !*/
  1088. /* under construction !*/
  1089. /* under construction !*/
  1090. /* under construction !*/
  1091. /* under construction !*/
  1092. /* under construction !*/
  1093. /* under construction !*/
  1094. /* under construction !*/
  1095. /* under construction !*/
  1096. /* under construction !*/
  1097. /* under construction !*/
  1098. /* under construction !*/
  1099. /* under construction !*/
  1100. /* under construction !*/
  1101. /* under construction !*/
  1102. /* under construction !*/
  1103. /* under construction !*/
  1104. /* under construction !*/
  1105. /* under construction !*/
  1106. /* under construction !*/
  1107. /* under construction !*/
  1108. /* under construction !*/
  1109. /* under construction !*/
  1110. /* under construction !*/
  1111. /* under construction !*/
  1112. /* under construction !*/
  1113. /* under construction !*/
  1114. /* under construction !*/
  1115. /* under construction !*/
  1116. /* under construction !*/
  1117. /* under construction !*/
  1118. /* under construction !*/
  1119. /* under construction !*/
  1120. /* under construction !*/
  1121. /* under construction !*/
  1122. /* under construction !*/
  1123. /* under construction !*/
  1124. /* under construction !*/
  1125. /* under construction !*/
  1126. /* under construction !*/
  1127. /* under construction !*/
  1128. /* under construction !*/
  1129. /* under construction !*/
  1130. /* under construction !*/
  1131. /* under construction !*/
  1132. /* under construction !*/
  1133. /* under construction !*/
  1134. /* under construction !*/
  1135. /* under construction !*/
  1136. /* under construction !*/
  1137. /* under construction !*/
  1138. /* under construction !*/
  1139. /* under construction !*/
  1140. #endif /* 0 */ 
  1141. #endif /* __NEW_NVRAMINTERFACE__ */ 
  1144. /*****************************************************************************
  1145.  * FUNCTION
  1146.  *  DeleteRecord
  1147.  * DESCRIPTION
  1148.  *  User level API for Deleting record from the file
  1149.  * PARAMETERS
  1150.  *  nFileId         [IN]        File LID
  1151.  *  nRecordId       [IN]        Record index in file
  1152.  *  pError          [OUT]       Error returned from PS
  1153.  * RETURNS
  1154.  * BOOL
  1155.  *  
  1156.  *****************************************************************************/
  1157. pBOOL DeleteRecord(U16 nFileId, U16 nRecordId, S16 *pError)
  1158. {
  1159.     /*----------------------------------------------------------------*/
  1160.     /* Local Variables                                                */
  1161.     /*----------------------------------------------------------------*/
  1163.     MYQUEUE queueNode;
  1164.     MMIEQNVRAMWRITERSP *writeMessage = NULL;
  1165.     U8 *pBuffer = NULL;
  1166.     S8 status = (S8) - 1;
  1167.     U32 msgSize;
  1168.     U8 noOfFiles = 0;
  1169.     U8 count = 0;
  1171.     /*----------------------------------------------------------------*/
  1172.     /* Code Body                                                      */
  1173.     /*----------------------------------------------------------------*/
  1174.     *pError = -1;
  1176.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_DELETE_REC_INT_HDLR));
  1178.     /* 0 Search for the LID index in logical_data_item_table_cust
  1179.        array of structures  */
  1181.     noOfFiles = NVRAM_EF_LAST_LID_CUST - NVRAM_LID_CUST_BEGIN - 1;
  1183.     for (count = 0; count < noOfFiles; ++count)
  1184.     {
  1186.         if (nFileId == logical_data_item_table_cust[count].LID)
  1187.         {
  1188.             break;
  1189.         }
  1190.     }
  1192.     pBuffer = (U8*) OslMalloc(logical_data_item_table_cust[count].size);
  1194.     memset(pBuffer, '', logical_data_item_table_cust[count].size);
  1196.     /* 1. Send Write Request */
  1197.     SendNVRAMWriteReq(nFileId, nRecordId, pBuffer, logical_data_item_table_cust[count].size);
  1199.     OslMfree(pBuffer);
  1201.     /* 2  Wait for write response on message queue */
  1203.     if (OslReadMsgQ(nvramQID, &queueNode, (U16*) & msgSize, OSL_INFINITE_WAIT) == OSL_SUCCESS)
  1204.     {
  1205.         writeMessage = (MMIEQNVRAMWRITERSP*) queueNode.oslDataPtr;
  1206.         if (writeMessage->result.flag == MMI_OK)
  1207.         {
  1209.             PRINT_INFORMATION((" Inside MMI_OK block"));
  1210.             *pError = NVRAM_WRITE_SUCCESS;
  1211.             status = MMI_TRUE;
  1213.         }
  1214.         else
  1215.         {
  1217.             PRINT_INFORMATION((" Inside MMI_ERROR block"));
  1218.             *pError = ST_FAILURE;
  1219.             status = MMI_FALSE;
  1221.         }
  1223.     }
  1225.     PRINT_INFORMATION((" Exiting Wriring record"));
  1226.     OslMfree(writeMessage);
  1228.     return status;
  1230. }
  1232. #else /* MMI_ON_WIN32 */ 
  1233. /* 
  1234.  * Structure of lookup table entry
  1235.  */
  1236. typedef struct
  1237. {
  1238.     U16 lid;
  1239.     U16 size;
  1240.     const U8 *default_value;
  1241. } pc_ltable_entry_struct;
  1243. /* 
  1244.  * Default Values on PC
  1245.  */
  1246. const U8 NVRAM_EF_ZERO_DEFAULT[] = {0X00};
  1247. const U8 NVRAM_EF_FF_DEFAULT[] = {0XFF};
  1249. pc_ltable_entry_struct pc_logical_data_item_table[] = 
  1250. {
  1251.     {NVRAM_EF_PHONEBOOK_SPEEDDIAL_LID, NVRAM_PHONEBOOK_SPEEDDIAL_RECORD_SIZE, NVRAM_EF_ZERO_DEFAULT},
  1252. #ifdef __MMI_MESSAGES_CHAT__    
  1253.     {NVRAM_EF_CHAT_ROOM_INFO_LID, NVRAM_CHAT_ROOM_INFO_RECORD_SIZE, NVRAM_EF_ZERO_DEFAULT},
  1254. #endif /* __MMI_MESSAGES_CHAT__ */
  1255. #ifdef __MMI_NITZ__    
  1256.         {NVRAM_EF_NITZ_NW_NAME_LID, NVRAM_NITZ_NW_NAME_SIZE, NVRAM_EF_ZERO_DEFAULT},
  1257. #endif /* __MMI_NITZ__ */
  1258.     {0, 0, NVRAM_EF_FF_DEFAULT}
  1259. };
  1262. /*****************************************************************************
  1263.  * FUNCTION
  1264.  *  ReadRecordInt
  1265.  * DESCRIPTION
  1266.  *  User level API for reading record from the file
  1267.  * PARAMETERS
  1268.  *  nFileId         [IN]        File LID
  1269.  *  nRecordId       [IN]        Record index in file
  1270.  *  pBuffer         [OUT]       Buffer in which data need to
  1271.  *  nBufferSize     [IN]        Size of record to be read
  1272.  *  pError          [OUT]       Error returned from PS
  1273.  *  filename        [?]         
  1274.  *  lineNumber      [IN]        
  1275.  *  it(?)           [IN]        Should be same as file
  1276.  *  memory(?)       [OUT]       For this.
  1277.  *  record(?)       [IN]        Size
  1278.  *  be(?)           [OUT]       Retrieved,caller will allocate
  1279.  * RETURNS
  1280.  * BOOL
  1281.  *  
  1282.  *****************************************************************************/
  1283. S32 ReadRecordInt(
  1284.         U16 nFileId,
  1285.         U16 nRecordId,
  1286.         void *pBuffer,
  1287.         U16 nBufferSize,
  1288.         S16 *pError,
  1289.         S8 *filename,
  1290.         S32 lineNumber)
  1291. {
  1292.     /*----------------------------------------------------------------*/
  1293.     /* Local Variables                                                */
  1294.     /*----------------------------------------------------------------*/
  1295.     S8 fileNameA[sizeof(NVRM_FILES_PATH) + 7];  /* 7 : xxx_xxx */
  1296.     S8 fileNameU[(sizeof(NVRM_FILES_PATH) + 7) * 2];
  1297.     U32 iBytesRead;
  1298.     FS_HANDLE handle;
  1299.     S32 retValue = -1;
  1300.     U32 temp = 0;
  1301.     static U8 is_nvram_init = 0;
  1303.     /*----------------------------------------------------------------*/
  1304.     /* Code Body                                                      */
  1305.     /*----------------------------------------------------------------*/
  1306.     if (!is_nvram_init)
  1307.     {
  1308.         S8 pathNameA[sizeof(NVRM_FILES_PATH)];
  1309.         S8 pathNameU[(sizeof(NVRM_FILES_PATH)) * 2];
  1311.         sprintf(pathNameA, "..\..\WIN32FS\DRIVE_C\NVRAM\");
  1313.         AnsiiToUnicodeString(pathNameU, pathNameA);
  1315.         retValue = FS_CreateDir((PU16) pathNameU);
  1317.         if (retValue < FS_NO_ERROR && retValue != FS_FILE_EXISTS)
  1318.         {
  1319.             *pError = NVRAM_READ_FAIL;
  1320.             return retValue;
  1321.         }
  1323.         sprintf(pathNameA, "%s", NVRM_FILES_PATH);
  1325.         AnsiiToUnicodeString(pathNameU, pathNameA);
  1327.         retValue = FS_CreateDir((PU16) pathNameU);
  1329.         if (retValue < FS_NO_ERROR && retValue != FS_FILE_EXISTS)
  1330.         {
  1331.             *pError = NVRAM_READ_FAIL;
  1332.             return retValue;
  1333.         }
  1335.         is_nvram_init = 1;
  1336.     }
  1338.     sprintf(fileNameA, "%s%d_%d", NVRM_FILES_PATH, nFileId, nRecordId);
  1340.     AnsiiToUnicodeString(fileNameU, fileNameA);
  1342.     handle = FS_Open((PU16) fileNameU, FS_READ_ONLY);
  1343.     PRINT_INFORMATION_2( (MMI_TRACE_G1_FRM,"ReadRecordInt open org file: %d",handle));
  1345.     if (handle == FS_FILE_NOT_FOUND)
  1346.     {
  1347.         U32 len = 1;
  1348.         U16 i;
  1349.         pc_ltable_entry_struct *ldi;
  1351.         for (i = 0; i < (sizeof(pc_logical_data_item_table) / sizeof(pc_ltable_entry_struct)); i++)
  1352.         {
  1353.             ldi = &pc_logical_data_item_table[i];
  1354.             if (ldi->lid == nFileId)
  1355.             {
  1356.                 break;
  1357.             }
  1358.         }
  1360.         /* Assign Default */
  1361.         if (ldi->default_value == NVRAM_EF_ZERO_DEFAULT)
  1362.         {
  1363.             memset(pBuffer, 0x00, nBufferSize);
  1364.         }
  1365.         else if (ldi->lid == 0 ||   /* not found */
  1366.                  ldi->default_value == NVRAM_EF_FF_DEFAULT)
  1367.         {
  1368.             memset(pBuffer, 0xFF, nBufferSize);
  1369.         }
  1370.         else
  1371.         {
  1372.             memcpy(pBuffer, &ldi->default_value, ldi->size);
  1373.         }
  1375.         handle = FS_Open((PU16) fileNameU, FS_CREATE_ALWAYS);
  1376.         PRINT_INFORMATION_2( (MMI_TRACE_G1_FRM,"ReadRecordInt create new file: %d",handle));
  1378.         if (handle < FS_NO_ERROR)
  1379.         {
  1380.             *pError = NVRAM_READ_FAIL;
  1381.         }
  1382.         else
  1383.         {
  1384.             retValue = FS_Write(handle, pBuffer, nBufferSize, &iBytesRead);
  1385.             FS_Close(handle);
  1386.         }
  1388.         if (retValue >= FS_NO_ERROR)
  1389.         {
  1390.             *pError = NVRAM_READ_SUCCESS;
  1391.         }
  1392.         else
  1393.         {
  1394.             *pError = NVRAM_READ_FAIL;
  1395.         }
  1397.     }
  1398.     else
  1399.     {
  1400.         retValue = FS_Read(handle, pBuffer, nBufferSize, &iBytesRead);
  1401.         if (retValue >= FS_NO_ERROR)
  1402.         {
  1403.             retValue = iBytesRead;
  1404.             *pError = NVRAM_READ_SUCCESS;
  1405.         }
  1406.         else
  1407.         {
  1408.             *pError = NVRAM_READ_FAIL;
  1409.         }
  1411.         FS_Close(handle);
  1413.     }
  1415.     return retValue;
  1417. }
  1420. /*****************************************************************************
  1421.  * FUNCTION
  1422.  *  WriteRecordInt
  1423.  * DESCRIPTION
  1424.  *  User level API for writing record in the file
  1425.  *  
  1426.  *  The nBufferSize shall be even
  1427.  * PARAMETERS
  1428.  *  nFileId         [IN]        File LID
  1429.  *  nRecordId       [IN]        Record index in file
  1430.  *  pBuffer         [IN]        Buffer in which data need to
  1431.  *  nBufferSize     [IN]        Size of record to be write
  1432.  *  pError          [OUT]       Error returned from PS
  1433.  *  filename        [?]         
  1434.  *  lineNumber      [IN]        
  1435.  *  it(?)           [IN]        Should be same as file
  1436.  *  memory(?)       [IN]        For this.
  1437.  *  record(?)       [IN]        Size
  1438.  *  be(?)           [IN]        Retrieved,caller will allocate
  1439.  * RETURNS
  1440.  * BOOL
  1441.  *  
  1442.  *****************************************************************************/
  1443. S32 WriteRecordInt(
  1444.         U16 nFileId,
  1445.         U16 nRecordId,
  1446.         void *pBuffer,
  1447.         U16 nBufferSize,
  1448.         S16 *pError,
  1449.         S8 *filename,
  1450.         S32 lineNumber)
  1451. {
  1452.     /*----------------------------------------------------------------*/
  1453.     /* Local Variables                                                */
  1454.     /*----------------------------------------------------------------*/
  1455.     S8 fileNameA[sizeof(NVRM_FILES_PATH) + 7];  /* 7 : xxx_xxx */
  1456.     S8 fileNameU[(sizeof(NVRM_FILES_PATH) + 7) * 2];
  1457.     U32 iBytes;
  1458.     FS_HANDLE handle;
  1459.     S32 retValue = -1;
  1461.     /*----------------------------------------------------------------*/
  1462.     /* Code Body                                                      */
  1463.     /*----------------------------------------------------------------*/
  1464.     sprintf(fileNameA, "%s%d_%d", NVRM_FILES_PATH, nFileId, nRecordId);
  1466.     AnsiiToUnicodeString(fileNameU, fileNameA);
  1468.     handle = FS_Open((PU16) fileNameU, FS_CREATE_ALWAYS);
  1469.     PRINT_INFORMATION_2( (MMI_TRACE_G1_FRM,"WriteRecordInt open file: %d",handle));
  1471.     if (handle < FS_NO_ERROR)
  1472.     {
  1473.         *pError = NVRAM_WRITE_FAIL;
  1474.     }
  1475.     else
  1476.     {
  1477.         retValue = FS_Write(handle, pBuffer, nBufferSize, &iBytes);
  1478.         if (retValue >= FS_NO_ERROR)
  1479.         {
  1480.             retValue = iBytes;
  1481.             *pError = NVRAM_WRITE_SUCCESS;
  1482.         }
  1483.         else
  1484.         {
  1485.             *pError = NVRAM_WRITE_FAIL;
  1486.         }
  1488.         FS_Close(handle);
  1490.     }
  1491.     return retValue;
  1493. }
  1496. /*****************************************************************************
  1497.  * FUNCTION
  1498.  *  DeleteRecord
  1499.  * DESCRIPTION
  1500.  *  User level API for Deleting record from the file
  1501.  * PARAMETERS
  1502.  *  nFileId         [IN]        File LID
  1503.  *  nRecordId       [IN]        Record index in file
  1504.  *  pError          [OUT]       Error returned from PS
  1505.  * RETURNS
  1506.  * BOOL
  1507.  *  
  1508.  *****************************************************************************/
  1509. pBOOL DeleteRecord(U16 nFileId, U16 nRecordId, S16 *pError)
  1510. {
  1511.     /*----------------------------------------------------------------*/
  1512.     /* Local Variables                                                */
  1513.     /*----------------------------------------------------------------*/
  1514.     S8 fileName[100];
  1515.     S32 retValue = -1;
  1517.     /*----------------------------------------------------------------*/
  1518.     /* Code Body                                                      */
  1519.     /*----------------------------------------------------------------*/
  1520.     sprintf(fileName, "%s%d_%d", NVRM_FILES_PATH, nFileId, nRecordId);
  1522.     /* Remove file */
  1523.     retValue = remove(fileName);
  1524.     if (retValue == 0)
  1525.     {
  1526.         return MMI_TRUE;
  1527.     }
  1528.     else
  1529.     {
  1530.         return MMI_FALSE;
  1531.     }
  1532. }
  1534. #endif /* MMI_ON_WIN32 */ 
  1537. /*****************************************************************************
  1538.  * FUNCTION
  1539.  *  ReadValueInt
  1540.  * DESCRIPTION
  1541.  *  User level API for 1 byte , 2 byte and 8 byte
  1542.  *  
  1543.  *  The nBufferSize shall be even
  1544.  * PARAMETERS
  1545.  *  nDataItemId     [IN]        Data Item ID
  1546.  *  pBuffer         [IN]        Buffer in which data need to
  1547.  *  nDataType       [IN]        
  1548.  *  pError          [OUT]       Error returned from PS
  1549.  *  fileName        [?]         
  1550.  *  lineNumber      [IN]        
  1551.  *  memory(?)       [IN]        For this.
  1552.  *  be(?)           [IN]        Retrieved,caller will allocate
  1553.  * RETURNS
  1554.  * BOOL
  1555.  *  
  1556.  *****************************************************************************/
  1557. S32 ReadValueInt(U8 nDataItemId, void *pBuffer, U8 nDataType, S16 *pError, S8 *fileName, S32 lineNumber)
  1558. {
  1559.     /*----------------------------------------------------------------*/
  1560.     /* Local Variables                                                */
  1561.     /*----------------------------------------------------------------*/
  1563.     S32 status = -1;
  1564.     S16 error = -1;
  1566.     /*----------------------------------------------------------------*/
  1567.     /* Code Body                                                      */
  1568.     /*----------------------------------------------------------------*/
  1569.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_HDLR, nDataItemId, nDataType));
  1571.     switch (nDataType)
  1572.     {
  1574.         case DS_BYTE:
  1575.         {
  1576.             /* second time reading, it alwasy return one request item */
  1577.             if (byteDataReadFlag)
  1578.             {
  1579.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO_HDLR, nDataType));
  1580.                 /* Data is cached no need to read from NVRAM */
  1581.                 memcpy(pBuffer, &byte_data[nDataItemId * nDataType], nDataType);
  1582.                 status = DS_BYTE;
  1583.                 error = NVRAM_READ_SUCCESS;
  1584.             }
  1585.             /* process first time reading all data and return first request item data */
  1586.             else
  1587.             {
  1588.                 /* Read data from the NVRAM file */
  1589.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files, first time to read all out */
  1590.                 U8 tempBuffer[NVRAM_CACHE_SIZE];
  1592.                 status = ReadRecordInt(
  1593.                             NVRAM_EF_CACHE_BYTE_LID,
  1594.                             1,
  1595.                             tempBuffer,
  1596.                             sizeof(tempBuffer),
  1597.                             &error,
  1598.                             fileName,
  1599.                             lineNumber);
  1600.                 if (status == -1)
  1601.                 {
  1602.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1603.                     *pError = -1;
  1604.                     return status;
  1605.                 }
  1606.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO2_HDLR, nDataType));
  1607.                 /* copy out all total reading data */
  1608.                 memcpy(byte_data, tempBuffer, sizeof(tempBuffer));
  1609.                 byteDataReadFlag = 1;
  1610.                 /* return first request item data */
  1611.                 memcpy(pBuffer, &byte_data[nDataItemId * nDataType], nDataType);
  1612.                 status = DS_BYTE;
  1613.                 error = NVRAM_READ_SUCCESS;
  1615.             }
  1616.             break;
  1617.         }   /* End of case DS_BYTE */
  1619.         case DS_SHORT:
  1620.         {
  1621.             if (uintDataReadFlag)
  1622.             {
  1623.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO_HDLR, nDataType));
  1624.                 /* Data is cached no need to read from NVRAM */
  1625.                 memcpy(pBuffer, &uint_data[nDataItemId * nDataType], nDataType);
  1626.                 status = DS_SHORT;
  1627.                 error = NVRAM_READ_SUCCESS;
  1628.             }
  1629.             else
  1630.             {
  1631.                 /* Read data from the NVRAM file */
  1632.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files */
  1633.                 U8 tempBuffer[NVRAM_CACHE_SIZE];
  1635.                 status = ReadRecordInt(
  1636.                             NVRAM_EF_CACHE_SHORT_LID,
  1637.                             1,
  1638.                             tempBuffer,
  1639.                             sizeof(tempBuffer),
  1640.                             &error,
  1641.                             fileName,
  1642.                             lineNumber);
  1643.                 if (status == -1)
  1644.                 {
  1645.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1646.                     *pError = -1;
  1647.                     return status;
  1648.                 }
  1649.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO2_HDLR, nDataType));
  1650.                 memcpy(uint_data, tempBuffer, NVRAM_CACHE_SIZE);
  1651.                 uintDataReadFlag = 1;
  1652.                 memcpy(pBuffer, &uint_data[nDataItemId * nDataType], nDataType);
  1653.                 status = DS_SHORT;
  1654.                 error = NVRAM_READ_SUCCESS;
  1656.             }
  1657.             break;
  1658.         }   /* End of case DS_SHORT */
  1660.         case DS_DOUBLE:
  1661.         {
  1662.             if (doubleDataReadFlag)
  1663.             {
  1664.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO_HDLR, nDataType));
  1665.                 /* Data is cached no need to read from NVRAM */
  1666.                 memcpy(pBuffer, &double_data[nDataItemId * nDataType], nDataType);
  1667.                 status = DS_DOUBLE;
  1668.                 error = NVRAM_READ_SUCCESS;
  1669.             }
  1670.             else
  1671.             {
  1672.                 /* Read data from the NVRAM file */
  1673.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files */
  1674.                 U8 tempBuffer[NVRAM_CACHE_SIZE];
  1676.                 status = ReadRecordInt(
  1677.                             NVRAM_EF_CACHE_DOUBLE_LID,
  1678.                             1,
  1679.                             tempBuffer,
  1680.                             NVRAM_CACHE_SIZE,
  1681.                             &error,
  1682.                             fileName,
  1683.                             lineNumber);
  1684.                 if (status == -1)
  1685.                 {
  1686.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1687.                     *pError = -1;
  1688.                     return status;
  1689.                 }
  1690.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_READ_VAL_INT_INFO2_HDLR, nDataType));
  1691.                 memcpy(double_data, tempBuffer, NVRAM_CACHE_SIZE);
  1692.                 doubleDataReadFlag = 1;
  1693.                 memcpy(pBuffer, &double_data[nDataItemId * nDataType], nDataType);
  1694.                 status = DS_DOUBLE;
  1695.                 error = NVRAM_READ_SUCCESS;
  1697.             }
  1698.             break;
  1699.         }   /* End of case DS_DOUBLE */
  1700.     }
  1702.     *pError = error;
  1703.     return status;
  1704. }
  1707. /*****************************************************************************
  1708.  * FUNCTION
  1709.  *  WriteValueInt
  1710.  * DESCRIPTION
  1711.  *  User level API to write 1 byte , 2 byte and 8 byte
  1712.  *  
  1713.  *  The nBufferSize shall be even
  1714.  * PARAMETERS
  1715.  *  nDataItemId     [IN]        Data Item ID
  1716.  *  pBuffer         [IN]        Buffer in which data need to
  1717.  *  nDataType       [IN]        
  1718.  *  pError          [OUT]       Error returned from PS
  1719.  *  fileName        [?]         
  1720.  *  lineNumber      [IN]        
  1721.  *  memory(?)       [IN]        For this.
  1722.  *  be(?)           [IN]        Retrieved,caller will allocate
  1723.  * RETURNS
  1724.  * BOOL
  1725.  *  
  1726.  *****************************************************************************/
  1727. S32 WriteValueInt(U8 nDataItemId, void *pBuffer, U8 nDataType, S16 *pError, S8 *fileName, S32 lineNumber)
  1728. {
  1729.     /*----------------------------------------------------------------*/
  1730.     /* Local Variables                                                */
  1731.     /*----------------------------------------------------------------*/
  1733.     S16 error = -1;
  1734.     S32 status = -1;
  1736.     /*----------------------------------------------------------------*/
  1737.     /* Code Body                                                      */
  1738.     /*----------------------------------------------------------------*/
  1739.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_HDLR, nDataItemId, nDataType));
  1741.     switch (nDataType)
  1742.     {
  1743.         case DS_BYTE:
  1744.         {
  1745.             /* second time access, it always sets the request item */
  1746.             if (byteDataReadFlag)
  1747.             {
  1748.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO_HDLR, nDataType));
  1749.                 /* Data is cached no need to read from NVRAM */
  1750.                 memcpy(&byte_data[nDataItemId * nDataType], pBuffer, nDataType);
  1751.                 /* write into NVRAM module, if not wait for falshing directly */
  1752.                 if (!byteDataWriteFlashFlag)
  1753.                 {
  1754.                     status = WriteRecordInt(
  1755.                                 NVRAM_EF_CACHE_BYTE_LID,
  1756.                                 1,
  1757.                                 byte_data,
  1758.                                 NVRAM_CACHE_SIZE,
  1759.                                 &error,
  1760.                                 fileName,
  1761.                                 lineNumber);
  1762.                     if (status == -1)
  1763.                     {
  1764.                         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  1765.                         *pError = -1;
  1766.                         return status;
  1767.                     }
  1768.                 }
  1769.                 status = DS_BYTE;
  1770.                 error = NVRAM_WRITE_SUCCESS;
  1771.             }
  1772.             /* process first time access all data and return first write item data */
  1773.             else
  1774.             {
  1775.                 /* Read all data from the NVRAM file */
  1776.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files */
  1777.                 status = ReadRecordInt(
  1778.                             NVRAM_EF_CACHE_BYTE_LID,
  1779.                             1,
  1780.                             byte_data,
  1781.                             NVRAM_CACHE_SIZE,
  1782.                             &error,
  1783.                             fileName,
  1784.                             lineNumber);
  1785.                 if (status == -1)
  1786.                 {
  1787.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1788.                     *pError = -1;
  1789.                     return status;
  1790.                 }
  1791.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO2_HDLR, nDataType));
  1792.                 memcpy(&byte_data[nDataItemId * nDataType], pBuffer, nDataType);
  1793.                 /* write into NVRAM module, if not wait for falshing directly */
  1794.                 if (!byteDataWriteFlashFlag)
  1795.                 {
  1796.                     status = WriteRecordInt(
  1797.                                 NVRAM_EF_CACHE_BYTE_LID,
  1798.                                 1,
  1799.                                 byte_data,
  1800.                                 NVRAM_CACHE_SIZE,
  1801.                                 &error,
  1802.                                 fileName,
  1803.                                 lineNumber);
  1804.                 }
  1805.                 byteDataReadFlag = 1;
  1806.                 status = DS_BYTE;
  1807.                 error = NVRAM_WRITE_SUCCESS;
  1808.             }
  1809.             break;
  1810.         }   /* End of case DS_BYTE */
  1812.         case DS_SHORT:
  1813.         {
  1814.             if (uintDataReadFlag)
  1815.             {
  1816.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO_HDLR, nDataType));
  1817.                 /* Data is cached no need to read from NVRAM */
  1818.                 memcpy(&uint_data[nDataItemId * nDataType], pBuffer, nDataType);
  1819.                 /* write into NVRAM module, if not wait for falshing directly */
  1820.                 if (!uintDataWriteFlashFlag)
  1821.                 {
  1822.                     status = WriteRecordInt(
  1823.                                 NVRAM_EF_CACHE_SHORT_LID,
  1824.                                 1,
  1825.                                 uint_data,
  1826.                                 NVRAM_CACHE_SIZE,
  1827.                                 &error,
  1828.                                 fileName,
  1829.                                 lineNumber);
  1830.                     if (status == -1)
  1831.                     {
  1832.                         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  1833.                         *pError = -1;
  1834.                         return status;
  1835.                     }
  1836.                 }
  1837.                 status = DS_SHORT;
  1838.                 error = NVRAM_WRITE_SUCCESS;
  1840.             }
  1841.             else
  1842.             {
  1843.                 /* Read data from the NVRAM file */
  1844.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files */
  1845.                 status = ReadRecordInt(
  1846.                             NVRAM_EF_CACHE_SHORT_LID,
  1847.                             1,
  1848.                             uint_data,
  1849.                             NVRAM_CACHE_SIZE,
  1850.                             &error,
  1851.                             fileName,
  1852.                             lineNumber);
  1853.                 if (status == -1)
  1854.                 {
  1855.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1856.                     *pError = -1;
  1857.                     return status;
  1858.                 }
  1859.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO2_HDLR, nDataType));
  1860.                 memcpy(&uint_data[nDataItemId * nDataType], pBuffer, nDataType);
  1861.                 /* write into NVRAM module, if not wait for falshing directly */
  1862.                 if (!uintDataWriteFlashFlag)
  1863.                 {
  1864.                     WriteRecordInt(
  1865.                         NVRAM_EF_CACHE_SHORT_LID,
  1866.                         1,
  1867.                         uint_data,
  1868.                         NVRAM_CACHE_SIZE,
  1869.                         &error,
  1870.                         fileName,
  1871.                         lineNumber);
  1872.                 }
  1873.                 uintDataReadFlag = 1;
  1874.                 status = DS_SHORT;
  1875.                 error = NVRAM_WRITE_SUCCESS;
  1876.             }
  1877.             break;
  1878.         }   /* End of case DS_SHORT */
  1880.         case DS_DOUBLE:
  1881.         {
  1882.             if (doubleDataReadFlag)
  1883.             {
  1884.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO_HDLR, nDataType));
  1885.                 /* Data is cached no need to read from NVRAM */
  1886.                 memcpy(&double_data[nDataItemId * nDataType], pBuffer, nDataType);
  1887.                 /* write into NVRAM module, if not wait for falshing directly */
  1888.                 if (!doubleDataWriteFlashFlag)
  1889.                 {
  1890.                     status = WriteRecordInt(
  1891.                                 NVRAM_EF_CACHE_DOUBLE_LID,
  1892.                                 1,
  1893.                                 double_data,
  1894.                                 NVRAM_CACHE_SIZE,
  1895.                                 &error,
  1896.                                 fileName,
  1897.                                 lineNumber);
  1898.                     if (status == -1)
  1899.                     {
  1900.                         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  1901.                         *pError = -1;
  1902.                         return status;
  1903.                     }
  1904.                 }
  1905.                 status = DS_DOUBLE;
  1906.                 error = NVRAM_WRITE_SUCCESS;
  1907.             }
  1908.             else
  1909.             {
  1910.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_VAL_INT_INFO_HDLR, nDataType));
  1911.                 /* Read data from the NVRAM file */
  1912.                 /* NVRAM_CACHED_FILE_LID is defined in Pluto NVRAM files */
  1913.                 status = ReadRecordInt(
  1914.                             NVRAM_EF_CACHE_DOUBLE_LID,
  1915.                             1,
  1916.                             double_data,
  1917.                             NVRAM_CACHE_SIZE,
  1918.                             &error,
  1919.                             fileName,
  1920.                             lineNumber);
  1921.                 if (status == -1)
  1922.                 {
  1923.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_READ_VAL_INT_HDLR));
  1924.                     *pError = -1;
  1925.                     return status;
  1926.                 }
  1927.                 memcpy(&double_data[nDataItemId * nDataType], pBuffer, nDataType);
  1928.                 /* write into NVRAM module, if not wait for falshing directly */
  1929.                 if (!doubleDataWriteFlashFlag)
  1930.                 {
  1931.                     status = WriteRecordInt(
  1932.                                 NVRAM_EF_CACHE_DOUBLE_LID,
  1933.                                 1,
  1934.                                 double_data,
  1935.                                 NVRAM_CACHE_SIZE,
  1936.                                 &error,
  1937.                                 fileName,
  1938.                                 lineNumber);
  1939.                     if (status == -1)
  1940.                     {
  1941.                         MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  1942.                         *pError = -1;
  1943.                         return status;
  1944.                     }
  1945.                 }
  1946.                 status = DS_DOUBLE;
  1947.                 error = NVRAM_WRITE_SUCCESS;
  1948.                 doubleDataReadFlag = 1;
  1949.             }
  1950.             break;
  1951.         }   /* End of case DS_DOUBLE */
  1953.     }   /* End of switch */
  1955.     *pError = error;
  1956.     return status;
  1957. }
  1960. /*****************************************************************************
  1961.  * FUNCTION
  1962.  *  SetFlashNVRAMCatchData
  1963.  * DESCRIPTION
  1964.  *  This function is to set the flag if want to flash the BYTE, SHORT, or DOUBLE of catch datas into NVRAM.
  1965.  * PARAMETERS
  1966.  *  nDataType                   [IN]        
  1967.  *  l_DataWriteFlashFlag        [IN]        
  1968.  *  a(?)                        [IN]        Is to enable to flash into NVRAM or not, TRUE is to flash into NVRAM, otherwise is false.
  1969.  * RETURNS
  1970.  *  Data set success or not.
  1971.  *****************************************************************************/
  1972. U8 SetFlashNVRAMCatchData(U8 nDataType, U8 l_DataWriteFlashFlag)
  1973. {
  1974.     /*----------------------------------------------------------------*/
  1975.     /* Local Variables                                                */
  1976.     /*----------------------------------------------------------------*/
  1978.     /*----------------------------------------------------------------*/
  1979.     /* Code Body                                                      */
  1980.     /*----------------------------------------------------------------*/
  1981.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_FLASH_CATCH_DATA_HDLR, nDataType, l_DataWriteFlashFlag));
  1983.     switch (nDataType)
  1984.     {
  1985.         case DS_BYTE:
  1986.             byteDataWriteFlashFlag = l_DataWriteFlashFlag;
  1987.             break;
  1988.         case DS_SHORT:
  1989.             uintDataWriteFlashFlag = l_DataWriteFlashFlag;
  1990.             break;
  1991.         case DS_DOUBLE:
  1992.             doubleDataWriteFlashFlag = l_DataWriteFlashFlag;
  1993.             break;
  1994.         default:
  1995.             MMI_ASSERT(0);
  1996.             break;
  1997.     }
  1998.     return MMI_TRUE;
  1999. }
  2002. /*****************************************************************************
  2003.  * FUNCTION
  2004.  *  SetFlashAllNVRAMCatchData
  2005.  * DESCRIPTION
  2006.  *  This function is to set the flag if want to flash all the BYTE, SHORT, and DOUBLE of catch datas into NVRAM.
  2007.  * PARAMETERS
  2008.  *  l_DataWriteFlashFlag        [IN]        
  2009.  *  a(?)                        [IN]        Is to enable to flash into NVRAM or not, TRUE is to flash into NVRAM, otherwise is false.
  2010.  * RETURNS
  2011.  *  Data set success or not.
  2012.  *****************************************************************************/
  2013. U8 SetFlashAllNVRAMCatchData(U8 l_DataWriteFlashFlag)
  2014. {
  2015.     /*----------------------------------------------------------------*/
  2016.     /* Local Variables                                                */
  2017.     /*----------------------------------------------------------------*/
  2019.     /*----------------------------------------------------------------*/
  2020.     /* Code Body                                                      */
  2021.     /*----------------------------------------------------------------*/
  2022.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_FLASH_CATCH_ALL_DATA_HDLR, l_DataWriteFlashFlag));
  2024.     byteDataWriteFlashFlag = l_DataWriteFlashFlag;
  2025.     uintDataWriteFlashFlag = l_DataWriteFlashFlag;
  2026.     doubleDataWriteFlashFlag = l_DataWriteFlashFlag;
  2027.     return MMI_TRUE;
  2028. }
  2031. /*****************************************************************************
  2032.  * FUNCTION
  2033.  *  WriteFlashNVRAMCatchData
  2034.  * DESCRIPTION
  2035.  *  This function is to write the BYTE, SHORT, DOUBLE of catch datas into NVRAM.
  2036.  * PARAMETERS
  2037.  *  nDataType       [IN]        
  2038.  *  a(?)            [IN]        Is BYTE, SHORT, DOUBLE data type.
  2039.  * RETURNS
  2040.  *  Data write success or not.
  2041.  *****************************************************************************/
  2042. S32 WriteFlashNVRAMCatchData(U8 nDataType)
  2043. {
  2044.     /*----------------------------------------------------------------*/
  2045.     /* Local Variables                                                */
  2046.     /*----------------------------------------------------------------*/
  2047.     S32 status = -1;
  2048.     S16 error = -1;
  2050.     /*----------------------------------------------------------------*/
  2051.     /* Code Body                                                      */
  2052.     /*----------------------------------------------------------------*/
  2053.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_WRITE_NVM_CATCH_DATA_HDLR, nDataType));
  2055.     switch (nDataType)
  2056.     {
  2057.         case DS_BYTE:
  2058.             if (byteDataWriteFlashFlag)
  2059.             {
  2060.                 byteDataWriteFlashFlag = MMI_FALSE;
  2061.                 status = WriteRecordInt(
  2062.                             NVRAM_EF_CACHE_BYTE_LID,
  2063.                             1,
  2064.                             byte_data,
  2065.                             sizeof(byte_data),
  2066.                             &error,
  2067.                             __FILE__,
  2068.                             __LINE__);
  2069.                 if (status == -1)
  2070.                 {
  2071.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2072.                     MMI_ASSERT(0);
  2073.                     return status;
  2074.                 }
  2075.             }
  2076.             break;
  2077.         case DS_SHORT:
  2078.             if (uintDataWriteFlashFlag)
  2079.             {
  2080.                 uintDataWriteFlashFlag = MMI_FALSE;
  2081.                 status = WriteRecordInt(
  2082.                             NVRAM_EF_CACHE_SHORT_LID,
  2083.                             1,
  2084.                             uint_data,
  2085.                             sizeof(uint_data),
  2086.                             &error,
  2087.                             __FILE__,
  2088.                             __LINE__);
  2089.                 if (status == -1)
  2090.                 {
  2091.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2092.                     MMI_ASSERT(0);
  2093.                     return status;
  2094.                 }
  2095.             }
  2096.             break;
  2097.         case DS_DOUBLE:
  2098.             if (doubleDataWriteFlashFlag)
  2099.             {
  2100.                 doubleDataWriteFlashFlag = MMI_FALSE;
  2101.                 status = WriteRecordInt(
  2102.                             NVRAM_EF_CACHE_DOUBLE_LID,
  2103.                             1,
  2104.                             double_data,
  2105.                             sizeof(double_data),
  2106.                             &error,
  2107.                             __FILE__,
  2108.                             __LINE__);
  2109.                 if (status == -1)
  2110.                 {
  2111.                     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2112.                     MMI_ASSERT(0);
  2113.                     return status;
  2114.                 }
  2115.             }
  2116.             break;
  2117.         default:
  2118.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_WARN_NVM_WRITE_HDLR));
  2119.             MMI_ASSERT(0);
  2120.             break;
  2121.     }
  2122.     return status;
  2124. }
  2127. /*****************************************************************************
  2128.  * FUNCTION
  2129.  *  WriteFlashAllNVRAMCatchData
  2130.  * DESCRIPTION
  2131.  *  This function is to write all catch data into NVRAM.
  2132.  * PARAMETERS
  2133.  *  void
  2134.  * RETURNS
  2135.  *  Data write success or not.
  2136.  *****************************************************************************/
  2137. S32 WriteFlashAllNVRAMCatchData(void)
  2138. {
  2139.     /*----------------------------------------------------------------*/
  2140.     /* Local Variables                                                */
  2141.     /*----------------------------------------------------------------*/
  2142.     S32 status = -1;
  2143.     S16 error = -1;
  2145.     /*----------------------------------------------------------------*/
  2146.     /* Code Body                                                      */
  2147.     /*----------------------------------------------------------------*/
  2148.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_NVM_FLASH_ALL_CATCH_DATA_HDLR));
  2150.     if (byteDataWriteFlashFlag)
  2151.     {
  2152.         byteDataWriteFlashFlag = MMI_FALSE;
  2153.         status = WriteRecordInt(NVRAM_EF_CACHE_BYTE_LID, 1, byte_data, NVRAM_CACHE_SIZE, &error, __FILE__, __LINE__);
  2154.         if (status == -1)
  2155.         {
  2156.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2157.             MMI_ASSERT(0);
  2158.             return status;
  2159.         }
  2160.     }
  2161.     if (uintDataWriteFlashFlag)
  2162.     {
  2163.         uintDataWriteFlashFlag = MMI_FALSE;
  2164.         status = WriteRecordInt(NVRAM_EF_CACHE_SHORT_LID, 1, uint_data, NVRAM_CACHE_SIZE, &error, __FILE__, __LINE__);
  2165.         if (status == -1)
  2166.         {
  2167.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2168.             MMI_ASSERT(0);
  2169.             return status;
  2170.         }
  2171.     }
  2172.     if (doubleDataWriteFlashFlag)
  2173.     {
  2174.         doubleDataWriteFlashFlag = MMI_FALSE;
  2175.         status = WriteRecordInt(NVRAM_EF_CACHE_DOUBLE_LID, 1, double_data, NVRAM_CACHE_SIZE, &error, __FILE__, __LINE__);
  2176.         if (status == -1)
  2177.         {
  2178.             MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_ERROR_NVM_WRITE_VAL_INT_HDLR));
  2179.             MMI_ASSERT(0);
  2180.             return status;
  2181.         }
  2182.     }
  2183.     return status;
  2184. }
  2187. /*****************************************************************************
  2188.  * FUNCTION
  2189.  *  IsInNVRAMProcedure
  2190.  * DESCRIPTION
  2191.  *  This function is to check if in NVRAM procedure while loop
  2192.  * PARAMETERS
  2193.  *  void
  2194.  * RETURNS
  2195.  *  MMI_TRUE - in NVRAM procedure
  2196.  *  MMI_FALSE - not in NVRAM procedure
  2197.  *****************************************************************************/
  2198. U8 IsInNVRAMProcedure(void)
  2199. {
  2200.     /*----------------------------------------------------------------*/
  2201.     /* Local Variables                                                */
  2202.     /*----------------------------------------------------------------*/
  2204.     /*----------------------------------------------------------------*/
  2205.     /* Code Body                                                      */
  2206.     /*----------------------------------------------------------------*/
  2207.     PRINT_INFORMATION((" IsInNVRAMProcedure(%d)", in_nvram_procedure));
  2208.     return (in_nvram_procedure > 0) ? (U8) MMI_TRUE : (U8) MMI_FALSE;
  2209. }