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

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

MTK

开发平台：

C/C++

L4Drv.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.  * L4Drv.C
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   MAUI
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This file is intends for Timer/Clock control.
  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.  * removed!
  97.  *
  98.  * removed!
  99.  * removed!
  100.  * removed!
  101.  *
  102.  * removed!
  103.  * removed!
  104.  * removed!
  105.  *
  106.  * removed!
  107.  * removed!
  108.  * removed!
  109.  *
  110.  * removed!
  111.  * removed!
  112.  * removed!
  113.  *
  114.  * removed!
  115.  * removed!
  116.  * removed!
  117.  *
  118.  * removed!
  119.  * removed!
  120.  * removed!
  121.  *
  122.  * removed!
  123.  * removed!
  124.  * removed!
  125.  *
  126.  * removed!
  127.  * removed!
  128.  * removed!
  129.  *
  130.  * removed!
  131.  * removed!
  132.  * removed!
  133.  *
  134.  * removed!
  135.  * removed!
  136.  * removed!
  137.  *
  138.  * removed!
  139.  * removed!
  140.  * removed!
  141.  *
  142.  * removed!
  143.  * removed!
  144.  * removed!
  145.  *
  146.  * removed!
  147.  * removed!
  148.  * removed!
  149.  *
  150.  * removed!
  151.  * removed!
  152.  * removed!
  153.  *
  154.  * removed!
  155.  * removed!
  156.  * removed!
  157.  *
  158.  * removed!
  159.  * removed!
  160.  * removed!
  161.  *
  162.  * removed!
  163.  * removed!
  164.  * removed!
  165.  *
  166.  * removed!
  167.  * removed!
  168.  * removed!
  169.  *
  170.  * removed!
  171.  * removed!
  172.  * removed!
  173.  *
  174.  *------------------------------------------------------------------------------
  175.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  176.  *============================================================================
  177.  ****************************************************************************/
  179. /*******************************************************************************
  180.  * Copyright Notice
  181.  * ?2002 - 2003, Pixtel Communications, Inc., 1489 43rd Ave. W.,
  182.  * Vancouver, B.C. V6M 4K8 Canada. All Rights Reserved.
  183.  *  (It is illegal to remove this copyright notice from this software or any
  184.  *  portion of it)
  185. *******************************************************************************/
  187. /*******************************************************************************
  188.  *
  189.  * Filename:
  190.  * ---------
  191.  * L4Drv.c
  192.  *
  193.  * Project:
  194.  * --------
  195.  *   MediaTeck GSM
  196.  *
  197.  * Description:
  198.  * ------------
  199.  *   This Module defines the l4 driver routines.
  200.  *
  201.  * Author:
  202.  * -------
  203.  * -------
  204.  *             
  205.  *
  206.  * HISTORY
  207.  * -------
  208.  * Created On 13 Dec
  209. *******************************************************************************/
  211. /* ------- Include Files ----------------------------- */
  212. #ifndef MMI_ON_WIN32
  214. /*  Include: MMI header file */
  215. #include "MMI_features.h"
  216. #include "stdC.h"
  217. #include "L4Dr1.h"
  218. #include "PixtelDataTypes.h"
  219. /* ... Add More MMI header */
  220. #include "globalconstants.h"
  221. #include "QueueGprot.h"
  222. #include "OslMemory.h"
  223. /* amit Audio L4 integration header file */
  224. #include "AudioInc.h"
  225. #include "TimerEvents.h"
  226. #include "TaskInit.h"
  227. #include "KeyBrd.h"
  228. #include "DebugInitDef.h"
  229. #include "l4dr.h"
  230. #include "MMI_trc.h"
  231. #include "gpioInc.h"
  232. #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  233. #include "TouchScreenGprot.h"
  234. #endif 
  235. #include "MMITaskProt.h"
  237. /***************************************************************************** 
  238. * Define
  239. *****************************************************************************/
  240. /* the recommended value: 12 or 24 */
  241. #define SIMULTANEOUS_TIMER_NUM         (12)
  243. /* MSB(Most Significant Bit) of g_timer_table.timer_id[i] is align_timer_mask */
  244. #define NO_ALIGNMENT_TIMER_MASK        (0x8000)
  245. #define ALIGNMENT_TIMER_MASK           (0)
  247. /* ticks of 20 millisecond. because KAL did not define the valye. define in floating falue to avoid early rouning */
  248. #define MMI_TICKS_20_MSEC  (KAL_TICKS_1_SEC/50.0)
  250. /* ticks of 5 millisecond. because KAL did not define the valye. define in floating falue to avoid early rouning */
  251. #define MMI_TICKS_5_MSEC  (KAL_TICKS_1_SEC/200.0)
  253. /***************************************************************************** 
  254. * Typedef 
  255. *****************************************************************************/
  256. typedef void (*L4FuncPtr) (oslParaType *);
  257. typedef struct
  258. {
  259.     U16 eventID;
  260.     L4FuncPtr entryFuncPtr;
  261. } L4eventInfo;
  263. /* 
  264.  * MTK added for two kinds of timer, one is for exactly time, another allow to delay.
  265.  * TO Pixtel, This two defines should move to a proper place where 
  266.  * can be used by other files.
  267.  */
  269. typedef struct timertable
  270. {
  271.     /* store the timer_id. MSB(Most Significant Bit) is align_timer_mask */
  272.     U16 timer_id[SIMULTANEOUS_TIMER_NUM];
  273.     /* store the event_id that returns from evshed_set_event() */
  274.     eventid event_id[SIMULTANEOUS_TIMER_NUM];
  275.     /* store the timer_expiry_func */
  276.     oslTimerFuncPtr callback_func[SIMULTANEOUS_TIMER_NUM];
  277.     /* point to the next TIMERTABLE data */
  278.     struct timertable *next;
  279. } TIMERTABLE;
  281. /***************************************************************************** 
  282. * Local Variable
  283. *****************************************************************************/
  284. /*
  285.  * In most case, the timers won't run simultaneously.
  286.  * We run-time allocate the memory to store the timer information. 
  287.  */
  288. static TIMERTABLE g_timer_table = {0};
  289. static U16 g_timer_table_size = 0;
  290. static U16 g_timer_table_used = 0;
  292. static oslTaskFuncPtr get_clocktime_callback_func;
  293. static oslTaskFuncPtr set_clocktime_callback_func;
  296. /***************************************************************************** 
  297. * Local Function
  298. *****************************************************************************/
  299. //#define __MMI_FRM_TIMER_UNIT_TEST__
  301. #ifdef __MMI_FRM_TIMER_UNIT_TEST__
  302. static void mmi_frm_ut_timer();
  303. static void mmi_frm_ut_align_timer(void *p);
  304. static void mmi_frm_ut_nonalign_timer(void *p);
  305. #endif /* __MMI_FRM_TIMER_UNIT_TEST__ */
  308. /***************************************************************************** 
  309. * Global Variable
  310. *****************************************************************************/
  311. extern stack_timer_struct base_timer1;
  312. extern stack_timer_struct base_timer2;
  313. extern event_scheduler *event_scheduler1_ptr, *event_scheduler2_ptr;
  315. /***************************************************************************** 
  316. * Global Function
  317. *****************************************************************************/
  320. /*****************************************************************************
  321.  * FUNCTION
  322.  *  L4SetClock
  323.  * DESCRIPTION
  324.  *  This function is to set the clock request.
  325.  * PARAMETERS
  326.  *  datetime        [IN]        
  327.  *  FuncRspPtr      [IN]        
  328.  *  a(?)            [IN]        Void
  329.  * RETURNS
  330.  *  void
  331.  *****************************************************************************/
  332. void L4SetClock(rtc_format_struct datetime, oslTaskFuncPtr FuncRspPtr)
  333. {
  334.     /*----------------------------------------------------------------*/
  335.     /* Local Variables                                                */
  336.     /*----------------------------------------------------------------*/
  337.     ilm_struct *ilm_ptr = NULL;
  338.     mmi_eq_set_rtc_time_req_struct *local_data;
  340.     /*----------------------------------------------------------------*/
  341.     /* Code Body                                                      */
  342.     /*----------------------------------------------------------------*/
  343.     /* store the set time clock callback function */
  344.     set_clocktime_callback_func = FuncRspPtr;
  346.     ilm_ptr = allocate_ilm(MOD_MMI);
  347.     ilm_ptr->msg_id = (U16) MSG_ID_MMI_EQ_SET_RTC_TIME_REQ;
  348.     local_data = (mmi_eq_set_rtc_time_req_struct*)
  349.         construct_local_para(sizeof(mmi_eq_set_rtc_time_req_struct), TD_CTRL);
  351.     local_data->set_type = RTC_SETTING_TYPE_DATETIME;
  352.     local_data->rtc_type = RTC_TIME_CLOCK_IND;
  353.     local_data->info.alarm_format = 0;
  354.     local_data->info.alarm_index = 0;
  355.     local_data->info.type = 0;
  356.     local_data->info.text[0] = '';
  357.     local_data->info.recurr = 0;
  358.     local_data->info.data_time.rtc_year = datetime.rtc_year;
  359.     local_data->info.data_time.rtc_wday = datetime.rtc_wday;
  360.     local_data->info.data_time.rtc_mon = datetime.rtc_mon;
  361.     local_data->info.data_time.rtc_day = datetime.rtc_day;
  362.     local_data->info.data_time.rtc_hour = datetime.rtc_hour;
  363.     local_data->info.data_time.rtc_min = datetime.rtc_min;
  364.     local_data->info.data_time.rtc_sec = datetime.rtc_sec;
  366.     ilm_ptr->local_para_ptr = (local_para_struct*) local_data;
  367.     ilm_ptr->peer_buff_ptr = NULL;
  368.     SEND_ILM(MOD_MMI, MOD_L4C, MMI_L4C_SAP, ilm_ptr);
  369. }
  372. /*****************************************************************************
  373.  * FUNCTION
  374.  *  L4SetClockRSP
  375.  * DESCRIPTION
  376.  *  This function is to get to the result of clock set response.
  377.  * PARAMETERS
  378.  *  buf         [?]         
  379.  *  a(?)        [IN]        Buf
  380.  * RETURNS
  381.  *  void
  382.  *****************************************************************************/
  383. void L4SetClockRSP(void *buf)
  384. {
  385.     /*----------------------------------------------------------------*/
  386.     /* Local Variables                                                */
  387.     /*----------------------------------------------------------------*/
  389.     /*----------------------------------------------------------------*/
  390.     /* Code Body                                                      */
  391.     /*----------------------------------------------------------------*/
  392.     if (set_clocktime_callback_func != NULL)
  393.     {
  394.         set_clocktime_callback_func(buf);
  395.     }
  396. }
  399. /*****************************************************************************
  400.  * FUNCTION
  401.  *  L4GetClockTime
  402.  * DESCRIPTION
  403.  *  This function is to request to get the clock.
  404.  * PARAMETERS
  405.  *  FuncRspPtr      [IN]        
  406.  *  a(?)            [IN]        Void
  407.  * RETURNS
  408.  *  void
  409.  *****************************************************************************/
  410. void L4GetClockTime(oslTaskFuncPtr FuncRspPtr)
  411. {
  412.     /*----------------------------------------------------------------*/
  413.     /* Local Variables                                                */
  414.     /*----------------------------------------------------------------*/
  415.     ilm_struct *ilm_ptr = NULL;
  416.     mmi_eq_get_rtc_time_req_struct *local_data;
  418.     /*----------------------------------------------------------------*/
  419.     /* Code Body                                                      */
  420.     /*----------------------------------------------------------------*/
  421.     /* store the get time clock callback function */
  422.     get_clocktime_callback_func = FuncRspPtr;
  424.     ilm_ptr = allocate_ilm(MOD_MMI);
  425.     local_data = (mmi_eq_get_rtc_time_req_struct*)
  426.         construct_local_para(sizeof(mmi_eq_get_rtc_time_req_struct), TD_CTRL);
  428.     local_data->rtc_type = RTC_TIME_CLOCK_IND;
  430.     ilm_ptr->msg_id = (U16) MSG_ID_MMI_EQ_GET_RTC_TIME_REQ;
  431.     ilm_ptr->local_para_ptr = (local_para_struct*) local_data;
  432.     ilm_ptr->peer_buff_ptr = NULL;
  434.     SEND_ILM(MOD_MMI, MOD_L4C, MMI_L4C_SAP, ilm_ptr);
  435. }
  438. /*****************************************************************************
  439.  * FUNCTION
  440.  *  L4GetClockTimeRSP
  441.  * DESCRIPTION
  442.  *  This function is to receive the clock response.
  443.  * PARAMETERS
  444.  *  buf         [?]         
  445.  *  a(?)        [IN]        Buf
  446.  * RETURNS
  447.  *  void
  448.  *****************************************************************************/
  449. void L4GetClockTimeRSP(void *buf)
  450. {
  451.     /*----------------------------------------------------------------*/
  452.     /* Local Variables                                                */
  453.     /*----------------------------------------------------------------*/
  455.     /*----------------------------------------------------------------*/
  456.     /* Code Body                                                      */
  457.     /*----------------------------------------------------------------*/
  458.     if (get_clocktime_callback_func != NULL)
  459.     {
  460.         get_clocktime_callback_func(buf);
  461.     }
  462. }
  465. /*****************************************************************************
  466.  * FUNCTION
  467.  *  L4InitTimer
  468.  * DESCRIPTION
  469.  *  This function is to init the timer while task create.
  470.  * PARAMETERS
  471.  *  void
  472.  *  a(?)        [IN]        Void
  473.  * RETURNS
  474.  *  void
  475.  *****************************************************************************/
  476. void L4InitTimer(void)
  477. {
  478.     /*----------------------------------------------------------------*/
  479.     /* Local Variables                                                */
  480.     /*----------------------------------------------------------------*/
  481.     TIMERTABLE *p;
  482.     TIMERTABLE *pp;
  484.     /*----------------------------------------------------------------*/
  485.     /* Code Body                                                      */
  486.     /*----------------------------------------------------------------*/
  487.     /* Try to free TIMERTABLE list exclude g_timer_table */
  488.     p = g_timer_table.next;
  489.     pp = NULL;
  490.     do
  491.     {
  492.         if (p != NULL)
  493.         {
  494.             pp = p->next;
  495.             OslMfree(p);
  496.         }
  497.         p = pp;
  498.     } while (p != NULL);
  499.     /* reset g_timer_talbe */
  500.     memset(&g_timer_table, 0, sizeof(TIMERTABLE));
  501.     g_timer_table_size = SIMULTANEOUS_TIMER_NUM;
  502.     g_timer_table_used = 0;
  504.     /* Initiate the clock time callback function. */
  505.     get_clocktime_callback_func = NULL;
  506.     set_clocktime_callback_func = NULL;
  508.     /* Initate the no alignment stack timer */
  509.     stack_init_timer(&base_timer1, "MMI_Base_Timer1", MOD_MMI);
  511.     /* Create a no alignment timer schedule */
  512.     event_scheduler1_ptr = new_evshed(
  513.                             &base_timer1,
  514.                             L4StartBaseTimer,
  515.                             L4StopBaseTimer,
  516.                             0,
  517.                             kal_evshed_get_mem,
  518.                             kal_evshed_free_mem,
  519.                             0);
  521.     /* Initate the alignment stack timer */
  522.     stack_init_timer(&base_timer2, "MMI_Base_Timer2", MOD_MMI);
  524.     /* Create an alignment timer schedule */
  525.     event_scheduler2_ptr = new_evshed(
  526.                             &base_timer2,
  527.                             L4StartBaseTimer,
  528.                             L4StopBaseTimer,
  529.                             0,
  530.                             kal_evshed_get_mem,
  531.                             kal_evshed_free_mem,
  532.                             254);
  534.     #ifdef __MMI_FRM_TIMER_UNIT_TEST__   
  535.     mmi_frm_ut_timer();
  536.     #endif /* __MMI_FRM_TIMER_UNIT_TEST__ */
  538. }
  541. /*****************************************************************************
  542.  * FUNCTION
  543.  *  L4StopBaseTimer
  544.  * DESCRIPTION
  545.  *  This function is to assign the stop timer base.
  546.  * PARAMETERS
  547.  *  base_timer_ptr      [?]         
  548.  *  a(?)                [IN]        Base_timer_ptr
  549.  * RETURNS
  550.  *  void
  551.  *****************************************************************************/
  552. void L4StopBaseTimer(void *base_timer_ptr)
  553. {
  554.     /*----------------------------------------------------------------*/
  555.     /* Local Variables                                                */
  556.     /*----------------------------------------------------------------*/
  558.     /*----------------------------------------------------------------*/
  559.     /* Code Body                                                      */
  560.     /*----------------------------------------------------------------*/
  561.     stack_stop_timer((stack_timer_struct*) base_timer_ptr);
  562. }
  565. /*****************************************************************************
  566.  * FUNCTION
  567.  *  L4StartBaseTimer
  568.  * DESCRIPTION
  569.  *  This function is to assign the start timer base.
  570.  * PARAMETERS
  571.  *  base_timer_ptr      [?]         
  572.  *  time_out            [IN]        
  573.  *  a(?)                [IN]        Base_timer_ptr
  574.  *  b(?)                [IN]        Time_out
  575.  * RETURNS
  576.  *  void
  577.  *****************************************************************************/
  578. void L4StartBaseTimer(void *base_timer_ptr, unsigned int time_out)
  579. {
  580.     /*----------------------------------------------------------------*/
  581.     /* Local Variables                                                */
  582.     /*----------------------------------------------------------------*/
  584.     /*----------------------------------------------------------------*/
  585.     /* Code Body                                                      */
  586.     /*----------------------------------------------------------------*/
  587.     stack_start_timer((stack_timer_struct*) base_timer_ptr, 0, time_out);
  588. }
  591. /*****************************************************************************
  592.  * FUNCTION
  593.  *  L4CallBackTimer
  594.  * DESCRIPTION
  595.  *  This function is to execute the timer expire.
  596.  * PARAMETERS
  597.  *  p           [?]         
  598.  *  a(?)        [IN]        P
  599.  * RETURNS
  600.  *  void
  601.  *****************************************************************************/
  602. void L4CallBackTimer(void *p)
  603. {
  604.     /*----------------------------------------------------------------*/
  605.     /* Local Variables                                                */
  606.     /*----------------------------------------------------------------*/
  607.     U32 nTimerId = (U32) p;
  608.     TIMERTABLE *pTable = &g_timer_table;
  609.     U32 i = 0;
  610.     oslTimerFuncPtr pTimerExpiry = NULL;
  612.     /*----------------------------------------------------------------*/
  613.     /* Code Body                                                      */
  614.     /*----------------------------------------------------------------*/
  615.     MMI_ASSERT(nTimerId < MAX_TIMERS);
  617.     /* find the nTimerId in TIMERTABLE list */
  618.     do
  619.     {
  620.         /* MSB(Most Significant Bit) of timer_id[i] is align_timer_mask */
  621.         if ((pTable->timer_id[i] & (~NO_ALIGNMENT_TIMER_MASK)) == (U16) nTimerId)
  622.         {
  623.             /* find out nTimerId */
  624.             if (pTable->callback_func[i] != NULL)
  625.             {
  626.                 pTimerExpiry = pTable->callback_func[i];
  627.                 MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_L4DRV_CBTIMER_HDLR, nTimerId, pTimerExpiry));
  628.                 g_timer_table_used--;
  629.                 pTable->event_id[i] = 0;
  630.                 pTable->timer_id[i] = 0;
  631.                 pTable->callback_func[i] = NULL;
  632.                 /*
  633.                  * we process g_timer_table_used, event_id and timer_id ... first 
  634.                  * because the user may call stoptimer() in the timer_expiry_func
  635.                  */
  636.                 pTimerExpiry(p);
  637.             }
  638.             break;
  639.         }
  640.         i++;
  641.         if (i >= SIMULTANEOUS_TIMER_NUM)
  642.         {
  643.             pTable = pTable->next;
  644.             i = 0;
  645.         }
  646.     } while (pTable != NULL);
  647.     /* can't find nTimerId, do nothing */
  649.     mmi_frm_fetch_msg_from_extQ_to_circularQ();
  651.     /* 
  652.      * Because we modify MMI process protocol events and key events mechanism,
  653.      * we don't need to process key events here.
  654.      */
  655. }
  658. /*****************************************************************************
  659.  * FUNCTION
  660.  *  L4TimerUsePreciseTick
  661.  * DESCRIPTION
  662.  *  Typically we round timer period to multiple of 100ms. However, some timers need to be
  663.  *  more accurate.
  664.  * PARAMETERS
  665.  *  nTimerId        [IN]        Timer ID
  666.  * RETURNS
  667.  *  void
  668.  *****************************************************************************/
  669. MMI_BOOL L4TimerUsePreciseTick(unsigned short nTimerId)
  670. {
  671.     /*----------------------------------------------------------------*/
  672.     /* Local Variables                                                */
  673.     /*----------------------------------------------------------------*/
  675.     /*----------------------------------------------------------------*/
  676.     /* Code Body                                                      */
  677.     /*----------------------------------------------------------------*/
  678.     switch (nTimerId)
  679.     {
  680.     #if defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__)
  681.         case PEN_POLLING_TIMER:
  682.             return MMI_TRUE;
  683.     #endif /* defined(__MMI_TOUCH_SCREEN__) || defined(__MMI_HANDWRITING_PAD__) */ 
  684.         default:
  685.             return MMI_FALSE;
  686.     }
  687. }
  690. /*****************************************************************************
  691.  * FUNCTION
  692.  *  L4StartTimer
  693.  * DESCRIPTION
  694.  *  This function is to start timer. To added for two kinds of timer, one is for exactly time, another allow to delay.
  695.  * PARAMETERS
  696.  *  nTimerId            [IN]        
  697.  *  TimerExpiry         [IN]        
  698.  *  funcArg             [?]         
  699.  *  nTimeDuration       [IN]        
  700.  *  alignment           [IN]        
  701.  *  e(?)                [IN]        Alignment
  702.  *  a(?)                [IN]        NTimerId
  703.  *  d(?)                [IN]        NTimeDuration
  704.  *  c(?)                [IN]        FuncArg
  705.  *  b(?)                [IN]        TimerExpiry
  706.  * RETURNS
  707.  *  void
  708.  *****************************************************************************/
  709. void L4StartTimer(
  710.         unsigned short nTimerId,
  711.         oslTimerFuncPtr TimerExpiry,
  712.         void *funcArg,
  713.         unsigned long nTimeDuration,
  714.         unsigned char alignment)
  715. {
  716.     /*----------------------------------------------------------------*/
  717.     /* Local Variables                                                */
  718.     /*----------------------------------------------------------------*/
  719.     TIMERTABLE *pTable = NULL;
  720.     U16 i = 0;
  721.     U32 temp;
  723.     /*----------------------------------------------------------------*/
  724.     /* Code Body                                                      */
  725.     /*----------------------------------------------------------------*/
  726.     if (TimerExpiry == NULL)
  727.     {   /* If TimerExpiry is NULL, we don't start the timer */
  728.         MMI_ASSERT(0);
  729.         return;
  730.     }
  732.     MMI_ASSERT(nTimerId < MAX_TIMERS);
  734.     if (L4TimerUsePreciseTick(nTimerId))
  735.     {
  736.         temp = (nTimeDuration * KAL_TICKS_10_MSEC) / 10;
  737.         if (temp == 0)
  738.         {
  739.             temp = KAL_TICKS_10_MSEC;
  740.         }
  741.         alignment = TIMER_IS_NO_ALIGNMENT;
  742.     }
  743.     else
  744.     {
  745.         if (nTimeDuration == 1000)
  746.         {
  747.             temp = KAL_TICKS_1_SEC - 4;
  748.         }
  749.         else
  750.         {
  751.             temp = (U32)((nTimeDuration / 5) * MMI_TICKS_5_MSEC);
  752.         }
  754.         if (temp == 0)
  755.         {
  756.             /* Cause by by rounding. If expire immediately, MoDIS boot-up failure because MMI keeps running and block NVRAM task */
  757.             temp = (U32)MMI_TICKS_5_MSEC;
  758.         }
  760.     }   /* if (L4TimerUsePreciseTick(nTimerId)) */
  762.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_L4DRV_STARTTIMER_HDLR, nTimerId, TimerExpiry, temp, alignment));
  764.     pTable = &g_timer_table;
  765.     if (g_timer_table_used >= g_timer_table_size)
  766.     {
  767.         /*
  768.          * TIMERTABLE list doesn't have enough space, allocate the memory 
  769.          *
  770.          * If we need to allocate the memeory, it means that MMI may have 
  771.          * such many timers run simultaneously. We won't free the memory 
  772.          * after we allocate more memory in TIMERTABLE list.
  773.          */
  774.         do
  775.         {
  776.             if (pTable->next == NULL)
  777.             {
  778.                 pTable->next = OslMalloc(sizeof(TIMERTABLE));
  779.                 memset(pTable->next, 0, sizeof(TIMERTABLE));
  780.                 g_timer_table_size += SIMULTANEOUS_TIMER_NUM;
  781.                 pTable = pTable->next;
  782.                 i = 0;
  783.                 break;
  784.             }
  785.             pTable = pTable->next;
  786.         } while (pTable != NULL);
  787.     }
  788.     else
  789.     {
  790.         /* find the empty record in g_timer_table list */
  791.         i = 0;
  792.         do
  793.         {
  794.             if (pTable->event_id[i] == NULL)
  795.             {   /* find the empty space */
  796.                 break;
  797.             }
  798.             i++;
  799.             if (i >= SIMULTANEOUS_TIMER_NUM)
  800.             {
  801.                 pTable = pTable->next;
  802.                 i = 0;
  803.             }
  804.         } while (pTable != NULL);
  806.         if (pTable == NULL)
  807.         {
  808.             /* Can't find the empty space in TIMERTABLE list, assert!!! */
  809.             MMI_ASSERT(0);
  810.         }
  811.     }   /* if (g_timer_table_used >= g_timer_table_size) */
  813.     /* 
  814.      * already find the empty record, and then start timer 
  815.      *
  816.      * event_sheduler1 = NO alignment scherulder
  817.      * event_sheduler2 = alignment scherulder (low power)
  818.      */
  819.     if (alignment == TIMER_IS_NO_ALIGNMENT)
  820.     {
  821.         /* MSB(Most Significant Bit) is align_timer_mask */
  822.         pTable->timer_id[i] = nTimerId | NO_ALIGNMENT_TIMER_MASK;
  823.         pTable->event_id[i] = evshed_set_event(
  824.                                 event_scheduler1_ptr,
  825.                                 (kal_timer_func_ptr) L4CallBackTimer,
  826.                                 (void*)nTimerId,
  827.                                 temp);
  828.         pTable->callback_func[i] = TimerExpiry;
  829.         g_timer_table_used++;
  830.     }
  831.     else if (alignment == TIMER_IS_ALIGNMENT)
  832.     {
  833.         /* MSB(Most Significant Bit) is align_timer_mask */
  834.         pTable->timer_id[i] = nTimerId | ALIGNMENT_TIMER_MASK;
  835.         pTable->event_id[i] = evshed_set_event(
  836.                                 event_scheduler2_ptr,
  837.                                 (kal_timer_func_ptr) L4CallBackTimer,
  838.                                 (void*)nTimerId,
  839.                                 temp);
  840.         pTable->callback_func[i] = TimerExpiry;
  841.         g_timer_table_used++;
  842.     }
  843. }
  846. /*****************************************************************************
  847.  * FUNCTION
  848.  *  L4StopTimer
  849.  * DESCRIPTION
  850.  *  This function is to stop timer. To added for two kinds of timer, one is for exactly time, another allow to delay.
  851.  * PARAMETERS
  852.  *  nTimerId        [IN]        
  853.  *  a(?)            [IN]        NTimerId
  854.  * RETURNS
  855.  *  void
  856.  *****************************************************************************/
  857. void L4StopTimer(unsigned short nTimerId)
  858. {
  859.     /*----------------------------------------------------------------*/
  860.     /* Local Variables                                                */
  861.     /*----------------------------------------------------------------*/
  862.     TIMERTABLE *pTable = &g_timer_table;
  863.     U16 i = 0;
  865.     /*----------------------------------------------------------------*/
  866.     /* Code Body                                                      */
  867.     /*----------------------------------------------------------------*/
  868.     MMI_ASSERT(nTimerId < MAX_TIMERS);
  869.     MMI_TRACE((MMI_TRACE_G1_FRM, MMI_FRM_INFO_L4DRV_STOPTIMER_HDLR, nTimerId));
  871.     /* find the nTimerId in TIMERTABLE list */
  872.     do
  873.     {
  874.         /* MSB(Most Significant Bit) of timer_id[i] is align_timer_mask */
  875.         if ((pTable->timer_id[i] & (~NO_ALIGNMENT_TIMER_MASK)) == nTimerId)
  876.         {
  877.             /* find the nTimerId */
  878.             if (pTable->event_id[i] != NULL)
  879.             {
  880.                 if ((pTable->timer_id[i] & NO_ALIGNMENT_TIMER_MASK) == NO_ALIGNMENT_TIMER_MASK)
  881.                 {   /* NO_ALIGNMENT_TIMER */
  882.                     evshed_cancel_event(event_scheduler1_ptr, &(pTable->event_id[i]));
  883.                 }
  884.                 else
  885.                 {   /* ALIGNMENT_TIMER */
  886.                     evshed_cancel_event(event_scheduler2_ptr, &(pTable->event_id[i]));
  887.                 }
  889.                 g_timer_table_used--;
  890.                 pTable->event_id[i] = NULL;
  891.                 pTable->timer_id[i] = 0;
  892.                 pTable->callback_func[i] = NULL;
  893.             }
  894.             break;
  895.         }
  896.         i++;
  897.         if (i >= SIMULTANEOUS_TIMER_NUM)
  898.         {
  899.             pTable = pTable->next;
  900.             i = 0;
  901.         }
  902.     } while (pTable != NULL);
  904.     /* if can't find nTimerId, do nothing */
  906. }
  908. /*****************************************************************************
  909.  * FUNCTION
  910.  *  mmi_frm_is_align_base_timer
  911.  * DESCRIPTION
  912.  *  is the given base timer an alignment one
  913.  * PARAMETERS
  914.  *  base_timer_ptr        [IN]        base timer pointer
  915.  * RETURNS
  916.  *  IMER_IS_ALIGNMENT (MMI_TRUE) or TIMER_IS_NO_ALIGNMENT (MMI_FALSE)
  917.  *****************************************************************************/
  918. MMI_BOOL mmi_frm_is_align_base_timer(void *base_timer_ptr)
  919. {
  920.     if ( base_timer_ptr == (void *)&base_timer2 )
  921.         return MMI_TRUE;
  922.     else
  923.         return MMI_FALSE;
  924. }
  926. /***************************************************************************** 
  927. * Local Function
  928. *****************************************************************************/
  930. #ifdef __MMI_FRM_TIMER_UNIT_TEST__
  932. #define ALIGN_TEST_TIMEOUT      1000   /* ms */
  933. #define NON_ALIGN_TEST_TIMEOUT  1100   /* ms */
  935. #define ALIGN_TEST_TM_ID        MMI_TIMER_BASE
  936. #define NON_ALIGN_TEST_TM_ID    KEY_TIMER_ID_NONE
  938. /*****************************************************************************
  939.  * FUNCTION
  940.  *  mmi_frm_ut_timer
  941.  * DESCRIPTION
  942.  *  timer unit-test
  943.  * PARAMETERS
  944.  *  none
  945.  * RETURNS
  946.  *  none
  947.  *****************************************************************************/
  948. static void mmi_frm_ut_timer()
  949. {
  950.     /* unit test for non-alignment timer in NVRAM access */
  951.     L4StartTimer(NON_ALIGN_TEST_TM_ID, (oslTimerFuncPtr)mmi_frm_ut_nonalign_timer, 
  952.         (void *)NON_ALIGN_TEST_TM_ID, NON_ALIGN_TEST_TIMEOUT, TIMER_IS_NO_ALIGNMENT);
  953.     
  954.     /* unit test for alignment timer in NVRAM access */
  955.     L4StartTimer(ALIGN_TEST_TM_ID, (oslTimerFuncPtr)mmi_frm_ut_align_timer, 
  956.         (void *)ALIGN_TEST_TM_ID, ALIGN_TEST_TIMEOUT, TIMER_IS_ALIGNMENT);
  957. }
  960. /*****************************************************************************
  961.  * FUNCTION
  962.  *  mmi_frm_ut_nonalign_timer
  963.  * DESCRIPTION
  964.  *  timer callback for non-align timer unit test
  965.  * PARAMETERS
  966.  *  timer id
  967.  * RETURNS
  968.  *  none
  969.  *****************************************************************************/
  970. static void mmi_frm_ut_nonalign_timer(void *p)
  971. {
  972.     if (IsInNVRAMProcedure())
  973.     {
  974.         Trace2(TRACE_GROUP_1, "[UT] non-align timer works in nvram access");
  975.         //kal_print("n[UT] non-align timer works in nvram accessn");
  976.     }
  977.     else
  978.     {
  979.         L4StartTimer(NON_ALIGN_TEST_TM_ID, (oslTimerFuncPtr)mmi_frm_ut_nonalign_timer, 
  980.             (void *)NON_ALIGN_TEST_TM_ID, NON_ALIGN_TEST_TIMEOUT, TIMER_IS_NO_ALIGNMENT);
  981.     }    
  982. }
  985. /*****************************************************************************
  986.  * FUNCTION
  987.  *  mmi_frm_ut_align_timer
  988.  * DESCRIPTION
  989.  *  timer callback for align timer unit test
  990.  * PARAMETERS
  991.  *  timer id
  992.  * RETURNS
  993.  *  none
  994.  *****************************************************************************/
  995. static void mmi_frm_ut_align_timer(void *p)
  996. {
  997.     if (IsInNVRAMProcedure())
  998.     {
  999.         Trace2(TRACE_GROUP_1, "[UT] align timer will die in nvram access");
  1000.         MMI_ASSERT(0);
  1001.     }
  1002.     else
  1003.     {
  1004.         L4StartTimer(ALIGN_TEST_TM_ID, (oslTimerFuncPtr)mmi_frm_ut_align_timer, 
  1005.             (void *)ALIGN_TEST_TM_ID, ALIGN_TEST_TIMEOUT, TIMER_IS_ALIGNMENT);
  1006.     }    
  1007. }
  1009. #endif /* __MMI_FRM_TIMER_UNIT_TEST__ */
  1011. #endif /* MMI_ON_WIN32 */