mcu/driver/devdrv/tia/src/tia.c

/*****************************************************************************
*  Copyright Statement:
*  --------------------
*  This software is protected by Copyright and the information contained
*  herein is confidential. The software may not be copied and the information
*  contained herein may not be used or disclosed except with the written
*  permission of MediaTek Inc. (C) 2017
*
*  BY OPENING THIS FILE, BUYER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
*  THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MEDIATEK SOFTWARE")
*  RECEIVED FROM MEDIATEK AND/OR ITS REPRESENTATIVES ARE PROVIDED TO BUYER ON
*  AN "AS-IS" BASIS ONLY. MEDIATEK EXPRESSLY DISCLAIMS ANY AND ALL WARRANTIES,
*  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED WARRANTIES OF
*  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR NONINFRINGEMENT.
*  NEITHER DOES MEDIATEK PROVIDE ANY WARRANTY WHATSOEVER WITH RESPECT TO THE
*  SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY, INCORPORATED IN, OR
*  SUPPLIED WITH THE MEDIATEK SOFTWARE, AND BUYER AGREES TO LOOK ONLY TO SUCH
*  THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO. MEDIATEK SHALL ALSO
*  NOT BE RESPONSIBLE FOR ANY MEDIATEK SOFTWARE RELEASES MADE TO BUYER'S
*  SPECIFICATION OR TO CONFORM TO A PARTICULAR STANDARD OR OPEN FORUM.
*
*  BUYER'S SOLE AND EXCLUSIVE REMEDY AND MEDIATEK'S ENTIRE AND CUMULATIVE
*  LIABILITY WITH RESPECT TO THE MEDIATEK SOFTWARE RELEASED HEREUNDER WILL BE,
*  AT MEDIATEK'S OPTION, TO REVISE OR REPLACE THE MEDIATEK SOFTWARE AT ISSUE,
*  OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE CHARGE PAID BY BUYER TO
*  MEDIATEK FOR SUCH MEDIATEK SOFTWARE AT ISSUE.
*
*  THE TRANSACTION CONTEMPLATED HEREUNDER SHALL BE CONSTRUED IN ACCORDANCE
*  WITH THE LAWS OF THE STATE OF CALIFORNIA, USA, EXCLUDING ITS CONFLICT OF
*  LAWS PRINCIPLES.  ANY DISPUTES, CONTROVERSIES OR CLAIMS ARISING THEREOF AND
*  RELATED THERETO SHALL BE SETTLED BY ARBITRATION IN SAN FRANCISCO, CA, UNDER
*  THE RULES OF THE INTERNATIONAL CHAMBER OF COMMERCE (ICC).
*
*****************************************************************************/

/*******************************************************************************
 *
 * Filename:
 * ---------
 *    tia.c
 *
 * Project:
 * --------
 *    VMOLY
 *
 * Description:
 * ------------
 *    TIA (Thermal Information Acquisition) driver for MD thermal
 *
 * Author:
 * -------
 * -------
 *
 *============================================================================
 *             HISTORY
 * Below this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *------------------------------------------------------------------------------
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 * removed!
 *
 * removed!
 * removed!
 * removed!
 *------------------------------------------------------------------------------
 * Upper this line, this part is controlled by PVCS VM. DO NOT MODIFY!!
 *============================================================================
 ****************************************************************************/

#include "kal_public_api.h"
#include "kal_ex_api.h"
#include "drv_comm.h"
#include "us_timer.h"
#include "cache_sw.h"
#include "tia_reg.h"
#include "tia.h"

// sensor information
static tfwk_sensor_info_t tia_sensor_info[TIA_SENSOR_NUM] = {
    {.sensor_id=1, .min_temperature=-200, .max_temperature=1150, .warning_temperature=9999, .accuracy=30, .resolution=10, .sensor_name="PA_Group_2_NTC"},
    {.sensor_id=2, .min_temperature=-200, .max_temperature=1150, .warning_temperature=9999, .accuracy=30, .resolution=10, .sensor_name="PA_Group_1_NTC"},
    {.sensor_id=3, .min_temperature=-200, .max_temperature=1150, .warning_temperature=9999, .accuracy=30, .resolution=10, .sensor_name="RF_IC_NTC"},
    {.sensor_id=4, .min_temperature=-200, .max_temperature=1150, .warning_temperature=9999, .accuracy=30, .resolution=10, .sensor_name="SOC_NTC"},
};
static kal_uint32 tia_sensor_hwShutdownTemp[TIA_SENSOR_NUM] = {9999, 9999, 9999, 9999};
const kal_uint32 tia_sensor_map[TIA_SENSOR_NUM] = {
  //PA_G2, PA_G1, RF_IC, SOC
    2,     1,     3,     0
};
#if defined(CHIP10992)
    static kal_bool tia_sensor_fake_en = KAL_FALSE;
    static kal_uint32 tia_sensor_fake_ohm[TIA_SENSOR_NUM];
#else
    static kal_bool tia_sensor_fake_en = KAL_TRUE;
    static kal_uint32 tia_sensor_fake_ohm[TIA_SENSOR_NUM] = {0x000186A0, 0x000186A0, 0x000186A0, 0x000186A0};
#endif

// threshold monitor
#define TIA_THR_TMP_MAX     (TIA_ADC_TMP_MAX * 10) // threshold temperature: valid max
#define TIA_THR_TMP_MIN     (TIA_ADC_TMP_MIN * 10) // threshold temperature: valid max
#define TIA_THR_TMP_HW_NEAR (100) // threshold temperature, near HW shutdown (>= HW - this_DEF)
#define TIA_THR_PP_NUM      2 // ping-pong number
#define TIA_THR_ALM_NUM     2 // alarm number
enum {  // threshold type
    TIA_THR_TYP_HW = 0,
    TIA_THR_TYP_SW,
    TIA_THR_TYP_WRN,
    TIA_THR_TYP_AL0,
    TIA_THR_TYP_AL1,
    TIA_THR_TYP_MAX
};
static const kal_char *tia_thr_typ_str[TIA_THR_TYP_MAX] = {"hw", "sw", "wrn", "al0", "al1"};
enum {  // alarm type
    TIA_ALM_TYP_RISING = 0,
    TIA_ALM_TYP_FALLING,
    TIA_ALM_TYP_DISABLE
};
static tfwk_thermal_cfg_t tia_thr_cfgs[TIA_SENSOR_NUM][TIA_THR_PP_NUM][TIA_THR_ALM_NUM];
static struct tia_thr_mon_s {
    kal_bool            vld; // valid or not
    kal_int32           thr; // threshold value, order: hw > sw > fim > al0 > al1
    tfwk_thermal_cfg_t *cfg; // pointer to tia_thr_cfgs (for sw/fim/alarm, not hw)
} tia_thr_mons[TIA_SENSOR_NUM][TIA_THR_PP_NUM][TIA_THR_TYP_MAX];
static kal_uint32 tia_thr_ppi[TIA_SENSOR_NUM]; // current ppi, update to ~ppi
static kal_uint32 tia_thr_hw;
#define TIA_HW_RESET_RECORD(tid) \
        DRV_WriteReg32(TOPRGU_WDT_NONRST_REG2, DRV_Reg32(TOPRGU_WDT_NONRST_REG2) | TOPRGU_TID_STATUS(tid))

#define TIA_TMR_MS_DFT 1000     // default polling period
#define TIA_TMR_MS_ITS 100      // intensive polling period
#define TIA_TMR_MS_MIN 64       // minimax polling period
static kal_timerid tia_tmr_id;
static kal_spinlockid tia_tmr_sl;
static void tia_tmr_set(kal_uint32 ms, kal_bool imm);

//#define TIA_STACK_PRF
#ifdef TIA_STACK_PRF
#define STACK_SIZE_MAX   0x1000
#define STACK_GUARD_PTN0 0x43415453 // STACKEND
#define STACK_GUARD_PTN1 0x444E454B
#define STACK_GUARD_TST  0xFEFEFEFE

static struct {
    kal_uint32 init_bas;
    kal_uint32 init_cur;
    kal_uint32 init_us;
    kal_uint32 done_cur;
    kal_uint32 done_use;
    kal_uint32 done_us;
} tia_stack_prf;

static void __attribute__((noinline)) tia_stack_prf_init(void)
{
    void *sp_ptr = NULL;
    register kal_uint32 adr;

    tia_stack_prf.init_cur = (kal_uint32) &sp_ptr;
    for (adr = tia_stack_prf.init_cur & ~0x7; adr > tia_stack_prf.init_cur - STACK_SIZE_MAX; adr -= 8) {
        if ((DRV_Reg32(adr) == STACK_GUARD_PTN0) && (DRV_Reg32(adr+4) == STACK_GUARD_PTN1)) {
            adr = CPU_CACHE_LINE_ALIGN_ADDR(adr) + CPU_CACHE_LINE_ALIGN_LEN(adr, 8);
            break;
        }
    }
    tia_stack_prf.init_bas = adr;
    for (; adr < tia_stack_prf.init_cur - 0x10; adr += 4) {
        DRV_WriteReg32(adr, STACK_GUARD_TST);
    }
    tia_stack_prf.init_us = ust_get_current_time();
}

static void __attribute__((noinline)) tia_stack_prf_done(void)
{
    void *sp_ptr = NULL;
    register kal_uint32 adr;

    tia_stack_prf.done_us = ust_get_current_time();
    tia_stack_prf.done_cur = (kal_uint32) &sp_ptr;
    for (adr = tia_stack_prf.init_bas; adr < tia_stack_prf.init_cur; adr += 4) {
        if (DRV_Reg32(adr) != STACK_GUARD_TST) {
            break;
        }
    }
    tia_stack_prf.done_use = adr;
}

static void __attribute__((noinline)) tia_stack_prf_result(void)
{
    MD_TRC(TIA_MSG_STACK_INFO,
           tia_stack_prf.init_cur, tia_stack_prf.init_bas, tia_stack_prf.init_cur - tia_stack_prf.init_bas,
           tia_stack_prf.done_cur, tia_stack_prf.done_use, tia_stack_prf.done_cur - tia_stack_prf.done_use,
           ust_us_duration(tia_stack_prf.init_us, tia_stack_prf.done_us));
}
#endif

static kal_int32 tia_temp(kal_uint32 tid)
{
    static struct {
        kal_uint32 frc;
        kal_int32  tmp;
    } tmps[TIA_SENSOR_NUM];
    kal_uint32 nid, reg, dbg, frc, rc, adc;
    kal_int32  tmp;

    if (tia_sensor_fake_en) {
        rc  = TIA_ADC_RC_FAKE;
        adc = tia_sensor_fake_ohm[tid];
        tmp = tia_adc_to_tmp(rc, adc);
        MD_TRC(TIA_MSG_AUXADC_TMP, tid, TIA_ADC_RC2K(rc), adc, tmp, tia_sensor_fake_en);
    } else {
        nid = TIA_SENSOR_NID(tid);
        reg = DRV_Reg32(TIA_HW_RC_ADC(nid));
        frc = ust_get_current_time();
        if (TIA_HW_ADC_VLD(reg)) {
            rc  = TIA_HW_RC_VAL(reg);
            adc = TIA_HW_ADC_VAL(reg);
            tmp = tia_adc_to_tmp(rc, adc);
            EXT_ASSERT(tmp != TIA_ADC_TMP_ERR, rc, adc, (kal_uint32) tmp);
            tmps[tid].frc = frc;
            tmps[tid].tmp = tmp;
            MD_TRC(TIA_MSG_AUXADC_TMP, tid, TIA_ADC_RC2K(rc), adc, tmp, tia_sensor_fake_en);
        } else {
            dbg = DRV_Reg32(TIA_TIA2_DEBUG);
            EXT_ASSERT((tmps[tid].frc != 0) && (tmps[tid].tmp != 0), tid, reg, dbg);
            tmp = tmps[tid].tmp;
            MD_TRC(TIA_MSG_ERR_ADC_INVALID, __func__, tid, reg, dbg, tmp, ust_us_duration(tmps[tid].frc, frc));
        }
    }

    return tmp;
}

static void tia_notify(kal_uint32 tid, kal_int32 tmp, tfwk_thermal_cfg_t* cfg)
{
    static thermal_sta_info_t tia_thr_ntf; // declare "static" in global bss, dont use stack area (kal timer limitation)
    kal_uint32 sid, idx;

    tia_thr_ntf.temp = tmp;
    memcpy(&tia_thr_ntf.cfg, cfg, sizeof(thermal_cfg_t));

    for (sid = THERMAL_LVTS_SENSOR_ID(0); sid < THERMAL_LVTS_SENSOR_ID(THERMAL_LVTS_SENSOR_NUM); sid++) {
        tia_thr_ntf.others[sid].sensor_id = sid;
        TIA_LVTS_GET_TEMP(sid, &tia_thr_ntf.others[sid].temp);
    }
    idx = sid;
    for (sid = THERMAL_TIA_SENSOR_ID(0); sid < THERMAL_TIA_SENSOR_ID(TIA_SENSOR_NUM); sid++) {
        if (TIA_SENSOR_TID(sid) == tid) {
            continue;
        }
        tia_thr_ntf.others[idx].sensor_id = sid;
        tia_thr_ntf.others[idx].temp = tia_temp(TIA_SENSOR_TID(sid));
        idx++;
    }

    tfwk_sensor_notify(&tia_thr_ntf);
}

static void tia_tmr_handler(void *param_ptr)
{
    kal_uint32 tid, idx, tms = 0;
    kal_int32 tmp;
    kal_bool hit, ins = KAL_FALSE;
    struct tia_thr_mon_s *mon;

    #ifdef TIA_STACK_PRF
    tia_stack_prf_init();
    #endif
    // check threshold
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        tmp = tia_temp(tid); // always update temperature locally
        mon = tia_thr_mons[tid][tia_thr_ppi[tid]];
        hit = KAL_FALSE;
        for (idx = 0; idx < TIA_THR_TYP_MAX; idx++) {
            if (mon[idx].vld) { hit = KAL_TRUE; break; }
        }
        if (!hit) { continue; }
        // hw threshold
        if (mon[TIA_THR_TYP_HW].vld) {
            if (tmp >= mon[TIA_THR_TYP_HW].thr) {
                MD_TRC(TIA_MSG_ERR_OVER_HW_THRESHOLD, __func__, tid, tmp, mon[TIA_THR_TYP_HW].thr);
                TIA_HW_RESET_RECORD(tid);
                TIA_LVTS_HW_RGU_RESET();
                break;
            } else if (tmp >= (mon[TIA_THR_TYP_HW].thr - TIA_THR_TMP_HW_NEAR)) {
                MD_TRC(TIA_MSG_NEAR_HW_THRESHOLD, tid, tmp, mon[TIA_THR_TYP_HW].thr);
            }
        }
        // rising sw/fim/alarm threshold
        hit = KAL_FALSE;
        for (idx = TIA_THR_TYP_SW; idx < TIA_THR_TYP_MAX; idx++) {
            if ((mon[idx].vld == KAL_FALSE) || (mon[idx].cfg->sensor_alarm_type != TIA_ALM_TYP_RISING)) {
                continue;
            }
            if (hit) { // disable lower threhold
                mon[idx].vld = KAL_FALSE;
                continue;
            }
            if (tmp >= mon[idx].thr) {
                tia_notify(tid, tmp, mon[idx].cfg);
                mon[idx].vld = KAL_FALSE;
                hit = KAL_TRUE;
                MD_TRC(TIA_MSG_OVER_THRESHOLD, tid, tmp, tia_thr_typ_str[idx], mon[idx].thr);
                MD_TRC(TIA_MSG_ALARM_INFO, mon[idx].cfg->enable, mon[idx].cfg->sensor_id, mon[idx].cfg->alarm_id,
                    mon[idx].cfg->threshold_value, mon[idx].cfg->hysteresis_value, mon[idx].cfg->sampling_period,
                    mon[idx].cfg->sensor_alarm_type);
            }
        }
        // falling alarm threshold
        hit = KAL_FALSE;
        for (idx = TIA_THR_TYP_AL1; idx >= TIA_THR_TYP_AL0; idx--) {
            if ((mon[idx].vld == KAL_FALSE) || (mon[idx].cfg->sensor_alarm_type != TIA_ALM_TYP_FALLING)) {
                continue;
            }
            if (hit) { // disable higher threhold
                mon[idx].vld = KAL_FALSE;
                continue;
            }
            if (tmp <= mon[idx].thr) {
                tia_notify(tid, tmp, mon[idx].cfg);
                mon[idx].vld = KAL_FALSE;
                hit = KAL_TRUE;
                MD_TRC(TIA_MSG_UNDER_THRESHOLD, tid, tmp, tia_thr_typ_str[idx], mon[idx].thr);
                MD_TRC(TIA_MSG_ALARM_INFO, mon[idx].cfg->enable, mon[idx].cfg->sensor_id, mon[idx].cfg->alarm_id,
                    mon[idx].cfg->threshold_value, mon[idx].cfg->hysteresis_value, mon[idx].cfg->sampling_period,
                    mon[idx].cfg->sensor_alarm_type);
            }
        }

        // sample period (config and insensive)
        for (idx = TIA_THR_TYP_SW; idx < TIA_THR_TYP_MAX; idx++) {
            kal_uint32 t;
            if (mon[idx].vld == KAL_FALSE) {
                continue;
            }
            t = mon[idx].cfg->sampling_period;
            if ((tms == 0) || (tms > t)) {
                tms = (t < TIA_TMR_MS_MIN)? TIA_TMR_MS_MIN: t;
            }
            if ((mon[idx].cfg->sensor_alarm_type == TIA_ALM_TYP_RISING) &&
                (tmp >= (mon[idx].cfg->threshold_value - (kal_int32) mon[idx].cfg->hysteresis_value))) {
                ins = KAL_TRUE;
                continue;
            }
            if ((mon[idx].cfg->sensor_alarm_type == TIA_ALM_TYP_FALLING) &&
                (tmp <= (mon[idx].cfg->threshold_value + (kal_int32) mon[idx].cfg->hysteresis_value))) {
                ins = KAL_TRUE;
                continue;
            }
        }
    }

    // update timer period
    if ((ins) && (tms > TIA_TMR_MS_ITS)) {
        tms = TIA_TMR_MS_ITS;
    }
    tia_tmr_set(tms, KAL_FALSE);
    #ifdef TIA_STACK_PRF
    tia_stack_prf_done();
    tia_stack_prf_result();
    #endif
}

static void tia_tmr_set(kal_uint32 ms, kal_bool imm)
{
    static kal_uint32 ms_cfg;
    kal_bool ms_trc = KAL_FALSE;
    kal_uint32 tck;

    if ((ms == 0) && tia_thr_hw) {
        ms = TIA_TMR_MS_DFT;
    }
    tck = kal_milli_secs_to_ticks(ms);

    kal_take_spinlock(tia_tmr_sl, KAL_INFINITE_WAIT);
    if (ms != ms_cfg) {
        if (ms_cfg != 1) {
            ms_trc = KAL_TRUE;
        }
        if (ms == 0) {
            kal_cancel_timer(tia_tmr_id);
            ms_cfg = 0;
        } else if (imm) {
            kal_disable_delayed_timer(tia_tmr_id);
            kal_set_timer(tia_tmr_id, tia_tmr_handler, NULL, 1, tck);
            ms_cfg = 1;
        } else {
            kal_enable_delayed_timer(tia_tmr_id, MAX_DELAY_UNLIMITED);
            kal_set_timer(tia_tmr_id, tia_tmr_handler, NULL, tck, tck);
            ms_cfg = ms;
        }
    }
    kal_give_spinlock(tia_tmr_sl);

    if (ms_trc) {
        MD_TRC(TIA_MSG_SAMPLING_PERIOD, ms);
    }
}

static kal_int32 thr_alarm_temp_max(kal_uint32 tid)
{
    struct tia_thr_mon_s *mon;
    kal_int32 idx, tmp = TIA_THR_TMP_MAX;

    mon = tia_thr_mons[tid][tia_thr_ppi[tid]];
    for (idx = 0; idx < TIA_THR_TYP_AL0; idx++) {
        if (tmp > mon[idx].thr) {
            tmp = mon[idx].thr;
        }
    }
    return tmp;
}

static kal_int32 thr_alarm_temp_min(kal_uint32 tid)
{
    kal_int32 tmp = TIA_THR_TMP_MIN;

    if (tmp < tia_sensor_info[tid].min_temperature) {
        tmp = tia_sensor_info[tid].min_temperature;
    }
    return tmp;
}

kal_int32 tia_set_alarm(kal_uint32 ncfg, tfwk_thermal_cfg_t* tcfgs)
{
    #define _upd_err_code(r,e) do {if ((r)==THERMAL_ERR_NONE) (r) = (e);} while (0)
    kal_int32 ret = THERMAL_ERR_NONE, tmp;
    kal_uint32 tid, ppi, idx, tms;
    struct tia_thr_mon_s *mon;
    tfwk_thermal_cfg_t *cfg;
    tfwk_thermal_cfg_t *cfg_f[TIA_SENSOR_NUM][TIA_THR_ALM_NUM] = {NULL}; // filter cfg list

    EXT_ASSERT(ncfg && tcfgs, ncfg, (kal_uint32) tcfgs, 0);

    // filter cfg
    for (idx = 0; idx < ncfg; idx++) {
        cfg = &tcfgs[idx];
        if (!TIA_SENSOR_SID_VALID(cfg->sensor_id)) {
            MD_TRC(TIA_MSG_ERR_SENSOR_ID, __func__, cfg->sensor_id);
            _upd_err_code(ret, THERMAL_ERR_SENSOR_ID);
            continue;
        }
        if (cfg->alarm_id >= TIA_THR_ALM_NUM) {
            MD_TRC(TIA_MSG_ERR_ALARM_ID, __func__, cfg->alarm_id);
            _upd_err_code(ret, THERMAL_ERR_ALARM_ID);
            continue;
        }
        tid = TIA_SENSOR_TID(cfg->sensor_id);
        tmp = thr_alarm_temp_max(tid);
        if (cfg->threshold_value >= tmp) {
            MD_TRC(TIA_MSG_ERR_THRESHOLD_RANGE_MAX, __func__, cfg->threshold_value, tmp);
            _upd_err_code(ret, THERMAL_ERR_THRESHOLD_RANGE);
            continue;
        }
        tmp = thr_alarm_temp_min(tid);
        if (cfg->threshold_value <= tmp) {
            MD_TRC(TIA_MSG_ERR_THRESHOLD_RANGE_MIN, __func__, cfg->threshold_value, tmp);
            _upd_err_code(ret, THERMAL_ERR_THRESHOLD_RANGE);
            continue;
        }
        cfg_f[tid][cfg->alarm_id] = cfg;
        MD_TRC(TIA_MSG_ALARM_INFO,cfg->enable, cfg->sensor_id, cfg->alarm_id, cfg->threshold_value,
            cfg->hysteresis_value, cfg->sampling_period, cfg->sensor_alarm_type);
    }

    // update internal cfg
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        if ((cfg_f[tid][0]==NULL) && (cfg_f[tid][1]==NULL)) {
            continue;
        }
        // clean first
        ppi = !tia_thr_ppi[tid];
        mon = tia_thr_mons[tid][ppi];
        mon[TIA_THR_TYP_SW].vld = KAL_FALSE;
        mon[TIA_THR_TYP_SW].cfg = NULL;
        mon[TIA_THR_TYP_WRN].vld = KAL_FALSE;
        mon[TIA_THR_TYP_WRN].cfg = NULL;
        memset(&mon[TIA_THR_TYP_AL0], 0x0, sizeof(struct tia_thr_mon_s)*TIA_THR_ALM_NUM);
        // update alarm
        if ((cfg_f[tid][0] == NULL) || (cfg_f[tid][1] == NULL)) {
            idx = (cfg_f[tid][0] == NULL);
            memcpy(&tia_thr_cfgs[tid][ppi][idx], cfg_f[tid][idx], sizeof(tfwk_thermal_cfg_t));
            if ((cfg_f[tid][idx]->enable != 0) && (cfg_f[tid][idx]->sensor_alarm_type < TIA_ALM_TYP_DISABLE)) {
                mon[TIA_THR_TYP_AL0].vld = KAL_TRUE;
                mon[TIA_THR_TYP_AL0].thr = cfg_f[tid][idx]->threshold_value;
                mon[TIA_THR_TYP_AL0].cfg = &tia_thr_cfgs[tid][ppi][idx];
            }
            idx = !idx;
            memset(&tia_thr_cfgs[tid][ppi][idx], 0x0, sizeof(tfwk_thermal_cfg_t));
        } else {
            memcpy(&tia_thr_cfgs[tid][ppi][0], cfg_f[tid][0], sizeof(tfwk_thermal_cfg_t));
            memcpy(&tia_thr_cfgs[tid][ppi][1], cfg_f[tid][1], sizeof(tfwk_thermal_cfg_t));
            idx = (cfg_f[tid][0]->threshold_value < cfg_f[tid][1]->threshold_value);
            tmp = TIA_THR_TYP_AL0;
            if ((cfg_f[tid][idx]->enable != 0) && (cfg_f[tid][idx]->sensor_alarm_type < TIA_ALM_TYP_DISABLE)) {
                mon[tmp].vld = KAL_TRUE;
                mon[tmp].thr = cfg_f[tid][idx]->threshold_value;
                mon[tmp].cfg = &tia_thr_cfgs[tid][ppi][idx];
                tmp++;
            }
            idx = !idx;
            if ((cfg_f[tid][idx]->enable != 0) && (cfg_f[tid][idx]->sensor_alarm_type < TIA_ALM_TYP_DISABLE)) {
                mon[tmp].vld = KAL_TRUE;
                mon[tmp].thr = cfg_f[tid][idx]->threshold_value;
                mon[tmp].cfg = &tia_thr_cfgs[tid][ppi][idx];
            }
        }
        // update sw/fim threshold if one more rising alarm
        for (idx = TIA_THR_TYP_AL0; idx <= TIA_THR_TYP_AL1; idx++) {
            if (mon[idx].vld && (mon[idx].cfg->sensor_alarm_type == TIA_ALM_TYP_RISING)) {
                mon[TIA_THR_TYP_SW].vld = (mon[TIA_THR_TYP_SW].thr <= TIA_THR_TMP_MAX);
                mon[TIA_THR_TYP_SW].cfg = mon[TIA_THR_TYP_SW].vld? mon[idx].cfg: NULL;
                mon[TIA_THR_TYP_WRN].vld = (mon[TIA_THR_TYP_WRN].thr <= TIA_THR_TMP_MAX);
                mon[TIA_THR_TYP_WRN].cfg = mon[TIA_THR_TYP_WRN].vld? mon[idx].cfg: NULL;
                break;
            }
        }
        tia_thr_ppi[tid] = ppi;
    }

    // update sampling period
    tms = 0;
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        mon = tia_thr_mons[tid][tia_thr_ppi[tid]];
        for (idx = TIA_THR_TYP_AL0; idx <= TIA_THR_TYP_AL1; idx++) {
            kal_uint32 t;
            if (mon[idx].vld == KAL_FALSE) {
                continue;
            }
            t = mon[idx].cfg->sampling_period;
            if ((tms == 0) || (tms > t)) {
                tms = (t < TIA_TMR_MS_MIN)? TIA_TMR_MS_MIN: t;
            }
        }
    }
    tia_tmr_set(tms, KAL_TRUE);

    if (ret != THERMAL_ERR_NONE) {
        MD_TRC(TIA_MSG_ERR_CODE, __func__, ret);
    }
    return ret;
}

kal_int32 tia_get_temp(kal_uint32 sensor_id, kal_int32 *temp)
{
    if (!TIA_SENSOR_SID_VALID(sensor_id)) {
        MD_TRC(TIA_MSG_ERR_SENSOR_ID, __func__, sensor_id);
        return THERMAL_ERR_SENSOR_ID;
    }
    EXT_ASSERT(temp!=NULL, sensor_id, (kal_uint32) temp, 0);

    *temp = tia_temp(TIA_SENSOR_TID(sensor_id));

    return THERMAL_ERR_NONE;
}

kal_int32 tia_get_temp_all(kal_uint32 ninfo, thermal_temp_info_t *infos)
{
    kal_uint32 idx;
    thermal_temp_info_t *inf;

    EXT_ASSERT((ninfo==TIA_SENSOR_NUM) && (infos!=NULL), ninfo, (kal_uint32) infos, 0);

    for (idx = 0; idx < TIA_SENSOR_NUM; idx++) {
        inf = &infos[idx];
        inf->temp = tia_temp(idx);
        inf->sensor_id = TIA_SENSOR_SID(idx);
    }

    return THERMAL_ERR_NONE;
}

void tia_init(void)
{
    tfwk_sensor_if_t sif = {.get_temp_fp = tia_get_temp, .set_alarm_fp = tia_set_alarm};
    tfwk_sensor_info_t *sinfo_rt;
    kal_uint32 tid, ppi;
    struct tia_thr_mon_s *act;

    UNUSED_PARAMETER(tia_thr_typ_str);

    tia_adc_init();
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        tia_temp(tid); // update first record
    }

    #ifndef NVRAM_NOT_PRESENT // update from nvram
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        nvram_thermal_sensor_info_struct sinfo_nv;
        if (tia_nvram_read_sensor_info(TIA_SENSOR_SID(tid), &sinfo_nv)) {
            sinfo_rt = &tia_sensor_info[tid];
            sinfo_rt->sensor_id           = sinfo_nv.sensor_id;
            sinfo_rt->min_temperature     = sinfo_nv.min_temp;
            sinfo_rt->max_temperature     = sinfo_nv.max_temp;
            sinfo_rt->warning_temperature = sinfo_nv.warn_temp;
            sinfo_rt->accuracy            = sinfo_nv.accuracy;
            sinfo_rt->resolution          = sinfo_nv.resolution;
            memcpy(sinfo_rt->sensor_name, sinfo_nv.sensor_name, sizeof(sinfo_rt->sensor_name));
            tia_sensor_hwShutdownTemp[tid] = sinfo_nv.hws_temp;
        }
    }
    #endif

    // update to tia_thr_mons, tia_thr_hw
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        kal_uint32 hws = tia_sensor_hwShutdownTemp[tid];
        kal_bool vld = (hws <= TIA_THR_TMP_MAX);
        tia_thr_hw += vld;
        sinfo_rt = &tia_sensor_info[tid];
        for (ppi = 0; ppi < TIA_THR_PP_NUM; ppi++) {
            act = tia_thr_mons[tid][ppi];
            act[TIA_THR_TYP_HW].thr = hws;
            act[TIA_THR_TYP_HW].vld = vld;
            act[TIA_THR_TYP_SW].thr = sinfo_rt->max_temperature;
            act[TIA_THR_TYP_WRN].thr = sinfo_rt->warning_temperature;
        }
    }

    // register to tfwk
    tfwk_sensor_reg(TFWK_TIA, TIA_SENSOR_NUM, tia_sensor_info, &sif);

    // kal timer
    tia_tmr_id = kal_create_timer("TIA");
    tia_tmr_sl = kal_create_spinlock("TIA");
    tia_tmr_set(0, KAL_TRUE);
}

void tia_dbg_sns_infs(kal_uint32 tid)
{
    kal_uint32 msk;
    tfwk_sensor_info_t *inf;

    msk = (tid >= TIA_SENSOR_NUM)? ((1 << TIA_SENSOR_NUM) - 1): (1 << tid);
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        if (msk & (1 << tid)) {
            inf = &tia_sensor_info[tid]; UNUSED_PARAMETER(inf);
            MD_TRC(TIA_MSG_SENSOR_INFO, inf->sensor_id, inf->min_temperature, inf->max_temperature,
                inf->warning_temperature, tia_sensor_hwShutdownTemp[tid], inf->accuracy,
                inf->resolution, TIA_SENSOR_NID(tid), inf->sensor_name);
        }
    }
}

void tia_dbg_thr_cfgs(kal_uint32 tid)
{
    kal_uint32 msk, idx;
    tfwk_thermal_cfg_t *cfg;

    msk = (tid >= TIA_SENSOR_NUM)? ((1 << TIA_SENSOR_NUM) - 1): (1 << tid);
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        if ((msk & (1 << tid)) == 0) {
            continue;
        }
        for (idx = 0; idx < TIA_THR_ALM_NUM; idx++) {
            cfg = &tia_thr_cfgs[tid][tia_thr_ppi[tid]][idx]; UNUSED_PARAMETER(cfg);
            MD_TRC(TIA_MSG_ALARM_INFO, cfg->enable, cfg->sensor_id, cfg->alarm_id,
                cfg->threshold_value, cfg->hysteresis_value, cfg->sampling_period,
                cfg->sensor_alarm_type);
        }
    }
}

void tia_dbg_thr_mons(kal_uint32 tid)
{
    kal_uint32 msk, idx;
    struct tia_thr_mon_s *mon;

    msk = (tid >= TIA_SENSOR_NUM)? ((1 << TIA_SENSOR_NUM) - 1): (1 << tid);
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        if ((msk & (1 << tid)) == 0) {
            continue;
        }
        for (idx = 0; idx < TIA_THR_TYP_MAX; idx++) {
            mon = &tia_thr_mons[tid][tia_thr_ppi[tid]][idx];
            MD_TRC(TIA_MSG_MONITOR_INFO, tid, tia_thr_typ_str[idx], mon->vld, mon->thr);
            if (mon->vld && mon->cfg) {
                MD_TRC(TIA_MSG_ALARM_INFO, mon->cfg->enable, mon->cfg->sensor_id, mon->cfg->alarm_id,
                    mon->cfg->threshold_value, mon->cfg->hysteresis_value, mon->cfg->sampling_period,
                    mon->cfg->sensor_alarm_type);
            }
        }
    }
}

void tia_dbg_fake_en(kal_bool en)
{
    #ifdef __MTK_INTERNAL__
    tia_sensor_fake_en = en;
    #endif
}

void tia_dbg_fake_ohm(kal_uint32 tid, kal_uint32 ohm)
{
    #ifdef __MTK_INTERNAL__
    kal_uint32 msk;

    msk = (tid >= TIA_SENSOR_NUM)? ((1 << TIA_SENSOR_NUM) - 1): (1 << tid);
    for (tid = 0; tid < TIA_SENSOR_NUM; tid++) {
        if (msk & (1 << tid)) {
            tia_sensor_fake_ohm[tid] = ohm;
        }
    }
    #endif
}

void tia_dbg_sw_reset(void)
{
    #ifdef __MTK_INTERNAL__
    /// WDT_DEBUG_CTL3: [13] debugsys_thermal_req=0, [14] debugsys_req=0
    DRV_WriteReg32(0xC00070a8, 0x51000000);
    // TOPRGU_CH_DEBUGSYS_EAP_SEL: [1] DEBUGSYS_HAND_SHAKE_REQ_EN=0
    DRV_WriteReg32(0xC0007718, 0x00000000);
    // TOPRGU_CH_DEBUGSYS_EAP_MODE: [0] DEBUGSYS_EN=0
    DRV_WriteReg32(0xC0007714, 0x00000000);
    // DRM_LATCH_CTL: [0] rg_latch_en=0, [6] rg_dramc_latch_en=0,
    //                [11] rg_dramc_rd_test_en=0, [12] rg_dramc_rdwt_test_en=0,
    //                [13] dvfsrc_latch_en=0, [14] emi_latch_en=0
    DRV_WriteReg32(0xC0010044, 0x95000000);
    // DRM_DEBUG_CTL2: [9] dvfsrc_en=0, [8] emi_dcs_en=0
    DRV_WriteReg32(0xC00100a0, (DRV_Reg32(0xC00100a0) & ~0xff000300) | 0x55000000);
    // DRM_MODE: [7] ddr_reserve_mode_wo=1
    DRV_WriteReg32(0xC0010000, 0x22000000);

    ust_us_busyloop(100);

    // TOPRGUWDT_RESTART
    DRV_WriteReg32(0xC0007008, 0x00001971);
    // TOPRGUWDT_MODE
    DRV_WriteReg32(0xC0007000, (DRV_Reg32(0xC0007000) & ~0xff000048) | 0x22000000);
    // TOPRGUWDT_SWRST
    DRV_WriteReg32(0xC0007014, 0x00001209);
    #endif
}

void* tia_dbg_symbol(kal_char *sym)
{
    #ifdef __MTK_INTERNAL__
    if (strcmp(sym, "tia_thr_mons") == 0) {
        return (void *) tia_thr_mons;
    } else if (strcmp(sym, "tia_thr_ppi") == 0) {
        return (void *) tia_thr_ppi;
    } else if (strcmp(sym, "tia_tmr_handler") == 0) {
        return (void *) tia_tmr_handler;
    }
    #endif
    return NULL;
}