--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/cs/drivers/drv_app/lcc/lcc_handle_timers.c	Fri Oct 16 06:23:26 2020 +0000
@@ -0,0 +1,336 @@
+/******************************************************************************
+ * Power Task (pwr)
+ * Design and coding by Svend Kristian Lindholm, skl@ti.com
+ *
+ * Timers
+ *
+ * $Id: pwr_handle_timers.c 1.1 Wed, 20 Aug 2003 10:22:37 +0200 skl $
+ *
+ ******************************************************************************/
+#ifndef __PWR_HANDLE_TIMERS_C_
+#define __PWR_HANDLE_TIMERS_C_
+
+UINT32 rvf_get_tick_count(void);
+void pwr_check_timers(void);
+T_RVM_RETURN pwr_create_timer(UINT32 *timer_begin);
+T_RVM_RETURN pwr_start_timer(UINT32 *timer_begin);
+void stop_ci_charge(void);
+void pwr_modulate_off(void);
+void pwr_send_msg(uint32 msg_id ,T_RVF_ADDR_ID src_addr_id, T_RVF_ADDR_ID  dest_addr_id);
+int pwr_capacity(uint16 Vbat);
+void mmi_send_msg(struct mmi_info_ind_s *event);
+void end_charging_house_keeping(void);
+void cv_charging_house_keeping(void);
+
+// Timer functions
+
+UINT32 pwr_timer_elapsed(UINT32 time_begin, UINT32 current_timer)
+{
+// return elapsed time in [ms]
+    return (current_timer - time_begin) * 60 / 13;
+}
+
+T_RVM_RETURN pwr_start_timer(UINT32 *timer_begin)
+{
+    ttw(ttr(TTrTimer, "pwr_start_timer(%d)" NL, 0));
+
+    // Start timer (will be checked each time an ADC measurement is received)
+    *timer_begin  = rvf_get_tick_count();
+
+    ttw(ttr(TTrTimer, "pwr_start_timer(%d)" NL, 0xFF));
+    return (RV_OK);
+}
+
+T_RVM_RETURN pwr_stop_timer(UINT32 *timer_begin)
+{
+    ttw(ttr(TTrTimer, "pwr_stop_timer(%d)" NL, 0));
+
+    *timer_begin  = 0;
+
+    ttw(ttr(TTrTimer, "pwr_stop_timer(%d)" NL, 0xFF));
+    return (RV_OK);
+}
+
+void pwr_stop_timers(void)
+{
+    // Only stop charging related timers - not supervision timers
+
+    pwr_stop_timer(&pwr_ctrl->time_begin_T1);
+    pwr_stop_timer(&pwr_ctrl->time_begin_T2);
+    pwr_stop_timer(&pwr_ctrl->time_begin_T3);
+    pwr_stop_timer(&pwr_ctrl->time_begin_T4);
+    pwr_stop_timer(&pwr_ctrl->time_begin_mod_cycle);
+
+}
+
+T_RVM_RETURN pwr_create_timer(UINT32 *timer_begin)
+{
+    ttw(ttr(TTrTimer, "pwr_create_timer(%d)" NL, 0));
+
+    *timer_begin  = 0;
+
+    ttw(ttr(TTrTimer, "pwr_create_timer(%d)" NL, 0xFF));
+    return (RV_OK);
+}
+
+T_RV_RET process_pwr_handle_T1_expiration (T_PWR_REQ *request)
+{
+    ttw(ttr(TTrTimer, "process_pwr_handle_T1_expiration(%d)" NL, 0));
+
+    switch (pwr_ctrl->state) {
+    case SUP :
+        break;
+    case CCI :
+    case CCV :
+    case LCI :
+    case LCV :
+        // Change state
+        pwr_ctrl->state = SUP;
+        end_charging_house_keeping();
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_T1_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    ttw(ttr(TTrTimer, "process_pwr_handle_T1_expiration(%d)" NL, 0xFF));
+    pwr_free(request);
+}
+
+T_RV_RET process_pwr_handle_T2_expiration (T_PWR_REQ *request)
+{
+    ttw(ttr(TTrTimer, "process_pwr_handle_T2_expiration(%d)" NL, 0));
+    switch (pwr_ctrl->state) {
+    case SUP :
+        // Another timer did expire prior to the T2 timer - ignore this expiration
+        break;
+    case CCV :
+    case LCV :
+        // Change state
+        pwr_ctrl->state = SUP;
+        end_charging_house_keeping();
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_T2_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    pwr_free(request);
+    ttw(ttr(TTrTimer, "process_pwr_handle_T2_expiration(%d)" NL, 0xFF));
+}
+
+T_RV_RET process_pwr_handle_T3_expiration (T_PWR_REQ *request)
+{
+    ttw(ttr(TTrTimer, "process_pwr_handle_T3_expiration(%d)" NL, 0));
+    switch (pwr_ctrl->state) {
+    case SUP :
+        // Stop & reset timers
+        pwr_stop_timers();
+        break;
+    case CCI :
+    case CCV :
+    case LCI :
+    case LCV :
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_T3_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    pwr_free(request);
+    ttw(ttr(TTrTimer, "process_pwr_handle_T3_expiration(%d)" NL, 0xFF));
+}
+
+T_RV_RET process_pwr_handle_T4_expiration (T_PWR_REQ *request)
+{
+    ttw(ttr(TTrTimer, "process_pwr_handle_T4_expiration(%d)" NL, 0));
+    switch (pwr_ctrl->state) {
+    case SUP :
+        // Yes - since timing issues can make this timer expire in SUP state
+        // It can take a long time before we know if a charger has been unplugged
+        break;
+    case CCV :
+    case LCV :
+        pwr_stop_timer(&pwr_ctrl->time_begin_T4);
+        pwr_modulate_off();
+        // Wait for duty cycle timer to expire before restarting this timer
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_T4_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    pwr_free(request);
+    ttw(ttr(TTrTimer, "process_pwr_handle_T4_expiration(%d)" NL, 0xFF));
+}
+
+T_RV_RET process_pwr_handle_mod_cycle_expiration (T_PWR_REQ *request)
+{
+    ttw(ttr(TTrTimer, "process_pwr_handle_mod_cycle_expiration(%d)" NL, 0));
+    switch (pwr_ctrl->state) {
+    case SUP :
+        // Yes - since timing issues can make this timer expire in SUP state
+        // It can take a long time before we know if a charger has been unplugged
+        break;
+    case CCV :
+    case LCV :
+        // Calculate k value
+        // Start DC timer
+        // Start T4 timer based on k value
+        // Modulation ON
+        cv_charging_house_keeping();
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_mod_cycle_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    pwr_free(request);
+    ttw(ttr(TTrTimer, "process_pwr_handle_mod_cycle_expiration(%d)" NL, 0xFF));
+}
+
+T_RV_RET process_pwr_handle_mmi_info_expiration(T_PWR_REQ *request)
+{
+    struct mmi_info_ind_s MMI_Event;
+
+    ttw(ttr(TTrTimer, "process_pwr_handle_mmi_info_expiration(%d)" NL, 0));
+    switch (pwr_ctrl->state) {
+    case SUP :
+        // Send MMI info events according to configured repetition interval
+        if (pwr_ctrl->flag_mmi_registered == 1) {
+            pwr_ctrl->mmi_ptr->header.msg_id = MMI_BAT_SUPERVISION_INFO_IND;
+            pwr_ctrl->mmi_ptr->Vbat = pwr_cfg->data.Vbat_avg_mV;
+            pwr_ctrl->mmi_ptr->Tbat = pwr_cfg->data.Tbat_avg;
+            pwr_ctrl->mmi_ptr->Cbat = pwr_capacity(pwr_cfg->data.Vbat_avg_mV);
+            mmi_send_msg(pwr_ctrl->mmi_ptr);
+        }
+        // Restart timer
+        ttw(ttr(TTrTimerLow,"MMI info timer started(%d)" NL, 0));
+        pwr_start_timer(&pwr_ctrl->time_begin_mmi_rep);
+
+        break;
+    case INI :
+    case CCI :
+    case CCV :
+    case LCI :
+    case LCV :
+        // DON'T send any events when charging or initializing
+        break;
+    default :
+        {
+        // Exception Handling - Unknown State
+        ttr(TTrFatal, "process_pwr_handle_mmi_info_expiration: Unknown State: %d" NL, pwr_ctrl->state);
+        break;
+        }
+    }
+    pwr_free(request);
+    ttw(ttr(TTrTimer, "process_pwr_handle_mmi_info_expiration(%d)" NL, 0xFF));
+}
+
+
+void pwr_check_timers()
+{
+    UINT32 timer;
+
+    ttw(ttr(TTrTimer, "pwr_check_timers(%d)" NL, 0));
+    // Check timers T1, T2, T3, T4, duty cycle & mmi timer -  if expired send timer expired events
+    timer  = rvf_get_tick_count();
+
+    // T1
+    if (pwr_ctrl->time_begin_T1 != 0) {
+        // Started - but is it expired?
+        pwr_ctrl->time_elapsed_T1  = pwr_timer_elapsed(pwr_ctrl->time_begin_T1, timer);
+        if (pwr_ctrl->time_elapsed_T1 > pwr_cfg->bat.T1) {
+            // EXPIRED!
+            ttw(ttr(TTrTimer, "T1 expired (%d):" NL, pwr_ctrl->time_elapsed_T1));
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_T1 = 0;
+            pwr_ctrl->time_begin_T1   = 0;
+            // Send timer expired event
+            pwr_send_msg(TIMER_T1_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    // T2
+    if (pwr_ctrl->time_begin_T2 != 0) {
+        // Started - but is it expired?
+        pwr_ctrl->time_elapsed_T2  = pwr_timer_elapsed(pwr_ctrl->time_begin_T2, timer);
+        if (pwr_ctrl->time_elapsed_T2 > pwr_cfg->bat.T2) {
+            // EXPIRED!
+            ttw(ttr(TTrTimer, "T2 expired (%d):" NL, pwr_ctrl->time_elapsed_T2));
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_T2 = 0;
+            pwr_ctrl->time_begin_T2   = 0;
+            // Send timer expired event
+            pwr_send_msg(TIMER_T2_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    // T3
+    if (pwr_ctrl->time_begin_T3 != 0) {
+        // Started - but is it expired?
+        pwr_ctrl->time_elapsed_T3  = pwr_timer_elapsed(pwr_ctrl->time_begin_T3, timer);
+        if (pwr_ctrl->time_elapsed_T3 > pwr_cfg->bat.T3) {
+            // EXPIRED!
+            ttw(ttr(TTrTimer, "T3 expired (%d):" NL, pwr_ctrl->time_elapsed_T3));
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_T3 = 0;
+            pwr_ctrl->time_begin_T3   = 0;
+            // Send timer expired event
+            pwr_send_msg(TIMER_T3_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    // T4
+    if (pwr_ctrl->time_begin_T4 != 0) {
+        // Started - but is it expired?
+        pwr_ctrl->time_elapsed_T4  = pwr_timer_elapsed(pwr_ctrl->time_begin_T4, timer);
+        if (pwr_ctrl->time_elapsed_T4 > pwr_cfg->data.T4) {
+            // EXPIRED!
+            ttw(ttr(TTrTimer, "T4 expired (%d):" NL, pwr_ctrl->time_elapsed_T4));
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_T4 = 0;
+            pwr_ctrl->time_begin_T4   = 0;
+            // Send timer expired event
+            pwr_send_msg(TIMER_T4_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    // Duty cycle timer (Lithium only)
+    if (pwr_ctrl->time_begin_mod_cycle != 0) {
+        // Started - but is it expired?
+        pwr_ctrl->time_elapsed_mod_cycle  = pwr_timer_elapsed(pwr_ctrl->time_begin_mod_cycle, timer);
+        if (pwr_ctrl->time_elapsed_mod_cycle > pwr_cfg->common.mod_cycle) {
+            // EXPIRED!
+            ttw(ttr(TTrTimer, "DC expired (%d):" NL, pwr_ctrl->time_elapsed_mod_cycle));
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_mod_cycle = 0;
+            pwr_ctrl->time_begin_mod_cycle   = 0;
+            // Send timer expired event
+            pwr_send_msg(TIMER_MOD_CYCLE_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    // MMI repetition timer
+    if (pwr_ctrl->time_begin_mmi_rep != 0) {
+        // Started - but has it expired?
+        pwr_ctrl->time_elapsed_mmi_rep  = pwr_timer_elapsed(pwr_ctrl->time_begin_mmi_rep, timer);
+        if (pwr_ctrl->time_elapsed_mmi_rep > pwr_cfg->mmi.repetition) {
+            // EXPIRED!
+            // 'Stop' timer
+            pwr_ctrl->time_elapsed_mmi_rep = 0;
+            pwr_ctrl->time_begin_mmi_rep   = 0;
+            ttw(ttr(TTrTimer, "MMI info timer expired (%d):" NL, pwr_ctrl->time_elapsed_mmi_rep));
+            // Send timer expired event
+            pwr_send_msg(TIMER_MMI_INFO_EXPIRED, pwr_ctrl->addr_id, pwr_ctrl->addr_id);
+        }
+    }
+    ttw(ttr(TTrTimer, "pwr_check_timers(%d)" NL, 0xFF));
+
+}
+#endif