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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > MTK > 查看源码
rtc.c
资源名称：rtc.rar　[点击查看]
上传用户：duomei918
上传日期：2022-03-01
资源大小：19k
文件大小：112k
源码类别：

MTK

开发平台：

Visual C++

rtc.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.  *    rtc.c
  41.  *
  42.  * Project:
  43.  * --------
  44.  *   Maui_Software
  45.  *
  46.  * Description:
  47.  * ------------
  48.  *   This Module defines the RTC driver.
  49.  *
  50.  * Author:
  51.  * -------
  52.  * -------
  53.  * -------
  54.  *
  55.  *============================================================================
  56.  *             HISTORY
  57.  * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  58.  *------------------------------------------------------------------------------
  59.  * removed!
  60.  * removed!
  61.  * removed!
  62.  *
  63.  * removed!
  64.  * removed!
  65.  * removed!
  66.  *
  67.  * removed!
  68.  * removed!
  69.  * removed!
  70.  *
  71.  * removed!
  72.  * removed!
  73.  * removed!
  74.  *
  75.  * removed!
  76.  * removed!
  77.  * removed!
  78.  *
  79.  * removed!
  80.  * removed!
  81.  * removed!
  82.  *
  83.  * removed!
  84.  * removed!
  85.  * removed!
  86.  *
  87.  * removed!
  88.  * removed!
  89.  * removed!
  90.  *
  91.  * removed!
  92.  * removed!
  93.  * removed!
  94.  *
  95.  * removed!
  96.  * removed!
  97.  * removed!
  98.  *
  99.  * removed!
  100.  * removed!
  101.  * removed!
  102.  *
  103.  * removed!
  104.  * removed!
  105.  * removed!
  106.  *
  107.  * removed!
  108.  * removed!
  109.  * removed!
  110.  *
  111.  * removed!
  112.  * removed!
  113.  * removed!
  114.  *
  115.  * removed!
  116.  * removed!
  117.  * removed!
  118.  *
  119.  * removed!
  120.  * removed!
  121.  * removed!
  122.  *
  123.  * removed!
  124.  * removed!
  125.  * removed!
  126.  *
  127.  * removed!
  128.  * removed!
  129.  * removed!
  130.  *
  131.  * removed!
  132.  * removed!
  133.  * removed!
  134.  *
  135.  * removed!
  136.  * removed!
  137.  * removed!
  138.  *
  139.  * removed!
  140.  * removed!
  141.  * removed!
  142.  *
  143.  * removed!
  144.  * removed!
  145.  * removed!
  146.  *
  147.  * removed!
  148.  * removed!
  149.  * removed!
  150.  *
  151.  * removed!
  152.  * removed!
  153.  * removed!
  154.  *
  155.  * removed!
  156.  * removed!
  157.  * removed!
  158.  *
  159.  * removed!
  160.  * removed!
  161.  * removed!
  162.  *
  163.  * removed!
  164.  * removed!
  165.  * removed!
  166.  *
  167.  * removed!
  168.  * removed!
  169.  * removed!
  170.  *
  171.  * removed!
  172.  * removed!
  173.  * removed!
  174.  *
  175.  * removed!
  176.  * removed!
  177.  * removed!
  178.  *
  179.  * removed!
  180.  * removed!
  181.  * removed!
  182.  *
  183.  * removed!
  184.  * removed!
  185.  * removed!
  186.  *
  187.  * removed!
  188.  * removed!
  189.  * removed!
  190.  *
  191.  * removed!
  192.  * removed!
  193.  * removed!
  194.  *
  195.  * removed!
  196.  * removed!
  197.  * removed!
  198.  *
  199.  * removed!
  200.  * removed!
  201.  * removed!
  202.  *
  203.  * removed!
  204.  * removed!
  205.  * removed!
  206.  *
  207.  * removed!
  208.  * removed!
  209.  * removed!
  210.  *
  211.  * removed!
  212.  * removed!
  213.  * removed!
  214.  *
  215.  * removed!
  216.  * removed!
  217.  * removed!
  218.  *
  219.  * removed!
  220.  * removed!
  221.  * removed!
  222.  *
  223.  * removed!
  224.  * removed!
  225.  * removed!
  226.  *
  227.  * removed!
  228.  * removed!
  229.  * removed!
  230.  *
  231.  * removed!
  232.  * removed!
  233.  * removed!
  234.  *
  235.  * removed!
  236.  * removed!
  237.  * removed!
  238.  *
  239.  * removed!
  240.  * removed!
  241.  * removed!
  242.  *
  243.  * removed!
  244.  * removed!
  245.  * removed!
  246.  *
  247.  * removed!
  248.  * removed!
  249.  * removed!
  250.  *
  251.  * removed!
  252.  * removed!
  253.  * removed!
  254.  *
  255.  * removed!
  256.  * removed!
  257.  * removed!
  258.  *
  259.  * removed!
  260.  * removed!
  261.  * removed!
  262.  *
  263.  * removed!
  264.  * removed!
  265.  * removed!
  266.  *
  267.  * removed!
  268.  * removed!
  269.  * removed!
  270.  *
  271.  * removed!
  272.  * removed!
  273.  * removed!
  274.  *
  275.  * removed!
  276.  * removed!
  277.  * removed!
  278.  *
  279.  * removed!
  280.  * removed!
  281.  * removed!
  282.  *
  283.  * removed!
  284.  * removed!
  285.  * removed!
  286.  *
  287.  * removed!
  288.  * removed!
  289.  * removed!
  290.  *
  291.  * removed!
  292.  * removed!
  293.  * removed!
  294.  *
  295.  * removed!
  296.  * removed!
  297.  * removed!
  298.  *
  299.  * removed!
  300.  * removed!
  301.  * removed!
  302.  *
  303.  * removed!
  304.  * removed!
  305.  * removed!
  306.  *
  307.  * removed!
  308.  * removed!
  309.  * removed!
  310.  *
  311.  * removed!
  312.  * removed!
  313.  * removed!
  314.  *
  315.  * removed!
  316.  * removed!
  317.  * removed!
  318.  *
  319.  * removed!
  320.  * removed!
  321.  * removed!
  322.  *
  323.  * removed!
  324.  * removed!
  325.  * removed!
  326.  *
  327.  * removed!
  328.  * removed!
  329.  * removed!
  330.  *
  331.  * removed!
  332.  * removed!
  333.  * removed!
  334.  *
  335.  * removed!
  336.  * removed!
  337.  * removed!
  338.  *
  339.  * removed!
  340.  * removed!
  341.  * removed!
  342.  *
  343.  * removed!
  344.  * removed!
  345.  * removed!
  346.  *
  347.  * removed!
  348.  * removed!
  349.  * removed!
  350.  *
  351.  * removed!
  352.  * removed!
  353.  * removed!
  354.  *
  355.  * removed!
  356.  * removed!
  357.  * removed!
  358.  *
  359.  * removed!
  360.  * removed!
  361.  * removed!
  362.  *
  363.  * removed!
  364.  * removed!
  365.  * removed!
  366.  *
  367.  * removed!
  368.  * removed!
  369.  * removed!
  370.  *
  371.  * removed!
  372.  * removed!
  373.  * removed!
  374.  *
  375.  * removed!
  376.  * removed!
  377.  * removed!
  378.  *
  379.  * removed!
  380.  * removed!
  381.  * removed!
  382.  *
  383.  * removed!
  384.  * removed!
  385.  * removed!
  386.  *
  387.  * removed!
  388.  * removed!
  389.  * removed!
  390.  * removed!
  391.  * removed!
  392.  * removed!
  393.  * removed!
  394.  * removed!
  395.  * removed!
  396.  * removed!
  397.  * removed!
  398.  * removed!
  399.  * removed!
  400.  * removed!
  401.  * removed!
  402.  * removed!
  403.  * removed!
  404.  * removed!
  405.  * removed!
  406.  * removed!
  407.  * removed!
  408.  * removed!
  409.  * removed!
  410.  * removed!
  411.  * removed!
  412.  * removed!
  413.  * removed!
  414.  * removed!
  415.  * removed!
  416.  * removed!
  417.  * removed!
  418.  * removed!
  419.  * removed!
  420.  * removed!
  421.  * removed!
  422.  * removed!
  423.  * removed!
  424.  * removed!
  425.  * removed!
  426.  * removed!
  427.  * removed!
  428.  * removed!
  429.  * removed!
  430.  * removed!
  431.  * removed!
  432.  * removed!
  433.  * removed!
  434.  * removed!
  435.  * removed!
  436.  * removed!
  437.  * removed!
  438.  * removed!
  439.  * removed!
  440.  * removed!
  441.  * removed!
  442.  * removed!
  443.  * removed!
  444.  * removed!
  445.  * removed!
  446.  * removed!
  447.  * removed!
  448.  * removed!
  449.  * removed!
  450.  * removed!
  451.  * removed!
  452.  * removed!
  453.  * removed!
  454.  * removed!
  455.  * removed!
  456.  * removed!
  457.  * removed!
  458.  * removed!
  459.  * removed!
  460.  * removed!
  461.  * removed!
  462.  * removed!
  463.  * removed!
  464.  * removed!
  465.  * removed!
  466.  * removed!
  467.  * removed!
  468.  * removed!
  469.  * removed!
  470.  * removed!
  471.  * removed!
  472.  * removed!
  473.  * removed!
  474.  * removed!
  475.  * removed!
  476.  * removed!
  477.  * removed!
  478.  * removed!
  479.  * removed!
  480.  * removed!
  481.  * removed!
  482.  * removed!
  483.  * removed!
  484.  *------------------------------------------------------------------------------
  485.  * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
  486.  *============================================================================
  487.  ****************************************************************************/
  488. #include    "drv_features.h"
  489. #include  "kal_release.h"
  490. #include  "stack_common.h"  
  491. #include  "stack_msgs.h"
  492. #include  "app_ltlcom.h"       /* Task message communiction */
  493. #include  "drv_comm.h"
  494. #include    "drvsignals.h"
  496. #ifndef DRV_RTC_NOT_EXIST
  498. #include  "reg_base.h"
  499. #include  "rtc_hw.h"
  500. #include  "rtc_sw.h"
  501. #include  "intrCtrl.h"
  502. #include    "stack_ltlcom.h"       /*msg_send_ext_queue.....definitions*/
  503. #include    "stack_config.h"        /*MOD_UART1_HISR,MOD_UART2_HISR*/
  504. #include    "drv_hisr.h"
  505. #ifdef __MULTI_BOOT__
  506. #include "kal_release.h"
  507. #include "syscomp_config.h"
  508. #include "multiboot_config.h"
  509. #endif   /*__MULTI_BOOT__*/
  510. #include "bmt.h"
  511. #include    "nvram_struct.h"
  512. #include    "nvram_enums.h"
  513. #include    "nvram_data_items.h"
  514. #include    "nvram.h"
  515. #include    "nvram_interface.h"
  516. #include    "nvram_user_defs.h"
  517. #include    "drv_trc.h"
  518. #if defined(__GPS_SUPPORT__) // Indicate GPS task that the time is modified by upper layer
  519. #include "gps_struct.h"
  520. extern kal_bool gps_task_init_ok(void);
  521. #endif // #if defined(__GPS_SUPPORT__)
  522. //#include    "l1_core_private.h"
  523. /*#define  RTC_Test*/
  524. /* #define RTC_CAL_DEBUG */
  525. /* #define RTC_CAL_DEBUG2 */
  526. #if !defined(IC_BURNIN_TEST) && !defined(IC_MODULE_TEST) && !defined(__MAUI_BASIC__) && !defined(__FUE__) && !defined(DRV_RTC_NO_REG_COMM)
  527. #ifdef DRV_RTC_HW_CALI
  528. #define RTC_HW_CALIBRATION
  529. #else
  530. #define RTC_SW_CALIBRATION
  531. #endif
  532. #endif
  534. // Define to enable sleep workaround debug message
  535. #if defined(DRV_RTC_SLEEP_LOCKED_UP_WA)
  536. #if defined(MTK_SLEEP_ENABLE)
  537. // If the chip has sleep mode locked up issue, and sleep mechanism is enabled, 
  538. // We need to perform enable workaround to avoid locked up in sleep mode while loop
  539. #define SLEEP_WORKAROUND_IN_RTC
  540. // Define to enable debug message of SLEEP_WORKAROUND_IN_RTC
  541. //#define RTC_SLEEP_WA_DEBUG
  542. #endif // #if defined(MTK_SLEEP_ENABLE)
  543. #endif // #if defined(DRV_RTC_SLEEP_LOCKED_UP_WA)
  545. static kal_bool    First_PowerOn=KAL_FALSE;/*use a static variable to recode is this first power on*/
  546. #if !defined(__FUE__)
  547. static rtc_callbac RTC_CALLBAC;
  548. static rtc_module  RTCConfig;
  550. /*for rtc calibration*/
  551. #if defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION)
  553.    #if defined(__USB_ENABLE__) && !defined(__NVRAM_IN_USB_MS__)
  554.    extern kal_bool INT_USBBoot(void);
  555.    #endif /*__USB_ENABLE__*/
  557.    extern kal_uint32 L1I_GetTimeStamp(void);
  559. /*for rtc calibration*/
  560. void rtc_cali_init(void *timer_param);
  562. /* Calibration State */
  563. typedef enum
  564. {
  565.    CAL_STATE_NONE = 0,
  566.    CAL_STATE_INIT,
  567.    CAL_STATE_INIT2,
  568.    CAL_STATE_START,
  569.    CAL_STATE_RESET
  570. } rtc_cali_state;
  573. static kal_uint8 cali_state = (kal_uint8)CAL_STATE_NONE;
  574. static kal_uint8 rtc_tc_int_var = TC_EN_None;
  575. static kal_uint16 tc_min_expire_cnt = 0;
  578. #if defined(RTC_HW_CALIBRATION)
  579. #define RTC_CALI_PERIOD_MINS   (6)  // unit: minutes
  580. #define RTC_CALI_PERIOD_SECS   (RTC_CALI_PERIOD_MINS*60)  // unit: minutes
  581. #define RTC_CALI_REPEAT_DUR_SECS    (8)   // spec: 8 seconds to do one repeate calibration    
  582. #define RTC_CALI_REPEAT_TOTAL_CNT   (RTC_CALI_PERIOD_SECS>>3)
  583. #define RTC_CALI_TICK_VALUE (13000*RTC_CALI_PERIOD_MINS)
  584. #define RTC_STANDARD_FREQ  (32768)
  585. #define RTC_STANDARD_FREQ_8SECS  (RTC_STANDARD_FREQ*8)
  587. #define RTC_CALI_REPEAT_MAX   (63)
  588. #define RTC_CALI_REPEAT_MIN   (-64)
  589. #define RTC_CALI_ONE_TIME_MAX   (2045)
  590. #define RTC_CALI_ONE_TIME_MIN   (-2048)
  592. static kal_uint32 rtc_current_frame_tick;
  593. static kal_uint32 rtc_current_freq_8secs;
  594. static kal_bool one_time_cali = KAL_FALSE;
  595. static kal_int32 inaccurate_total_cnt = 0;
  596. static kal_int32 no_diff_cnt = 0;
  598. #elif defined(RTC_SW_CALIBRATION)
  599. extern BMTStruct BMT;          /*Main BMT struct*/
  600. /* extern NVRAM API */
  601. //extern kal_bool nvram_external_read_data(kal_uint8 LID,kal_uint8 rec_index, kal_uint8* buffer, kal_uint16 buffer_size);
  602. kal_timerid   rtc_timer_id=0;
  603. void rtc_timer(void *timer_param); 
  604. void rtc_get_next_time(void);
  605. void rtc_forward_time(t_rtc *rtc_time, kal_uint16 hours, kal_uint16 mins, kal_uint16 secs);
  606. void rtc_backward_time(t_rtc *rtc_time, kal_uint16 hours, kal_uint16 mins, kal_uint16 secs);
  607. void rtc_write_to_nvram(void);
  609. #if defined(SLEEP_WORKAROUND_IN_RTC)
  610. // The tick to trigger rtc_sleep_wa_timer_cb to disable sleep mode
  611. // We may delayed waked up at 59:04, set kal timer to wake up after 52 sec
  612. // We may keep in sleep-disabled mode at least for 4 sec per hour
  613. #define RTC_SLEEP_WA_DISABLE_SLEEP_TICK 11266  // ~ 52 sec, (13000/60) * 52 
  614. kal_timerid   rtc_sleep_wa_timer_id=0;
  615. void rtc_sleep_wa_timer_cb(void *timer_param);
  616. void rtc_sleep_wa_enable_sleep_mode(void);
  617. void rtc_sleep_wa_disable_sleep_mode(void);
  618. kal_uint8 rtc_sleep_wa_handle;
  619. volatile kal_bool rtc_sleep_wa_disable_sleep_performed = KAL_FALSE; // Init value: disable sleep NOT performed
  620. // static t_rtc rtc_sleep_wa_ref;
  621. #endif // #ifdef SLEEP_WORKAROUND_IN_RTC
  623. #define rtc_cali_hr_period (1)/*hour*/ 
  624. #define rtc_cali_min_period (2)/*minute*/ 
  625. #define rtc_cali_tick_value (13000*60*rtc_cali_hr_period + 13000*rtc_cali_min_period)
  626. #define rtc_cali_tick_safe_margin   13000 /* ticks */
  627. #define rtc_tick_update_interval (217)/*1300/6 = 216 and 2/3*/
  628. #define rtc_sec_update_interval (1)
  630. static const kal_uint8 days_in_month[13] = 
  631. {
  632.    0, /*Null*/ 
  633.    31, /*Jan*/
  634.    28, /*Feb*/
  635.    31, /*Mar*/
  636.    30, /*Apr*/
  637.    31, /*May*/
  638.    30, /*Jun*/
  639.    31, /*Jul*/
  640.    31, /*Aug*/
  641.    30, /*Sep*/
  642.    31, /*Oct*/
  643.    30, /*Nov*/
  644.    31  /*Dec*/
  645. };
  647. static rtc_nvram_data  rtc_nvram_s;
  648. static t_rtc next_current_time;
  649. static kal_uint32 next_frame_tick, tick_left=0;
  650. static kal_uint16 one_third_tick_count = 0; /* 217 - 216and2/3 = 1/3. The counts for the 1/3. */
  652. static kal_uint8 rtc_al_int_var = AL_EN_None;
  653. static kal_int32 pwroff_inacc_ticks = 0;
  654. static kal_uint32 frame_tick1;
  655. static kal_uint32 frame_tick2;
  656. static kal_int32 frame_tick_1hr_diff;
  657. #endif /* RTC_SW_CALIBRATION */
  658. #endif /*  defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION) */
  659. //extern void dbg_print(char *fmt,...);
  660. #ifdef RTC_Test
  661. void RTC_delay(void)
  662. {
  663. kal_uint16 i;
  664. for (i=0;i<2000;i++);
  665. }
  666. #endif
  668. void RTC_setBBPU(kal_uint16 data)
  669. {
  670.    data &= 0x00ff;
  671.    data |= 0x4300;
  672.    #if defined(DRV_RTC_WRITE_ENABLE)
  673.    data |= RTC_BBPU_WRITE_EN;
  674.    #endif // #if defined(DRV_RTC_WRITE_ENABLE)
  675.    DRV_WriteReg(RTC_BBPU,data);
  676. }
  677. #endif //#if !defined(__FUE__)
  679. #if defined(DRV_RTC_HW_CALI)
  680. /*
  681. * FUNCTION                                                            
  682. * RTC_write_trigger
  683. *
  684. * DESCRIPTION                                                           
  685. *    This function is to enable the transfers from core to RTC.
  686. *
  687. * CALLS  
  688. * It is called to trigger RTC register writing.
  689. *
  690. * PARAMETERS
  691. * None
  692. *
  693. * RETURNS
  694. * None
  695. *
  696. * GLOBALS AFFECTED
  697. *   external_global
  698. */
  699. void RTC_write_trigger(void)
  700. {
  701.    DRV_WriteReg(RTC_WRTGR, RTC_WRTGR_WRTGR);
  702. }
  704. /*
  705. * FUNCTION                                                            
  706. * RTC_write_trigger
  707. *
  708. * DESCRIPTION                                                           
  709. *    This function is to enable the transfers from core to RTC and wait till it's done.
  710. *
  711. * CALLS  
  712. * It is called to trigger RTC register writing.
  713. *
  714. * PARAMETERS
  715. * None
  716. *
  717. * RETURNS
  718. * None
  719. *
  720. * GLOBALS AFFECTED
  721. *   external_global
  722. */
  723. void RTC_write_trigger_wait(void)
  724. {
  725.    kal_uint32 count=0;
  726.    
  727.    DRV_WriteReg(RTC_WRTGR, RTC_WRTGR_WRTGR);
  728.    //while(count < 10000)
  729.    while(count < 0xffffffff)
  730.    {
  731.       if ((RTC_BBPU_CBUSY & DRV_Reg(RTC_BBPU))==0)
  732.          break;
  733.       count++;
  734.    }
  735. }
  737. #endif //#if defined(DRV_RTC_HW_CALI)
  739. #if !defined(__FUE__)
  740. /*
  741. * FUNCTION                                                            
  742. * isPWROnByRTC
  743. *
  744. * DESCRIPTION                                                           
  745. *    This function is to check whether "power on" is due to RTC.
  746. *
  747. * CALLS  
  748. * It is called to check whether "power on" is due to RTC.
  749. *
  750. * PARAMETERS
  751. * None
  752. *
  753. * RETURNS
  754. * KAL_TRUE: "Power on" is due to RTC.
  755. * KAL_FALSE: "Power on" is not due to RTC.
  756. *
  757. * GLOBALS AFFECTED
  758. *   external_global
  759. */
  760. kal_bool isPWROnByRTC(void)
  761. {
  762. #if defined(DRV_RTC_PWRON_BBPU_POLARITY) || defined(FPGA)
  763. kal_uint16 BBPU;
  764. kal_uint16 POLAR;
  765. kal_uint16 PWRSW;
  766. BBPU = DRV_Reg(RTC_BBPU);
  767. POLAR = BBPU & RTC_BBPU_PWR_POLARITY;
  768. POLAR >>= 1;
  769. PWRSW = BBPU & RTC_BBPU_PWR_SW;
  770. PWRSW >>= 4;
  772. if (POLAR == PWRSW)
  773. {
  774. return KAL_TRUE;
  775. }
  776. else
  777. {
  778. return KAL_FALSE;
  779. }
  780. #endif   /*DRV_RTC_PWRON_BBPU_POLARITY,FPGA*/
  782. #if defined(DRV_RTC_PWRON_BBPU_SW)
  783.    if (DRV_Reg(RTC_BBPU) & RTC_BBPU_PWR_SW)
  784.       return KAL_TRUE;
  785.    else
  786.       return KAL_FALSE;
  787. #endif   /*DRV_RTC_PWRON_BBPU_SW*/
  788. }
  789. //=================================================================
  790. /*
  791. * FUNCTION                                                            
  792. * RTC_IRQOneShotEnable
  793. *
  794. * DESCRIPTION                                                           
  795. *    This function is to setup that RTC interrupt is at oneshot mode
  796. * or at automatic reset mode. 
  797. *
  798. * CALLS  
  799. * It is called to setup that RTC interrupt is at oneshot mode
  800. * or at automatic reset mode. 
  801. *
  802. * PARAMETERS
  803. * oneShotEN:
  804. *     ONE_SHOT_DIS, automatic reset mode
  805. *     ONE_SHOT_EN, one shot mode
  806. *
  807. * RETURNS
  808. * None
  809. *
  810. * GLOBALS AFFECTED
  811. *   external_global
  812. */
  813. void RTC_IRQOneShotEnable(kal_uint8 oneShotEN)
  814. {
  815. if (oneShotEN == ONE_SHOT_DIS)
  816. {
  817. DRV_Reg(RTC_IRQ_EN) &= ~RTC_IRQ_EN_ONESHOT;
  818. }
  819. else
  820. {
  821. DRV_Reg(RTC_IRQ_EN) |= RTC_IRQ_EN_ONESHOT;
  822. }
  823. #if defined(DRV_RTC_HW_CALI)
  824.    RTC_write_trigger_wait();
  825. #endif
  826. }
  827. //=================================================================
  828. /*
  829. * FUNCTION                                                            
  830. * RTC_Config
  831. *
  832. * DESCRIPTION                                                           
  833. *    Configure the RTC interrupt 
  834. *
  835. * CALLS  
  836. * This function is called to enable RTC interrupt
  837. *
  838. * PARAMETERS
  839. * AL_EN:
  840. * AL_EN_None: Alarm interrupt is disable.
  841. * AL_EN_bySEC: Alarm interrupt is issued by second.
  842. * AL_EN_byMIN: Alarm interrupt is issued by minute.
  843. * TC_EN:
  844. * TC_EN_None: TC interrupt is disable
  845. * TC_EN_bySEC: TC interrupt is issued by second.
  846. * TC_EN_byMIN: TC interrupt is issued by minute.
  847. *
  848. * RETURNS
  849. * None
  850. *
  851. * GLOBALS AFFECTED
  852. *   external_global
  853. */
  854. void RTC_Config(kal_uint8 AL_EN,kal_uint8 TC_EN)
  855. {
  856. kal_uint16 tmp;
  857. kal_uint16 BBPU;
  858.    kal_uint32 savedMask;
  860.    #if defined(DRV_RTC_HW_CALI)
  861.    RTC_wait_busy();
  862.    #endif   
  863.    
  864.    #if defined(DRV_RTC_W_FLAG)
  865.    while (DRV_Reg(RTC_IRQ_EN) & 0x8000){;};
  866.    #endif // #if defined(DRV_RTC_W_FLAG)
  868.    savedMask = SaveAndSetIRQMask();   
  871. tmp = DRV_Reg(RTC_IRQ_EN);
  872. tmp &=~RTC_IRQ_EN_ONESHOT;
  873. BBPU = DRV_Reg(RTC_BBPU);
  875. #if defined(RTC_HW_CALIBRATION)
  876.    /* Save user's configuration for Alarm and Time Clock settings. */
  877.    if (TC_EN != TC_EN_NoChange)
  878.       rtc_tc_int_var = TC_EN;
  879.    if (cali_state == CAL_STATE_INIT)
  880.    {
  881.       /* In the calibration INIT state, we need "minute" interrupt. */
  882.       if ((TC_EN != TC_EN_ChkS) && (TC_EN != TC_EN_ChkM))
  883.          TC_EN = TC_EN_NoChange;
  884.    }
  885.    else if (cali_state == (kal_uint8)CAL_STATE_START)
  886.    {
  887.       if (one_time_cali == KAL_TRUE)
  888.       {
  889.          /* We need "seconds" interrupt. */
  890.          if (TC_EN != TC_EN_ChkS)
  891.             TC_EN = TC_EN_NoChange;
  892.       }
  893.       else
  894.       {
  895.          /* We need "minute" interrupt. */
  896.          if ((TC_EN != TC_EN_ChkS) && (TC_EN != TC_EN_ChkM))
  897.             TC_EN = TC_EN_NoChange;
  898.       }
  899.    }
  900. #elif defined(RTC_SW_CALIBRATION)
  901.    /* Save user's configuration for Alarm and Time Clock settings. */
  902.    if (AL_EN != AL_EN_NoChange)
  903.       rtc_al_int_var = AL_EN;
  904.    if (TC_EN != TC_EN_NoChange)
  905.       rtc_tc_int_var = TC_EN;
  906.    if (cali_state == (kal_uint8)CAL_STATE_INIT)
  907.    {
  908.       /* In the calibration INIT state, we need "second" interrupt. */
  909.       if (TC_EN != TC_EN_ChkS)
  910.          TC_EN = TC_EN_NoChange;
  911.    }
  912.    else if (cali_state == (kal_uint8)CAL_STATE_START)
  913.    {
  914.       /* In the calibration START state, we need "minute" interrupt. */
  915.       if ((TC_EN != TC_EN_ChkS) && (TC_EN != TC_EN_ChkM))
  916.          TC_EN = TC_EN_NoChange;
  917.    }
  918. #endif /* RTC_SW_CALIBRATION */
  919. switch(AL_EN)
  920. {
  921. case AL_EN_None:
  922. tmp &= ~RTC_IRQ_EN_AL;  /*RTC_ALIRQEnable(KAL_FALSE);*/
  923. BBPU &=~(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  924. break;
  926. case AL_EN_ChkS:
  927. tmp |= RTC_IRQ_EN_AL;
  928. DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_SEC));
  929. BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  930. break;
  932. case AL_EN_ChkMS:
  933. tmp |= RTC_IRQ_EN_AL;
  934. DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_MIN));
  935. BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  936. break;
  937.       
  938.       case AL_EN_ChkHMS:
  939.          tmp |= RTC_IRQ_EN_AL;
  940.          DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_HOU));
  941.          BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  942. break;
  943.    
  944.    case AL_EN_ChkDHMS:
  945.       tmp |= RTC_IRQ_EN_AL;
  946.       DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_DOM));
  947.       BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  948. break;
  950. case AL_EN_ChkWHMS:
  951.    tmp |= RTC_IRQ_EN_AL;
  952.    DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_DOW));
  953.    BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  954. break;
  956.    case AL_EN_ChkMDHMS:
  957.       tmp |= RTC_IRQ_EN_AL;
  958.       DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_MTH));
  959.       BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  960. break;
  962.    case AL_EN_ChkYMDHMS:
  963.       tmp |= RTC_IRQ_EN_AL;
  964.       DRV_WriteReg(RTC_AL_MASK,(~RTC_AL_MASK_YEA));
  965.       BBPU |=(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  966. break;
  968.    case AL_EN_NoChange:
  969.       break;
  971. default:
  972. break;
  973. }
  975. switch(TC_EN)
  976. {
  977. case TC_EN_None:
  978. tmp &= ~RTC_IRQ_EN_TC;
  979. break;
  981. case TC_EN_ChkS:
  982. tmp |= RTC_IRQ_EN_TC;
  983. DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_SEC);
  984. break;
  986. case TC_EN_ChkM:
  987. tmp |= RTC_IRQ_EN_TC;
  988. DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_MIN);
  989. break;
  991.    case TC_EN_ChkH:
  992.       tmp |= RTC_IRQ_EN_TC;
  993.       DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_HOU);
  994. break;
  996. case TC_EN_ChkD:
  997.       tmp |= RTC_IRQ_EN_TC;
  998.       DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_DOM);
  999. break;
  1001. case TC_EN_ChkW:
  1002.       tmp |= RTC_IRQ_EN_TC;
  1003.       DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_DOW);
  1004. break;
  1006. case TC_EN_ChkMon:
  1007.       tmp |= RTC_IRQ_EN_TC;
  1008.       DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_MTH);
  1009. break;
  1011. case TC_EN_ChkY:
  1012.       tmp |= RTC_IRQ_EN_TC;
  1013.       DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_YEA);
  1014. break;
  1015.     
  1016.       case TC_EN_NoChange:
  1017.          break;
  1018.          
  1019. default:
  1020. break;
  1021. }
  1022. DRV_WriteReg(RTC_IRQ_EN,tmp);
  1024. #if defined(DRV_RTC_WRITE_ENABLE)
  1025. BBPU |= RTC_BBPU_WRITE_EN;
  1026. #endif // #if defined(DRV_RTC_WRITE_ENABLE)
  1028. DRV_WriteReg(RTC_BBPU,(BBPU|RTC_BBPU_KEY));/*0227 TY adds*/
  1029. #if defined(DRV_RTC_HW_CALI)
  1030.    DRV_WriteReg(RTC_WRTGR, RTC_WRTGR_WRTGR);
  1031.    //RTC_write_trigger();
  1032. #endif /* DRV_RTC_HW_CALI */
  1033. RestoreIRQMask(savedMask);
  1035. #if defined(DRV_RTC_HW_CALI)
  1036. RTC_wait_busy();
  1037. #endif /* DRV_RTC_HW_CALI */
  1039. }
  1040. #endif /*!defined(__FUE__)*/
  1042. #if ( defined(__GPS_SUPPORT__) || defined(RTC_HW_CALIBRATION) )
  1043. extern kal_bool kal_query_systemInit(void);
  1044. // Return KAL_TRUE: OS is running, we can send ilm at this moment
  1045. // Return KAL_FALSE: OS is NOT running, we are called at boot time phase
  1046. kal_bool IsOSRunning(void){
  1047. // kal_query_systemInit() return KAL_TRUE: System is at init phase
  1048. // kal_query_systemInit() return KAL_FALSE: System is NOT at init phase
  1049. return (kal_bool)(!kal_query_systemInit());
  1051. }
  1053. #endif //#if ( defined(__GPS_SUPPORT__) || defined(RTC_HW_CALIBRATION) )
  1054. /*
  1055. * FUNCTION                                                            
  1056. * RTC_InitTC_Time
  1057. *
  1058. * DESCRIPTION                                                           
  1059. *    Setup the current time
  1060. *
  1061. * CALLS  
  1062. * This function is called to setup the current time
  1063. *
  1064. * PARAMETERS
  1065. * rtctime: the current time.
  1066. *
  1067. * RETURNS
  1068. * None
  1069. *
  1070. * GLOBALS AFFECTED
  1071. *   external_global
  1072. */
  1073. void RTC_InitTC_Time(t_rtc *rtctime) //validate
  1074. {
  1075.    kal_uint32 savedMask=0;
  1076. #if defined(__GPS_SUPPORT__)
  1077. ilm_struct *RTC_ilm;
  1078. rtc_gps_time_change_ind_struct *rtc_ind = NULL;
  1079. #endif //#if defined(__GPS_SUPPORT__)
  1080. #if !defined(DRV_RTC_HW_CALI)
  1081.    kal_uint32 loop=0;
  1082. #endif /* DRV_RTC_HW_CALI */
  1083.    
  1085. #if defined(DRV_RTC_HW_CALI) && !defined(__FUE__)
  1086. RTC_wait_busy();
  1087. #endif   
  1088.    
  1089. #if defined(RTC_SW_CALIBRATION)
  1090.    if(rtc_timer_id!=0)
  1091.    {
  1092.       cali_state = (kal_uint8)CAL_STATE_RESET;
  1093.     kal_cancel_timer(rtc_timer_id);
  1094.    }
  1095. #endif /* RTC_SW_CALIBRATION */
  1097. #if defined(__GPS_SUPPORT__) // Indicate GPS task that the time is modified by upper layer
  1099. if (IsOSRunning()){ // not use gps_task_init_ok, otherwise may encounter gps init later, but not set rtc_ind here.
  1100. rtc_ind = (rtc_gps_time_change_ind_struct*)
  1101. construct_local_para(sizeof(rtc_gps_time_change_ind_struct), TD_CTRL);
  1103. // Save current time to message
  1104. rtc_ind->previous_rtc.rtc_sec = DRV_Reg(RTC_TC_SEC);
  1105. rtc_ind->previous_rtc.rtc_min = DRV_Reg(RTC_TC_MIN);
  1106. rtc_ind->previous_rtc.rtc_hour = DRV_Reg(RTC_TC_HOU);
  1107. rtc_ind->previous_rtc.rtc_day = DRV_Reg(RTC_TC_DOM);
  1108. rtc_ind->previous_rtc.rtc_mon = DRV_Reg(RTC_TC_MTH);
  1109. rtc_ind->previous_rtc.rtc_year = DRV_Reg(RTC_TC_YEA);
  1110. }
  1112. #endif //#if defined(__GPS_SUPPORT__)
  1114.    #if defined(DRV_RTC_HW_CALI) && !defined(__FUE__)
  1115.    RTC_wait_busy();
  1116.    #endif
  1118. #if !defined(__FUE__)
  1119.    savedMask = SaveAndSetIRQMask();   
  1120. #endif /*!defined(__FUE__)*/
  1123. /*update time*/
  1124. DRV_WriteReg(RTC_TC_SEC,rtctime->rtc_sec);
  1125. DRV_WriteReg(RTC_TC_MIN,rtctime->rtc_min);
  1126. DRV_WriteReg(RTC_TC_HOU,rtctime->rtc_hour);
  1127. DRV_WriteReg(RTC_TC_DOM,rtctime->rtc_day);
  1128. /*DRV_WriteReg(RTC_TC_DOW,rtctime->rtc_wday);*/
  1129. DRV_WriteReg(RTC_TC_MTH,rtctime->rtc_mon);
  1130. DRV_WriteReg(RTC_TC_YEA,rtctime->rtc_year);
  1134. #if !defined(__FUE__)
  1135. RestoreIRQMask(savedMask);
  1136. #endif /*!defined(__FUE__)*/
  1138. #if defined(DRV_RTC_HW_CALI)
  1139.    RTC_write_trigger_wait();
  1140. #else /* DRV_RTC_HW_CALI */
  1141. //for(loop=0;loop<1000;loop++){};
  1142. // Use while loop with fields check instead of for loop
  1143. // We compare each field until all the fields are what we set to RTC module
  1144. loop = 0;
  1145. while(1){
  1146. if ( 
  1147. (DRV_Reg(RTC_TC_SEC) == rtctime->rtc_sec) &&
  1148. (DRV_Reg(RTC_TC_MIN) == rtctime->rtc_min) &&
  1149. (DRV_Reg(RTC_TC_HOU) == rtctime->rtc_hour) &&
  1150. (DRV_Reg(RTC_TC_DOM) == rtctime->rtc_day) &&
  1151. (DRV_Reg(RTC_TC_MTH) == rtctime->rtc_mon) &&
  1152. (DRV_Reg(RTC_TC_YEA) == rtctime->rtc_year) ){
  1153. break;
  1154. }
  1155. loop ++;
  1156. if (loop >= 10000){
  1157. // Warning: RTC may NOT complet the update
  1158. break;
  1159. }
  1160. }
  1163. #if !defined(LOW_COST_SUPPORT)
  1164. #if !defined(__FUE__)
  1165.   drv_trace8(TRACE_GROUP_9, RTC_INIT_TC_TIME, rtctime->rtc_year, rtctime->rtc_mon,
  1166.             rtctime->rtc_day, rtctime->rtc_hour, rtctime->rtc_min, rtctime->rtc_sec, 0, 0);
  1167. #endif
  1168. #endif
  1170. #endif /* DRV_RTC_HW_CALI */
  1172. #if defined(__GPS_SUPPORT__) // Indicate GPS task that the time is modified by upper layer
  1174. if (IsOSRunning()){ // use double check to prevent call gps_task_init_ok() before 2nd MAUI loaded.
  1175.    if (gps_task_init_ok()){    // use gps task init ok to verify is gps already init, otherwise in factory mode or charging mode has no gps task
  1176.    // Save new RTC time to message
  1177.   module_type module_id;
  1179.    rtc_ind->new_rtc.rtc_sec = DRV_Reg(RTC_TC_SEC);
  1180.    rtc_ind->new_rtc.rtc_min = DRV_Reg(RTC_TC_MIN);
  1181.   rtc_ind->new_rtc.rtc_hour = DRV_Reg(RTC_TC_HOU);
  1182.    rtc_ind->new_rtc.rtc_day = DRV_Reg(RTC_TC_DOM);
  1183.    rtc_ind->new_rtc.rtc_mon = DRV_Reg(RTC_TC_MTH);
  1184.   rtc_ind->new_rtc.rtc_year = DRV_Reg(RTC_TC_YEA);
  1186.    if(KAL_TRUE == kal_if_hisr())
  1187.    {
  1188.    module_id = MOD_DRV_HISR;
  1189.    }
  1190.    else
  1191.   {
  1192.    module_id = stack_get_active_module_id();
  1193.    }
  1194.   RTC_ilm = allocate_ilm(module_id);
  1195.    RTC_ilm->src_mod_id = module_id;
  1196.    RTC_ilm->dest_mod_id = MOD_GPS;
  1197.   RTC_ilm->sap_id = RTC_GPS_SAP;
  1198.    RTC_ilm->msg_id = MSG_ID_RTC_GPS_TIME_CHANGE_IND;
  1199.    RTC_ilm->local_para_ptr = (local_para_struct *)rtc_ind;
  1200.   RTC_ilm->peer_buff_ptr = NULL;
  1201.    msg_send_ext_queue(RTC_ilm);
  1202.    }
  1203. }
  1204. #endif //#if defined(__GPS_SUPPORT__)
  1207. #if defined(RTC_HW_CALIBRATION)
  1208. // For H/W calibration case, we only enable calibration process when OS is running case
  1209. // Or the calibration process may modify RTC register values to unexpected value during boot time
  1210. if (IsOSRunning()){
  1211. cali_state = (kal_uint8)CAL_STATE_NONE;
  1212. rtc_cali_init(0);
  1213. }
  1214. #elif defined(RTC_SW_CALIBRATION)
  1215. /*reset calibration, start after rtc initialization*/
  1216.    if(rtc_timer_id!=0)
  1217.    {
  1218.       next_current_time = *rtctime;
  1219.     rtc_cali_init((void*)rtc_timer_id);
  1221.      /* save current time to nvram */
  1222.       rtc_nvram_s.time_valid = KAL_TRUE;
  1223.       rtc_nvram_s.rtc_time = next_current_time;
  1224.       rtc_write_to_nvram();
  1225.    }
  1226. #endif /* RTC_SW_CALIBRATION */
  1228. #ifdef RTC_Test
  1229. RTC_delay();
  1230. #endif
  1231. }
  1233. #if defined(RTC_SW_CALIBRATION)
  1234. /*
  1235. * FUNCTION                                                            
  1236. * RTC_Cali_Time
  1237. *
  1238. * DESCRIPTION                                                           
  1239. *    update the current time
  1240. *
  1241. * CALLS  
  1242. * This function is to update the current time
  1243. *
  1244. * PARAMETERS
  1245. * rtctime: the current time.
  1246. *
  1247. * RETURNS
  1248. * None
  1249. *
  1250. * GLOBALS AFFECTED
  1251. *   external_global
  1252. */
  1253. void RTC_Cali_Time(t_rtc *rtctime) //validate
  1254. {   
  1255.    /*update time*/
  1256.    DRV_WriteReg(RTC_TC_SEC,rtctime->rtc_sec);
  1257. DRV_WriteReg(RTC_TC_MIN,rtctime->rtc_min);
  1258. DRV_WriteReg(RTC_TC_HOU,rtctime->rtc_hour);
  1259. DRV_WriteReg(RTC_TC_DOM,rtctime->rtc_day);
  1260. DRV_WriteReg(RTC_TC_MTH,rtctime->rtc_mon);
  1261. DRV_WriteReg(RTC_TC_YEA,rtctime->rtc_year);
  1262. #if !defined(LOW_COST_SUPPORT)
  1263. #if !defined(__FUE__)
  1264.   drv_trace8(TRACE_GROUP_9, RTC_CALI_TIME, rtctime->rtc_year, rtctime->rtc_mon,
  1265.             rtctime->rtc_day, rtctime->rtc_hour, rtctime->rtc_min, rtctime->rtc_sec, 0, 0);
  1266. #endif
  1267. #endif
  1268. }
  1269. /*
  1270. * FUNCTION                                                            
  1271. * RTC_Check_Alarm
  1272. *
  1273. * DESCRIPTION                                                           
  1274. *    check if alarm expires after calibrating time
  1275. *
  1276. * CALLS  
  1277. * This function is to check if alarm expires after calibrating time
  1278. *
  1279. * PARAMETERS
  1280. * rtctime: the current time.
  1281. *
  1282. * RETURNS
  1283. * None
  1284. *
  1285. * GLOBALS AFFECTED
  1286. *   external_global
  1287. */
  1288. void RTC_Check_Alarm(t_rtc rtctime) //validate
  1289. {   
  1290.    kal_uint8 irq=0;
  1291.    t_rtc alarm_time, current_time;
  1292.    kal_uint32 alarm_sec=0, current_sec=0, new_time=0;
  1294.    irq = DRV_Reg(RTC_IRQ_EN);
  1295.    /*configure alarm or not*/
  1296.    if(irq&RTC_IRQ_EN_AL)
  1297.    {
  1298.       RTC_GetALTime(&alarm_time);
  1299.       RTC_GetTime(&current_time);
  1300.       if(alarm_time.rtc_hour==0)
  1301.          alarm_sec=(kal_uint32)(24*3600+alarm_time.rtc_min*60+alarm_time.rtc_sec);
  1302.       else
  1303.          alarm_sec=(kal_uint32)(alarm_time.rtc_hour*3600+alarm_time.rtc_min*60+alarm_time.rtc_sec);
  1304.       if(current_time.rtc_hour==0)
  1305.          current_sec=(kal_uint32)(24*3600+current_time.rtc_min*60+current_time.rtc_sec);
  1306.       else
  1307.          current_sec=(kal_uint32)(current_time.rtc_hour*3600+current_time.rtc_min*60+current_time.rtc_sec);   
  1308.       /*exceed alarm or not*/         
  1309.       if(current_sec<alarm_sec)            
  1310.       {
  1311.          if(rtctime.rtc_hour==0)
  1312.             new_time=(kal_uint32)(24*3600+rtctime.rtc_min*60+rtctime.rtc_sec);
  1313.          else
  1314.             new_time=(kal_uint32)(rtctime.rtc_hour*3600+rtctime.rtc_min*60+rtctime.rtc_sec);   
  1315.          /*change alarm or not*/   
  1316.          if(new_time>=alarm_sec)               
  1317.          {
  1318.              RTC_SetAlarm(&rtctime);
  1319.          }   
  1320.       }   
  1321.    }    
  1322. }
  1323. #endif /* RTC_SW_CALIBRATION */
  1325. /*
  1326. * FUNCTION                                                            
  1327. * RTC_GetTime
  1328. *
  1329. * DESCRIPTION                                                           
  1330. *    Obtain the current time
  1331. *
  1332. * CALLS  
  1333. * This function is called to obtain the current time
  1334. *
  1335. * PARAMETERS
  1336. * rtctime: the current time.
  1337. *
  1338. * RETURNS
  1339. * None
  1340. *
  1341. * GLOBALS AFFECTED
  1342. *   external_global
  1343. */
  1344. void RTC_GetTime(t_rtc *rtctime ) //validate
  1345. {
  1346. #if !defined(__FUE__)
  1347.    kal_uint32 savedMask;
  1349. #if defined(DRV_RTC_HW_CALI)
  1350. RTC_wait_busy();
  1351. #endif   
  1353.    savedMask = SaveAndSetIRQMask();   
  1354. #endif /* !defined(__FUE__) */
  1355. rtctime->rtc_sec = DRV_Reg(RTC_TC_SEC);
  1356. rtctime->rtc_min = DRV_Reg(RTC_TC_MIN);
  1357. rtctime->rtc_hour = DRV_Reg(RTC_TC_HOU);
  1358. rtctime->rtc_day = DRV_Reg(RTC_TC_DOM);
  1359. rtctime->rtc_mon = DRV_Reg(RTC_TC_MTH);
  1360. rtctime->rtc_wday = DRV_Reg(RTC_TC_DOW);
  1361. rtctime->rtc_year = DRV_Reg(RTC_TC_YEA);
  1362. #if !defined(__FUE__)
  1363. RestoreIRQMask(savedMask);
  1364. #ifdef RTC_Test
  1365. RTC_delay();
  1366. #endif
  1367. #endif /* !defined(__FUE__) */
  1369.    // check the RTC validation, 
  1370. #if ( defined(__GPS_SUPPORT__) || defined(RTC_HW_CALIBRATION) )
  1371.    if((rtctime->rtc_sec>59) || 
  1372.       (rtctime->rtc_min>59) || 
  1373.       (rtctime->rtc_hour>23)|| 
  1374.       (rtctime->rtc_day>31) || (rtctime->rtc_day == 0) ||
  1375.       (rtctime->rtc_wday>7) || (rtctime->rtc_wday == 0) ||
  1376.       (rtctime->rtc_mon>12) || (rtctime->rtc_mon == 0)  ||
  1377.       (rtctime->rtc_year>127))
  1378.    {   
  1379.       if( IsOSRunning() && (RTC_isFisrtOn() == KAL_FALSE))
  1380.       {
  1381. #if defined(__PRODUCTION_RELEASE__)
  1382.          rtctime->rtc_sec=0; 
  1383.          rtctime->rtc_min=0;
  1384.          rtctime->rtc_hour=0;
  1385.          rtctime->rtc_day=1;
  1386.          rtctime->rtc_wday=1;  //Monday
  1387.          rtctime->rtc_mon=1;   //January
  1388.          rtctime->rtc_year = 4; //2004
  1389.          RTC_InitTC_Time(rtctime);
  1390. #else //#if defined(__PRODUCTION_RELEASE__)
  1391.          ASSERT(0);
  1392. #endif //#if defined(__PRODUCTION_RELEASE__)
  1393.       }
  1394.    }
  1395. #endif //#if ( defined(__GPS_SUPPORT__) || defined(RTC_HW_CALIBRATION) )
  1396. }
  1398. /*
  1399. * FUNCTION                                                            
  1400. * RTC_SetAlarm
  1401. *
  1402. * DESCRIPTION                                                           
  1403. *    Setup the alarm time
  1404. *
  1405. * CALLS  
  1406. * This function is called to setup the alarm time
  1407. *
  1408. * PARAMETERS
  1409. * rtctime: the expected alarm time.
  1410. *
  1411. * RETURNS
  1412. * None
  1413. *
  1414. * GLOBALS AFFECTED
  1415. *   external_global
  1416. */
  1417. void RTC_SetAlarm(t_rtc *rtctime ) //validate 
  1418. {
  1419. kal_uint32 loop;
  1420. #if !defined(__FUE__)
  1421.    //kal_uint32 savedMask=0;
  1422.    //savedMask = SaveAndSetIRQMask();
  1423. #endif /* !defined(__FUE__) */
  1425.    #if defined(DRV_RTC_HW_CALI) && !defined(__FUE__)
  1426.    RTC_wait_busy();
  1427.    #endif
  1429.     /* Add for loop to ensure that RTC alarm time has been written in. */
  1430.    for (loop = 0; loop < 1000000; loop++)
  1431.    {
  1432.       DRV_WriteReg(RTC_AL_SEC,rtctime->rtc_sec);
  1433.    DRV_WriteReg(RTC_AL_MIN,rtctime->rtc_min);
  1434.    DRV_WriteReg(RTC_AL_HOU,rtctime->rtc_hour);
  1435.    DRV_WriteReg(RTC_AL_DOM,rtctime->rtc_day);
  1436.    DRV_WriteReg(RTC_AL_MTH,rtctime->rtc_mon);
  1437.    DRV_WriteReg(RTC_AL_YEA,rtctime->rtc_year);
  1438.       #if defined(DRV_RTC_HW_CALI)
  1439.       RTC_write_trigger();
  1440.       #endif /*DRV_RTC_HW_CALI*/
  1441.       if ((DRV_Reg(RTC_AL_SEC) == rtctime->rtc_sec) && (DRV_Reg(RTC_AL_MIN) == rtctime->rtc_min)
  1442.          && (DRV_Reg(RTC_AL_HOU) == rtctime->rtc_hour) && (DRV_Reg(RTC_AL_DOM) == rtctime->rtc_day)
  1443.          && (DRV_Reg(RTC_AL_MTH) == rtctime->rtc_mon) && (DRV_Reg(RTC_AL_YEA) == rtctime->rtc_year))
  1444.          break;
  1445.    }
  1446. #if !defined(__FUE__)
  1447.    //RestoreIRQMask(savedMask);
  1448. #ifdef RTC_Test
  1449. RTC_delay();
  1450. #endif
  1451. #endif /* !defined(__FUE__) */
  1452. #if !defined(LOW_COST_SUPPORT)
  1453. #if !defined(__FUE__)
  1454.   drv_trace8(TRACE_GROUP_9, RTC_SET_ALARM, rtctime->rtc_year, rtctime->rtc_mon,
  1455.             rtctime->rtc_day, rtctime->rtc_hour, rtctime->rtc_min, rtctime->rtc_sec, 0, 0);
  1456. #endif
  1457. #endif
  1458. }
  1460. /*
  1461. * FUNCTION                                                            
  1462. * RTC_GetALTime
  1463. *
  1464. * DESCRIPTION                                                           
  1465. *    Obtain the alarm time
  1466. *
  1467. * CALLS  
  1468. * This function is called to obtain the alarm time setting
  1469. *
  1470. * PARAMETERS
  1471. * rtctime: the alarm time.
  1472. *
  1473. * RETURNS
  1474. * None
  1475. *
  1476. * GLOBALS AFFECTED
  1477. *   external_global
  1478. */
  1479. void RTC_GetALTime(t_rtc *rtctime ) //validate
  1480. {
  1482. #if defined(DRV_RTC_HW_CALI) && !defined(__FUE__)
  1483. RTC_wait_busy();
  1484. #endif   
  1486. rtctime->rtc_sec = DRV_Reg(RTC_AL_SEC);
  1487. rtctime->rtc_min = DRV_Reg(RTC_AL_MIN);
  1488. rtctime->rtc_hour = DRV_Reg(RTC_AL_HOU);
  1489. rtctime->rtc_day = DRV_Reg(RTC_AL_DOM);
  1490. rtctime->rtc_mon = DRV_Reg(RTC_AL_MTH);
  1491. rtctime->rtc_wday = DRV_Reg(RTC_AL_DOW);
  1492. rtctime->rtc_year = DRV_Reg(RTC_AL_YEA);
  1493. #ifdef RTC_Test
  1494. RTC_delay();
  1495. #endif
  1497. #if !defined(LOW_COST_SUPPORT)
  1498. #if !defined(__FUE__)
  1499.   drv_trace8(TRACE_GROUP_8, RTC_GET_AL_TIME, rtctime->rtc_year, rtctime->rtc_mon,
  1500.             rtctime->rtc_day, rtctime->rtc_hour, rtctime->rtc_min, rtctime->rtc_sec, 0, 0);
  1501. #endif
  1502. #endif
  1503. }
  1504. #if !defined(__FUE__)
  1505. //=================================================================
  1506. /*
  1507. * FUNCTION                                                            
  1508. * RTC_HISR
  1509. *
  1510. * DESCRIPTION                                                           
  1511. *    RTC interrupt handler
  1512. *
  1513. * CALLS  
  1514. * This function is called when RTC intr. is coming
  1515. *
  1516. * PARAMETERS
  1517. * None
  1518. *
  1519. * RETURNS
  1520. * None
  1521. *
  1522. * GLOBALS AFFECTED
  1523. *   external_global
  1524. */
  1525. void RTC_HISR(void)
  1526. {
  1527. kal_uint16 status;
  1529. #if defined(DRV_RTC_PWRON_BBPU_POLARITY)
  1530.    kal_uint16 BBPU;
  1531.    kal_uint16 POLAR;
  1532.    kal_uint16 PWRSW;
  1533.    
  1534.    BBPU = DRV_Reg(RTC_BBPU);
  1535.    POLAR = BBPU & RTC_BBPU_PWR_POLARITY;
  1536.    POLAR >>= 1;
  1537.    PWRSW = BBPU & RTC_BBPU_PWR_SW;
  1538.    #if defined(DRV_RTC_BBPU_AS_6205)
  1539.    PWRSW >>= 2;
  1540.    #else /*!MT6205*/
  1541.    PWRSW >>= 4;
  1542.    #endif   /*MT6205*/
  1544.    if (POLAR != PWRSW)
  1545.    {
  1546.       #ifndef __L1_STANDALONE__
  1547.       IRQMask(IRQ_RTC_CODE);
  1548.       ASSERT(0);
  1549.       return;
  1550.       #endif   /*__L1_STANDALONE__*/
  1551.    }
  1552. #endif   /*DRV_RTC_PWRON_BBPU_POLARITY*/ 
  1553. #if 0 /*remove this part because rtc initialization is before latch power*/
  1554. #if defined(DRV_RTC_PWRON_BBPU_SW)
  1555. /* under construction !*/
  1556. /* under construction !*/
  1557.       #ifndef __L1_STANDALONE__
  1558. /* under construction !*/
  1559. /* under construction !*/
  1560.       #endif   /*__L1_STANDALONE__*/
  1561. /* under construction !*/
  1562. #endif   /*DRV_RTC_PWRON_BBPU_SW*/
  1563. #endif 
  1564.    
  1565.    status = DRV_Reg(RTC_IRQ_STATUS);
  1566. if (status & RTC_IRQ_STATUS_AL_STAT)
  1567. {
  1568. RTC_CALLBAC.rtc_alfunc();
  1569.       #if defined(RTC_AS_MT6218)
  1570. // set AUTO_PDN bit of RTC_BBPU again which is cleared by RTC 
  1571. {
  1572.    kal_uint16 reg;
  1574.    reg = DRV_Reg(RTC_BBPU);
  1575.    reg |= (RTC_BBPU_KEY|RTC_BBPU_AUTOPDN); 
  1576.    DRV_WriteReg(RTC_BBPU, reg );
  1577.          #if defined(DRV_RTC_HW_CALI)
  1578.          RTC_write_trigger();
  1579.          #endif /*DRV_RTC_HW_CALI*/
  1580. }
  1581. #endif
  1582. }
  1583. if (status & RTC_IRQ_STATUS_TC_STAT)
  1584. {
  1585. RTC_CALLBAC.rtc_tcfunc();
  1586.     #if defined(DRV_RTC_HW_CALI)
  1587.     RTC_write_trigger();
  1588.     #endif /*DRV_RTC_HW_CALI*/
  1589. }
  1591. IRQClearInt(IRQ_RTC_CODE);
  1592. IRQUnmask(IRQ_RTC_CODE);
  1593. }
  1595. void RTC_LISR(void)
  1596. {
  1597.    IRQMask(IRQ_RTC_CODE);
  1598.    //kal_activate_hisr(RTCConfig.hisr);
  1599.     drv_active_hisr(DRV_RTC_HISR_ID);
  1600. }
  1601. #endif /*!defined(__FUE__)*/
  1602. /*
  1603. * FUNCTION                                                            
  1604. * RTC_isFisrtOn
  1605. *
  1606. * DESCRIPTION                                                           
  1607. *    Check whether RTC is first on
  1608. *
  1609. * CALLS  
  1610. * This function is called to check whether RTC is first on
  1611. *
  1612. * PARAMETERS
  1613. * None
  1614. *
  1615. * RETURNS
  1616. * KAL_TRUE: RTC is first on
  1617. * KAL_FALSE: RTC is not first on
  1618. *
  1619. * GLOBALS AFFECTED
  1620. *   external_global
  1621. */
  1622. kal_bool RTC_isFisrtOn(void) //validate
  1623. {
  1624. kal_uint16 key1 = DRV_Reg(RTC_POWERKEY1);
  1625. kal_uint16 key2 = DRV_Reg(RTC_POWERKEY2);
  1627. if ((key1 == RTC_POWERKEY1_KEY)&&(key2 == RTC_POWERKEY2_KEY))
  1628. {
  1629.    /*TY adds this 2004/10/21 to record this is first power on*/
  1630.    //First_PowerOn=KAL_FALSE;
  1631. return KAL_FALSE;
  1632. }
  1633. else
  1634. {
  1635.    /*TY adds this 2004/10/21 to record if this is first power on*/
  1636.    First_PowerOn=KAL_TRUE;
  1637. return KAL_TRUE;
  1638. }
  1639. }
  1640. #if !defined(__FUE__)
  1641. /*
  1642. * FUNCTION                                                            
  1643. * RTC_is_MS_FirstPowerOn
  1644. *
  1645. * DESCRIPTION                                                           
  1646. *    Check whether RTC is first power on
  1647. *
  1648. * CALLS  
  1649. * This function is called by MMI. MMI wants to knows this status
  1650. *  whenever he wants but the function "RTC_isFisrtOn" is only valid
  1651. *  before calling DRV_POWERON function
  1652. *
  1653. * PARAMETERS
  1654. * None
  1655. *
  1656. * RETURNS
  1657. * KAL_TRUE: RTC is first on
  1658. * KAL_FALSE: RTC is not first on
  1659. *
  1660. * GLOBALS AFFECTED
  1661. *   external_global
  1662. */
  1663. /*TY adds this 2004/10/21 to record if this is first power on*/    
  1664. kal_bool RTC_is_MS_FirstPowerOn(void) //validate
  1665. {
  1666. if (First_PowerOn==KAL_FALSE)
  1667. {    
  1668. return KAL_FALSE;
  1669. }
  1670. else
  1671. {    
  1672. return KAL_TRUE;
  1673. }
  1674. }
  1675. #endif /*!defined(__FUE__)*/
  1677. /*
  1678. * FUNCTION                                                            
  1679. * RTC_setPWRKey
  1680. *
  1681. * DESCRIPTION                                                           
  1682. *    Setup RTC power key
  1683. *
  1684. * CALLS  
  1685. * This function is called when RTC is first on
  1686. *
  1687. * PARAMETERS
  1688. * None
  1689. *
  1690. * RETURNS
  1691. * None
  1692. *
  1693. * GLOBALS AFFECTED
  1694. *   external_global
  1695. */
  1696. void RTC_setPWRKey(void) //validate
  1697. {
  1699. #if defined(DRV_RTC_HW_CALI) && !defined(__FUE__)
  1700. RTC_wait_busy();
  1701. #endif   
  1703. DRV_WriteReg(RTC_POWERKEY1,RTC_POWERKEY1_KEY);
  1704. DRV_WriteReg(RTC_POWERKEY2,RTC_POWERKEY2_KEY);
  1706. #if defined(DRV_RTC_HW_CALI)
  1707. RTC_write_trigger_wait();
  1708. #endif // #if defined(DRV_RTC_HW_CALI)
  1710. // After PWRKEY is configured to correct setting, set RTC XOSCCALI register
  1711. // This register is to control XOU swing
  1712. // This register is also configured in ADC_init(), but when PWRKEY is NOT matched, 
  1713. // the write operation of XOCCALI register will be failed
  1714. #if defined(DRV_RTC_XOSC_DEF_8)
  1715. DRV_WriteReg(RTC_XOSCCAL,0x8);
  1716. #else // #if defined(DRV_RTC_XOSC_DEF_8)
  1717. DRV_WriteReg(RTC_XOSCCAL,0x1f);
  1718. #endif // #if defined(DRV_RTC_XOSC_DEF_8)
  1719.    
  1720.    
  1721. #if defined(DRV_RTC_HW_CALI)
  1722. RTC_write_trigger_wait();
  1723. #endif // #if defined(DRV_RTC_HW_CALI)
  1725. }
  1727. #if !defined(__FUE__)
  1729. #if defined(RTC_HW_CALIBRATION)
  1730. /*
  1731. * FUNCTION                                                            
  1732. * rtc_get_cali_offset
  1733. *
  1734. * DESCRIPTION                                                           
  1735. *    To get the repeat calibration count value from register
  1736. *
  1737. * CALLS  
  1738. * This function is called when doing RTC HW calibration
  1739. *
  1740. * PARAMETERS
  1741. * None
  1742. *
  1743. * RETURNS
  1744. * the calibration count:  -0x40~0x3f (-64~63)
  1745. *
  1746. * GLOBALS AFFECTED
  1747. *   external_global
  1748. */
  1749. kal_int8 rtc_get_cali_offset(void)
  1750. {
  1751.    kal_uint16   data;
  1752.    kal_int8     ret_val=0;
  1754.    data = DRV_Reg(RTC_CALI);
  1755.    if (data&0x0040)
  1756.    {
  1757.       ret_val = (kal_int8)((~(data)+1)&0x007f);
  1758.       ret_val = -ret_val;
  1759.    }
  1760.    else
  1761.    {
  1762.       ret_val = (kal_int8)data;
  1763.    }
  1764.    return ret_val;
  1765. }
  1767. /*
  1768. * FUNCTION                                                            
  1769. * rtc_do_repeat_cali
  1770. *
  1771. * DESCRIPTION                                                           
  1772. *    To set the repeat calibration count value to register
  1773. *
  1774. * CALLS  
  1775. * This function is called when doing RTC HW calibration
  1776. *
  1777. * PARAMETERS
  1778. * None
  1779. *
  1780. * RETURNS
  1781. * the calibration count:  -0x40~0x3f (-64~63)
  1782. *
  1783. * GLOBALS AFFECTED
  1784. *   external_global
  1785. */
  1786. void rtc_do_repeat_cali(kal_int32  inaccurate_cnt)
  1787. {
  1788.    kal_int32   cali_cnt;
  1789.    kal_uint8   value;
  1791.    cali_cnt = inaccurate_cnt/RTC_CALI_REPEAT_TOTAL_CNT;
  1792.    /* divided by total count from last repeat calibration to this time. No that we don't do repeat
  1793.       calibration when there's no inaccurate count. */
  1794.    cali_cnt = cali_cnt/(1+no_diff_cnt);
  1795.    #ifdef RTC_CAL_DEBUG
  1796.    kal_prompt_trace(MOD_RTC_HISR, "Adjust %d count for repeat calibration registerrn", cali_cnt);
  1797.    #endif /* RTC_CAL_DEBUG */
  1798. #if !defined(LOW_COST_SUPPORT)
  1799.    drv_trace1(TRACE_GROUP_10, RTC_REPEAT_CALI_ADJUST_COUNT, cali_cnt);
  1800. #endif // #if !defined(LOW_COST_SUPPORT)
  1801.    cali_cnt += rtc_get_cali_offset();
  1802.    #ifdef RTC_CAL_DEBUG
  1803.    kal_prompt_trace(MOD_RTC_HISR, "Now the value for repeat calibration is %drn", cali_cnt);
  1804.    #endif /* RTC_CAL_DEBUG */
  1805. #if !defined(LOW_COST_SUPPORT)
  1806.    drv_trace1(TRACE_GROUP_10, RTC_REPEAT_CALI_VALUE, cali_cnt);
  1807. #endif // #if !defined(LOW_COST_SUPPORT)
  1809.    if (cali_cnt > RTC_CALI_REPEAT_MAX)
  1810.    {
  1811.       #ifdef RTC_CAL_DEBUG
  1812.       kal_prompt_trace(MOD_RTC_HISR, "Warning!! value %d exceeds repeat calibration MAX value!rn", cali_cnt);
  1813.       #endif /* RTC_CAL_DEBUG */
  1814. #if !defined(LOW_COST_SUPPORT)
  1815.       drv_trace1(TRACE_GROUP_10, RTC_REPEAT_CALI_VALUE_EXCEED_MAX, cali_cnt);
  1816. #endif // #if !defined(LOW_COST_SUPPORT)
  1817.       cali_cnt = RTC_CALI_REPEAT_MAX;
  1818.    }
  1819.    else if (cali_cnt < RTC_CALI_REPEAT_MIN)
  1820.    {
  1821.       #ifdef RTC_CAL_DEBUG
  1822.       kal_prompt_trace(MOD_RTC_HISR, "Warning!! value %d exceeds repeat calibration MIN value!rn", cali_cnt);
  1823.       #endif /* RTC_CAL_DEBUG */
  1824. #if !defined(LOW_COST_SUPPORT)
  1825.       drv_trace1(TRACE_GROUP_10, RTC_REPEAT_CALI_VALUE_EXCEED_MIN, cali_cnt);
  1826. #endif // #if !defined(LOW_COST_SUPPORT)
  1827.       cali_cnt = RTC_CALI_REPEAT_MIN;
  1828.    }
  1829.    if (cali_cnt < 0)
  1830.    {
  1831.       value = ((kal_uint8)(~(-cali_cnt)+1)) & 0x7f;
  1832.    }
  1833.    else
  1834.    {
  1835.       value = (kal_uint8)cali_cnt;
  1836.    }
  1837.    DRV_WriteReg(RTC_CALI, value);
  1838. }
  1840. /*
  1841. * FUNCTION                                                            
  1842. * rtc_do_one_time_cali
  1843. *
  1844. * DESCRIPTION                                                           
  1845. *    To do the one shot calibration
  1846. *
  1847. * CALLS  
  1848. * This function is called when doing RTC HW calibration
  1849. *
  1850. * PARAMETERS
  1851. * None
  1852. *
  1853. * RETURNS
  1854. * KAL_TRUE: need to do more one shot calibraiton
  1855. *  KAL_FASLE: No need to do more one shot calibration
  1856. *
  1857. * GLOBALS AFFECTED
  1858. *   external_global
  1859. */
  1860. kal_bool rtc_do_one_time_cali(void)
  1861. {
  1862.    kal_uint16  value;
  1864.    if (inaccurate_total_cnt > RTC_CALI_ONE_TIME_MAX)
  1865.    {
  1866.       /* Exceed max value. So calibration with RTC_CALI_ONE_TIME_MAX */
  1867.       inaccurate_total_cnt -= RTC_CALI_ONE_TIME_MAX;
  1868.       value = RTC_CALI_ONE_TIME_MAX;
  1869.       #ifdef RTC_CAL_DEBUG
  1870.       kal_prompt_trace(MOD_RTC_HISR, "Do one shot calibration for %d counts, remains: %d countsrn", RTC_CALI_ONE_TIME_MAX, inaccurate_total_cnt);
  1871.       #endif /* RTC_CAL_DEBUG */
  1872. #if !defined(LOW_COST_SUPPORT)
  1873.       drv_trace2(TRACE_GROUP_10, RTC_ONESHOT_CALI_PERFORM_COUNT, RTC_CALI_ONE_TIME_MAX, inaccurate_total_cnt);
  1874. #endif // #if !defined(LOW_COST_SUPPORT)
  1875.    }
  1876.    else if (inaccurate_total_cnt < RTC_CALI_ONE_TIME_MIN)
  1877.    {
  1878.       /* Less than the min value. So calibration with RTC_CALI_ONE_TIME_MIN */
  1879.       inaccurate_total_cnt -= RTC_CALI_ONE_TIME_MIN;
  1880.       /* 2's complement. */
  1881.       value = (~(-RTC_CALI_ONE_TIME_MIN) + 1) & 0x0fff;
  1882.       #ifdef RTC_CAL_DEBUG
  1883.       kal_prompt_trace(MOD_RTC_HISR, "Do one shot calibration for %d counts, remains: %d countsrn", RTC_CALI_ONE_TIME_MIN, inaccurate_total_cnt);
  1884.       #endif /* RTC_CAL_DEBUG */
  1885. #if !defined(LOW_COST_SUPPORT)
  1886.       drv_trace2(TRACE_GROUP_10, RTC_ONESHOT_CALI_PERFORM_COUNT, RTC_CALI_ONE_TIME_MAX, inaccurate_total_cnt);
  1887. #endif // #if !defined(LOW_COST_SUPPORT)
  1888.    }
  1889.    else
  1890.    {
  1891.       #ifdef RTC_CAL_DEBUG
  1892.       kal_prompt_trace(MOD_RTC_HISR, "Do one shot calibration for %d counts, remains: 0 countsrn", inaccurate_total_cnt);
  1893.       #endif /* RTC_CAL_DEBUG */
  1894. #if !defined(LOW_COST_SUPPORT)
  1895.       drv_trace2(TRACE_GROUP_10, RTC_ONESHOT_CALI_PERFORM_COUNT, inaccurate_total_cnt, 0);
  1896. #endif // #if !defined(LOW_COST_SUPPORT)
  1897.       /* calibration with inaccurate_total_cnt */
  1898.       if (inaccurate_total_cnt < 0)
  1899.       {
  1900.       /* 2's complement. */
  1901.          value = ((kal_uint16)(~(-inaccurate_total_cnt)+1)) & 0x0fff;
  1902.       }
  1903.       else
  1904.       {
  1905.          value = (kal_uint16)inaccurate_total_cnt;
  1906.       }
  1907.       inaccurate_total_cnt = 0;
  1908.    }
  1909.    #ifdef RTC_CAL_DEBUG
  1910.    kal_prompt_trace(MOD_RTC_HISR, "Write to one shot calib. value: %xrn", value);
  1911.    #endif /* RTC_CAL_DEBUG */
  1912. #if !defined(LOW_COST_SUPPORT)
  1913.    drv_trace1(TRACE_GROUP_10, RTC_ONESHOT_CALI_VALUE, value);
  1914. #endif // #if !defined(LOW_COST_SUPPORT)
  1915.    DRV_WriteReg(RTC_DIFF, value);
  1916.    if (inaccurate_total_cnt==0)
  1917.    {
  1918.       #ifdef RTC_CAL_DEBUG
  1919.       kal_prompt_trace(MOD_RTC_HISR, "Finish one shot calibration!!rn");
  1920.       #endif /* RTC_CAL_DEBUG */
  1921. #if !defined(LOW_COST_SUPPORT)
  1922.       drv_trace0(TRACE_GROUP_10, RTC_ONESHOT_CALI_FINISH);
  1923. #endif // #if !defined(LOW_COST_SUPPORT)
  1924.       return KAL_FALSE;
  1925.    }
  1926.    else
  1927.       return KAL_TRUE;
  1928. }
  1929. #endif /* RTC_HW_CALIBRATION */
  1931. /*
  1932. * FUNCTION                                                            
  1933. * RTC_TCintr
  1934. *
  1935. * DESCRIPTION                                                           
  1936. *    RTC Time tick interrupt handler
  1937. *
  1938. * CALLS  
  1939. * This function is called to handle TC interrupt
  1940. *
  1941. * PARAMETERS
  1942. * None
  1943. *
  1944. * RETURNS
  1945. * None
  1946. *
  1947. * GLOBALS AFFECTED
  1948. *   external_global
  1949. */
  1950. void RTC_TCintr(void)
  1951. {
  1952. #ifndef L4_NOT_PRESENT
  1953.  ilm_struct *RTC_ilm;
  1954.  RTC_Primitive *RTC_Prim;
  1955.    kal_bool msg_b; //for avoid Lint Warning 534: Ignoring return value of function 'msg_send_ext_queue"
  1956. #if defined(RTC_HW_CALIBRATION)
  1957.    kal_uint32 frame_tick;
  1958.    t_rtc current_time;
  1959.    kal_uint32 diff_frame_tick;
  1961.    if (cali_state != (kal_uint8)CAL_STATE_NONE)
  1962.    {
  1963.       kal_bool need_trigger;
  1964.       kal_int32  inaccurate_frame_tick = 0;
  1966.       need_trigger = KAL_FALSE;
  1967.       RTC_GetTime(&current_time);
  1968.       if (current_time.rtc_sec == 0)
  1969.       {
  1970.          if (cali_state == (kal_uint8)CAL_STATE_INIT)
  1971.          {
  1972.             /* Get the L1 frame tick for reference. */
  1973.             rtc_current_frame_tick = L1I_GetTimeStamp();
  1974.             cali_state = (kal_uint8)CAL_STATE_START;
  1975.             #ifdef RTC_CAL_DEBUG
  1976.             kal_prompt_trace(MOD_RTC_HISR, "Start to measure RTC inaccurate. current time - (%d:%d:%d)",
  1977.                current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec);
  1978.             kal_prompt_trace(MOD_RTC_HISR, "ini L1 ticks=%drn",rtc_current_frame_tick);
  1979.             #endif /* RTC_CAL_DEBUG */
  1980. #if !defined(LOW_COST_SUPPORT)
  1981.             drv_trace4(TRACE_GROUP_10, RTC_HW_CALI_START_MEASURE_INACCURATE, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec, 0);
  1982.             drv_trace1(TRACE_GROUP_10, RTC_HW_CALI_INIT_MEASURE_ACCURATE_L1_TICK, rtc_current_frame_tick);
  1983. #endif // #if !defined(LOW_COST_SUPPORT)
  1984.          }
  1985.          else if (cali_state == (kal_uint8)CAL_STATE_START)
  1986.          {
  1987.             tc_min_expire_cnt++;
  1988.             if (RTC_CALI_PERIOD_MINS<=tc_min_expire_cnt)
  1989.             {
  1990.                tc_min_expire_cnt = 0;
  1991.                /* Get the L1 frame tick for computation. */
  1992.                frame_tick = L1I_GetTimeStamp();
  1993.                if(frame_tick>=rtc_current_frame_tick)
  1994.                 diff_frame_tick=(frame_tick - rtc_current_frame_tick);
  1995.                else
  1996.                {
  1997.                 diff_frame_tick=(0xffffffff-rtc_current_frame_tick+frame_tick+1);
  1998.                }
  1999.                /* Compute the difference between expected frame tick count and real frame tick count. */
  2000.                inaccurate_frame_tick = diff_frame_tick - RTC_CALI_TICK_VALUE;
  2001.                #ifdef RTC_CAL_DEBUG
  2002.                kal_prompt_trace(MOD_RTC_HISR, "Finish to measure RTC inaccurate for %d mins. current time - (%d:%d:%d)",
  2003.                   RTC_CALI_PERIOD_MINS, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec);
  2004.                kal_prompt_trace(MOD_RTC_HISR, "L1 ticks=%d, inaccurate ticks=%drn",frame_tick, inaccurate_frame_tick);
  2005.                #endif /* RTC_CAL_DEBUG */
  2006. #if !defined(LOW_COST_SUPPORT)
  2007.                drv_trace4(TRACE_GROUP_10, RTC_HW_CALI_FINISH_MEASURE_INACCURATE, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec, 0);
  2008.                drv_trace2(TRACE_GROUP_10, RTC_HW_CALI_FINISH_MEASURE_ACCURATE_L1_TICK, frame_tick, inaccurate_frame_tick);
  2009. #endif // #if !defined(LOW_COST_SUPPORT)
  2011.                /* The next expected frame tick count. */
  2012.                rtc_current_frame_tick += RTC_CALI_TICK_VALUE;
  2013.                if (inaccurate_frame_tick == 0)
  2014.                {
  2015.                   no_diff_cnt++;
  2016.                   #ifdef RTC_CAL_DEBUG
  2017.                   kal_prompt_trace(MOD_RTC_HISR, "No difference and no need do calibration!!  no_diff_cnt=%d rn", no_diff_cnt);
  2018.                   #endif /* RTC_CAL_DEBUG */
  2019. #if !defined(LOW_COST_SUPPORT)
  2020.                   drv_trace1(TRACE_GROUP_10, RTC_HW_CALI_NO_NEED_TO_CALI, no_diff_cnt);
  2021. #endif // #if !defined(LOW_COST_SUPPORT)
  2022.                }
  2023.                else
  2024.                {
  2025.                   if (inaccurate_frame_tick < 0)
  2026.                   {
  2027.                      /* Note that there are 650/3 frames ticks per second. */
  2028.                      inaccurate_total_cnt = (-inaccurate_frame_tick)*rtc_current_freq_8secs*3/8/650;
  2029.                      inaccurate_total_cnt = -inaccurate_total_cnt;
  2030.                   }
  2031.                   else
  2032.                   {
  2033.                      inaccurate_total_cnt = inaccurate_frame_tick*rtc_current_freq_8secs*3/8/650;
  2034.                   }
  2035.                   #ifdef RTC_CAL_DEBUG
  2036.                   kal_prompt_trace(MOD_RTC_HISR, "Do repeat calibration for %d countsrn", inaccurate_total_cnt);
  2037.                   #endif /* RTC_CAL_DEBUG */
  2038. #if !defined(LOW_COST_SUPPORT)
  2039.                   drv_trace1(TRACE_GROUP_10, RTC_REPEAT_CALI_PERFORM_CALI, inaccurate_total_cnt);
  2040. #endif // #if !defined(LOW_COST_SUPPORT)
  2041.                   rtc_do_repeat_cali(inaccurate_total_cnt);
  2042.                   one_time_cali = KAL_TRUE;
  2043.                   /* Enable TC seconds interrupt */
  2044.                   if (rtc_tc_int_var != TC_EN_ChkS)
  2045.                 DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_SEC);
  2046.                   need_trigger = KAL_TRUE;
  2047.                   no_diff_cnt = 0;
  2048.                }
  2049.             }
  2050.             else
  2051.             {
  2052.                #ifdef RTC_CAL_DEBUG
  2053.                kal_prompt_trace(MOD_RTC_HISR, "In progress for HW RTC calibration. current time - (%d:%d:%d)",
  2054.                   current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec);
  2055.                #endif /* RTC_CAL_DEBUG */
  2056. #if !defined(LOW_COST_SUPPORT)
  2057.                drv_trace4(TRACE_GROUP_10, RTC_HW_CALI_IN_PROGRESS, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec, 0);
  2058. #endif // #if !defined(LOW_COST_SUPPORT)
  2059.                
  2060.             }
  2061.          }
  2062.       } /* (current_time.rtc_sec == 0) */
  2063.       if (one_time_cali == KAL_TRUE)
  2064.       {
  2065.          kal_bool ret_value;
  2067.          ret_value = rtc_do_one_time_cali();
  2068.          need_trigger = KAL_TRUE;
  2069.          if (ret_value == KAL_FALSE)
  2070.          {
  2071.             /* No need to do one shot calibration. Change back to minute interrupt if needed. */
  2072.             if (rtc_tc_int_var != TC_EN_ChkS)
  2073.             {
  2074.           DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_MIN);
  2075.             }
  2076.             one_time_cali = KAL_FALSE;
  2077.          }
  2078.       }
  2079.       if (need_trigger == KAL_TRUE)
  2080.       {
  2081.          RTC_write_trigger();
  2082.       }
  2083. #elif defined(RTC_SW_CALIBRATION)
  2084.    t_rtc current_time;
  2085.    kal_uint32 frame_tick;
  2086. #if defined(SLEEP_WORKAROUND_IN_RTC)
  2087. kal_uint32 rtc_sleep_wa_delay_tick;
  2088. static t_rtc previous_time;
  2089. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2091.    if (cali_state != (kal_uint8)CAL_STATE_NONE)
  2092.    {
  2093.       RTC_GetTime(&current_time);
  2094.       if (cali_state == (kal_uint8)CAL_STATE_INIT)
  2095.       {
  2096.        kal_uint16 reg_comm2;
  2097.        //kal_uint16 tmp;
  2099.       //tmp = DRV_Reg(RTC_IRQ_EN);
  2100.       //tmp &=~RTC_IRQ_EN_ONESHOT;
  2101.    //tmp |= RTC_IRQ_EN_TC;
  2102.        //DRV_WriteReg(RTC_IRQ_EN,tmp);
  2104.          #ifdef RTC_CAL_DEBUG2
  2105.          kal_prompt_trace(MOD_RTC_HISR, "Start to do poweroff calibration");
  2106.          #endif /* RTC_CAL_DEBUG */
  2107.          
  2108. #if !defined(LOW_COST_SUPPORT)
  2109.          drv_trace0(TRACE_GROUP_10, RTC_SW_CALI_START_POWEROFF_CALI);
  2110. #endif // #if !defined(LOW_COST_SUPPORT)
  2111.          /* Change to calibration start state. */
  2112.          cali_state = (kal_uint8)CAL_STATE_START;
  2113.          if (pwroff_inacc_ticks != 0)
  2114.          {
  2115.             kal_uint16 hours, mins, secs;
  2116.             kal_bool neg = KAL_FALSE;
  2118.             tc_min_expire_cnt = 0;
  2119.             /* Check the time has to be forward or backward. */
  2120.             if (pwroff_inacc_ticks < 0)
  2121.             {
  2122.                neg = KAL_TRUE;
  2123.                pwroff_inacc_ticks = -pwroff_inacc_ticks;
  2124.             }
  2125.             /* Calculate the time shift for hour(60*13000), minute(13000) and second(650/3). */
  2126.             hours = pwroff_inacc_ticks/(13000*60);
  2127.             pwroff_inacc_ticks = pwroff_inacc_ticks%(13000*60);
  2128.             mins = pwroff_inacc_ticks/13000;
  2129.             pwroff_inacc_ticks = pwroff_inacc_ticks%13000;
  2130.             secs = pwroff_inacc_ticks*3/650;
  2131.             #ifdef RTC_CAL_DEBUG2
  2132.             kal_prompt_trace(MOD_RTC_HISR, "current time before poweroff calibration- (%d:%d:%d)",
  2133.                current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec);
  2134.             #endif /* RTC_CAL_DEBUG */
  2135. #if !defined(LOW_COST_SUPPORT)
  2136.             drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_START_POWEROFF_CALI_TIME, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec, 0);
  2137. #endif // #if !defined(LOW_COST_SUPPORT)
  2138.             
  2139.             /* Calculate the ticks to reach the nearest second boundary. */
  2140.             if (neg==KAL_TRUE)
  2141.             {
  2142.                pwroff_inacc_ticks = pwroff_inacc_ticks - (secs*650/3);
  2143.                rtc_backward_time(&current_time, hours, mins, secs);
  2144.             }
  2145.             else
  2146.             {
  2147.                secs++;
  2148.                pwroff_inacc_ticks = (secs*650/3) - pwroff_inacc_ticks;
  2149.                rtc_forward_time(&current_time, hours, mins, secs);
  2150.             }
  2151.             /* Set the correct time here. */
  2152.             RTC_Cali_Time(&current_time);
  2153.             #ifdef RTC_CAL_DEBUG2
  2154.             kal_prompt_trace(MOD_RTC_HISR, "current time after poweroff calibration- (%d:%d:%d)",
  2155.                current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec);
  2156.             #endif /* RTC_CAL_DEBUG */
  2157. #if !defined(LOW_COST_SUPPORT)
  2158.             drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_FINISH_POWEROFF_CALI_TIME, current_time.rtc_hour, current_time.rtc_min, current_time.rtc_sec, 0);
  2159. #endif // #if !defined(LOW_COST_SUPPORT)
  2160.             if (pwroff_inacc_ticks != 0)
  2161.             {
  2162.                #ifdef RTC_CAL_DEBUG2
  2163.                kal_prompt_trace(MOD_RTC_HISR, "wait %d ticks to do second poweroff calibration",
  2164.                   pwroff_inacc_ticks);
  2165.                #endif /* RTC_CAL_DEBUG */
  2166. #if !defined(LOW_COST_SUPPORT)
  2167.                drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_FINISH_2ND_POWEROFF_CALI, pwroff_inacc_ticks);
  2168. #endif // #if !defined(LOW_COST_SUPPORT)
  2169.                /* Still some ticks hasn't been calibrated. So change to init2 state */
  2170.                cali_state = (kal_uint8)CAL_STATE_INIT2;
  2171.                /* Save the correct time in: next_current_time */
  2172.                next_current_time = current_time;
  2173.                /* We'll write the correct time again when the exact correspoding time(second) comes by using KAL timer. */
  2174.                kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_cali_init, NULL, pwroff_inacc_ticks,0);
  2175.             }
  2176.          }
  2177.          /* validate rtc nvram data */
  2178.        reg_comm2 = DRV_Reg(DRV_COMM_REG2);
  2179.          reg_comm2 |= DRV_COMM_REG2_RTC_NVRAM;
  2180.          DRV_WriteReg(DRV_COMM_REG2,reg_comm2);    
  2182.          /* Send msg to write current time to nvram */
  2183.          rtc_nvram_s.time_valid = KAL_TRUE;
  2184.          rtc_nvram_s.rtc_time = current_time;
  2185.          rtc_write_to_nvram();
  2187.          /* Turn on the TC minute interrupt if necessary. */
  2188.          if (rtc_tc_int_var != TC_EN_ChkS)
  2189.           DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_MIN);
  2190.          if (pwroff_inacc_ticks == 0)
  2191.          {
  2192.             tick_left=0;
  2193.             one_third_tick_count = 0;
  2195.             /* We may start calibration here. */
  2196.             next_current_time = current_time;
  2197.             kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, rtc_cali_tick_value+rtc_cali_tick_safe_margin,0);
  2198.             #if (!defined(__L1_STANDALONE__)) 
  2199.             frame_tick=L1I_GetTimeStamp();
  2200.             #endif
  2201.             #ifdef RTC_CAL_DEBUG
  2202.             kal_prompt_trace(MOD_RTC_HISR, "Start poweron calibration");
  2203.             kal_prompt_trace(MOD_RTC_HISR, "(%d:%d:%d): ",next_current_time.rtc_hour,next_current_time.rtc_min,next_current_time.rtc_sec);
  2204.             kal_prompt_trace(MOD_RTC_HISR, "ini tick=%drn",frame_tick);                                                   
  2205.             #endif /* RTC_CAL_DEBUG */
  2206. #if !defined(LOW_COST_SUPPORT)
  2207.             drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_START_POWERON_CALI_TIME, next_current_time.rtc_hour,next_current_time.rtc_min,next_current_time.rtc_sec, frame_tick);
  2208. #endif // #if !defined(LOW_COST_SUPPORT)
  2209.             next_frame_tick=frame_tick+rtc_cali_tick_value;         
  2210.             rtc_get_next_time();    
  2211.          }
  2212.       }
  2213.       else if (cali_state == (kal_uint8)CAL_STATE_START)
  2214.       {
  2215.          #if defined(SLEEP_WORKAROUND_IN_RTC)
  2216.          // When WA enabled, RTC ISR may be delayed, we can NOT guarantee trc_sec == 0 always
  2217.          // Our goal is to count tc_min_expire_cnt every minute
  2218.          if (current_time.rtc_min != /*lint -e(727)*/previous_time.rtc_min)
  2219.          #else
  2220.          // If WA not enabled, we just only need to confirm sec == 0
  2221.          /* rtc_sec is zero. Meaning it's TC minute expired. */
  2222.          if (current_time.rtc_sec == 0)
  2223.          #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2224.          {
  2225.             if (tc_min_expire_cnt == 0)
  2226.             {
  2227.                /* Save the frame stick as a refence. */
  2228.                frame_tick1=L1I_GetTimeStamp();
  2229.                #ifdef RTC_CAL_DEBUG2
  2230.                kal_prompt_trace(MOD_RTC_HISR, "Inaccuracy measurement start");
  2231.                #endif /* RTC_CAL_DEBUG */
  2232. #if !defined(LOW_COST_SUPPORT)
  2233.                drv_trace0(TRACE_GROUP_10, RTC_SW_CALI_POWERON_CALI_START_INACCURACY_MEASURE);
  2234. #endif // #if !defined(LOW_COST_SUPPORT)
  2235.                
  2236.             }
  2237. #if defined(SLEEP_WORKAROUND_IN_RTC)
  2238. else if (tc_min_expire_cnt == 59)
  2239. {
  2240. // Calculate how many ticks we should wait to disable sleep mode
  2241. // We plan to wakeup at 58 sec
  2242. rtc_sleep_wa_delay_tick = 58 - (kal_uint32)current_time.rtc_sec;
  2243. rtc_sleep_wa_delay_tick = (kal_uint32) ((rtc_sleep_wa_delay_tick * 1000) / 4.615);
  2244. // Set kal timer in order to disable sleep mode for RTC calibration
  2245. kal_set_timer(rtc_sleep_wa_timer_id, (kal_timer_func_ptr)rtc_sleep_wa_timer_cb, NULL, rtc_sleep_wa_delay_tick,0);
  2246. #ifdef RTC_SLEEP_WA_DEBUG
  2247. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Start disable sleep timer with tick: %d", 
  2248. current_time.rtc_min, current_time.rtc_sec, rtc_sleep_wa_delay_tick);
  2249. #endif /* RTC_SLEEP_WA_DEBUG */
  2250. }
  2251. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2252.             else if (tc_min_expire_cnt == 60)
  2253.             {
  2254. #if defined(SLEEP_WORKAROUND_IN_RTC)
  2255. // We only calculate 1hr diff when disable_sleep is performed
  2256. // This means there is no problem between kal timer and our rtc TC intr
  2257. if (rtc_sleep_wa_disable_sleep_performed)
  2258. {
  2259. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2260.             
  2261.                /* Get the frame stick after 60 minutes passed. */
  2262.                frame_tick2=L1I_GetTimeStamp();
  2263.                /* Calculate the frame tick number for 1 hr of RTC time. */
  2264.                if(frame_tick2>=frame_tick1) 
  2265.                 frame_tick_1hr_diff=(kal_int32)(frame_tick2-frame_tick1 - 13000*60);
  2266.                else
  2267.                 frame_tick_1hr_diff=(kal_int32)(0xffffffff+frame_tick2-frame_tick1+1 - 13000*60);
  2268.                
  2269.                #ifdef RTC_CAL_DEBUG2
  2270.                kal_prompt_trace(MOD_RTC_HISR, "Inaccuracy measurement done for one hour: %d ticks", frame_tick_1hr_diff);
  2271.                #endif /* RTC_CAL_DEBUG */
  2272. #if !defined(LOW_COST_SUPPORT)
  2273.                drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_POWERON_CALI_FINISH_INACCURACY_MEASURE, frame_tick_1hr_diff);
  2274. #endif // #if !defined(LOW_COST_SUPPORT)
  2275.                
  2276.                /* save frame_tick_1hr_diff(inaccuracy) to nvram here */
  2277.                //rtc_nvram_s.ticks_diff_valid = KAL_TRUE;
  2278.                //rtc_nvram_s.ticks_diff_per_hour = frame_tick_1hr_diff;
  2279.                //rtc_write_to_nvram();
  2280.                
  2281. #if defined(SLEEP_WORKAROUND_IN_RTC)
  2282. #ifdef RTC_SLEEP_WA_DEBUG
  2283. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Calculate power off calibration info", 
  2284. current_time.rtc_min, current_time.rtc_sec);
  2285. #endif /* RTC_SLEEP_WA_DEBUG */
  2286. } // if (rtc_sleep_wa_disable_sleep_performed)
  2287. else
  2288. {
  2289. #ifdef RTC_SLEEP_WA_DEBUG
  2290. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Warning!!, disable sleep mode NOT performed", 
  2291. current_time.rtc_min, current_time.rtc_sec);
  2292. #endif /* RTC_SLEEP_WA_DEBUG */
  2293. }
  2294. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2295.                
  2296. #if defined(SLEEP_WORKAROUND_IN_RTC)
  2297. rtc_sleep_wa_disable_sleep_performed = KAL_FALSE;
  2298. // After RTC calibration processing is done, re-enabel sleep mode
  2299. // We always enable sleep mode in this stage
  2300. rtc_sleep_wa_enable_sleep_mode();
  2301. #ifdef RTC_SLEEP_WA_DEBUG
  2302. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Enable sleep mode", 
  2303. current_time.rtc_min, current_time.rtc_sec);
  2304. #endif /* RTC_SLEEP_WA_DEBUG */
  2305. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2306.             }
  2307.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2308.             // Only sec, min, hour info is enough for us
  2309.             previous_time.rtc_sec = current_time.rtc_sec;
  2310.             previous_time.rtc_min = current_time.rtc_min;
  2311.             previous_time.rtc_hour = current_time.rtc_hour;
  2312.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2313.             tc_min_expire_cnt++;
  2314.          }
  2315.       }
  2316. #endif /* RTC_SW_CALIBRATION */
  2317. #if defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION)
  2318.       /* Check user's configuration for Time Clock interrupt. */
  2319.    switch(rtc_tc_int_var)
  2320.    {
  2321.    case TC_EN_None:
  2322.    return;
  2323.    break;
  2324.    
  2325.    case TC_EN_ChkS:
  2326.    break;
  2327.    
  2328.    case TC_EN_ChkM:
  2329.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2330.             // If WA enabled, we won't check sec, because it would be delayed
  2331.             ;
  2332.             #else
  2333.             // Original design: sec must be 0 if it is user TC setting
  2334.             if (current_time.rtc_sec != 0)
  2335.                return;
  2336.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2337.    break;
  2338.    
  2339.       case TC_EN_ChkH:
  2340.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2341.             // If WA enabled, we won't check sec, because it would be delayed
  2342.             if ((current_time.rtc_min != 0))
  2343.                return;
  2344.             #else
  2345.             // Original design: sec must be 0 if it is user TC setting
  2346.             if ((current_time.rtc_sec != 0) || (current_time.rtc_min != 0))
  2347.                return;
  2348.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2349.    break;
  2350.    
  2351.    case TC_EN_ChkD:
  2352.    case TC_EN_ChkW:
  2353.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2354.             // If WA enabled, we won't check sec, because it would be delayed
  2355.             if ((current_time.rtc_min != 0) ||(current_time.rtc_hour != 0))
  2356.                return;
  2357.             #else
  2358.             // Original design: sec must be 0 if it is user TC setting
  2359.             if ((current_time.rtc_sec != 0) || (current_time.rtc_min != 0) ||(current_time.rtc_hour != 0))
  2360.                return;
  2361.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2362.    break;
  2363.    case TC_EN_ChkMon:
  2364.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2365.             // If WA enabled, we won't check sec, because it would be delayed
  2366.             if ((current_time.rtc_min != 0) ||(current_time.rtc_hour != 0) 
  2367.                ||(current_time.rtc_day != 1))
  2368.                return;
  2369.             #else
  2370.             // Original design: sec must be 0 if it is user TC setting
  2371.             if ((current_time.rtc_sec != 0) || (current_time.rtc_min != 0) ||(current_time.rtc_hour != 0) 
  2372.                ||(current_time.rtc_day != 1))
  2373.                return;
  2374.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2375.    break;
  2376.    
  2377.    case TC_EN_ChkY:
  2378.             #if defined(SLEEP_WORKAROUND_IN_RTC)
  2379.             // If WA enabled, we won't check sec, because it would be delayed
  2380.             if ((current_time.rtc_min != 0) ||(current_time.rtc_hour != 0) 
  2381.                ||(current_time.rtc_day != 1) || (current_time.rtc_mon != 1))
  2382.                return;
  2383.             #else
  2384.             // Original design: sec must be 0 if it is user TC setting
  2385.             if ((current_time.rtc_sec != 0) || (current_time.rtc_min != 0) ||(current_time.rtc_hour != 0) 
  2386.                ||(current_time.rtc_day != 1) || (current_time.rtc_mon != 1))
  2387.                return;
  2388.             #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  2389.    break;
  2390.  
  2391.          case TC_EN_NoChange:
  2392.             break;
  2393.       
  2394.    default:
  2395.    break;
  2396.    }
  2397.    } /*(cali_state != CAL_STATE_NONE)*/
  2398.    #ifdef RTC_CAL_DEBUG
  2399.    //frame_tick=L1I_GetTimeStamp();
  2400.    kal_prompt_trace(MOD_RTC_HISR, "TC interrupt for userrn");
  2401.    #endif /* RTC_CAL_DEBUG */
  2402.    drv_trace0(TRACE_GROUP_10, RTC_TC_INTR_FOR_USER);
  2403.    
  2404.    
  2405. #endif /* defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION) */
  2407.    //RTC_ilm = allocate_ilm(MOD_RTC_HISR);
  2408.    RTC_ilm = allocate_ilm(MOD_DRV_HISR);
  2409.    RTC_Prim = (RTC_Primitive*)
  2410.    construct_local_para(sizeof(RTC_Primitive), TD_CTRL);
  2411.    RTC_Prim->rtc_ind = RTC_TC_IND;
  2412.    //RTC_ilm->src_mod_id = MOD_RTC_HISR;
  2413.    RTC_ilm->src_mod_id = MOD_DRV_HISR;
  2414.    RTC_ilm->dest_mod_id = MOD_UEM;
  2415.    RTC_ilm->sap_id = DRIVER_PS_SAP;
  2416.    RTC_ilm->msg_id = MSG_ID_DRVUEM_RTC_PERIOD_IND;
  2417.    RTC_ilm->local_para_ptr = (local_para_struct *)RTC_Prim;
  2418. RTC_ilm->peer_buff_ptr = NULL;
  2419.    /*lint -e(534)*/msg_b = msg_send_ext_queue(RTC_ilm);
  2420. #endif   /*L4_NOT_PRESENT*/   
  2421. }
  2423. void RTC_ALintr(void)
  2424. {
  2425.    kal_uint16 BBPU;
  2426. #ifndef L4_NOT_PRESENT
  2427.  kal_bool btmp;
  2428. #endif   /*L4_NOT_PRESENT*/ 
  2430. #ifndef L4_NOT_PRESENT
  2431. ilm_struct *RTC_ilm;
  2432. RTC_Primitive *RTC_Prim;
  2433. #endif   /*L4_NOT_PRESENT*/ 
  2434.    BBPU = DRV_Reg(RTC_BBPU);
  2435.    BBPU &=~(RTC_BBPU_ALARM_SW);/*0227 TY adds*/
  2436. #if defined(DRV_RTC_WRITE_ENABLE)
  2437. BBPU |= RTC_BBPU_WRITE_EN;
  2438. #endif // #if defined(DRV_RTC_WRITE_ENABLE)
  2439. DRV_WriteReg(RTC_BBPU,(BBPU|RTC_BBPU_KEY));/*0227 TY adds*/
  2440. #if defined(DRV_RTC_HW_CALI)
  2441.    RTC_write_trigger();
  2442. #endif /*DRV_RTC_HW_CALI*/
  2443.    drv_trace0(TRACE_GROUP_10, RTC_AL_INTR);
  2444.    
  2445. #ifndef L4_NOT_PRESENT
  2446.    //RTC_ilm = allocate_ilm(MOD_RTC_HISR);
  2447.    RTC_ilm = allocate_ilm(MOD_DRV_HISR);
  2448.    RTC_Prim = (RTC_Primitive*)
  2449.    construct_local_para(sizeof(RTC_Primitive), TD_CTRL);
  2450.    RTC_Prim->rtc_ind = RTC_AL_IND;
  2451.    //RTC_ilm->src_mod_id = MOD_RTC_HISR;
  2452.    RTC_ilm->src_mod_id = MOD_DRV_HISR;
  2453.    RTC_ilm->dest_mod_id = MOD_UEM;
  2454.    RTC_ilm->sap_id = DRIVER_PS_SAP;
  2455.    RTC_ilm->msg_id = MSG_ID_DRVUEM_RTC_PERIOD_IND;
  2456.    RTC_ilm->local_para_ptr = (local_para_struct *)RTC_Prim;
  2457. RTC_ilm->peer_buff_ptr = NULL;
  2458.    btmp = msg_send_ext_queue(RTC_ilm);
  2459. #endif   /*L4_NOT_PRESENT*/ 
  2460.    
  2461. }
  2464. #if defined(RTC_SW_CALIBRATION)
  2465. /*
  2466. * FUNCTION                                                            
  2467. * rtc_write_to_nvram
  2468. *
  2469. * DESCRIPTION                                                           
  2470. *    Save RTC SW calibration data to nvram
  2471. *
  2472. * CALLS  
  2473. * This function is called internally for RTC SW calibration
  2474. *
  2475. * PARAMETERS
  2476. * None
  2477. *
  2478. * RETURNS
  2479. * None
  2480. *
  2481. * GLOBALS AFFECTED
  2482. *  None
  2483. */
  2484. void rtc_write_to_nvram(void)
  2485. {
  2486.    ilm_struct *rtc_ilm_ptr=0;
  2487.    void  *parm_stream=0;
  2488.    void  *data_stream=0;
  2489.    kal_uint16 pdu_len;
  2490.    kal_bool msg_b; //for avoid Lint Warning 534: Ignoring return value of function 'msg_send_ext_queue"
  2492.    
  2493. #if !defined(LOW_COST_SUPPORT)
  2494.    drv_trace0(TRACE_GROUP_10, RTC_SW_CALI_WRITE_NVRAM);
  2495. #endif // #if !defined(LOW_COST_SUPPORT)
  2496.    
  2497.    rtc_ilm_ptr = allocate_ilm(MOD_RTC_HISR);
  2498.    rtc_ilm_ptr->msg_id = MSG_ID_NVRAM_WRITE_REQ;
  2500.    parm_stream = construct_local_para(sizeof(nvram_write_req_struct), TD_CTRL);
  2501.    data_stream = construct_peer_buff(sizeof(rtc_nvram_data), 0, 0, TD_CTRL);
  2503.    ((nvram_write_req_struct*) parm_stream)->file_idx =  (nvram_lid_enum)NVRAM_EF_RTC_DATA_LID;
  2504.    ((nvram_write_req_struct*) parm_stream)->para = 1;
  2506.    pdu_len = sizeof(rtc_nvram_data);
  2507.    /*lint -e(534)*/kal_mem_cpy(get_pdu_ptr(data_stream, &pdu_len), (void*)&rtc_nvram_s, sizeof(rtc_nvram_data));
  2509.    rtc_ilm_ptr->local_para_ptr = (local_para_struct*) parm_stream;
  2510.    rtc_ilm_ptr->peer_buff_ptr = (peer_buff_struct*) data_stream;
  2512.    rtc_ilm_ptr->src_mod_id  = MOD_RTC_HISR;
  2513.    rtc_ilm_ptr->dest_mod_id = MOD_NVRAM;
  2514.    rtc_ilm_ptr->sap_id = PS_NVRAM_SAP;
  2515.    msg_b = msg_send_ext_queue(rtc_ilm_ptr);
  2517. #if !defined(LOW_COST_SUPPORT)
  2518. #if !defined(__FUE__)
  2519.   drv_trace8(TRACE_GROUP_9, RTC_WRITE_TO_NVRAM, rtc_nvram_s.rtc_time.rtc_year, rtc_nvram_s.rtc_time.rtc_mon,
  2520.       rtc_nvram_s.rtc_time.rtc_day, rtc_nvram_s.rtc_time.rtc_hour, rtc_nvram_s.rtc_time.rtc_min, 
  2521.       rtc_nvram_s.rtc_time.rtc_sec, 0, 0);
  2522. #endif
  2523. #endif
  2524. }
  2526. /*
  2527. * FUNCTION                                                            
  2528. * rtc_compare_time
  2529. *
  2530. * DESCRIPTION                                                           
  2531. *  Compare the rtc time.
  2532. *
  2533. * CALLS  
  2534. * This function is called internally for RTC SW calibration
  2535. *
  2536. * PARAMETERS
  2537. * rtc_time1
  2538. * rtc_time2
  2539. *
  2540. * RETURNS
  2541. * KAL_TRUE if rtc_time1 > rtc_time2. Else, return KAL_FALSE
  2542. *
  2543. * GLOBALS AFFECTED
  2544. *  None
  2545. */
  2546. kal_bool rtc_compare_time(t_rtc *rtc_time1, t_rtc *rtc_time2)
  2547. {
  2548.    if (rtc_time1->rtc_year < rtc_time2->rtc_year)
  2549.       return KAL_FALSE;
  2550.    else if (rtc_time1->rtc_year == rtc_time2->rtc_year)
  2551.    {
  2552.       if (rtc_time1->rtc_mon < rtc_time2->rtc_mon)
  2553.          return KAL_FALSE;
  2554.       else if (rtc_time1->rtc_mon == rtc_time2->rtc_mon)
  2555.       {
  2556.          if (rtc_time1->rtc_day < rtc_time2->rtc_day)
  2557.             return KAL_FALSE;
  2558.          else if (rtc_time1->rtc_day == rtc_time2->rtc_day)
  2559.          {
  2560.             if (rtc_time1->rtc_hour < rtc_time2->rtc_hour)
  2561.                return KAL_FALSE;
  2562.             else if (rtc_time1->rtc_hour == rtc_time2->rtc_hour)
  2563.             {
  2564.                if (rtc_time1->rtc_min < rtc_time2->rtc_min)
  2565.                   return KAL_FALSE;
  2566.                else if (rtc_time1->rtc_min == rtc_time2->rtc_min)
  2567.                {
  2568.                   if (rtc_time1->rtc_sec <= rtc_time2->rtc_sec)
  2569.                      return KAL_FALSE;
  2570.                }
  2571.             }
  2572.          }
  2573.       }
  2574.    }
  2575.    return KAL_TRUE;
  2576. }
  2578. /*
  2579. * FUNCTION                                                            
  2580. * rtc_get_diff_time
  2581. *
  2582. * DESCRIPTION                                                           
  2583. *  Get the time different between 2 RTC time into hours and minute. Note that if the year difference is
  2584. *  more than 1 then we'll see it as invalid.
  2585. *
  2586. * CALLS  
  2587. * This function is called internally for RTC SW calibration
  2588. *
  2589. * PARAMETERS
  2590. * curr_time: INPUT for current RTC time
  2591. * prev_time: INPUT for previous RTC time
  2592. *  ret_hours: OUTPUT for hours of time difference between current time and previous time
  2593. *  ret_mins: OUTPUT for minutes of time difference between current time and previous time
  2594. *
  2595. * RETURNS
  2596. * KAL_TRUE: If the time difference is valid
  2597. *  KAL_FALSE: If the time difference is invalid such as curr_time is older, or the time difference is 
  2598. *             too large.
  2599. *
  2600. * GLOBALS AFFECTED
  2601. *  None
  2602. */
  2603. kal_bool rtc_get_diff_time(t_rtc *curr_time, t_rtc *prev_time, kal_uint16 *ret_hours, kal_uint16 *ret_mins)
  2604. {
  2605.    kal_int16 secs;
  2606.    kal_int16 mins;
  2607.    kal_int32 hours;
  2608.    kal_int16 days;
  2610.    /* Invalid if the current time is older. */
  2611.    if (KAL_FALSE == rtc_compare_time(curr_time, prev_time))
  2612.       return KAL_FALSE;
  2614.    /* Invalid if the year difference is more than 1. */
  2615.    if (curr_time->rtc_year>(prev_time->rtc_year+1))
  2616.       return KAL_FALSE;
  2618.    days = 0;
  2619.    secs = 0;
  2620.    mins = 0;
  2621.    hours = 0;
  2622.    if (curr_time->rtc_sec < prev_time->rtc_sec)
  2623.    {
  2624.       secs = 60;
  2625.       mins = -1;
  2626.    }
  2627.    secs += (curr_time->rtc_sec - prev_time->rtc_sec);
  2628.    if (curr_time->rtc_min < (prev_time->rtc_min - mins))
  2629.    {
  2630.       mins += 60;
  2631.       hours = -1;
  2632.    }
  2633.    mins += (curr_time->rtc_min - prev_time->rtc_min);
  2634.    if (secs >= 30)
  2635.       mins++;
  2636.    if (curr_time->rtc_hour < (prev_time->rtc_hour - hours))
  2637.    {
  2638.       hours += 24;
  2639.       days = -1;
  2640.    }
  2641.    hours += (curr_time->rtc_hour - prev_time->rtc_hour);
  2642.    if ((curr_time->rtc_year==prev_time->rtc_year) && (curr_time->rtc_mon==prev_time->rtc_mon))
  2643.    {
  2644.       days += (curr_time->rtc_day - prev_time->rtc_day);
  2645.    }
  2646.    else
  2647.    {
  2648.       kal_uint8   month;
  2649.       kal_uint8   month_end;
  2651.       days += (days_in_month[prev_time->rtc_mon] - prev_time->rtc_day);
  2652.       month_end = (curr_time->rtc_year == prev_time->rtc_year) ? curr_time->rtc_mon : 13; 
  2653.       for (month = (prev_time->rtc_mon+1); month < month_end; month++)
  2654.       {
  2655.          days += days_in_month[month];
  2656.       }
  2657.       if ((0==(prev_time->rtc_year%4))&&(prev_time->rtc_mon<=2))
  2658.       {
  2659.          if (curr_time->rtc_year != prev_time->rtc_year)
  2660.             days++;
  2661.          else if (curr_time->rtc_mon>2)
  2662.             days++;
  2663.       }
  2664.       month_end = (curr_time->rtc_year == prev_time->rtc_year) ? 0 : curr_time->rtc_mon; 
  2665.       for (month = 1; month < month_end; month++)
  2666.       {
  2667.          days += days_in_month[month];
  2668.       }
  2669.       days += curr_time->rtc_day;
  2670.       if ((curr_time->rtc_year != prev_time->rtc_year)&&(0==(curr_time->rtc_year%4))&&(curr_time->rtc_mon>2))
  2671.          days++;
  2672.    }
  2673.    hours += (days*24);
  2674.    *ret_mins = (kal_uint16)mins;
  2675.    *ret_hours = (kal_uint16)hours;
  2676.    return KAL_TRUE;
  2677. }
  2679. /*
  2680. * FUNCTION                                                            
  2681. * rtc_forward_time
  2682. *
  2683. * DESCRIPTION                                                           
  2684. *  Increase the RTC time by hours, minutes and seconds.
  2685. *
  2686. * CALLS  
  2687. * This function is called internally for RTC SW calibration
  2688. *
  2689. * PARAMETERS
  2690. * rtc_time: current RTC time
  2691. * hours: hours to increase time
  2692. *  mins: minutes to increase time
  2693. *  secs: seconds to increase time
  2694. *
  2695. * RETURNS
  2696. * None
  2697. *
  2698. * GLOBALS AFFECTED
  2699. *  None
  2700. */
  2701. void rtc_forward_time(t_rtc *rtc_time, kal_uint16 hours, kal_uint16 mins, kal_uint16 secs)
  2702. {
  2703.    secs += rtc_time->rtc_sec;
  2704.    mins += rtc_time->rtc_min;
  2705.    hours += rtc_time->rtc_hour;
  2706. #if !defined(LOW_COST_SUPPORT)
  2707.    //TIMER_HISR stack only 512 bytes, remove trace
  2708.    //drv_trace8(TRACE_GROUP_10, RTC_FORWARD_TIME_1, rtc_time->rtc_hour, rtc_time->rtc_min, rtc_time->rtc_sec, hours, mins, secs, 0, 0);
  2709. #endif // #if !defined(LOW_COST_SUPPORT)
  2710.    
  2711.    if (secs>59)
  2712.    {
  2713.       /*min*/
  2714.       mins+=secs/60;
  2715.       secs%=60;
  2716.    }
  2717.    rtc_time->rtc_sec = secs;
  2718.    if (mins>59)
  2719.    {
  2720.       /*hour*/
  2721.       hours+=mins/60;
  2722.       mins%=60;
  2723.    }
  2724.    rtc_time->rtc_min = mins;
  2725.    if (hours>23)
  2726.    {
  2727.       kal_uint16  days;
  2728.       kal_uint8   max_day;
  2730.       /*day of week*/
  2731.       days = hours/24;
  2732.       hours%=24;
  2733.       rtc_time->rtc_wday+=days;
  2734.       if(rtc_time->rtc_wday>7)
  2735.          rtc_time->rtc_wday-=7;
  2736.       /*day of month*/            
  2737.       rtc_time->rtc_day+=days;
  2738.       max_day = days_in_month[rtc_time->rtc_mon];
  2739.       if(rtc_time->rtc_mon==2)
  2740.       {
  2741.        kal_uint32 remender;
  2742.        remender=rtc_time->rtc_year%4;
  2743.        if(remender==0)
  2744.        max_day++;
  2745.       }    
  2746.       if(rtc_time->rtc_day>max_day)
  2747.       {
  2748.          rtc_time->rtc_day-=max_day;
  2749.          
  2750.          /*month of year*/
  2751.          rtc_time->rtc_mon++;
  2752.          if(rtc_time->rtc_mon>12)
  2753.          {
  2754.             rtc_time->rtc_mon=1;
  2755.             rtc_time->rtc_year++;
  2756.          }                                      
  2757.       }   
  2758.    }
  2759.    rtc_time->rtc_hour = hours;
  2760.    
  2761. #if !defined(LOW_COST_SUPPORT)
  2762.    //TIMER_HISR stack only 512 bytes, remove trace
  2763.    //drv_trace4(TRACE_GROUP_10, RTC_FORWARD_TIME_2, rtc_time->rtc_hour, rtc_time->rtc_min, rtc_time->rtc_sec, 0);
  2764. #endif // #if !defined(LOW_COST_SUPPORT)
  2765. }
  2767. /*
  2768. * FUNCTION                                                            
  2769. * rtc_backward_time
  2770. *
  2771. * DESCRIPTION                                                           
  2772. *  Decrease the RTC time by hours, minutes and seconds.
  2773. *
  2774. * CALLS  
  2775. * This function is called internally for RTC SW calibration
  2776. *
  2777. * PARAMETERS
  2778. * rtc_time: current RTC time
  2779. * hours: hours to decrease time
  2780. *  mins: minutes to decrease time
  2781. *  secs: seconds to decrease time
  2782. *
  2783. * RETURNS
  2784. * None
  2785. *
  2786. * GLOBALS AFFECTED
  2787. *  None
  2788. */
  2789. void rtc_backward_time(t_rtc *rtc_time, kal_uint16 hours, kal_uint16 mins, kal_uint16 secs)
  2790. {
  2791.    kal_uint8 day;
  2793. #if !defined(LOW_COST_SUPPORT)
  2794. #if !defined(__FUE__)
  2795.    drv_trace8(TRACE_GROUP_10, RTC_BACKWARD_TIME_1, rtc_time->rtc_hour, rtc_time->rtc_min, rtc_time->rtc_sec, hours, mins, secs, 0, 0);
  2796. #endif
  2797. #endif // #if !defined(LOW_COST_SUPPORT)
  2798.    day = 0;
  2799.    if (secs > rtc_time->rtc_sec)
  2800.    {
  2801.       rtc_time->rtc_sec += 60;
  2802.       mins++;
  2803.    }
  2804.    rtc_time->rtc_sec -= secs;
  2805.    if (mins > rtc_time->rtc_min)
  2806.    {
  2807.       rtc_time->rtc_min += 60;
  2808.       hours++;
  2809.    }
  2810.    rtc_time->rtc_min -= mins;   
  2811.    if (hours > rtc_time->rtc_hour)
  2812.    {
  2813.       rtc_time->rtc_hour += 24;
  2814.       day = 1;
  2815.    }
  2816.    rtc_time->rtc_hour -= hours;   
  2817.    if(day==1)
  2818.    {
  2819.       rtc_time->rtc_wday--;
  2820.       if (rtc_time->rtc_wday == 0)
  2821.          rtc_time->rtc_wday = 7;
  2822.       rtc_time->rtc_day--;
  2823.       if (rtc_time->rtc_day == 0)
  2824.       {
  2825.          rtc_time->rtc_mon--;
  2826.          if (rtc_time->rtc_mon == 0)
  2827.          {
  2828.             rtc_time->rtc_mon = 12;
  2829.             rtc_time->rtc_year--;
  2830.          }
  2831.          rtc_time->rtc_day = days_in_month[rtc_time->rtc_mon];
  2832.        if(rtc_time->rtc_mon==2)
  2833.        {
  2834.        kal_uint32 remender;
  2835.        remender=rtc_time->rtc_year%4;
  2836.        if(remender==0)
  2837.           rtc_time->rtc_day++;
  2838.        }    
  2839.       }
  2840.    }   
  2841. #if !defined(LOW_COST_SUPPORT)
  2842.    drv_trace4(TRACE_GROUP_10, RTC_BACKWARD_TIME_2, rtc_time->rtc_hour, rtc_time->rtc_min, rtc_time->rtc_sec, 0);
  2843. #endif // #if !defined(LOW_COST_SUPPORT)
  2844. }
  2846. /*
  2847. * FUNCTION                                                            
  2848. * rtc_update_time
  2849. *
  2850. * DESCRIPTION                                                           
  2851. *     update time according to time stamp
  2852. *
  2853. * CALLS  
  2854. * This function is to update time according to time stamp
  2855. *
  2856. * PARAMETERS
  2857. * None
  2858. *
  2859. * RETURNS
  2860. * None
  2861. *
  2862. * GLOBALS AFFECTED
  2863. *   external_global
  2864. */
  2865. void rtc_update_time(void)
  2866. {
  2867.    kal_uint32 current_frame_tick, diff_frame_tick;
  2868.    kal_uint32 sec;
  2869.    kal_uint32 tick_left_temp;
  2870.    kal_uint16 one_third_tick_count_temp;
  2871.    //kal_uint32 max_day=0;  
  2872.    #ifdef RTC_CAL_DEBUG
  2873.    t_rtc rtctime;
  2874.    #endif /* RTC_CAL_DEBUG */
  2875.    
  2876.    #if (!defined(__L1_STANDALONE__)) 
  2877.    current_frame_tick=L1I_GetTimeStamp();
  2878.    #endif
  2879.    /* Calculate the different ticks between the current time and expected time for calibration timeout. */
  2880.    if(current_frame_tick>=next_frame_tick) 
  2881.     diff_frame_tick=(current_frame_tick-next_frame_tick)+tick_left;   
  2882.    else
  2883.    {
  2884.     diff_frame_tick=(0xffffffff+current_frame_tick-next_frame_tick+1)+tick_left;   
  2885.       #ifdef RTC_CAL_DEBUG
  2886.       kal_prompt_trace(MOD_RTC_HISR, "KAL time out early, expected:%d (ticks), now:%d rn", next_frame_tick, current_frame_tick);
  2887.       #endif /* RTC_CAL_DEBUG */
  2888.       
  2889. #if !defined(LOW_COST_SUPPORT)
  2890.       drv_trace2(TRACE_GROUP_10, RTC_SW_CALI_KAL_EXPIRE_EARLY, next_frame_tick, current_frame_tick);
  2891. #endif // #if !defined(LOW_COST_SUPPORT)
  2892.    }
  2893.    /* Convert the ticks to minutes. */
  2894.    sec=(diff_frame_tick/rtc_tick_update_interval);
  2895.    sec=sec*rtc_sec_update_interval;
  2897.    /* the 1/3 tick for each second. (217 - 216&2/3)*/
  2898.    one_third_tick_count_temp = one_third_tick_count + sec;
  2899.    tick_left_temp=(diff_frame_tick%rtc_tick_update_interval) + one_third_tick_count_temp/3;
  2900.    /* record the left 1/3 tick count. */
  2901.    one_third_tick_count_temp %=3;
  2903.    /* The below calculation is neccessary because the tick_left_temp may be larger than
  2904.       rtc_tick_update_interval again. */
  2905.    while (tick_left_temp >= rtc_tick_update_interval)
  2906.    {
  2907.       sec += (tick_left_temp/rtc_tick_update_interval);
  2908.       one_third_tick_count_temp += (tick_left_temp/rtc_tick_update_interval);
  2909.       tick_left_temp = ((tick_left_temp%rtc_tick_update_interval)+one_third_tick_count_temp/3);
  2910.       one_third_tick_count_temp %=3;
  2911.    }
  2913.    /* 15 ticks is about 69 ms. */
  2914.    if (tick_left_temp > 15)
  2915.    {
  2916.       /* If the inaccuracy for second boundary is more than 15 ticks, set kal timer to reach the boundary and wait. */
  2917.       kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, (rtc_tick_update_interval-tick_left_temp+1),0);
  2918.       #ifdef RTC_CAL_DEBUG2
  2919.       kal_prompt_trace(MOD_RTC_HISR, "calibration time out not in the second boundary:%d (ticks) rn", tick_left_temp);
  2920.       #endif /* RTC_CAL_DEBUG */
  2921. #if !defined(LOW_COST_SUPPORT)
  2922.       drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_TIMOUE_NOT_IN_SEC_BOUNDARY, tick_left_temp);
  2923. #endif // #if !defined(LOW_COST_SUPPORT)
  2924.       return;
  2925.    }
  2926.    /* At this moment, it's around the second boundary. So we do the calibration here now. */
  2927.    tick_left = tick_left_temp;
  2928.    one_third_tick_count = one_third_tick_count_temp;
  2929.    tc_min_expire_cnt = 0;
  2930.    /* Plus some ticks to the timer period to guarantee it will expire longer than expected. */
  2931.    kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, rtc_cali_tick_value+rtc_cali_tick_safe_margin,0);
  2932.    /*update time*/
  2933.    /*sec*/
  2934.    rtc_forward_time(&next_current_time, 0, 0, sec);
  2936.    RTC_Cali_Time(&next_current_time);
  2938.    /* Save current time and frame_tick_1hr_diff to nvram. */
  2939.    rtc_nvram_s.time_valid = KAL_TRUE;
  2940.    rtc_nvram_s.rtc_time = next_current_time;
  2941.    rtc_nvram_s.ticks_diff_valid = KAL_TRUE;
  2942.    rtc_nvram_s.ticks_diff_per_hour = frame_tick_1hr_diff;
  2943.    rtc_write_to_nvram();
  2945.    #ifdef RTC_CAL_DEBUG
  2946.    RTC_GetTime(&rtctime);
  2947.    kal_prompt_trace(MOD_RTC_HISR, "calibration time out(%d:%d:%d):%d rn"
  2948.       ,rtctime.rtc_hour,rtctime.rtc_min,rtctime.rtc_sec, current_frame_tick);
  2949.    kal_prompt_trace(MOD_RTC_HISR, "(update %d:%d:%d,):%d rn"
  2950.    ,next_current_time.rtc_hour,next_current_time.rtc_min,next_current_time.rtc_sec,current_frame_tick);
  2951.    #endif /* RTC_CAL_DEBUG */
  2952.    
  2953.    #ifdef RTC_CAL_DEBUG
  2954. #if !defined(LOW_COST_SUPPORT)
  2955.    drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_TIMOUE_OUT, rtctime.rtc_hour, rtctime.rtc_min, rtctime.rtc_sec, current_frame_tick);
  2956. #endif // #if !defined(LOW_COST_SUPPORT)
  2957.    #endif /* RTC_CAL_DEBUG */
  2958. #if !defined(LOW_COST_SUPPORT)
  2959.    drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_UPDATE_TIME, next_current_time.rtc_hour, next_current_time.rtc_min, next_current_time.rtc_sec, current_frame_tick);
  2960. #endif // #if !defined(LOW_COST_SUPPORT)
  2961.    /* Calculate the next calibration timeout in frame tick and time. */
  2962.    next_frame_tick=rtc_cali_tick_value+current_frame_tick;
  2963.    rtc_get_next_time();      
  2964. }
  2965. /*
  2966. * FUNCTION                                                            
  2967. * rtc_get_next_time
  2968. *
  2969. * DESCRIPTION                                                           
  2970. *     calculate next time out time
  2971. *
  2972. * CALLS  
  2973. * This function is to calculate nexe time out time
  2974. *
  2975. * PARAMETERS
  2976. * None
  2977. *
  2978. * RETURNS
  2979. * None
  2980. *
  2981. * GLOBALS AFFECTED
  2982. *   external_global
  2983. */
  2984. void rtc_get_next_time(void)
  2985. {
  2986.      /*next time*/
  2987.    rtc_forward_time(&next_current_time, rtc_cali_hr_period, rtc_cali_min_period, 0);
  2988. }   
  2991. /*
  2992. * FUNCTION                                                            
  2993. * rtc_poweroff_cali_init
  2994. *
  2995. * DESCRIPTION                                                           
  2996. *  Calculate the last poweroff period of the handset and the RTC inaccuracy between this period.
  2997. *
  2998. * CALLS  
  2999. * This function is called internally in handset power on sequence.
  3000. *
  3001. * PARAMETERS
  3002. * None
  3003. *
  3004. * RETURNS
  3005. * None
  3006. *
  3007. * GLOBALS AFFECTED
  3008. *   external_global
  3009. */
  3010. void rtc_poweroff_cali_init(void)
  3011. {
  3012. kal_uint16 reg_comm2;
  3013. kal_bool   btmp;
  3015.    pwroff_inacc_ticks = 0;
  3016.    btmp = nvram_external_read_data((kal_uint16)NVRAM_EF_RTC_DATA_LID, 1, (kal_uint8 *)&rtc_nvram_s, sizeof(rtc_nvram_data));
  3017.    #ifdef RTC_CAL_DEBUG2
  3018.    kal_prompt_trace(MOD_RTC_HISR, "Get nvram data");
  3019.    kal_prompt_trace(MOD_RTC_HISR, "time valid?: %d", rtc_nvram_s.time_valid);
  3020.    kal_prompt_trace(MOD_RTC_HISR, "%d-%d-%d (%d:%d:%d): ",rtc_nvram_s.rtc_time.rtc_year, rtc_nvram_s.rtc_time.rtc_mon,
  3021.       rtc_nvram_s.rtc_time.rtc_day, rtc_nvram_s.rtc_time.rtc_hour, rtc_nvram_s.rtc_time.rtc_min, rtc_nvram_s.rtc_time.rtc_sec);
  3022.    kal_prompt_trace(MOD_RTC_HISR, "tick diff valide?: %d", rtc_nvram_s.ticks_diff_valid);                                                   
  3023.    kal_prompt_trace(MOD_RTC_HISR, "ticks_diff_per_hour=%d", rtc_nvram_s.ticks_diff_per_hour);                                                   
  3024.    #endif /* RTC_CAL_DEBUG */
  3025. #if !defined(LOW_COST_SUPPORT)
  3026. #if !defined(__FUE__)
  3027.    drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_POWEROFF_CALI_INIT1, rtc_nvram_s.time_valid);
  3028.    drv_trace8(TRACE_GROUP_10, RTC_SW_CALI_POWEROFF_CALI_INIT2, rtc_nvram_s.rtc_time.rtc_year, rtc_nvram_s.rtc_time.rtc_mon,
  3029.       rtc_nvram_s.rtc_time.rtc_day, rtc_nvram_s.rtc_time.rtc_hour, rtc_nvram_s.rtc_time.rtc_min, rtc_nvram_s.rtc_time.rtc_sec, 0, 0);
  3030.    drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_POWEROFF_CALI_INIT3, rtc_nvram_s.ticks_diff_valid);
  3031.    drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_POWEROFF_CALI_INIT3, rtc_nvram_s.ticks_diff_per_hour);
  3032. #endif
  3033. #endif // #if !defined(LOW_COST_SUPPORT)
  3035.    
  3036.    /* RTC_isFirstOn() may be called before in DRV_POWERON(). */
  3037. if ((First_PowerOn==KAL_TRUE) || (KAL_FALSE == RTC_isFisrtOn()))
  3038.    {
  3039.       reg_comm2 = DRV_Reg(DRV_COMM_REG2);
  3041.       /* DRV_COMM_REG2_RTC_NVRAM is to determine if the content of RTC nvram is valid or not. */
  3042.       if ((reg_comm2 & DRV_COMM_REG2_RTC_NVRAM) && (rtc_nvram_s.time_valid == KAL_TRUE) && (rtc_nvram_s.ticks_diff_valid == KAL_TRUE))
  3043.       {
  3044.          kal_uint16 hours, mins, secs;
  3045.          t_rtc time;
  3046.          kal_bool valid;
  3048.          /* Get the RTC current time. */
  3049.          RTC_GetTime(&time);
  3050.          #ifdef RTC_CAL_DEBUG2
  3051.          kal_prompt_trace(MOD_RTC_HISR, "The current power on time: %d-%d-%d (%d:%d:%d): ", time.rtc_year, time.rtc_mon,
  3052.             time.rtc_day, time.rtc_hour, time.rtc_min, time.rtc_sec);
  3053.          #endif /* RTC_CAL_DEBUG */
  3054. #if !defined(LOW_COST_SUPPORT)
  3055. #if !defined(__FUE__)
  3056.          drv_trace8(TRACE_GROUP_10, RTC_SW_CALI_CURR_POWER_TIME, time.rtc_year, time.rtc_mon,
  3057.             time.rtc_day, time.rtc_hour, time.rtc_min, time.rtc_sec, 0, 0);
  3058. #endif
  3059. #endif // #if !defined(LOW_COST_SUPPORT)
  3060.          
  3061.          
  3062.          /* calculate the power off period in hours and minutes. */
  3063.          valid = rtc_get_diff_time(&time, &(rtc_nvram_s.rtc_time), &hours, &mins);
  3064.          #ifdef RTC_CAL_DEBUG2
  3065.          kal_prompt_trace(MOD_RTC_HISR, "poweroff period - valid: %d, hours: %d, minutes: %d", valid, hours, mins);
  3066.          #endif /* RTC_CAL_DEBUG */
  3067. #if !defined(LOW_COST_SUPPORT)
  3068.          drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_POWEROFF_PERIOD_VALID, valid, hours, mins, 0);
  3069. #endif // #if !defined(LOW_COST_SUPPORT)
  3070.          /* Check if these values are reasonable. */
  3071.          if ((valid == KAL_TRUE) && (hours < 7200) 
  3072.             && (rtc_nvram_s.ticks_diff_per_hour > -1300) && (rtc_nvram_s.ticks_diff_per_hour < 1300))
  3073.          {
  3074.             /* calculate the inaccurate difference. */
  3075.             pwroff_inacc_ticks = hours*rtc_nvram_s.ticks_diff_per_hour+ mins*rtc_nvram_s.ticks_diff_per_hour/60;
  3077.             #ifdef RTC_CAL_DEBUG2
  3078.             kal_prompt_trace(MOD_RTC_HISR, "inaccurate ticks during poweroff: %d", pwroff_inacc_ticks);
  3079.             #endif /* RTC_CAL_DEBUG */
  3080. #if !defined(LOW_COST_SUPPORT)
  3081.             drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_INACCURATE_TICK_DURING_POWEROFF, pwroff_inacc_ticks);
  3082. #endif // #if !defined(LOW_COST_SUPPORT)
  3084.             /* Check if it's alarm power on and the time has to be backward. */
  3085.             if ((BMT.PWRon == (kal_uint8)RTCPWRON) && (pwroff_inacc_ticks < 0))
  3086.             {
  3087.                extern void DRV_POWEROFF(void);
  3088.                t_rtc alarm_time;
  3090. #if !defined(LOW_COST_SUPPORT)
  3091.                drv_trace0(TRACE_GROUP_10, RTC_SW_CALI_ALARM_POWERON_AND_NEED_BACKWARD_TIME);
  3092. #endif // #if !defined(LOW_COST_SUPPORT)
  3094.                pwroff_inacc_ticks = -pwroff_inacc_ticks;
  3095.                hours = pwroff_inacc_ticks/(13000*60);
  3096.                pwroff_inacc_ticks = pwroff_inacc_ticks%(13000*60);
  3097.                mins = pwroff_inacc_ticks/13000;
  3098.                pwroff_inacc_ticks = pwroff_inacc_ticks%13000;
  3099.                secs = pwroff_inacc_ticks*3/650;
  3101.                RTC_GetALTime(&alarm_time);
  3103.                /* calculate the correct time */
  3104.                rtc_backward_time(&time, hours, mins, secs);
  3105.                /* Check if the correct time is before the alarm time. */
  3106.                if (KAL_TRUE == rtc_compare_time(&alarm_time, &time))
  3107.                {
  3108.                   #ifdef RTC_CAL_DEBUG2
  3109.                   kal_prompt_trace(MOD_RTC_HISR, "Alarm power on, and power off the phone");
  3110.                   #endif /* RTC_CAL_DEBUG */
  3111. #if !defined(LOW_COST_SUPPORT)
  3112.                   drv_trace0(TRACE_GROUP_10, RTC_SW_CALI_ALARM_POWERON_AND_POWEROFF);
  3113. #endif // #if !defined(LOW_COST_SUPPORT)
  3114.                   
  3115.                   RTC_Cali_Time(&time);
  3116.                   /* invalidate DRV_COMM_REG2_RTC_NVRAM because time has been calibrated. */
  3117.                   reg_comm2 &= ~(DRV_COMM_REG2_RTC_NVRAM);
  3118.                   DRV_WriteReg(DRV_COMM_REG2,reg_comm2);
  3119.                   #if defined(DRV_RTC_HW_CALI)
  3120.                   RTC_write_trigger();
  3121.                   #endif /*DRV_RTC_HW_CALI*/
  3122.                   /* Power off the phone and wait for alarm power on again.*/
  3123.                   DRV_POWEROFF();
  3124.                }
  3125.             }
  3126.          }/* if ((valid == */
  3127.       } /* if((reg & DRV_COMM_REG2_RTC_NVRAM */
  3128.    } /* if((KAL_FALSE == RTC_isFisrtOn() */
  3129. }
  3131. /*
  3132. * FUNCTION                                                            
  3133. * rtc_timer
  3134. *
  3135. * DESCRIPTION                                                           
  3136. *     system timer callback function
  3137. *
  3138. * CALLS  
  3139. * This function is called when calibration timer time out
  3140. *
  3141. * PARAMETERS
  3142. * timer_param
  3143. *
  3144. * RETURNS
  3145. * None
  3146. *
  3147. * GLOBALS AFFECTED
  3148. *   external_global
  3149. */
  3150. void rtc_timer(void *timer_param)
  3151. {
  3152. //   kal_uint32 savedMask;
  3153.    kal_uint8  rtc_sec;
  3155. #if defined(SLEEP_WORKAROUND_IN_RTC)
  3156. #if (!defined(__L1_STANDALONE__)) 
  3157. kal_uint32 current_frame_tick;
  3158. #endif
  3159. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  3161.    rtc_sec = DRV_Reg(RTC_TC_SEC);
  3162.    if ((rtc_tc_int_var != TC_EN_None) && (rtc_tc_int_var != TC_EN_ChkS))
  3163.    {
  3164.       /* avoid the situation when rtc_sec is around zero for minute interrupt. */
  3165.       if (rtc_sec < 3 || rtc_sec > 57)
  3166.       {
  3167.          #ifdef RTC_CAL_DEBUG
  3168.          kal_prompt_trace(MOD_RTC_HISR, "rtc time is in minute boundary :(%d): calibration delays 6 secs. ", rtc_sec);
  3169.          #endif /* RTC_CAL_DEBUG */
  3170. #if !defined(LOW_COST_SUPPORT)
  3171.          drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_RTC_TIME_IN_MINUTE_BOUNDARY, rtc_sec);
  3172. #endif // #if !defined(LOW_COST_SUPPORT)
  3173.          
  3174.          /* To skip the miniute boundary, delay about 6 secs to do the calibration. */
  3175.          kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, 1300 ,0);
  3176.          return;
  3177.       }
  3178.    }
  3179. #if defined(SLEEP_WORKAROUND_IN_RTC)
  3180. // Added by GuoXin begin
  3181. // New check case: If KAL timer expired early than the time we expected, 
  3182. // we set KAL timer to 6 sec later
  3183. #if (!defined(__L1_STANDALONE__)) 
  3184. current_frame_tick = L1I_GetTimeStamp();
  3185. /* Calculate the different ticks between the current time and expected time for calibration timeout. */
  3186. if(current_frame_tick < next_frame_tick){
  3187. #ifdef RTC_CAL_DEBUG
  3188. kal_prompt_trace(MOD_RTC_HISR, "(1)KAL time out early, expected:%d (ticks), now:%d rn", next_frame_tick, current_frame_tick);
  3189. #endif /* RTC_CAL_DEBUG */
  3190. kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, 1300 ,0);
  3191. return;
  3192. }
  3193. #endif // #if (!defined(__L1_STANDALONE__)) 
  3194. // Added by GuoXin end
  3195. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  3196.    if (rtc_al_int_var != AL_EN_None)
  3197.    {
  3198.       kal_uint8  al_rtc_sec;
  3199.       kal_uint8  sec_diff;
  3201.       al_rtc_sec = DRV_Reg(RTC_AL_SEC);
  3202.       sec_diff = (rtc_sec >= al_rtc_sec) ? (rtc_sec-al_rtc_sec):(al_rtc_sec-rtc_sec);
  3203.       /* avoid the situation when al_rtc_sec is around rtc_sec for alarm interrupt. */
  3204.       if (sec_diff < 3 || sec_diff > 57)
  3205.       {
  3206.          #ifdef RTC_CAL_DEBUG
  3207.          kal_prompt_trace(MOD_RTC_HISR, "rtc time is in alarm boundary :(%d): calibration delays 6 secs. ", rtc_sec);
  3208.          #endif /* RTC_CAL_DEBUG */
  3209. #if !defined(LOW_COST_SUPPORT)
  3210.          drv_trace1(TRACE_GROUP_10, RTC_SW_CALI_RTC_TIME_IN_ALARM_BOUNDARY, rtc_sec);
  3211. #endif // #if !defined(LOW_COST_SUPPORT)
  3212.          
  3213.          /* To skip the alarm boundary, delay about 6 secs to do the calibration. */
  3214.          kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, 1300 ,0);
  3215.          return;
  3216.       }
  3217.    }
  3218. //   savedMask = SaveAndSetIRQMask();
  3219.    rtc_update_time();      
  3220. //   RestoreIRQMask(savedMask);   
  3221. }  
  3222. #endif /* RTC_SW_CALIBRATION */
  3224. #if defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION)
  3225. /*
  3226. * FUNCTION                                                            
  3227. * rtc_cali_init
  3228. *
  3229. * DESCRIPTION                                                           
  3230. *     Initialize rtc calibration
  3231. *
  3232. * CALLS  
  3233. * This function is called at power on or user configures time.
  3234. *
  3235. * PARAMETERS
  3236. * None
  3237. *
  3238. * RETURNS
  3239. * None
  3240. *
  3241. * GLOBALS AFFECTED
  3242. *   external_global
  3243. */
  3244. void rtc_cali_init(void *timer_param)
  3245. {   
  3246. #if defined(RTC_SW_CALIBRATION)
  3247.    kal_uint32 frame_tick=0;
  3248. #endif /* RTC_SW_CALIBRATION */
  3250.    if (cali_state == (kal_uint8)CAL_STATE_NONE)
  3251.    {
  3252. #ifdef RTC_HW_CALIBRATION
  3253.       /* Change calibration state to init and enable RTC minute interrupt.
  3254.          And wait 'till the RTC minute expired to start calibration. */
  3255.       cali_state = (kal_uint8)CAL_STATE_INIT;
  3256.       if (rtc_tc_int_var != TC_EN_ChkM)
  3257. #elif defined(RTC_SW_CALIBRATION)
  3258.       /* Change calibration state to init and enable RTC second interrupt.
  3259.          And wait 'till the RTC second expired to start calibration. */
  3260.       cali_state = (kal_uint8)CAL_STATE_INIT;
  3261.       if (rtc_tc_int_var != TC_EN_ChkS)
  3262. #endif
  3263.       {
  3264.        kal_uint16 tmp;
  3266.          /**/
  3267.       tmp = DRV_Reg(RTC_IRQ_EN);
  3268.       tmp &=~RTC_IRQ_EN_ONESHOT;
  3269.    tmp |= RTC_IRQ_EN_TC;
  3270.        DRV_WriteReg(RTC_IRQ_EN,tmp);
  3271. #ifdef RTC_HW_CALIBRATION
  3272.    DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_MIN);
  3273.          RTC_write_trigger_wait();
  3274.       }
  3275.       tc_min_expire_cnt = 0;
  3276.       no_diff_cnt = 0;
  3277.       rtc_current_freq_8secs = RTC_STANDARD_FREQ_8SECS + rtc_get_cali_offset();
  3278.       #ifdef RTC_CAL_DEBUG
  3279.       kal_prompt_trace(MOD_RTC_HISR, "Initial: repeat calibration count is %d rn", (rtc_current_freq_8secs-RTC_STANDARD_FREQ_8SECS));
  3280.       #endif /* RTC_CAL_DEBUG */
  3281. #if !defined(LOW_COST_SUPPORT)
  3282.       drv_trace1(TRACE_GROUP_10, RTC_HW_CALI_INIT_REPEAT_CALI_COUNT, (rtc_current_freq_8secs-RTC_STANDARD_FREQ_8SECS));
  3283. #endif // #if !defined(LOW_COST_SUPPORT)
  3284.    }
  3285. #elif defined(RTC_SW_CALIBRATION)
  3286.    DRV_WriteReg(RTC_CII_EN,RTC_CII_EN_SEC);
  3287.       }
  3288.    }
  3289.    else if ((cali_state == (kal_uint8)CAL_STATE_INIT2) || (cali_state == (kal_uint8)CAL_STATE_RESET))
  3290.    {
  3291.       /* next_current_time has already been set before in RTC_InitTC_Time() or RTC_TCintr(). */
  3292.       if (cali_state == (kal_uint8)CAL_STATE_INIT2)
  3293.       {
  3294.          /* Set the adjusted correct time (power off calibration) in this moment. */
  3295.          RTC_Cali_Time(&next_current_time);
  3296.          #ifdef RTC_CAL_DEBUG2
  3297.          kal_prompt_trace(MOD_RTC_HISR, "current time after 2nd poweroff calibration- (%d:%d:%d)",
  3298.             next_current_time.rtc_hour, next_current_time.rtc_min, next_current_time.rtc_sec);
  3299.          #endif /* RTC_CAL_DEBUG */
  3300. #if !defined(LOW_COST_SUPPORT)
  3301.          drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_AFTER_2ND_POWEROFF_CALI, next_current_time.rtc_hour, next_current_time.rtc_min, next_current_time.rtc_sec, 0);
  3302. #endif // #if !defined(LOW_COST_SUPPORT)
  3303.          
  3304.       }
  3305.       /* Start power on calibration by KAL timer. */
  3306.       kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_timer, NULL, rtc_cali_tick_value+rtc_cali_tick_safe_margin,0);
  3307.       #if (!defined(__L1_STANDALONE__)) 
  3308.       frame_tick=L1I_GetTimeStamp();
  3309.       #endif
  3310.       #ifdef RTC_CAL_DEBUG
  3311.       kal_prompt_trace(MOD_RTC_HISR, "Start poweron calibration");
  3312.       kal_prompt_trace(MOD_RTC_HISR, "(%d:%d:%d): ",next_current_time.rtc_hour,next_current_time.rtc_min,next_current_time.rtc_sec);
  3313.       kal_prompt_trace(MOD_RTC_HISR, "ini tick=%drn",frame_tick);                                                   
  3314.       #endif /* RTC_CAL_DEBUG */
  3315. #if !defined(LOW_COST_SUPPORT)
  3316.       drv_trace4(TRACE_GROUP_10, RTC_SW_CALI_POWERON_CALI_START,next_current_time.rtc_hour,next_current_time.rtc_min,next_current_time.rtc_sec, frame_tick);
  3317. #endif // #if !defined(LOW_COST_SUPPORT)
  3318.       
  3319.       tick_left=0;
  3320.       one_third_tick_count = 0;
  3321.       tc_min_expire_cnt = 0;
  3322.       next_frame_tick=frame_tick+rtc_cali_tick_value;         
  3323.       rtc_get_next_time();
  3324.       /* Change to "start" state. */
  3325.       cali_state = (kal_uint8)CAL_STATE_START;
  3326.    }
  3327. #endif /* RTC_SW_CALIBRATION */
  3328. }   
  3330. /*
  3331. * FUNCTION                                                            
  3332. * rtc_sleep_wa_timer_cb
  3333. *
  3334. * DESCRIPTION                                                           
  3335. *  The sleep mode workaround timer callback handler
  3336. *
  3337. * CALLS  
  3338. * This function is called when we are going to perform RTC S/W calibration hourly
  3339. *   When 59 min reaches, we enable kal timer with this function as callback function
  3340. *
  3341. * PARAMETERS
  3342. * None
  3343. *
  3344. * RETURNS
  3345. * None
  3346. *
  3347. * GLOBALS AFFECTED
  3348. *   external_global
  3349. */
  3350. #if defined(SLEEP_WORKAROUND_IN_RTC)
  3351. void rtc_sleep_wa_timer_cb(void *timer_param){
  3352. kal_uint32 rtc_sleep_wa_delay_tick;
  3353. t_rtc current_time;
  3355. // Get reference time of 59th min
  3356. RTC_GetTime(&current_time);
  3360. // Protection check, in case kal timer expires after we finished calibration process:
  3361. // to avoid the following case:
  3362. // calbration process -> enable sleep mode -> kal timer trigger to disable sleep mode
  3363. if ( (tc_min_expire_cnt == 60) ){
  3365. // Check if we expire early, if expire early ==> Re-start kal disable sleep timer
  3366. // We only do this when tc_min_expire_cnt == 60, or means we expire too late
  3367. if (current_time.rtc_sec < 58){
  3368. // Calculate how many ticks we should wait to disable sleep mode
  3369. // We plan to wakeup at 58 sec
  3370. rtc_sleep_wa_delay_tick = 58 - (kal_uint32)current_time.rtc_sec;
  3371. rtc_sleep_wa_delay_tick = (kal_uint32) ((rtc_sleep_wa_delay_tick * 1000 * 60) / 13);
  3372. // Set kal timer in order to disable sleep mode for RTC calibration
  3373. kal_set_timer(rtc_sleep_wa_timer_id, (kal_timer_func_ptr)rtc_sleep_wa_timer_cb, NULL, rtc_sleep_wa_delay_tick,0);
  3374. #ifdef RTC_SLEEP_WA_DEBUG
  3375. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Re-start disable sleep timer with tick: %d", 
  3376. current_time.rtc_min, current_time.rtc_sec, rtc_sleep_wa_delay_tick);
  3377. #endif /* RTC_SLEEP_WA_DEBUG */
  3378. return;
  3379. }
  3382. // Disable sleep mode, because we are going to perform RTC calibration in few seconds
  3383. rtc_sleep_wa_disable_sleep_mode();
  3384. rtc_sleep_wa_disable_sleep_performed = KAL_TRUE;
  3385. #ifdef RTC_SLEEP_WA_DEBUG
  3386. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Disable sleep mode", 
  3387. current_time.rtc_min, current_time.rtc_sec);
  3388. #endif /* RTC_SLEEP_WA_DEBUG */
  3389. }else{
  3390. #ifdef RTC_SLEEP_WA_DEBUG
  3391. kal_prompt_trace(MOD_RTC_HISR, "SleepWA: (%d:%d), Warning!!, disable sleep timer expired too late", 
  3392. current_time.rtc_min, current_time.rtc_sec);
  3393. #endif /* RTC_SLEEP_WA_DEBUG */
  3394. }
  3396. }
  3398. void rtc_sleep_wa_enable_sleep_mode(){
  3399. L1SM_SleepEnable(rtc_sleep_wa_handle);
  3400. }
  3401. void rtc_sleep_wa_disable_sleep_mode(){
  3402. L1SM_SleepDisable(rtc_sleep_wa_handle);
  3403. }
  3404. #endif // #ifdef SLEEP_WORKAROUND_IN_RTC
  3406. #endif /*defined(RTC_HW_CALIBRATION) || defined(RTC_SW_CALIBRATION)*/
  3408. /*
  3409. * FUNCTION                                                            
  3410. * RTC_start_cali
  3411. *
  3412. * DESCRIPTION                                                           
  3413. *  The entry function of RTC calibration.
  3414. *
  3415. * CALLS  
  3416. * This function is called in bmt_task_init()(in bmt_create.c) because at this moment of the 
  3417. *  function, the file system is ready for accessing nvram data.
  3418. *
  3419. * PARAMETERS
  3420. * None
  3421. *
  3422. * RETURNS
  3423. * None
  3424. *
  3425. * GLOBALS AFFECTED
  3426. *   external_global
  3427. */
  3428. void RTC_start_cali(void)
  3429. {
  3430. #if defined(RTC_SW_CALIBRATION) || defined(RTC_HW_CALIBRATION)
  3431.    #if defined(__USB_ENABLE__) && !defined(__NVRAM_IN_USB_MS__)
  3432.       /* In this compile option case, when it's USB mode powered on we can't do RTC calibration
  3433.          because L1 time stamp won't be updated (L1I_GetTimeStamp()).*/
  3434.       if (KAL_FALSE == INT_USBBoot() )
  3435.       {
  3436.    #endif
  3437.       #if (!defined(__L1_STANDALONE__)) 
  3438.             #if defined(RTC_HW_CALIBRATION)
  3439.                rtc_cali_init(0);
  3440.             #elif defined(RTC_SW_CALIBRATION)
  3441.       rtc_timer_id=kal_create_timer("RTCcal_Timer");
  3442.          rtc_poweroff_cali_init();
  3443.          kal_set_timer(rtc_timer_id, (kal_timer_func_ptr)rtc_cali_init, NULL, 1, 0);
  3444.          #endif
  3445.          #endif /* (!defined(__L1_STANDALONE__)) */
  3446. #if defined(SLEEP_WORKAROUND_IN_RTC)
  3447. rtc_sleep_wa_timer_id = kal_create_timer("RTC_sleep_wa_Timer");
  3448. rtc_sleep_wa_handle = L1SM_GetHandle();
  3449. #endif // #if defined(SLEEP_WORKAROUND_IN_RTC)
  3450.    #if defined(__USB_ENABLE__) && !defined(__NVRAM_IN_USB_MS__)
  3451.       }
  3452.    #endif
  3453. #endif /* defined(RTC_SW_CALIBRATION) || defined(RTC_HW_CALIBRATION) */
  3454. }
  3457. /*
  3458. * FUNCTION                                                            
  3459. * RTC_init
  3460. *
  3461. * DESCRIPTION                                                           
  3462. *     RTC initialization function
  3463. *
  3464. * CALLS  
  3465. * This function is initialize RTC software
  3466. *
  3467. * PARAMETERS
  3468. * RTC_TCCallback: time update callback function
  3469. * RTC_ALCallback: alarm callback function
  3470. *
  3471. * RETURNS
  3472. * None
  3473. *
  3474. * GLOBALS AFFECTED
  3475. *   external_global
  3476. */
  3477. void RTC_init(void (*RTC_TCCallback)(void),void (*RTC_ALCallback)(void)) //validate
  3478. {
  3479. /*status = DRV_Reg(RTC_IRQ_STATUS);*/
  3480. RTC_CALLBAC.rtc_tcfunc = RTC_TCCallback;
  3481. RTC_CALLBAC.rtc_alfunc = RTC_ALCallback;
  3482. /**(volatile kal_uint16 *)RTC_IRQ_EN = RTC_IRQ_EN_ONESHOT;*/
  3483. /*DRV_WriteReg(RTC_IRQ_EN,RTC_IRQ_EN_ALLOFF);*/
  3485. if (RTCConfig.hisr == NULL)
  3486. {
  3487.    //RTCConfig.hisr = kal_create_hisr("RTC_HISR",2,512,RTC_HISR,NULL);
  3488.    RTCConfig.hisr=(void*)0x1234;
  3489.    DRV_Register_HISR(DRV_RTC_HISR_ID, RTC_HISR);
  3490. }   
  3491.    /*RTC IRQ configuration*/
  3492.    #ifdef __MULTI_BOOT__
  3493. if (INT_BootMode() == MTK_NORMAL_MODE)
  3494. {
  3495.       IRQ_Register_LISR(IRQ_RTC_CODE, RTC_LISR,"RTC handler");
  3496. IRQSensitivity(IRQ_RTC_CODE,LEVEL_SENSITIVE);
  3497. #if !defined(IC_MODULE_TEST) // Disable RTC interrupt in module test
  3498.       IRQUnmask(IRQ_RTC_CODE);
  3499.       #endif
  3500.    }
  3501.    #else /*__MULTI_BOOT__*/
  3502.    IRQ_Register_LISR(IRQ_RTC_CODE, RTC_LISR,"RTC handler");
  3503.    IRQSensitivity(IRQ_RTC_CODE,LEVEL_SENSITIVE);
  3504. #if !defined(IC_MODULE_TEST) // Disable RTC interrupt in module test
  3505.       IRQUnmask(IRQ_RTC_CODE);
  3506.       #endif
  3507.    #endif   /*__MULTI_BOOT__*/
  3508.    /*config RTC driving current*/
  3509.    /*#if defined(DRV_RTC_XOSC_DEF_8)
  3510.    DRV_WriteReg(RTC_XOSCCAL,0x8);
  3511.    #endif*/
  3512. }
  3514. #if defined(DRV_RTC_HW_CALI)
  3515. /*
  3516. * FUNCTION                                                            
  3517. * RTC_wait_debounce
  3518. *
  3519. * DESCRIPTION                                                           
  3520. *     To wait until RTC is not in debouncing
  3521. *
  3522. * CALLS  
  3523. * This function is called in RTC initialization
  3524. *
  3525. * PARAMETERS
  3526. * None
  3527. *
  3528. * RETURNS
  3529. * None
  3530. *
  3531. * GLOBALS AFFECTED
  3532. *   external_global
  3533. */
  3534. void RTC_wait_debounce(void)
  3535. {
  3536.    kal_uint32 count=0;
  3537.    while(count < 0xffffffff)
  3538.    {
  3539.       if ((RTC_BBPU_DBING & DRV_Reg(RTC_BBPU))==0)
  3540.          break;
  3541.       count++;
  3542.    }
  3543.    #ifdef RTC_CAL_DEBUG
  3544.    kal_prompt_trace(MOD_RTC_HISR, "RTC wait debounce count = %xrn",count);
  3545.    #endif /* RTC_CAL_DEBUG */
  3546. }
  3548. /*
  3549. * FUNCTION                                                            
  3550. * RTC_wait_busy
  3551. *
  3552. * DESCRIPTION                                                           
  3553. *     To wait until the read/write channels between RTC / Core is not busy
  3554. *
  3555. * CALLS  
  3556. * This function is called after RTC register is written and triggered
  3557. *
  3558. * PARAMETERS
  3559. * None
  3560. *
  3561. * RETURNS
  3562. * None
  3563. *
  3564. * GLOBALS AFFECTED
  3565. *   external_global
  3566. */
  3567. void RTC_wait_busy(void)
  3568. {
  3569.    kal_uint32 count=0;
  3570.    while(count < 0xffffffff)
  3571.    {
  3572.       if ((RTC_BBPU_CBUSY & DRV_Reg(RTC_BBPU))==0)
  3573.          break;
  3574.       count++;
  3575.    }
  3576.    #ifdef RTC_CAL_DEBUG
  3577.    kal_prompt_trace(MOD_RTC_HISR, "RTC wait busy count = %xrn",count);
  3578.    #endif /* RTC_CAL_DEBUG */
  3579. }
  3581. /*
  3582. * FUNCTION                                                            
  3583. * RTC_reload
  3584. *
  3585. * DESCRIPTION                                                           
  3586. *     Reload the values from RTC domain to Core domain
  3587. *
  3588. * CALLS  
  3589. * This function can be treated as a debugging function.
  3590. *
  3591. * PARAMETERS
  3592. * None
  3593. *
  3594. * RETURNS
  3595. * None
  3596. *
  3597. * GLOBALS AFFECTED
  3598. *   external_global
  3599. */
  3600. void RTC_reload(void)
  3601. {
  3602.    kal_uint16 reg;
  3603.    
  3604.    reg = DRV_Reg(RTC_BBPU);
  3605.    reg |= (RTC_BBPU_RELOAD|RTC_BBPU_KEY);
  3606. #if defined(DRV_RTC_WRITE_ENABLE)
  3607. reg |= RTC_BBPU_WRITE_EN;
  3608. #endif // #if defined(DRV_RTC_WRITE_ENABLE)
  3609.    DRV_WriteReg(RTC_BBPU, reg);
  3610. }
  3612. /*
  3613. * FUNCTION                                                            
  3614. * RTC_init
  3615. *
  3616. * DESCRIPTION                                                           
  3617. *     RTC hardware initialization function
  3618. *
  3619. * CALLS  
  3620. * This function is initialize RTC HW
  3621. *
  3622. * PARAMETERS
  3623. * None
  3624. *
  3625. * RETURNS
  3626. * None
  3627. *
  3628. * GLOBALS AFFECTED
  3629. *   external_global
  3630. */
  3631. void RTC_HW_Init(void)
  3632. {
  3633. // Wait H/W mechanism to issue reload command automatically at power on phase begin
  3634. RTC_wait_debounce();
  3635. RTC_wait_busy();
  3636.    // Wait H/W mechanism to issue reload command automatically at power on phase end
  3637. //We are afraid H/W mechanism failed ...
  3638.    RTC_reload();
  3639.    RTC_write_trigger_wait();
  3640.    //We are afraid H/W mechanism failed ...
  3641. }
  3642. #endif /* DRV_RTC_HW_CALI */
  3644. #endif /*!defined(__FUE__)*/
  3647. /*
  3648. * FUNCTION                                                            
  3649. * RTC_is_config_valid
  3650. *
  3651. * DESCRIPTION                                                           
  3652. *  Check if RTC time and Alarm are valid. If these
  3653. *  settings are not correct, we treat it as first power on and
  3654. *  reconfigure RTC.
  3655. *
  3656. * CALLS  
  3657. * This function is to check if RTC time and Alarm are valid.
  3658. *
  3659. * PARAMETERS
  3660. * valid or not
  3661. *
  3662. * RETURNS
  3663. * None
  3664. *
  3665. * GLOBALS AFFECTED
  3666. *   external_global
  3667. */
  3669. kal_bool RTC_is_config_valid(void)
  3670. {
  3671.    t_rtc time, alarm;
  3672.    
  3673.    RTC_GetTime(&time);
  3674.    RTC_GetALTime(&alarm);
  3675.    
  3676.    if((time.rtc_sec>59) ||(alarm.rtc_sec>59)||
  3677.       (time.rtc_min>59) ||(alarm.rtc_min>59)||
  3678.       (time.rtc_hour>23)||(alarm.rtc_hour>23)   ||
  3679.       (time.rtc_day>31) ||(alarm.rtc_day>31) || (time.rtc_day == 0) ||(alarm.rtc_day == 0) || 
  3680.       (time.rtc_wday>7) ||(alarm.rtc_wday>7) || (time.rtc_wday== 0) ||(alarm.rtc_wday== 0) || 
  3681.       (time.rtc_mon>12) ||(alarm.rtc_mon>12) || (time.rtc_mon == 0) ||(alarm.rtc_mon == 0) )
  3682.    {   
  3683. #if !defined(LOW_COST_SUPPORT)
  3684. #if !defined(__FUE__)
  3685.       drv_trace8(TRACE_GROUP_9, RTC_NOT_CONFIG_VALID_TIME, time.rtc_year, time.rtc_mon,
  3686.             time.rtc_day, time.rtc_hour, time.rtc_min, time.rtc_sec, 0, 0);
  3687.       drv_trace8(TRACE_GROUP_9, RTC_NOT_CONFIG_VALID_ALARM, alarm.rtc_year, alarm.rtc_mon,
  3688.             alarm.rtc_day, alarm.rtc_hour, alarm.rtc_min, alarm.rtc_sec, 0, 0);
  3689. #endif
  3690. #endif
  3691.       alarm.rtc_sec=0;
  3692.       alarm.rtc_min=0;
  3693.       alarm.rtc_hour=0;
  3694.       alarm.rtc_day=1;
  3695.       alarm.rtc_wday=1;
  3696.       alarm.rtc_mon=1;
  3697.       RTC_SetAlarm(&alarm);
  3698.       return KAL_FALSE;      
  3699. }
  3700. #if !defined(LOW_COST_SUPPORT)
  3701. #if !defined(__FUE__)
  3702.    drv_trace8(TRACE_GROUP_9, RTC_IS_CONFIG_VALID_TIME, time.rtc_year, time.rtc_mon,
  3703.             time.rtc_day, time.rtc_hour, time.rtc_min, time.rtc_sec, 0, 0);
  3704.    drv_trace8(TRACE_GROUP_9, RTC_IS_CONFIG_VALID_ALARM, alarm.rtc_year, alarm.rtc_mon,
  3705.             alarm.rtc_day, alarm.rtc_hour, alarm.rtc_min, alarm.rtc_sec, 0, 0);
  3706. #endif
  3707. #endif
  3708.    return KAL_TRUE;
  3709. }   
  3712. /*
  3713. * FUNCTION                                                            
  3714. * RTC_read_xosc_reg
  3715. *
  3716. * DESCRIPTION                                                           
  3717. *  Read RTC XOSC register value
  3718. *
  3719. * CALLS  
  3720. * This function is for enginner mode.
  3721. *
  3722. * PARAMETERS
  3723. *  None
  3724. *
  3725. * RETURNS
  3726. * RTC XOSC register value
  3727. *
  3728. * GLOBALS AFFECTED
  3729. *   external_global
  3730. */
  3731. kal_uint8 RTC_read_xosc_reg(void)
  3732. {
  3733.    kal_uint16   value;
  3735.    value = DRV_Reg(RTC_XOSCCAL);
  3736.    return ((kal_uint8)value);
  3737. }
  3739. /*
  3740. * FUNCTION                                                            
  3741. * RTC_write_xosc_reg
  3742. *
  3743. * DESCRIPTION                                                           
  3744. *  Set RTC XOSC register value.
  3745. *
  3746. * CALLS  
  3747. * This function is for enginner mode.
  3748. *
  3749. * PARAMETERS
  3750. *  RTC XOSC register value to set.
  3751. *
  3752. * RETURNS
  3753. * None
  3754. *
  3755. * GLOBALS AFFECTED
  3756. *   external_global
  3757. */
  3758. void RTC_write_xosc_reg(kal_uint8 reg_value)
  3759. {
  3760.    DRV_WriteReg(RTC_XOSCCAL, ((kal_uint16)reg_value));
  3761. #if defined(DRV_RTC_HW_CALI)
  3762.    RTC_write_trigger();
  3763. #endif
  3764. }
  3766. #endif /*DRV_RTC_NOT_EXIST*/