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

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

MTK

开发平台：

C/C++

GeneralDeviceInterface.c：源码内容
  1.     #endif /* defined(__MMI_SUBLCD__) */ 
  3.         /* redraw main lcd */
  4.         gdi_lcd_repaint_all();
  6.         /* resume screensaver if it is playing before sleep-in, must after lcd sleep out */
  7.         mmi_scrsvr_lcd_sleepout_handler();
  9.     #if defined(__WIFI_SUPPORT__) && defined (__MTK_TARGET__)
  10.         wndrv_LCD_isON();
  11.     #endif /* #if defined(__WIFI_SUPPORT__) && defined (__MTK_TARGET__) */
  12.         
  13.         /* tvout sleepout */
  14.     #ifdef __MMI_TVOUT__
  15.         mmi_phnset_tvout_lcd_sleepout_handler();
  16.     #endif 
  18.     #ifdef __MMI_TOUCH_SCREEN__
  19.         /* diamond, 2006/06/09 Pen will not be blocked if keypad lock timeout after backlight is off */
  20.         if ((g_idle_context.IsOnIdleScreen || g_idle_context.IsOnSimErrorScreen)&& g_keylock_context.gKeyPadLockFlag)
  21.         {
  22.             mmi_pen_block();
  23.         }
  24.     #endif /* __MMI_TOUCH_SCREEN__ */ 
  25.     }
  26. #endif /* MMI_ON_HARDWARE_P */ 
  27. }
  30. /*****************************************************************************
  31.  * FUNCTION
  32.  *  GpioTurnOnKeypadLight
  33.  * DESCRIPTION
  34.  *  turn on keypad backlight
  35.  *  
  36.  *  PARAMETERS:
  37.  *  void
  38.  *****************************************************************************/
  39. static void GpioTurnOnKeypadLight(void)
  40. {
  41. #ifdef MMI_ON_HARDWARE_P
  43. //KP Jerry add on 2007-03-26 start
  44. #ifdef __MMI_PROFILE_POWER_SAVING__
  45. if(GetCurrentActivatedProfileKeyBKStatus())
  46. {
  47. #endif
  48. //KP Jerry add on 2007-03-26 end
  50.     /*----------------------------------------------------------------*/
  51.     /* Local Variables                                                */
  52.     /*----------------------------------------------------------------*/
  54.     /*----------------------------------------------------------------*/
  55.     /* Code Body                                                      */
  56.     /*----------------------------------------------------------------*/
  57.     /* turn on keypad backlight if currently off and clam open */
  58.     if (keypad_backlight == 0 && gMMIClamState == 1 && g_keylock_context.gKeyPadLockFlag == 0)
  59.     {
  60.         KeyPadBackLightOn();
  61.         keypad_backlight = 1;
  62.     }
  63.     StartTimer(GPIO_KEYPAD_LIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, GpioTurnOffKeypadLight);
  65. //KP Jerry add on 2007-03-26 start
  66. #ifdef __MMI_PROFILE_POWER_SAVING__
  67. }
  68. #endif
  69. //KP Jerry add on 2007-03-26 end
  71. #endif /* MMI_ON_HARDWARE_P */ 
  72. }
  74. //KP Jerry add on 2007-4-25 start
  75. void SetkeypadBacklightStuatus(U8 value)
  76. {
  77. keypad_backlight = value;
  78. }
  79. //KP Jerry add on 2007-4-25 end
  81. #ifdef MMI_BK_LIGHT_DELAY_TIME
  84. /*****************************************************************************
  85.  * FUNCTION
  86.  *  mmi_gpio_set_main_lcd_level_5
  87.  * DESCRIPTION
  88.  *  Set main LCD level to 5.
  89.  *  PARAMETERS:
  90.  *  void
  91.  *****************************************************************************/
  92. static void mmi_gpio_set_main_lcd_level_5(void)
  93. {
  94.     /*----------------------------------------------------------------*/
  95.     /* Local Variables                                                */
  96.     /*----------------------------------------------------------------*/
  98.     /*----------------------------------------------------------------*/
  99.     /* Code Body                                                      */
  100.     /*----------------------------------------------------------------*/
  101.     SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  102. }
  103. #endif /* MMI_BK_LIGHT_DELAY_TIME */ 
  106. /*****************************************************************************
  107.  * FUNCTION
  108.  *  IsBacklightOn
  109.  * DESCRIPTION
  110.  *  Test whether the backlight is on (half-light or full-light)
  111.  *  
  112.  *  PARAMETERS:
  113.  *  void
  114.  *****************************************************************************/
  115. MMI_BOOL IsBacklightOn(void)
  116. {
  117.     /*----------------------------------------------------------------*/
  118.     /* Local Variables                                                */
  119.     /*----------------------------------------------------------------*/
  121.     /*----------------------------------------------------------------*/
  122.     /* Code Body                                                      */
  123.     /*----------------------------------------------------------------*/
  124.     if (lcd_backlight)
  125.     {
  126.         return MMI_TRUE;
  127.     }
  128.     else
  129.     {
  130.         return MMI_FALSE;
  131.     }
  132. }
  135. /*****************************************************************************
  136.  * FUNCTION
  137.  *  HalfModeBacklight
  138.  * DESCRIPTION
  139.  *  Takes the Backlight to Half Mode
  140.  *  (Backlit is dimmed but not black)
  141.  *  
  142.  *  PARAMETERS: void
  143.  *  void
  144.  *****************************************************************************/
  145. void HalfModeBacklight(void)
  146. {
  147. #ifdef MMI_ON_HARDWARE_P
  148.     /*----------------------------------------------------------------*/
  149.     /* Local Variables                                                */
  150.     /*----------------------------------------------------------------*/
  152.     /*----------------------------------------------------------------*/
  153.     /* Code Body                                                      */
  154.     /*----------------------------------------------------------------*/
  155.     if (gbacklight_mode == 1)   /* for AT command */
  156.     {
  157.         if (sublcd_backlight == 0)
  158.         {
  159.             SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  160.             sublcd_backlight = 1;
  161.         }
  163.         if (lcd_backlight == 0 && gMMIClamState == 1)   /* sleep mode */
  164.         {
  165.         #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  166.             GpioLCDSleepOut();
  168.             UI_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  170.             update_mainlcd_dt_display();
  171.             update_sublcd_dt_display();
  173.             /* resume screensaver if it is playing before sleep-in, must after lcd sleep out */
  174.             mmi_scrsvr_lcd_sleepout_handler();
  176.             /* tvout sleepout */
  177.         #ifdef __MMI_TVOUT__
  178.             mmi_phnset_tvout_lcd_sleepout_handler();
  179.         #endif 
  180.         #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  181.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL1);
  182.             lcd_backlight = 1;
  183.         }
  185.         if (isTimerSuspend == 1)
  186.         {
  187.             if (mmi_bootup_get_active_flight_mode() == 0)
  188.             {
  189.                 evshed_resume_all_events(event_scheduler1_ptr);
  190.             }
  191.             isTimerSuspend = 0;
  192.         }
  194.         if (gBackLightTimerStatus > 1)
  195.         {
  196.             StopTimer(BACKLIGHT_TIMER);
  197.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_OPEN_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  198.             gBackLightTimerStatus = 2;
  199.         }
  200.     }
  201. #endif /* MMI_ON_HARDWARE_P */ 
  202. }
  204. #if defined(__MMI_SYNC_LCD_GPIO_MODE__)
  207. /*****************************************************************************
  208.  * FUNCTION
  209.  *  mmi_gpio_turn_on_all_light
  210.  * DESCRIPTION
  211.  *  Turn on all light to whole bright
  212.  * PARAMETERS
  213.  *  void
  214.  * RETURNS
  215.  *  void
  216.  *****************************************************************************/
  217. static void mmi_gpio_turn_on_all_light(void)
  218. {
  219. #ifdef MMI_ON_HARDWARE_P
  220.     /*----------------------------------------------------------------*/
  221.     /* Local Variables                                                */
  222.     /*----------------------------------------------------------------*/
  224.     /*----------------------------------------------------------------*/
  225.     /* Code Body                                                      */
  226.     /*----------------------------------------------------------------*/
  227.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "turn_on_all_light() lcd_backlight=%d", lcd_backlight));    
  228.     
  229.     GpioLCDSleepOut();
  230.     SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  231.     lcd_backlight = 2;
  232. #endif /* MMI_ON_HARDWARE_P */ 
  233. }
  236. /*****************************************************************************
  237.  * FUNCTION
  238.  *  mmi_gpio_turn_off_all_light
  239.  * DESCRIPTION
  240.  *  Turn off all light to whole dark
  241.  * PARAMETERS
  242.  *  void
  243.  * RETURNS
  244.  *  void
  245.  *****************************************************************************/
  246. static void mmi_gpio_turn_off_all_light(void)
  247. {
  248. #ifdef MMI_ON_HARDWARE_P
  249.     /*----------------------------------------------------------------*/
  250.     /* Local Variables                                                */
  251.     /*----------------------------------------------------------------*/
  253.     /*----------------------------------------------------------------*/
  254.     /* Code Body                                                      */
  255.     /*----------------------------------------------------------------*/
  256.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "turn_off_all_light() lcd_backlight=%d", lcd_backlight));    
  257.     
  258.     /* set lcd backlight to half mode */
  259.     if (lcd_backlight != 0) /* backlight is on */
  260.     {
  261.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  262.         lcd_backlight = 0;
  263.     }
  264. #endif /* MMI_ON_HARDWARE_P */ 
  265. }
  268. /*****************************************************************************
  269.  * FUNCTION
  270.  *  TurnOffBacklight
  271.  * DESCRIPTION
  272.  *  It is typically paired with TurnOnBacklight(0) in order to resume backlight timer.
  273.  *  
  274.  *  PARAMETERS: void
  275.  *  void
  276.  *****************************************************************************/
  277. void TurnOffBacklight(void)
  278. {
  279.     /*----------------------------------------------------------------*/
  280.     /* Local Variables                                                */
  281.     /*----------------------------------------------------------------*/
  283.     /*----------------------------------------------------------------*/
  284.     /* Code Body                                                      */
  285.     /*----------------------------------------------------------------*/
  286.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "TurnOffBacklight(): lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  287.     
  288.     /* Share the same code for target and PC simulator */
  290.     /* AT command disables backlight mechanism */
  291.     if (gbacklight_mode == 0)
  292.     {
  293.         return;
  294.     }
  296.     if (gBackLightTimerStatus == 0)
  297.     {
  298.         StopTimer(BACKLIGHT_TIMER);
  299.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  300.         gBackLightTimerStatus = 1;
  301.     }
  302. }
  305. /*****************************************************************************
  306.  * FUNCTION
  307.  *  BacklightTimerHdlr
  308.  * DESCRIPTION
  309.  *  Timer handler to switch backlight state
  310.  *  
  311.  *  PARAMETERS: void
  312.  *  void
  313.  *****************************************************************************/
  314. static void BacklightTimerHdlr(void)
  315. {
  316. #ifdef MMI_ON_HARDWARE_P
  317.     /*----------------------------------------------------------------*/
  318.     /* Local Variables                                                */
  319.     /*----------------------------------------------------------------*/
  321.     /*----------------------------------------------------------------*/
  322.     /* Code Body                                                      */
  323.     /*----------------------------------------------------------------*/
  324.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "BacklightTimerHdlr() lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  326.     /* AT command disables backlight mechanism */
  327.     if (gbacklight_mode == 0)
  328.     {
  329.         return;
  330.     }
  332.     if (gBackLightTimerStatus == 0)
  333.     {
  334.         StopTimer(BACKLIGHT_TIMER);
  335.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  336.         gBackLightTimerStatus = 1;
  337.     }
  338.     else if (gBackLightTimerStatus == 1)
  339.     {
  340.         if (lcd_backlight == 2)
  341.         {
  342.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL1);
  343.             lcd_backlight = 1;
  344.         }
  346.         StopTimer(BACKLIGHT_TIMER);
  347.         StartTimer(BACKLIGHT_TIMER, LCD_CLAM_OPEN_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  348.         gBackLightTimerStatus = 2;
  349.     }
  350.     else    /* gBackLightTimerStatus == 2 */
  351.     {
  352.         if (lcd_backlight == 1)
  353.         {
  354.             if(/*!backlight_check_call_present()    //KP Jerry disable on 2006-12-21
  355.             &&*/ (g_phb_cntx.processing == FALSE)
  356.             /*&& (mdi_audio_get_state() != MDI_AUDIO_RECORD) && (mdi_audio_get_state() != MDI_AUDIO_RECORD_PAUSED)*/)    //KP Jerry disable on 2006-12-21
  357.             {
  358.                 SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  360.             #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)   /* { */
  361.                 GpioLCDSleepIn();
  362.             #ifdef __MMI_LCMSLEEP_BACK2IDLE__
  363.                 LCMSleepGotoIdleScreen();
  364.             #endif 
  365.             #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ /* } */
  366.                 lcd_backlight = 0;
  367.             }
  369.             gBackLightTimerStatus = 3;
  370.         }
  372.     #ifdef __MMI_CLAMSHELL__
  373.         if (isTimerSuspend == 0
  374.             && g_charbat_context.isChargerConnected == 0
  375. && !backlight_check_call_present()
  376. && mmi_msg_need_mem_full_ind() == 0 
  377. && g_phb_cntx.processing == FALSE
  378.     #if defined(__MMI_VIDEO_PLAYER__) && defined(__MMI_TVOUT__)
  379.             && mmi_vdoply_is_in_play_and_tvout_enable() == MMI_FALSE
  380.     #endif 
  381. /*&& mdi_audio_get_state() != MDI_AUDIO_RECORD && mdi_audio_get_state() != MDI_AUDIO_RECORD_PAUSED*/ )    //KP Jerry disable on 2006-12-21
  382.     #else /* __MMI_CLAMSHELL__ */ 
  383. if (isTimerSuspend == 0 && g_charbat_context.isChargerConnected == 0 
  384. && !backlight_check_call_present()
  385.     #if defined(__MMI_VIDEO_PLAYER__) && defined(__MMI_TVOUT__)
  386.             && mmi_vdoply_is_in_play_and_tvout_enable() == MMI_FALSE
  387.     #endif 
  388. && g_phb_cntx.processing == FALSE /*&& mdi_audio_get_state() != MDI_AUDIO_RECORD && mdi_audio_get_state() != MDI_AUDIO_RECORD_PAUSED*/ )    //KP Jerry disable on 2006-12-21
  389.     #endif /* __MMI_CLAMSHELL__ */ 
  390.         {
  391.             if (mmi_bootup_get_active_flight_mode() == 0)
  392.             {
  393.                 evshed_suspend_all_events(event_scheduler1_ptr);
  394.             }
  395.             isTimerSuspend = 1;
  396.         }
  397.     }
  398. #else /* MMI_ON_HARDWARE_P */ /* For PC Simulator only */
  399.     if (gbacklight_mode == 1)
  400.     {
  401.         if (gBackLightTimerStatus == 0)
  402.         {
  403.             StopTimer(BACKLIGHT_TIMER);
  404.             StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  405.             gBackLightTimerStatus = 1;
  406.         }
  407.         else if (gBackLightTimerStatus == 1)
  408.         {
  409.             if (lcd_backlight == 2)
  410.             {
  411.                 simulate_lcd_bklight_turn_off();
  412.                 lcd_backlight = 1;
  413.             }
  414.             if (sublcd_backlight == 1)
  415.             {
  416.                 simulate_sublcd_bklight_turn_off();
  417.                 sublcd_backlight = 0;
  418.             }
  419.             StopTimer(BACKLIGHT_TIMER);
  420.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_OPEN_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  421.             gBackLightTimerStatus = 2;
  422.         }
  423.         else    /* gBackLightTimerStatus == 2 */
  424.         {
  425.             if (sublcd_backlight == 1)
  426.             {
  427.                 simulate_sublcd_bklight_turn_off();
  428.                 sublcd_backlight = 0;
  429.             }
  430.             if (lcd_backlight == 1)
  431.             {
  432.                 simulate_lcd_bklight_turn_off();
  433.             }
  435.             gBackLightTimerStatus = 3;
  436.         }
  437.     }
  438. #endif /* MMI_ON_HARDWARE_P */ 
  439. }
  442. /*****************************************************************************
  443.  * FUNCTION
  444.  *  TurnOnBacklight
  445.  * DESCRIPTION
  446.  *  Turns On the backlight
  447.  * PARAMETERS
  448.  *  time_enum       [IN]        Time duration type
  449.  *****************************************************************************/
  450. void TurnOnBacklight(gpio_backlight_time_enum time_enum)
  451. {
  452. #ifdef MMI_ON_HARDWARE_P        /* { */
  453.     /*----------------------------------------------------------------*/
  454.     /* Local Variables                                                */
  455.     /*----------------------------------------------------------------*/
  457.     /*----------------------------------------------------------------*/
  458.     /* Code Body                                                      */
  459.     /*----------------------------------------------------------------*/
  460.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "TurnOnBacklight() time_enum=%d, BLTimerStat=%d", time_enum, gBackLightTimerStatus));    
  461.     
  462.     /* AT command disables backlight mechanism */
  463.     if (gbacklight_mode == 0)
  464.     {
  465.         return;
  466.     }
  468. #ifdef MMI_BK_LIGHT_DELAY_TIME
  469.     StopMyTimer(GPIO_BACKLIGHT_DELAY_TIMER);
  470. #endif 
  472.     /* resume timer if suspended */
  473.     if (isTimerSuspend == 1)
  474.     {
  475.         if (mmi_bootup_get_active_flight_mode() == 0)
  476.         {
  477.             evshed_resume_all_events(event_scheduler1_ptr);
  478.         }
  479.         isTimerSuspend = 0;
  480.     }
  481.     
  482. #ifdef LCM_MMI_TYPE_QUERY
  483. #ifdef __MMI_LCD_PARTIAL_ON__
  484.     /* If LCD is transmissive, there is meanless for partial display.
  485.        But if LCD is reflective or transflective, user can see the display when backlight is off.
  486.        In this case, when turn on backlight, handset should leave Screen saver */
  487.    if (get_lcm_type)
  488.    {
  489.        if (get_lcm_type() == LCM_TRANSFLECTIVE_TYPE)
  490.         {
  491.             LeavePartialOnScreenSaverIfOk();
  492.         }
  493.     }
  494. #endif    
  495. #endif /* LCM_MMI_TYPE_QUERY */
  497.     /* lcd backlight */
  498.     if (lcd_backlight == 0)
  499.     {
  500.         lcd_backlight = 2;
  502.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  503.         GpioLCDSleepOut();
  504.     #endif 
  506.     #ifdef __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__       /* { */
  508.     #ifdef MMI_BK_LIGHT_DELAY_TIME
  509.         StartTimer(GPIO_BACKLIGHT_DELAY_TIMER, MMI_BK_LIGHT_DELAY_TIME, mmi_gpio_set_main_lcd_level_5);
  510.     #else 
  511.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  512.     #endif 
  514.     #else /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* }{ */
  515.         if (gMMIClamState == 1) /* clam is opened */
  516.         {
  517.         #ifdef MMI_BK_LIGHT_DELAY_TIME
  518.             StartTimer(GPIO_BACKLIGHT_DELAY_TIMER, MMI_BK_LIGHT_DELAY_TIME, mmi_gpio_set_main_lcd_level_5);
  519.         #else 
  520.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  521.         #endif 
  523.             lcd_backlight = 2;
  524.         }
  525.         else    /* clam is closed */
  526.         {
  527.         #ifndef __MMI_SLIDE__
  528.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL1);
  529.             lcd_backlight = 1;
  530.         #else
  531.             #ifdef MMI_BK_LIGHT_DELAY_TIME
  532.                 StartTimer(GPIO_BACKLIGHT_DELAY_TIMER, MMI_BK_LIGHT_DELAY_TIME, mmi_gpio_set_main_lcd_level_5);
  533.             #else 
  534.                 SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  535.             #endif 
  536.                 lcd_backlight = 2;        
  537.         #endif 
  538.         }
  539.     #endif /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* } */
  540.     }
  541.     else if (lcd_backlight == 1)
  542.     {
  543.     #ifdef __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__
  544.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  545.         lcd_backlight = 2;
  547.     #else /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* }{ */
  548.     #ifndef __MMI_SLIDE__
  549.         if (gMMIClamState == 1 || !mmi_bootup_is_searching_or_idle_reached())   /* clam is opened */
  550.     #endif 
  551.         {
  552.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  553.             lcd_backlight = 2;
  554.         }
  555.     #endif /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* } */
  556.     }
  558.     /* turn on keypad backlight if currently off and clam open */
  559.     GpioTurnOnKeypadLight();
  561.     /* start/stop timer according to input parameter */
  562.     if (time_enum == GPIO_BACKLIGHT_PERMANENT)
  563.     {
  564.         StopTimer(BACKLIGHT_TIMER);
  565.         gBackLightTimerStatus = 0;
  566.     }
  567.     else if (gBackLightTimerStatus != 0)    /* start a timer */
  568.     {
  569.         StopTimer(BACKLIGHT_TIMER);
  571.     #ifdef __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__
  572.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  573.         gBackLightTimerStatus = 1;
  574.     #else /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* }{ */
  575.     #if defined (__MMI_CLAMSHELL__) && !defined(__MMI_SLIDE__)
  576.         if (gMMIClamState == 1) /* clam is opened */
  577.         {
  578.             StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  579.             gBackLightTimerStatus = 1;
  580.         }
  581.         else    /* clam is closed */
  582.         {
  583.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_CLOSE_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  584.             gBackLightTimerStatus = 1;
  585.         }
  586.     #else /* defined (__MMI_CLAMSHELL__) && !defined(__MMI_SLIDE__) */ 
  587.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  588.         gBackLightTimerStatus = 1;
  589.     #endif /* defined (__MMI_CLAMSHELL__) && !defined(__MMI_SLIDE__) */ 
  590.     #endif /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* } */
  591.     }
  592. #else /* MMI_ON_HARDWARE_P */ /* For PC Simulator only */                                                  /* }{ */
  594.     if (gbacklight_mode == 1)
  595.     {
  596.         if (sublcd_backlight == 0)
  597.         {
  598.             simulate_sublcd_bklight_turn_on();
  599.             sublcd_backlight = 1;
  600.         }
  602.         if (lcd_backlight == 0)
  603.         {
  604.             simulate_lcd_bklight_turn_on();
  605.             lcd_backlight = 2;
  606.         }
  607.         else if (lcd_backlight == 1)
  608.         {
  609.             simulate_lcd_bklight_turn_on();
  610.             lcd_backlight = 2;
  611.         }
  612.     }
  614.     if (time_enum == GPIO_BACKLIGHT_PERMANENT)
  615.     {
  616.         StopTimer(BACKLIGHT_TIMER);
  617.         gBackLightTimerStatus = 0;
  618.     }
  619.     else
  620.     {
  621.         if (gBackLightTimerStatus != 0) /* start a timer */
  622.         {
  623.             StopTimer(BACKLIGHT_TIMER);
  624.             StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  625.             gBackLightTimerStatus = 1;
  626.         }
  627.     }
  628. #endif /* MMI_ON_HARDWARE_P */ /* } */
  629. }
  632. /*****************************************************************************
  633.  * FUNCTION
  634.  *  CloseBacklight
  635.  * DESCRIPTION
  636.  *  Immeditae Baclight Close not going thru Half Mode
  637.  *  
  638.  *  PARAMETERS: void
  639.  *  void
  640.  *****************************************************************************/
  641. void CloseBacklight(void)
  642. {
  643. #ifdef MMI_ON_HARDWARE_P
  644.     /*----------------------------------------------------------------*/
  645.     /* Local Variables                                                */
  646.     /*----------------------------------------------------------------*/
  648.     /*----------------------------------------------------------------*/
  649.     /* Code Body                                                      */
  650.     /*----------------------------------------------------------------*/
  651.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "CloseBacklight() lcd_backlight=%d BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  652.     
  653.     /* AT command disables backlight mechanism */
  654.     if (gbacklight_mode == 0)
  655.     {
  656.         return;
  657.     }
  659.     /* stop backlight timer */
  660.     if (gBackLightTimerStatus != 0)
  661.     {
  662.         StopTimer(BACKLIGHT_TIMER);
  663.     }
  665. #ifdef __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__       /* { */
  666.     if (lcd_backlight == 1) /* backlight is half light */
  667.     {
  668.         lcd_backlight = 2;
  669.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  670.     }
  671.     else if (lcd_backlight == 0)    /* backlight is off */
  672.     {
  673.         lcd_backlight = 2;
  674.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  675.         GpioLCDSleepOut();
  677.         update_mainlcd_dt_display();
  678.         update_sublcd_dt_display();
  679.         gdi_layer_blt_previous(0, 0, UI_device_width - 1, UI_device_height - 1);
  681.         GpioWakeUpTimer();
  682.         gIsInSleepMode = 0;
  683.         /* resume screensaver if it is playing before sleep-in, must after lcd sleep out */
  684.         mmi_scrsvr_lcd_sleepout_handler();
  686.         SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  687.     #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  688.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  689.     }
  691. #else /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* }{ */
  692.     /* set lcd backlight to half mode */
  693.     if (lcd_backlight == 2) /* backlight is on */
  694.     {
  695.         lcd_backlight = 1;
  696.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL1);
  697.     }
  698.     else if (lcd_backlight == 0)    /* backlight is off */
  699.     {
  700.         lcd_backlight = 1;
  701.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  702.         GpioLCDSleepOut();
  703.         update_mainlcd_dt_display();
  704.         update_sublcd_dt_display();
  705.         gdi_layer_blt_previous(0, 0, UI_device_width - 1, UI_device_height - 1);
  707.         GpioWakeUpTimer();
  708.         gIsInSleepMode = 0;
  709.         /* resume screensaver if it is playing before sleep-in, must after lcd sleep out */
  710.         mmi_scrsvr_lcd_sleepout_handler();
  712.         SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  713.     #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  714.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  715.     }
  716. #endif /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ /* } */
  718.     /* turn off keypad backlight */
  719.     GpioTurnOffKeypadLight();
  720. #ifdef __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__
  721.     StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  722.     gBackLightTimerStatus = 1;
  723. #else /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ 
  724.     StartTimer(BACKLIGHT_TIMER, LCD_CLAM_CLOSE_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  725.     gBackLightTimerStatus = 2;
  726. #endif /* __MMI_GPIO_3_STAGE_SUB_BACKLIGHT__ */ 
  727. #endif /* MMI_ON_HARDWARE_P */ 
  728. }
  730. #else /* defined(__MMI_SYNC_LCD_GPIO_MODE__) */ 
  733. /*****************************************************************************
  734.  * FUNCTION
  735.  *  mmi_gpio_turn_on_all_light
  736.  * DESCRIPTION
  737.  *  Turn on all light to whole bright
  738.  * PARAMETERS
  739.  *  void
  740.  * RETURNS
  741.  *  void
  742.  *****************************************************************************/
  743. static void mmi_gpio_turn_on_all_light(void)
  744. {
  745. #ifdef MMI_ON_HARDWARE_P
  746.     /*----------------------------------------------------------------*/
  747.     /* Local Variables                                                */
  748.     /*----------------------------------------------------------------*/
  750.     /*----------------------------------------------------------------*/
  751.     /* Code Body                                                      */
  752.     /*----------------------------------------------------------------*/
  753.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "turn_on_all_light() lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  754.     
  755.     GpioLCDSleepOut();
  756.     SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  757.     lcd_backlight = 2;
  759.     SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  760.     sublcd_backlight = 2;
  761. #endif /* MMI_ON_HARDWARE_P */ 
  762. }
  765. /*****************************************************************************
  766.  * FUNCTION
  767.  *  mmi_gpio_turn_off_all_light
  768.  * DESCRIPTION
  769.  *  Turn off all light to whole dark
  770.  * PARAMETERS
  771.  *  void
  772.  * RETURNS
  773.  *  void
  774.  *****************************************************************************/
  775. static void mmi_gpio_turn_off_all_light(void)
  776. {
  777. #ifdef MMI_ON_HARDWARE_P
  778.     /*----------------------------------------------------------------*/
  779.     /* Local Variables                                                */
  780.     /*----------------------------------------------------------------*/
  782.     /*----------------------------------------------------------------*/
  783.     /* Code Body                                                      */
  784.     /*----------------------------------------------------------------*/
  785.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "turn_off_all_light() lcd_backlight=%d", lcd_backlight));    
  786.     
  787.     /* set lcd backlight to half mode */
  788.     if (lcd_backlight != 0) /* backlight is on */
  789.     {
  790.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  791.         lcd_backlight = 0;
  792.     }
  794.     /* turn on sub-lcd baclight */
  795.     if (sublcd_backlight != 0)
  796.     {
  797.         SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL0);
  798.         sublcd_backlight = 0;
  799.     }
  800. #endif /* MMI_ON_HARDWARE_P */ 
  801. }
  804. /*****************************************************************************
  805.  * FUNCTION
  806.  *  TurnOffBacklight
  807.  * DESCRIPTION
  808.  *  Turns Off the backlight
  809.  *  
  810.  *  PARAMETERS: void
  811.  *  void
  812.  *****************************************************************************/
  813. void TurnOffBacklight(void)
  814. {
  815.     /*----------------------------------------------------------------*/
  816.     /* Local Variables                                                */
  817.     /*----------------------------------------------------------------*/
  819.     /*----------------------------------------------------------------*/
  820.     /* Code Body                                                      */
  821.     /*----------------------------------------------------------------*/
  822.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "TurnOffBacklight() lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  823.         
  824.     /* Share the same code for target and PC simulator */
  826.     /* AT command disables backlight mechanism */
  827.     if (gbacklight_mode == 0)
  828.     {
  829.         return;
  830.     }
  832.     if (gBackLightTimerStatus == 0) /* resume backlight mechanism */
  833.     {
  834.         StopTimer(BACKLIGHT_TIMER);
  835.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  836.         gBackLightTimerStatus = 1;
  837.     }
  838. }
  841. /*****************************************************************************
  842.  * FUNCTION
  843.  *  BacklightTimerHdlr
  844.  * DESCRIPTION
  845.  *  Timer handler to switch backlight state
  846.  *  
  847.  *  PARAMETERS: void
  848.  *  void
  849.  *****************************************************************************/
  850. static void BacklightTimerHdlr(void)
  851. {
  852. #ifdef MMI_ON_HARDWARE_P
  853.     /*----------------------------------------------------------------*/
  854.     /* Local Variables                                                */
  855.     /*----------------------------------------------------------------*/
  857.     /*----------------------------------------------------------------*/
  858.     /* Code Body                                                      */
  859.     /*----------------------------------------------------------------*/
  860.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "BacklightTimerHdlr() lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  861.     
  862.     /* AT command disables backlight mechanism */
  863.     if (gbacklight_mode == 0)
  864.     {
  865.         return;
  866.     }
  868.     if (gBackLightTimerStatus == 0) /* resume backlight mechanism */
  869.     {
  870.         gBackLightTimerStatus = 1;
  871.         StopTimer(BACKLIGHT_TIMER);
  872.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  873.     }
  874.     else if (gBackLightTimerStatus == 1)
  875.     {
  876.         if (lcd_backlight == 2) /* full light, switch to half light */
  877.         {
  878.             SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL1);
  879.             lcd_backlight = 1;
  880.         }
  882.         if (sublcd_backlight == 1)
  883.         {
  884.             sublcd_backlight = 0;
  885.             SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL0);
  886.         }
  888.         StopTimer(BACKLIGHT_TIMER);
  890.     #ifdef __MMI_CLAMSHELL__
  891.         if (gMMIClamState == 0)
  892.         {
  893.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_CLOSE_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  894.         }
  895.         else
  896.     #endif /* __MMI_CLAMSHELL__ */ 
  897.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_OPEN_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  898.         gBackLightTimerStatus = 2;
  899.     }
  900.     else    /* gBackLightTimerStatus == 2 */
  901.     {
  902.         if (sublcd_backlight == 1)
  903.         {
  904.             SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL0);
  905.             sublcd_backlight = 0;
  906.         }
  908.         if (lcd_backlight == 1)
  909.         {
  910.             if(/*!backlight_check_call_present()    //KP Jerry disable on 2006-12-21
  911.             &&*/ (g_phb_cntx.processing == FALSE)
  912.             /*&& (mdi_audio_get_state() != MDI_AUDIO_RECORD) && (mdi_audio_get_state() != MDI_AUDIO_RECORD_PAUSED)*/)    //KP Jerry disable on 2006-12-21
  913.             {
  914.             #ifdef __MMI_LCD_PARTIAL_ON__
  915.                 /* We do not enter partial display screen saver before idle screen */
  916.                 if (((mmi_bootup_is_searching_or_idle_reached() == MMI_TRUE) || mmi_bootup_is_sim_removed() == MMI_TRUE)
  917.                     && PhnsetIsScrSvrPartialOn())
  918.                 {
  919.                     /* 1. Turn off backlight if defined(__MMI_GPIO_DISABLE_SLEEP_MODE__), but keep
  920.                        half backlight if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__).
  921.                        (Typically __MMI_GPIO_DISABLE_SLEEP_MODE__ means that LCM can 
  922.                        retain display even when backlight is turned off, and hence we
  923.                        can turn off backlight without making LCM sleep.)
  924.                        
  925.                        2. __MMI_LCMSLEEP_BACK2IDLE__ is currently ignored */
  926.                     if (gBackLightTimerStatus == 2)
  927.                     {
  928.                         EnterPartialOnScreenSaverIfOk();
  929.                     }
  930.                 #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  931.                     SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  932.                     lcd_backlight = 0;
  933.                 #endif /* defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  934.                 }
  935.                 else
  936.             #endif /* __MMI_LCD_PARTIAL_ON__ */ 
  937.                 {
  938.                     SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  939.                 #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  940.                     GpioLCDSleepIn();
  942.                 #ifdef __MMI_LCMSLEEP_BACK2IDLE__
  943.                     LCMSleepGotoIdleScreen();
  944.                 #endif 
  945.                 #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  946.                     lcd_backlight = 0;
  947.                 }
  948.             }
  950.             gBackLightTimerStatus = 3;
  951.         }
  953. if (isTimerSuspend == 0 && g_charbat_context.isChargerConnected == 0 
  954. && !backlight_check_call_present()
  955.     #ifdef __MMI_CLAMSHELL__
  956.             && mmi_msg_need_mem_full_ind() == 0
  957.     #endif 
  958.     #if defined(__MMI_VIDEO_PLAYER__) && defined(__MMI_TVOUT__)
  959.             && mmi_vdoply_is_in_play_and_tvout_enable() == MMI_FALSE
  960.     #endif 
  961.             && g_phb_cntx.processing == FALSE
  962. /*&& mdi_audio_get_state() != MDI_AUDIO_RECORD && mdi_audio_get_state() != MDI_AUDIO_RECORD_PAUSED*/ )    //KP Jerry disable on 2006-12-21
  963.         {
  964.             if (mmi_bootup_get_active_flight_mode() == 0)
  965.             {
  966.                 evshed_suspend_all_events(event_scheduler1_ptr);
  967.             }
  968.             isTimerSuspend = 1;
  969.         }
  970.     }
  971. #else /* MMI_ON_HARDWARE_P */ /* For PC Simulator only */
  973.     if (gbacklight_mode == 1)
  974.     {
  975.         if (gBackLightTimerStatus == 0)
  976.         {
  977.             StopTimer(BACKLIGHT_TIMER);
  978.             StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  979.             gBackLightTimerStatus = 1;
  980.         }
  981.         else if (gBackLightTimerStatus == 1)
  982.         {
  983.             if (lcd_backlight == 2)
  984.             {
  985.                 simulate_lcd_bklight_turn_off();
  986.                 lcd_backlight = 1;
  987.             }
  988.             if (sublcd_backlight == 1)
  989.             {
  990.                 simulate_sublcd_bklight_turn_off();
  991.                 sublcd_backlight = 0;
  992.             }
  993.             StopTimer(BACKLIGHT_TIMER);
  994.             StartTimer(BACKLIGHT_TIMER, LCD_CLAM_OPEN_HALFLITE_TO_OFF_TIME, BacklightTimerHdlr);
  995.             gBackLightTimerStatus = 2;
  996.         }
  997.         else    /* gBackLightTimerStatus == 2 */
  998.         {
  999.             if (sublcd_backlight == 1)
  1000.             {
  1001.                 simulate_sublcd_bklight_turn_off();
  1002.                 sublcd_backlight = 0;
  1003.             }
  1004.             if (lcd_backlight == 1)
  1005.             {
  1006.                 simulate_lcd_bklight_turn_off();
  1007.             }
  1009.             gBackLightTimerStatus = 3;
  1010.         }
  1011.     }
  1012. #endif /* MMI_ON_HARDWARE_P */ 
  1013. }
  1016. /*****************************************************************************
  1017.  * FUNCTION
  1018.  *  TurnOnBacklight
  1019.  * DESCRIPTION
  1020.  *  Turns On the backlight
  1021.  * PARAMETERS
  1022.  *  time_enum       [IN]        Time duration type
  1023.  *****************************************************************************/
  1024. void TurnOnBacklight(gpio_backlight_time_enum time_enum)
  1025. {
  1026. #ifdef MMI_ON_HARDWARE_P
  1027.     /*----------------------------------------------------------------*/
  1028.     /* Local Variables                                                */
  1029.     /*----------------------------------------------------------------*/
  1031.     /*----------------------------------------------------------------*/
  1032.     /* Code Body                                                      */
  1033.     /*----------------------------------------------------------------*/
  1034.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "TurnOnBacklight() time_enum=%d, BLTimerStat=%d", time_enum, gBackLightTimerStatus));    
  1035.     
  1036.     /* AT command disables backlight mechanism */
  1037.     if (gbacklight_mode == 0)
  1038.     {
  1039.         return;
  1040.     }
  1042. #ifdef MMI_BK_LIGHT_DELAY_TIME
  1043.     StopMyTimer(GPIO_BACKLIGHT_DELAY_TIMER);
  1044. #endif 
  1045.     /* resume timer if suspended */
  1046.     if (isTimerSuspend == 1)
  1047.     {
  1048.         if (mmi_bootup_get_active_flight_mode() == 0)
  1049.         {
  1050.             evshed_resume_all_events(event_scheduler1_ptr);
  1051.         }
  1052.         isTimerSuspend = 0;
  1053.     }
  1055. #ifdef LCM_MMI_TYPE_QUERY
  1056. #ifdef __MMI_LCD_PARTIAL_ON__
  1057.     /* If LCD is transmissive, there is meanless for partial display.
  1058.        But if LCD is reflective or transflective, user can see the display when backlight is off.
  1059.        In this case, when turn on backlight, handset should leave Screen saver */
  1060.    if (get_lcm_type)
  1061.    {
  1062.        if (get_lcm_type() == LCM_TRANSFLECTIVE_TYPE)
  1063.         {
  1064.             LeavePartialOnScreenSaverIfOk();
  1065.         }
  1066.     }
  1068. #endif    
  1069. #endif /* #ifdef LCM_MMI_TYPE_QUERY */
  1071.     /* turn on sub-lcd backlight if currently off */
  1072.     if (sublcd_backlight == 0)
  1073.     {
  1074.         SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  1075.         sublcd_backlight = 1;
  1076.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) && defined(__MMI_SUBLCD__)
  1077.         {
  1078.             S32 lcd_width;
  1079.             S32 lcd_height;
  1081.             gdi_lcd_set_active(GDI_LCD_SUB_LCD_HANDLE);
  1082.             gdi_lcd_get_dimension(&lcd_width, &lcd_height);
  1083.             UI_BLT_double_buffer(0, 0, lcd_width - 1, lcd_height - 1);
  1084.             gdi_lcd_set_active(GDI_LCD_MAIN_LCD_HANDLE);
  1086.         }
  1087.     #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) && defined(__MMI_SUBLCD__) */ 
  1088.     }
  1090.     if (lcd_backlight == 0 && gMMIClamState == 1)   /* sleep mode and clam open */
  1091.     {
  1092.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  1094.         GpioLCDSleepOut();
  1095.         update_mainlcd_dt_display();
  1096.         update_sublcd_dt_display();
  1097.         UI_BLT_double_buffer(0, 0, UI_device_width - 1, UI_device_height - 1);
  1099.         /* resume screensaver if it is playing before sleep-in */
  1100.         mmi_scrsvr_lcd_sleepout_handler();
  1102.         /* tvout sleepout */
  1103.     #ifdef __MMI_TVOUT__
  1104.         mmi_phnset_tvout_lcd_sleepout_handler();
  1105.     #endif 
  1107.     #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  1109.     #ifdef MMI_BK_LIGHT_DELAY_TIME
  1110.         StartTimer(GPIO_BACKLIGHT_DELAY_TIMER, MMI_BK_LIGHT_DELAY_TIME, mmi_gpio_set_main_lcd_level_5);
  1111.     #else 
  1112.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  1113.     #endif 
  1115.         lcd_backlight = 2;
  1116.     }
  1117.     else if (lcd_backlight == 1 && gMMIClamState == 1)  /* backlight off and clam open */
  1118.     {
  1119.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  1120.         lcd_backlight = 2;
  1121.     }
  1122.     else if (lcd_backlight == 2 && gMMIClamState == 1)  /* backlight off and clam open */
  1123.     {
  1124.      SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL5);
  1125.     }
  1127.     /* turn on keypad backlight if currently off and clam open */
  1128.     GpioTurnOnKeypadLight();
  1130.     /* start/stop timer according to input parameter */
  1131.     if (time_enum == GPIO_BACKLIGHT_PERMANENT)
  1132.     {
  1133.         StopTimer(BACKLIGHT_TIMER);
  1134.         gBackLightTimerStatus = 0;
  1135.     }
  1136.     else if (gBackLightTimerStatus != 0)    /* start a timer */
  1137.     {
  1138.         StopTimer(BACKLIGHT_TIMER);
  1139.         StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  1140.         gBackLightTimerStatus = 1;
  1141.     }
  1142. #else /* MMI_ON_HARDWARE_P */ /* For PC Simulator only */
  1143.     if (gbacklight_mode == 1)
  1144.     {
  1145.         if (sublcd_backlight == 0)
  1146.         {
  1147.             simulate_sublcd_bklight_turn_on();
  1148.             sublcd_backlight = 1;
  1149.         }
  1151.         if (lcd_backlight == 0)
  1152.         {
  1153.             simulate_lcd_bklight_turn_on();
  1154.             lcd_backlight = 2;
  1155.         }
  1156.         else if (lcd_backlight == 1)
  1157.         {
  1158.             simulate_lcd_bklight_turn_on();
  1159.             lcd_backlight = 2;
  1160.         }
  1161.     }
  1162.     if (time_enum == GPIO_BACKLIGHT_PERMANENT)
  1163.     {
  1164.         StopTimer(BACKLIGHT_TIMER);
  1165.         gBackLightTimerStatus = 0;
  1166.     }
  1167.     else
  1168.     {
  1169.         if (gBackLightTimerStatus != 0)
  1170.         {
  1171.             StopTimer(BACKLIGHT_TIMER);
  1172.             StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  1173.             gBackLightTimerStatus = 1;
  1174.         }
  1175.     }
  1176. #endif /* MMI_ON_HARDWARE_P */ 
  1177. }
  1180. /*****************************************************************************
  1181.  * FUNCTION
  1182.  *  CloseBacklight
  1183.  * DESCRIPTION
  1184.  *  Immeditae Baclight Close not going thru Half Mode
  1185.  *  We do not handle __MMI_LCD_PARTIAL_ON__ because CloseBacklight() is used only in clamshell
  1186.  *  
  1187.  *  PARAMETERS: void
  1188.  *  void
  1189.  *****************************************************************************/
  1190. void CloseBacklight()
  1191. {
  1192. #ifdef MMI_ON_HARDWARE_P
  1193.     /*----------------------------------------------------------------*/
  1194.     /* Local Variables                                                */
  1195.     /*----------------------------------------------------------------*/
  1197.     /*----------------------------------------------------------------*/
  1198.     /* Code Body                                                      */
  1199.     /*----------------------------------------------------------------*/
  1200.     PRINT_INFORMATION_2((MMI_TRACE_G7_MISC, "CloseBacklight() lcd_backlight=%d, BLTimerStat=%d", lcd_backlight, gBackLightTimerStatus));    
  1201.     
  1202.     /* AT command disables backlight mechanism */
  1203.     if (gbacklight_mode == 0)
  1204.     {
  1205.         return;
  1206.     }
  1208.     /* stop backlight timer */
  1209.     if (gBackLightTimerStatus != 0)
  1210.     {
  1211.         StopTimer(BACKLIGHT_TIMER);
  1212.     }
  1214.     /* turn off main-lcd backlight */
  1215.     if (lcd_backlight != 0)
  1216.     {
  1217.         SetGPIOLevelReq(GPIO_DEV_LED_MAINLCD, LED_LIGHT_LEVEL0);
  1218.     #if !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__)
  1219.         GpioLCDSleepIn();
  1221.     #ifdef __MMI_LCMSLEEP_BACK2IDLE__
  1222.         LCMSleepGotoIdleScreen();
  1223.     #endif 
  1224.     #endif /* !defined(__MMI_GPIO_DISABLE_SLEEP_MODE__) */ 
  1225.         lcd_backlight = 0;
  1226.     }
  1228.     /* turn off keypad backlight */
  1229.     GpioTurnOffKeypadLight();
  1231.     /* turn on sub-lcd baclight */
  1232.     if (sublcd_backlight == 0)
  1233.     {
  1234.         GpioWakeUpTimer();
  1235.         gIsInSleepMode = 0;
  1236.         GpioLCDSleepOut();
  1237.         SetGPIOLevelReq(GPIO_DEV_LED_SUBLCD, LED_LIGHT_LEVEL5);
  1238.         sublcd_backlight = 1;
  1239.     }
  1241.     StartTimer(BACKLIGHT_TIMER, g_phnset_gpio_cntx_p->bl_setting_hftime * 1000, BacklightTimerHdlr);
  1242.     gBackLightTimerStatus = 2;
  1243. #endif /* MMI_ON_HARDWARE_P */ 
  1244. }
  1245. #endif /* defined(__MMI_SYNC_LCD_GPIO_MODE__) */ 
  1248. /*****************************************************************************
  1249.  * FUNCTION
  1250.  *  mmi_gpio_backlight_ctrl_req_hdlr
  1251.  * DESCRIPTION
  1252.  *  Handler of MSG_ID_MMIAPI_BACKLIGHT_CONTROL_REQ
  1253.  * PARAMETERS
  1254.  *  msg     [IN]        Requested data
  1255.  * RETURNS
  1256.  *  void
  1257.  *****************************************************************************/
  1258. void mmi_gpio_backlight_ctrl_req_hdlr(void *msg)
  1259. {
  1260. #ifdef MMI_ON_HARDWARE_P
  1261.     /*----------------------------------------------------------------*/
  1262.     /* Local Variables                                                */
  1263.     /*----------------------------------------------------------------*/
  1264.     mmiapi_backlight_control_req_struct *req = (mmiapi_backlight_control_req_struct*) msg;
  1265.     mmiapi_backlight_control_rsp_struct *rsp =
  1266.         (mmiapi_backlight_control_rsp_struct*) OslConstructDataPtr(sizeof(mmiapi_backlight_control_rsp_struct));
  1268.     MYQUEUE Message;
  1270.     /*----------------------------------------------------------------*/
  1271.     /* Code Body                                                      */
  1272.     /*----------------------------------------------------------------*/
  1273.     StopTimer(BACKLIGHT_TIMER);
  1275.     if (req->on_off)
  1276.     {
  1277.         if (req->disable_timer)
  1278.         {
  1279.             mmi_gpio_turn_on_all_light();
  1280.         }
  1281.         else
  1282.         {
  1283.             if (gBackLightTimerStatus < 2 || gbacklight_mode == 0)
  1284.             {   /* resume backlight timer and turn on the backlight */
  1285.                 TurnOnBacklight(1);
  1286.             }
  1287.             else
  1288.             {
  1289.                 gBackLightTimerStatus = 0;
  1290.                 TurnOffBacklight();
  1291.             }
  1292.         }
  1293.     }
  1294.     else
  1295.     {
  1296.         mmi_gpio_turn_off_all_light();
  1297.     }
  1299.     if (gBackLightTimerStatus == 0) /* timer disabled */
  1300.     {
  1301.         rsp->disable_timer = TRUE;
  1302.     }
  1303.     else
  1304.     {
  1305.         rsp->disable_timer = FALSE;
  1306.     }
  1308.     rsp->on_off = req->on_off;
  1310.     Message.oslSrcId = MOD_MMI;
  1311.     Message.oslDestId = MOD_MED;
  1312.     Message.oslMsgId = MSG_ID_MMIAPI_BACKLIGHT_CONTROL_RSP;
  1313.     Message.oslDataPtr = (oslParaType*) rsp;
  1314.     Message.oslPeerBuffPtr = NULL;
  1316.     OslMsgSendExtQueue(&Message);
  1317. #endif /* MMI_ON_HARDWARE_P */ 
  1318. }
  1321. /*****************************************************************************
  1322.  * FUNCTION
  1323.  *  mmi_gpio_led_ctrl_req_hdlr
  1324.  * DESCRIPTION
  1325.  *  Handler of MSG_ID_MMIAPI_LED_CONTROL_REQ
  1326.  * PARAMETERS
  1327.  *  msg     [IN]        Requested data
  1328.  * RETURNS
  1329.  *  void
  1330.  *****************************************************************************/
  1331. void mmi_gpio_led_ctrl_req_hdlr(void *msg)
  1332. {
  1333. #ifdef MMI_ON_HARDWARE_P
  1334.     /*----------------------------------------------------------------*/
  1335.     /* Local Variables                                                */
  1336.     /*----------------------------------------------------------------*/
  1337.     mmiapi_led_control_req_struct *req = (mmiapi_led_control_req_struct*) msg;
  1338.     mmiapi_led_control_rsp_struct *rsp =
  1339.         (mmiapi_led_control_rsp_struct*) OslConstructDataPtr(sizeof(mmiapi_led_control_rsp_struct));
  1341.     MYQUEUE Message;
  1343.     /*----------------------------------------------------------------*/
  1344.     /* Code Body                                                      */
  1345.     /*----------------------------------------------------------------*/
  1346.     if (req->on_off)
  1347.     {
  1348.         /* disable led background play pattern */
  1349.         gpioOutOfCtrl = 1;
  1350.         StopLEDPatternBackGround();
  1352.         /* turn on led */
  1353.         SetBackLightStatusRedOn();
  1354.         SetBackLightStatusGreenOn();
  1355.         SetBackLightStatusBlueOn();
  1356.     }
  1357.     else
  1358.     {
  1359.         /* turn off led */
  1360.         SetBackLightStatusRedOff();
  1361.         SetBackLightStatusGreenOff();
  1362.         SetBackLightStatusBlueOff();
  1364.         /* enable led background play pattern */
  1365.         gpioOutOfCtrl = 0;
  1366.         StartLEDPatternBackGround();
  1367.     }
  1369.     rsp->on_off = req->on_off;
  1371.     Message.oslSrcId = MOD_MMI;
  1372.     Message.oslDestId = MOD_MED;
  1373.     Message.oslMsgId = MSG_ID_MMIAPI_LED_CONTROL_RSP;
  1374.     Message.oslDataPtr = (oslParaType*) rsp;
  1375.     Message.oslPeerBuffPtr = NULL;
  1377.     OslMsgSendExtQueue(&Message);
  1378. #endif /* MMI_ON_HARDWARE_P */ 
  1379. }
  1382. /*****************************************************************************
  1383.  * FUNCTION
  1384.  *  InitHWBacklightTest
  1385.  * DESCRIPTION
  1386.  *  Initialisation function for Back Light Test
  1387.  *  
  1388.  *  PARAMETERS: void
  1389.  *  void
  1390.  *****************************************************************************/
  1391. void InitHWBacklightTest(void)
  1392. {
  1393.     /*----------------------------------------------------------------*/
  1394.     /* Local Variables                                                */
  1395.     /*----------------------------------------------------------------*/
  1397.     /*----------------------------------------------------------------*/
  1398.     /* Code Body                                                      */
  1399.     /*----------------------------------------------------------------*/
  1400. #ifdef MMI_ON_HARDWARE_P
  1401.     SetProtocolEventHandler(SetBacklightMode, MSG_ID_MMI_EQ_SET_SLEEP_MODE_REQ_IND);
  1402. #endif 
  1403. }
  1406. /*****************************************************************************
  1407.  * FUNCTION
  1408.  *  SetBacklightModeExe
  1409.  * DESCRIPTION
  1410.  *  Sets BackLight Mode
  1411.  *  
  1412.  *  PARAMETERS: void
  1413.  *  mode        [IN]        
  1414.  *****************************************************************************/
  1415. void SetBacklightModeExe(U8 mode)
  1416. {
  1417. #ifdef MMI_ON_HARDWARE_P
  1418.     /*----------------------------------------------------------------*/
  1419.     /* Local Variables                                                */
  1420.     /*----------------------------------------------------------------*/
  1422.     /*----------------------------------------------------------------*/
  1423.     /* Code Body                                                      */
  1424.     /*----------------------------------------------------------------*/
  1425.     if (mode == 1)  /* enable backlight mechanism. */
  1426.     {
  1427.         gbacklight_mode = mode;
  1428.         TurnOffBacklight();
  1429.     }
  1430.     else    /* disable backlight mechanism. */
  1431.     {
  1432.         gbacklight_mode = 1;
  1433.         TurnOnBacklight(0);
  1434.         gbacklight_mode = mode;
  1435.     }
  1436. #endif /* MMI_ON_HARDWARE_P */ 
  1437. }
  1440. /*****************************************************************************
  1441.  * FUNCTION
  1442.  *  SetBacklightMode
  1443.  * DESCRIPTION
  1444.  *  Protocol Handler for MSG_ID_MMI_EQ_SET_SLEEP_MODE_REQ_IND
  1445.  *  
  1446.  *  PARAMETERS: info: Data from L4
  1447.  *  info        [IN]        
  1448.  *****************************************************************************/
  1449. void SetBacklightMode(void *info)
  1450. {
  1451. #ifdef MMI_ON_HARDWARE_P
  1452.     /*----------------------------------------------------------------*/
  1453.     /* Local Variables                                                */
  1454.     /*----------------------------------------------------------------*/
  1455.     mmi_eq_set_sleep_mode_req_ind_struct *msg = (mmi_eq_set_sleep_mode_req_ind_struct*) info;
  1457.     /*----------------------------------------------------------------*/
  1458.     /* Code Body                                                      */
  1459.     /*----------------------------------------------------------------*/
  1460.     SetBacklightModeExe((U8) msg->on_off);
  1461. #endif /* MMI_ON_HARDWARE_P */ 
  1463. }
  1465. /*
  1466.  * Audio volume path                                
  1467.  */
  1470. /*****************************************************************************
  1471.  * FUNCTION
  1472.  *  EnableHandsFree
  1473.  * DESCRIPTION
  1474.  *  Enables Hands Free Mode
  1475.  *  
  1476.  *  PARAMETERS: mode
  1477.  *  void
  1478.  *****************************************************************************/
  1479. void EnableHandsFree(void)
  1480. {
  1481.     /*----------------------------------------------------------------*/
  1482.     /* Local Variables                                                */
  1483.     /*----------------------------------------------------------------*/
  1485.     /*----------------------------------------------------------------*/
  1486.     /* Code Body                                                      */
  1487.     /*----------------------------------------------------------------*/
  1488.     mdi_audio_set_audio_mode(AUD_MODE_LOUDSPK);
  1489.     SetModeSpeechVolume();
  1490. }
  1493. /*****************************************************************************
  1494.  * FUNCTION
  1495.  *  DisbleHandsFree
  1496.  * DESCRIPTION
  1497.  *  Disables Hands Free Mode
  1498.  *  
  1499.  *  PARAMETERS: mode
  1500.  *  void
  1501.  *****************************************************************************/
  1502. void DisbleHandsFree(void)
  1503. {
  1504.     /*----------------------------------------------------------------*/
  1505.     /* Local Variables                                                */
  1506.     /*----------------------------------------------------------------*/
  1508.     /*----------------------------------------------------------------*/
  1509.     /* Code Body                                                      */
  1510.     /*----------------------------------------------------------------*/
  1511.     if (isEarphonePlugged)
  1512.     {
  1513.     #ifdef __CTM_SUPPORT__
  1514.         if (mmi_ctm_is_tty_on() == MMI_FALSE)
  1515.     #endif 
  1516.         {
  1517.             mdi_audio_set_audio_mode(AUD_MODE_HEADSET);
  1518.             SetModeSpeechVolume();
  1519.             return;
  1520.         }
  1521.     }
  1522.     mdi_audio_set_audio_mode(AUD_MODE_NORMAL);
  1523.     SetModeSpeechVolume();
  1524. }
  1527. /*****************************************************************************
  1528.  * FUNCTION
  1529.  *  SaveSpeechVolume
  1530.  * DESCRIPTION
  1531.  *  Saves Speech Volume
  1532.  *  
  1533.  *  PARAMETERS:
  1534.  *  level       [IN]        
  1535.  *****************************************************************************/
  1536. void SaveSpeechVolume(U8 level)
  1537. {
  1538.     /*----------------------------------------------------------------*/
  1539.     /* Local Variables                                                */
  1540.     /*----------------------------------------------------------------*/
  1541.     S16 error;
  1542.     U8 audio_mode = mdi_audio_get_audio_mode();
  1544.     /*----------------------------------------------------------------*/
  1545.     /* Code Body                                                      */
  1546.     /*----------------------------------------------------------------*/
  1547.     switch (audio_mode)
  1548.     {
  1549.         case AUD_MODE_NORMAL:
  1550.             WriteValue(NVRAM_NORMAL_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1551.             break;
  1552.         case AUD_MODE_HEADSET:
  1553.             WriteValue(NVRAM_HDSET_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1554.             break;
  1555.         case AUD_MODE_LOUDSPK:
  1556.             WriteValue(NVRAM_LDSPK_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1557.             break;
  1558.     }
  1559.     SetSpeechVolume(level);
  1560. }
  1563. /*****************************************************************************
  1564.  * FUNCTION
  1565.  *  SetModeSpeechVolume
  1566.  * DESCRIPTION
  1567.  *  Sets Speech Volume as per the mode
  1568.  *  
  1569.  *  PARAMETERS: void
  1570.  *  void
  1571.  *****************************************************************************/
  1572. void SetModeSpeechVolume(void)
  1573. {
  1574.     /*----------------------------------------------------------------*/
  1575.     /* Local Variables                                                */
  1576.     /*----------------------------------------------------------------*/
  1577.     U8 audio_mode = mdi_audio_get_audio_mode();
  1578.     U8 level;
  1579.     S16 error;
  1581.     /*----------------------------------------------------------------*/
  1582.     /* Code Body                                                      */
  1583.     /*----------------------------------------------------------------*/
  1584.     switch (audio_mode)
  1585.     {
  1586.         case AUD_MODE_NORMAL:
  1587.             ReadValue(NVRAM_NORMAL_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1588.             break;
  1589.         case AUD_MODE_HEADSET:
  1590.             ReadValue(NVRAM_HDSET_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1591.             break;
  1592.         case AUD_MODE_LOUDSPK:
  1593.             ReadValue(NVRAM_LDSPK_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1594.             break;
  1595.     }
  1596.     if (level == 0xFF)
  1597.     {
  1598.         level = LEVEL4;
  1599.         WriteValue(NVRAM_HDSET_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1600.         WriteValue(NVRAM_LDSPK_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1601.         WriteValue(NVRAM_NORMAL_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1602.     }
  1603.     SetSpeechVolume(level);
  1604. }
  1607. /*****************************************************************************
  1608.  * FUNCTION
  1609.  *  GetModeSpeechVolume
  1610.  * DESCRIPTION
  1611.  *  Gets Speech Volume as per the mode
  1612.  *  
  1613.  *  PARAMETERS: void
  1614.  *  void
  1615.  *****************************************************************************/
  1616. U8 GetModeSpeechVolume(void)
  1617. {
  1618.     /*----------------------------------------------------------------*/
  1619.     /* Local Variables                                                */
  1620.     /*----------------------------------------------------------------*/
  1621.     U8 audio_mode = mdi_audio_get_audio_mode();
  1622.     U8 level;
  1623.     S16 error;
  1625.     /*----------------------------------------------------------------*/
  1626.     /* Code Body                                                      */
  1627.     /*----------------------------------------------------------------*/
  1628.     switch (audio_mode)
  1629.     {
  1630.         case AUD_MODE_NORMAL:
  1631.             ReadValue(NVRAM_NORMAL_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1632.             break;
  1633.         case AUD_MODE_HEADSET:
  1634.             ReadValue(NVRAM_HDSET_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1635.             break;
  1636.         case AUD_MODE_LOUDSPK:
  1637.             ReadValue(NVRAM_LDSPK_MODE_VOICE_LEVEL, &level, DS_BYTE, &error);
  1638.             break;
  1639.     }
  1640.     if (level == 0xFF)
  1641.     {
  1642.         level = LEVEL4;
  1643.     }
  1644.     return level;
  1645. }
  1647. /*
  1648.  * Device control interface for other modules
  1649.  */
  1652. /*****************************************************************************
  1653.  * FUNCTION
  1654.  *  GpioCtrlReq
  1655.  * DESCRIPTION
  1656.  *  Api for other modules get gpio control
  1657.  *  
  1658.  *  PARAMETERS: action: MMIAPI_DEV_CTRL_GET / MMIAPI_DEV_CTRL_RELEASE
  1659.  *  action      [IN]        
  1660.  *****************************************************************************/
  1661. kal_uint8 GpioCtrlReq(kal_uint8 action)
  1662. {
  1663.     /*----------------------------------------------------------------*/
  1664.     /* Local Variables                                                */
  1665.     /*----------------------------------------------------------------*/
  1666.     U8 result = MMI_TRUE;
  1668.     /*----------------------------------------------------------------*/
  1669.     /* Code Body                                                      */
  1670.     /*----------------------------------------------------------------*/
  1671.     if (action == MMIAPI_DEV_CTRL_GET)
  1672.     {
  1673.         if (gpioOutOfCtrl == 1)
  1674.         {
  1675.             result = MMI_FALSE;
  1676.         }
  1677.         else
  1678.         {
  1679.             gpioOutOfCtrl = 1;
  1680.             StopLEDPatternBackGround();
  1681.         }
  1682.     }
  1683.     else if (action == MMIAPI_DEV_CTRL_RELEASE)
  1684.     {
  1685.         if (gpioOutOfCtrl == 0)
  1686.         {
  1687.             result = MMI_FALSE;
  1688.         }
  1689.         else
  1690.         {
  1691.             gpioOutOfCtrl = 0;
  1692.             StartLEDPatternBackGround();
  1693.             GpioTurnOffKeypadLight();
  1694.             TurnOnBacklight(1);
  1695.         }
  1696.     }
  1697.     else
  1698.     {
  1699.         result = MMI_FALSE;
  1700.     }
  1702.     return result;
  1703. }
  1706. /*****************************************************************************
  1707.  * FUNCTION
  1708.  *  GpioCtrlReqHdlr
  1709.  * DESCRIPTION
  1710.  *  Other module get device control through MMI
  1711.  *  
  1712.  *  PARAMETERS: mmiapi_device_get_ctrl_req_struct *
  1713.  *  inMsg       [IN]        
  1714.  *****************************************************************************/
  1715. void GpioCtrlReqHdlr(void *inMsg)
  1716. {
  1717. #ifdef MMI_ON_HARDWARE_P
  1718.     /*----------------------------------------------------------------*/
  1719.     /* Local Variables                                                */
  1720.     /*----------------------------------------------------------------*/
  1721.     mmiapi_device_get_ctrl_req_struct *p = (mmiapi_device_get_ctrl_req_struct*) inMsg;
  1722.     mmiapi_device_get_ctrl_rsp_struct *p_out;
  1724.     /*----------------------------------------------------------------*/
  1725.     /* Code Body                                                      */
  1726.     /*----------------------------------------------------------------*/
  1727.     p_out = OslConstructDataPtr(sizeof(mmiapi_device_get_ctrl_rsp_struct));
  1728.     p_out->result = GpioCtrlReq(p->action);
  1730.     GpioSendMsg(p->src_mod_id, MSG_ID_MMIAPI_DEVICE_GET_CTRL_RSP, (void*)p_out, (void*)NULL);
  1731. #endif /* MMI_ON_HARDWARE_P */ 
  1732. }
  1735. /*****************************************************************************
  1736.  * FUNCTION
  1737.  *  GpioPlayReq
  1738.  * DESCRIPTION
  1739.  *  Other module control gpio device
  1740.  *  
  1741.  *  PARAMETERS: p_type, p_level
  1742.  *  p_type      [IN]        
  1743.  *  p_level     [IN]        
  1744.  *****************************************************************************/
  1745. kal_uint8 GpioPlayReq(kal_uint8 p_type, kal_uint8 p_level)
  1746. {
  1747.     /*----------------------------------------------------------------*/
  1748.     /* Local Variables                                                */
  1749.     /*----------------------------------------------------------------*/
  1750.     U8 result = MMI_TRUE;
  1751.     U8 device = 0, level = 0;
  1753.     /*----------------------------------------------------------------*/
  1754.     /* Code Body                                                      */
  1755.     /*----------------------------------------------------------------*/
  1756.     switch (p_type)
  1757.     {
  1758.         case MMIAPI_DEV_TYPE_MAINLCD_BL:
  1759.             device = GPIO_DEV_LED_MAINLCD;
  1760.             break;
  1761.         case MMIAPI_DEV_TYPE_SUBLCD_BL:
  1762.             device = GPIO_DEV_LED_SUBLCD;
  1763.             break;
  1764.         case MMIAPI_DEV_TYPE_KEYPAD_BL:
  1765.             device = GPIO_DEV_LED_KEY;
  1766.             break;
  1767.         case MMIAPI_DEV_TYPE_LED_1:
  1768.             device = GPIO_DEV_LED_STATUS_1;
  1769.             break;
  1770.         case MMIAPI_DEV_TYPE_LED_2:
  1771.             device = GPIO_DEV_LED_STATUS_2;
  1772.             break;
  1773.         case MMIAPI_DEV_TYPE_LED_3:
  1774.             device = GPIO_DEV_LED_STATUS_3;
  1775.             break;
  1776.         case MMIAPI_DEV_TYPE_VIBRATOR:
  1777.             device = GPIO_DEV_VIBRATOR;
  1778.             break;
  1779.         default:
  1780.             result = MMI_FALSE;
  1781.             break;
  1782.     }
  1784.     switch (p_level)
  1785.     {
  1786.         case MMIAPI_DEV_LEVEL_0:
  1787.             level = LED_LIGHT_LEVEL0;
  1788.             break;
  1789.         case MMIAPI_DEV_LEVEL_1:
  1790.             level = LED_LIGHT_LEVEL1;
  1791.             break;
  1792.         case MMIAPI_DEV_LEVEL_2:
  1793.             level = LED_LIGHT_LEVEL2;
  1794.             break;
  1795.         case MMIAPI_DEV_LEVEL_3:
  1796.             level = LED_LIGHT_LEVEL3;
  1797.             break;
  1798.         case MMIAPI_DEV_LEVEL_4:
  1799.             level = LED_LIGHT_LEVEL4;
  1800.             break;
  1801.         case MMIAPI_DEV_LEVEL_5:
  1802.             level = LED_LIGHT_LEVEL5;
  1803.             break;
  1804.         default:
  1805.             result = MMI_FALSE;
  1806.             break;
  1807.     }
  1808.     SetGPIOLevelReq(device, level);
  1810.     return result;
  1811. }
  1814. /*****************************************************************************
  1815.  * FUNCTION
  1816.  *  GpioPlayReqHdlr
  1817.  * DESCRIPTION
  1818.  *  Other module play device function through MMI
  1819.  *  
  1820.  *  PARAMETERS: mmiapi_device_play_req_struct *
  1821.  *  inMsg       [IN]        
  1822.  *****************************************************************************/
  1823. void GpioPlayReqHdlr(void *inMsg)
  1824. {
  1825. #ifdef MMI_ON_HARDWARE_P
  1826.     /*----------------------------------------------------------------*/
  1827.     /* Local Variables                                                */
  1828.     /*----------------------------------------------------------------*/
  1829.     mmiapi_device_play_req_struct *p = (mmiapi_device_play_req_struct*) inMsg;
  1830.     mmiapi_device_play_rsp_struct *p_out;
  1832.     /*----------------------------------------------------------------*/
  1833.     /* Code Body                                                      */
  1834.     /*----------------------------------------------------------------*/
  1835.     p_out = OslConstructDataPtr(sizeof(mmiapi_device_play_rsp_struct));
  1836.     p_out->result = GpioPlayReq(p->type, p->level);
  1837.     GpioSendMsg(p->src_mod_id, MSG_ID_MMIAPI_DEVICE_PLAY_RSP, (void*)p_out, (void*)NULL);
  1838. #endif /* MMI_ON_HARDWARE_P */ 
  1839. }
  1841. /*******************************************************/
  1842. /*                                                     */
  1843. /*    Send Message to Lower layer                      */
  1844. /*                                                     */
  1845. /*******************************************************/
  1848. /*****************************************************************************
  1849.  * FUNCTION
  1850.  *  SendPlayPatternReqToHW
  1851.  * DESCRIPTION
  1852.  *  Send pattern request to H/W
  1853.  *  
  1854.  *  PARAMETERS: pattern: pattern to be played
  1855.  *  pattern     [IN]        
  1856.  *  action      [IN]        ON/OFF
  1857.  *****************************************************************************/
  1858. void SendPlayPatternReqToHW(U8 pattern, U8 action)
  1859. {
  1860.     /*----------------------------------------------------------------*/
  1861.     /* Local Variables                                                */
  1862.     /*----------------------------------------------------------------*/
  1863.     MYQUEUE Message;
  1864.     mmi_eq_play_pattern_req_struct *displayLedPattern;
  1866.     /*----------------------------------------------------------------*/
  1867.     /* Code Body                                                      */
  1868.     /*----------------------------------------------------------------*/
  1869.     Message.oslMsgId = MSG_ID_MMI_EQ_PLAY_PATTERN_REQ;
  1870.     displayLedPattern = OslConstructDataPtr(sizeof(mmi_eq_play_pattern_req_struct));
  1871.     displayLedPattern->pattern = pattern;
  1872.     displayLedPattern->action = action;
  1873.     Message.oslDataPtr = (oslParaType*) displayLedPattern;
  1874.     Message.oslPeerBuffPtr = NULL;
  1875.     Message.oslSrcId = MOD_MMI;
  1876.     Message.oslDestId = MOD_L4C;
  1877.     OslMsgSendExtQueue(&Message);
  1878. }
  1881. /*****************************************************************************
  1882.  * FUNCTION
  1883.  *  SetGPIOLevelReq
  1884.  * DESCRIPTION
  1885.  *  Set Levels of Devices like LCD, LEDs
  1886.  *  
  1887.  *  PARAMETERS: device: device
  1888.  *  device      [IN]        
  1889.  *  level       [IN]        Device Level
  1890.  *****************************************************************************/
  1891. void SetGPIOLevelReq(gpio_device_enum device, U8 level)
  1892. {
  1893.     /*----------------------------------------------------------------*/
  1894.     /* Local Variables                                                */
  1895.     /*----------------------------------------------------------------*/
  1896.     MYQUEUE Message;
  1897.     mmi_eq_exe_gpio_level_req_struct *setGPIOLevelReq;
  1899.     /*----------------------------------------------------------------*/
  1900.     /* Code Body                                                      */
  1901.     /*----------------------------------------------------------------*/
  1902. #ifdef __LCD_ESD_RECOVERY__
  1903.     if ((device == GPIO_DEV_LED_MAINLCD) || (device == GPIO_DEV_LED_SUBLCD))
  1904.     {
  1905.         if (level == LED_LIGHT_LEVEL0)
  1906.         {
  1907.             gdi_lcd_stop_esd_recovery_timer();
  1908.         }
  1909.         else
  1910.         {
  1911.             gdi_lcd_start_esd_recovery_timer();
  1912.         }
  1913.     }
  1914. #endif /* __LCD_ESD_RECOVERY__ */ 
  1916.     Message.oslMsgId = MSG_ID_MMI_EQ_EXE_GPIO_LEVEL_REQ;
  1917.     setGPIOLevelReq = OslConstructDataPtr(sizeof(mmi_eq_exe_gpio_level_req_struct));
  1918.     setGPIOLevelReq->gpio_dev_type = device;
  1919.     if ((device == GPIO_DEV_LED_MAINLCD) && (level == LED_LIGHT_LEVEL5))
  1920.     {
  1921.         setGPIOLevelReq->gpio_dev_level = g_phnset_gpio_cntx_p->bl_setting_level;
  1922.     }
  1923.     else
  1924.     {
  1925.         setGPIOLevelReq->gpio_dev_level = level;
  1926.     }
  1927.     Message.oslDataPtr = (oslParaType*) setGPIOLevelReq;
  1928.     Message.oslPeerBuffPtr = NULL;
  1929.     Message.oslSrcId = MOD_MMI;
  1930.     Message.oslDestId = MOD_L4C;
  1931.     OslMsgSendExtQueue(&Message);
  1932.     return;
  1933. }
  1936. /*****************************************************************************
  1937.  * FUNCTION
  1938.  *  SetMuteReq
  1939.  * DESCRIPTION
  1940.  *  Mutes the device
  1941.  *  
  1942.  *  PARAMETERS: device: device
  1943.  *  device      [IN]        
  1944.  *  onoff       [IN]        TRUE/FALSE
  1945.  *****************************************************************************/
  1946. void SetMuteReq(audio_type_enum device, MMI_BOOL onoff)
  1947. {
  1948.     /*----------------------------------------------------------------*/
  1949.     /* Local Variables                                                */
  1950.     /*----------------------------------------------------------------*/
  1951.     MYQUEUE Message;
  1952.     mmi_eq_set_mute_req_struct *setMuteReq;
  1954.     /*----------------------------------------------------------------*/
  1955.     /* Code Body                                                      */
  1956.     /*----------------------------------------------------------------*/
  1957.     Message.oslMsgId = MSG_ID_MMI_EQ_SET_MUTE_REQ;
  1958.     setMuteReq = OslConstructDataPtr(sizeof(mmi_eq_set_mute_req_struct));
  1959.     setMuteReq->audio_device = device;
  1960.     setMuteReq->mute_onoff = onoff;
  1961.     Message.oslDataPtr = (oslParaType*) setMuteReq;
  1962.     Message.oslPeerBuffPtr = NULL;
  1963.     Message.oslSrcId = MOD_MMI;
  1964.     Message.oslDestId = MOD_L4C;
  1965.     OslMsgSendExtQueue(&Message);
  1966. }
  1969. /*****************************************************************************
  1970.  * FUNCTION
  1971.  *  GpioSendMsg
  1972.  * DESCRIPTION
  1973.  *  Send message to other modules
  1974.  *  
  1975.  *  PARAMETERS: mmiapi_device_play_req_struct *
  1976.  *  src_mod_id          [IN]        
  1977.  *  msg_id              [IN]        
  1978.  *  local_param_ptr     [IN]        
  1979.  *  peer_buf_ptr        [IN]        
  1980.  *****************************************************************************/
  1981. void GpioSendMsg(U16 src_mod_id, U16 msg_id, void *local_param_ptr, void *peer_buf_ptr)
  1982. {
  1983.     /*----------------------------------------------------------------*/
  1984.     /* Local Variables                                                */
  1985.     /*----------------------------------------------------------------*/
  1987. #ifdef MMI_ON_HARDWARE_P
  1988.     MYQUEUE Message;
  1990.     /*----------------------------------------------------------------*/
  1991.     /* Code Body                                                      */
  1992.     /*----------------------------------------------------------------*/
  1993.     Message.oslMsgId = (oslMsgType) msg_id;         /* Type casting, to make compiler happer */
  1994.     Message.oslDataPtr = (oslParaType*) local_param_ptr;
  1995.     Message.oslPeerBuffPtr = peer_buf_ptr;
  1996.     Message.oslSrcId = MOD_MMI;
  1997.     Message.oslDestId = (oslModuleType) src_mod_id; /* Type casting, to make compiler happer */
  1998.     OslMsgSendExtQueue(&Message);
  1999. #endif /* MMI_ON_HARDWARE_P */ 
  2000. }
  2003. /*****************************************************************************
  2004.  * FUNCTION
  2005.  *  KeyPadLCDBackLightStop
  2006.  * DESCRIPTION
  2007.  *  KeyPadLCDBackLightStop
  2008.  *  
  2009.  *  PARAMETERS: void
  2010.  *  void
  2011.  *  RETURNS:
  2012.  *  void
  2013.  *****************************************************************************/
  2014. void KeyPadLCDBackLightStop(void)
  2015. {
  2016.     /*----------------------------------------------------------------*/
  2017.     /* Local Variables                                                */
  2018.     /*----------------------------------------------------------------*/
  2020.     /*----------------------------------------------------------------*/
  2021.     /* Code Body                                                      */
  2022.     /*----------------------------------------------------------------*/
  2023.     StopTimer(TIMER_KEYPAD_BACKLIGHT);
  2024.     LCDBackLightOff();
  2025.     KeyPadBackLightOff();
  2026. }
  2029. /*****************************************************************************
  2030.  * FUNCTION
  2031.  *  LCMSleepGotoIdleScreen
  2032.  * DESCRIPTION
  2033.  *  KeyPadLCDBackLightStop
  2034.  *  
  2035.  *  PARAMETERS: void
  2036.  *  void
  2037.  *****************************************************************************/
  2038. #if defined(__MMI_LCMSLEEP_BACK2IDLE__)
  2039. void LCMSleepGotoIdleScreen(void)
  2040. {
  2041.     /*----------------------------------------------------------------*/
  2042.     /* Local Variables                                                */
  2043.     /*----------------------------------------------------------------*/
  2045.     /*----------------------------------------------------------------*/
  2046.     /* Code Body                                                      */
  2047.     /*----------------------------------------------------------------*/
  2048.     if (isEarphonePlugged == 1 && backlight_check_call_present())
  2049.     {
  2050.         return;
  2051.     }
  2053. #if defined(__MMI_FACTORY_MODE__) || defined(__MMI_ENGINEER_MODE__)
  2054.     if (gCurrentMode == FACTORY_MODE || gCurrentMode == ENGINEERING_MODE)
  2055.     {
  2056.         return;
  2057.     }
  2058. #endif /* defined(__MMI_FACTORY_MODE__) || defined(__MMI_ENGINEER_MODE__) */ 
  2060.     PRINT_INFORMATION(("LCMSleepGotoIdleScreen():END Key Press, FP: %x", GetKeyHandler(KEY_END, KEY_EVENT_DOWN)));
  2061.     ExecuteCurrKeyHandler(KEY_END, KEY_EVENT_DOWN);
  2062. }
  2063. #endif /* defined(__MMI_LCMSLEEP_BACK2IDLE__) */ 
  2066. /*****************************************************************************
  2067.  * FUNCTION
  2068.  *  mmi_gpio_is_lcd_sleep
  2069.  * DESCRIPTION
  2070.  *  To tell applications that lcd is sleeping or not
  2071.  * PARAMETERS
  2072.  *  void
  2073.  * RETURNS
  2074.  *  void
  2075.  *****************************************************************************/
  2076. BOOL mmi_gpio_is_lcd_sleep(void)
  2077. {
  2078.     /*----------------------------------------------------------------*/
  2079.     /* Local Variables                                                */
  2080.     /*----------------------------------------------------------------*/
  2082.     /*----------------------------------------------------------------*/
  2083.     /* Code Body                                                      */
  2084.     /*----------------------------------------------------------------*/
  2085.     return gIsInSleepMode;
  2086. }