view src/cs/drivers/drv_app/lcc/lcc.h @ 686:59f07d67eb45

luna target split into luna1 and luna2 luna1 is FC Luna based on iWOW DSK v4.0 or v5.0 motherboard luna2 is FC Luna based on FC Caramel2 MB
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 12 Oct 2020 18:51:24 +0000
parents 945cf7f506b2
children
line wrap: on
line source

/******************************************************************************
 * Power Task (pwr)
 * Design and coding by Svend Kristian Lindholm, skl@ti.com
 *
 * PWR Types and globals
 *
 * $Id: pwr.h 1.2 Wed, 20 Aug 2003 12:54:50 +0200 skl $
 *
 ******************************************************************************/

#ifndef _LCC_H_
#define _LCC_H_

#include "lcc/lcc_cfg.h"

#ifdef _RVF
#include "rvf/rvf_api.h"
#include "rv/rv_general.h"
#include "lcc/lcc_api.h"
#include "lcc/lcc_cfg_i.h"
#endif

#define PWRVERSION 0x0202

/******************************************************************************
 * Types
 ******************************************************************************/

#ifndef BASIC_TYPES
#define BASIC_TYPES
typedef signed   char  int8;
typedef unsigned char  uint8;
typedef signed   short int16;
typedef unsigned short uint16;
typedef signed   int   int32;
typedef unsigned int   uint32;
#endif

typedef int8   epwr_t;      // error type



/******************************************************************************
 * RVF Types
 ******************************************************************************/

// Mail namings (REQ,IND,RSP) according to RIV010

// Request mail
struct pwr_req_s {
     T_RV_HDR header;
};

// Indication mail with ADC measurements
struct pwr_adc_ind_s {
     T_RV_HDR header;
     unsigned short data[9+1]; // ADC measurements + status of VRPCSTS register
};

// Response mail sent to ETM
struct pwr_tm_req_s {
     T_RV_HDR header;
};

typedef epwr_t                T_PWR_RET;
typedef struct pwr_req_s      T_PWR_REQ;

typedef struct
{
    uint16   alfa_num;     // Slope numerator
    uint16   alfa_denom;   // Slope denominator
    int16    beta;         // Offset
} T_PWR_I2V_CAL_BLOCK;

typedef struct
{
    uint16   alfa_num;     // Slope numerator
    uint16   alfa_denom;   // Slope denominator
    int16    beta;         // Offset
} T_PWR_VBAT_CAL_BLOCK;

// Corresponds to /pwr/i2v.cal and /pwr/vbat.cal
typedef struct
{
    T_PWR_I2V_CAL_BLOCK   i2v;
    T_PWR_VBAT_CAL_BLOCK vbat;
} T_PWR_CAL_BLOCK;

// Corresponds to /pwr/common.cfg
typedef struct
{
    uint32   sampling;     /* 4 */ // The sampling time [ms] used
    uint32   mod_cycle;    /* 4 */ // The modulation cycle time [ms] used when performing modulation (Lithium only)
    uint8    pins;         /* 1 */ // Number of battery pins 2 - 3 - 4
    uint8    chg_dedic;    /* 1 */ // Charging performed (TRUE) or not (FALSE) in dedicated mode
    uint8    alfa1;        /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Vbat
    uint8    alfa2;        /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Tbat
    uint8    alfa3;        /* 1 */ // The regulation parameter N (Exponentially Weighted Moving Average) for Trf
    uint8    rise_thr;     /* 1 */ // The battery rise temperature follows RF rise temperature threshold (Nickel only)
} T_PWR_COMMON_CFG_BLOCK;

// Corresponds to /pwr/bat/bat<N>.cfg
typedef struct
{
    uint16   type;          /* 2 */ // Battery type - Nickel or Lithium
    uint16   rf_temp;       /* 2 */ // Use rf temperature (TRUE) or not (FALSE) if no battery temperature is availlable
    uint32   id_low;        /* 4 */ // Low battery id limit - used for identification
    uint32   id_high;       /* 4 */ // High battery id limit - used for identification
    uint16   cbat;          /* 2 */ // Standard battery capacity [mAh]
    uint16   ratio;         /* 2 */ // Time ratio of charge current [C] (%) - ratio x cbat = max charger current
    uint32   T1;            /* 4 */ // The total time charging counter
    uint32   T2;            /* 4 */ // The CV charging complete timer (-Nickel)
    uint32   T3;            /* 4 */ // The re-charge attempt timer counter
    uint16   chg_start_thr; /* 2 */ // The CV charge begin battery voltage threshold value (-Nickel)
    uint16   chg_stop_thr;  /* 2 */ // The (CI and CV) charge end (stop) battery voltage threshold value
    uint16   chg_ctrl_thr;  /* 2 */ // The minimal charge control ('k_min') value threshold
    uint16   chg_again_thr; /* 2 */ // The charge again capacity threshold (t=20 degrees)
} T_PWR_BAT_CFG_BLOCK;

// Corresponds to /pwr/bat/temp<N>.cfg
typedef struct
{
    int16      tbat_min;  /* 2 */  // Minimum battery temperature allowed
    int16      tbat_max;  /* 2*/  // Maximum battery temperature allowed

    uint16    a0;         /* 2 */  // Capacity temperature compensation a0 (a2*t*t + a1*t +a0)
    uint16    a1;         /* 2 */  // Capacity temperature compensation a1 (a2*t*t + a1*t +a0)
    uint16    a2;         /* 2 */  // Capacity temperature compensation a2 (a2*t*t + a1*t +a0)
                          // Capacity compensation function relative to t=20 degrees
                          // C(t=0) = C(t=20) + capacity compensation function(t=-20)

    uint16   cap[9+1];      /* 20 */ // Capacity as a function of voltage measured at t=20 degrees - C(t=20)
                          // Capacity vector : 100%, 90%, 80%, 70% ,60% ,50%, 40%, 30%, 20%, 10%

    uint16     i_meas1;   /* 2 */  // The choosen measurement current, i_measure (typically 10uA and 50uA)
    uint16     i_meas2;   /* 2 */  // The choosen measurement current, i_measure (typically 10uA and 50uA)
    uint16     v2t_1[8+1];  /* 18 */ // The voltage to temperature mapper for i_measure
    uint16     v2t_2[8+1];  /* 18 */ // The voltage to temperature mapper for i_measure
                          // Temperature vector : -20, -10, 0, 10 ,20 ,30, 40, 50, 60
                          // Interpolation is applied when mapping


} T_PWR_BAT_TEMP_CFG_BLOCK;

// Corresponds to /pwr/chg/chg<N>.cfg
typedef struct
{
    uint16   type;       /* 2 */ // Charger type - Regulated (CI or CV) or unregulated (UNREGULATED)
    uint16   ichg_max;   /* 2 */ // Maximum charger current [mA] - normally decides the fast charging current
    uint16   vchg_low;   /* 2 */ // Low charger voltage limit  (Open circuit - used for identification )
    uint16   vchg_high;  /* 2 */ // High charger voltage limit (Open circuit- used for identification)
} T_PWR_CHG_CFG_BLOCK;

// The power data block - dynamical data collected
typedef struct
{
    uint16       bat_id;             // Measured battery ID
    uint16       chg_id;             // Measured charger ID

    uint16       Vbat;               // Latest measured battery voltage
    uint16       Vbat_avg;           // Latest _average_ battery voltage
    uint16       Vbat_avg_mV;        // Latest _average_ battery voltage

    uint16       Tbat;               // Latest measured battery temperature
    uint16       Tbat_avg;           // Latest _average_ battery temperature

    uint16       T_rf;               // Latest measured RF temperature
    uint16       T_rf_avg;           // Latest _average_ RF temperature

    uint16       Vchg;               // Latest measured charger voltage
    uint16       Ichg;               // Latest measured charger current

    uint16       Cbat;               // Battery capacity in %

    char         cfg_id;             // Configuration ID (bat<n>.cfg)
    char         chg_cfg_id;         // Charger Configuration ID (chg<n>.cfg)
    char         bforce;             // Force usage of battery configuration
    char         cforce;             // Force usage of charger configuration
    uint16       k;                  // Modulation value
    uint32       T4;                 // The modulation ON T4 timer counter (variable!!)
} T_PWR_DATA_BLOCK;

// The PWR control block - state and debug info
typedef struct
{
    int      state;                  // The battery & charging state of the PWR task
    uint8    flag_chg_plugged;       // Charger has been plugged (1) or not (0) flag
    uint8    flag_chg_prev_plugged;  // The previous charger poll said plugged (1) or not plugged (0) flag
    uint8    flag_chg_cfg_read;      // Charger configuration has been read (1) or not (0) flag
    uint8    flag_cal_cfg_read;      // Calibration files has been read (1) or not (0) flag
    uint8    flag_bat_unknown;       // Battery was unknown (1) - or not (0) - the MMI must be told
    uint8    flag_chg_unknown;       // Charger plugged  was unknown (1) - or not (0) - the MMI must be told
    uint8    flag_mmi_registered;    // MMI has registered (1) or not (0)
    uint8    flag_prechg_started;    // Stay in precharge state PRE - Apply fast charging no matter what charger type
    uint8    flag_chg_int_disabled;  // Charger interrupts are disabled (1) or enabled (0)
    uint8    flag_ini_virgo;         // Entering INI state for the very first time - in order to control some very basic initialization
    uint8    cfg_id;                 // Applied battery configuration id
    uint8    chg_cfg_id;             // Applied charger configuration id
    uint8    count_bat_type;         // The number of battery identification measurements reported in state INI
    uint8    count_chg_type;         // The number of charger identification measurements made in state SUP
    uint8    chg_unplug_vec[CONSECUTIVE_CHG_UNPLUGS];    // The charger unplug vector keeps the latest polled values of charger unplug
    uint8    index;                  // The current index of the charger unplug vector
    uint16   capacity;               // The current capacity : 0..100%

    // Timers
    UINT32   time_begin_T0;          // T0: Sampling timer  (constant but modulo ADC updates)
    UINT32   time_elapsed_T0;
    UINT32   time_begin_T1;          // T1: The total charging time timer (constant)
    UINT32   time_elapsed_T1;
    UINT32   time_begin_T2;          // T2: The total CV charging time timer (constant)
    UINT32   time_elapsed_T2;
    UINT32   time_begin_T3;          // T3: The charge-again-without start-stop of charging (constant)
    UINT32   time_elapsed_T3;
    UINT32   time_begin_T4;          // T4: The duty cycle timer
    UINT32   time_elapsed_T4;
    UINT32   time_begin_mod_cycle;   // The modulation cycle timer
    UINT32   time_elapsed_mod_cycle;
    UINT32   time_begin_mmi_rep;     // MMI repetition
    UINT32   time_elapsed_mmi_rep;

    UINT32   tmask;                  // The trace mask used for the PWR process - activated by test mode

    T_RVF_ADDR_ID addr_id;           // Task address id assigned by Riviera framework
    T_RVF_MB_ID   prim_id;           // Memory bank id assigned by Riviera framework

    T_RV_RETURN rpath;               // Return path of the MMI - initialized in pwr_register
    struct mmi_info_ind_s *mmi_ptr;  // Pointer to mmi event memory assigned by the MMI
} T_PWR_CTRL_BLOCK;

// The PWR configuration block - common, charger and battery
typedef struct
{
    T_PWR_CAL_BLOCK cal;             // Calibration matrix
    T_PWR_COMMON_CFG_BLOCK common;   // Common configuration
    T_PWR_BAT_CFG_BLOCK bat;         // Battery configuration
    T_PWR_BAT_TEMP_CFG_BLOCK temp;   // Battery temperature configuration
    T_PWR_CHG_CFG_BLOCK chg;         // Charger configuration
    T_PWR_MMI_CFG_BLOCK mmi;         // MMI configuration
    T_PWR_DATA_BLOCK data;           // Data (dynamic) related to configuration
} T_PWR_CFG_BLOCK;

// Use these values if no FFS files are found
// Units: [ms], [mV] and [mA]
#ifndef PWR_FFS_CFG
    #define PWR_T0_THR            10000
    #define PWR_T1_THR            1800000 // 1/2 hour
    #define PWR_T2_THR            25000
    #define PWR_T3_THR            10000
    #define PWR_MOD_CYCLE_THR    10000
    #define PWR_MMI_REP_THR       60000
    #define PWR_ICHG_MAX          400
    #define EXP_MOVING_AVG_FILTER1 5
    #define EXP_MOVING_AVG_FILTER2 10
    #define EXP_MOVING_AVG_FILTER3 10
    #define PWR_TEMPERATURE_LOW   -20
    #define PWR_TEMPERATURE_HIGH   45
    #define PWR_CV_START_THR      4050
    #define PWR_CHG_STOP_THR      4100
    #define PWR_RISE_THR          4
    #define PWR_MIN_K             20
    #define PWR_MAX_K             200
#endif

#define TYPEN 0x0080               /* Enables the 10uA bias current for the main battery type reading */
#define THERMAL_SENSOR_10uA 0x0041 /* THSENS0 , THSENS1, THSENS2 = 0, 0, 0  MESBAT = 1 */
#define THERMAL_SENSOR_30uA 0x0051 /* THSENS0 , THSENS1, THSENS2 = 0, 1, 0  MESBAT = 1 */
#define THERMAL_SENSOR_50uA 0x0061 /* THSENS0 , THSENS1, THSENS2 = 0, 0, 1  MESBAT = 1 */
#define THERMAL_SENSOR_80uA 0x0079 /* THSENS0 , THSENS1, THSENS2 = 1, 1, 1  MESBAT = 1 */
#define MESBAT              0x0001 /* Resistive divider connected to main battery */
#define CHARGER_IT_MSK      0x0008 /* Mask the charger plug/unplug interrupts */
#define ALL_IT_UMSK         0x0000 /* Unmask all interrupt 2 register related interrupts */

// Convert functions
#define ADC_to_mV(ADC) ((pwr_cfg->cal.vbat.alfa_num*(ADC))/(pwr_cfg->cal.vbat.alfa_denom) + pwr_cfg->cal.vbat.beta)
#define ADC_to_mA(ADC) ((pwr_cfg->cal.i2v.alfa_num*(ADC))/(pwr_cfg->cal.i2v.alfa_denom) + pwr_cfg->cal.i2v.beta)

// Inverse convert functions
#define mV_to_ADC(V) (pwr_cfg->cal.vbat.alfa_num*((V)/pwr_cfg->cal.vbat.alfa_denom) - pwr_cfg->cal.vbat.beta)
#define mA_to_ADC(I) (pwr_cfg->cal.i2v.alfa_num*((I)/pwr_cfg->cal.i2v.alfa_denom) - pwr_cfg->cal.i2v.beta)

/******************************************************************************
 * Errors
 ******************************************************************************/

enum PWR_ERRORS {
    EPWR_OK          =  0  /* ok */
};

/******************************************************************************
 * Enumerations
 ******************************************************************************/

// Message IDs for all PWR module messages
typedef enum PWR_MESSAGES {
    NOP = 0,

    /* Requests */
        /* ABB */
        /* MMI */
    MMI_REGISTER_REQ         = 20,

    /* Timers*/
    TIMER_T1_EXPIRED         = 30,
    TIMER_T2_EXPIRED,
    TIMER_T3_EXPIRED,
    TIMER_T4_EXPIRED,
    TIMER_MOD_CYCLE_EXPIRED,
    TIMER_MMI_INFO_EXPIRED,

    /* Indications */
    /* PWR */
    PWR_CHARGER_PLUGGED_IND  = 40,
    PWR_CHARGER_UNPLUGGED_IND,

    /* Confirmations */

    /* Test mode */
    /* Request */
    PWR_TM_READ_REQ = 70,
    PWR_TM_WRITE_REQ,

    /* Indications */
    PWR_TM_READ_IND = 80,
    PWR_TM_WRITE_IND,

    PWR_ADC_IND = 90

} pwr_msg_e;

// See LCC Detailed Design Specification
typedef enum PWR_STATES {
    CAL = 0, // Reading calibration file(s)
    PRE = 1, // Pre-charging no matter which charger type
    INI = 2, // Reading configuration files
    SUP = 3, // No charging - supervision only
    CCI = 4, // Charging using CI/CV charger
    LCI = 5, // Charging using linear charger
    CCV = 6, // Charging using CI/CV charger
    LCV = 7  // Charging using linear charger
} pwr_states_e;

// See RD818
typedef enum CHG_TYPES {
    CI = 1,
    CV = 2,
    UNREGULATED = 3
} chg_types_e;

// See RD818
typedef enum BAT_TYPES {
    LITHIUM = 1,
    NICKEL = 2
} bat_types_e;

// See RIV261
typedef enum CAUSE_TYPES {
    BATTERY_TEMPERATURE_OK   = 0,
    BATTERY_TEMPERATURE_LOW  = 1,
    BATTERY_TEMPERATURE_HIGH = 2
} cause_types_e;

enum PWR_Errors {
    // PWR Common Target Errors
    PWR_OK          =    0,  // Ok
    PWR_INDEX       =  -1,   // Unknown index
    PWR_OK_MORE     = -63,   // Ok, more data coming
    PWR_PACKET      = -62,   // Packet error (checksum or other)
    PWR_FATAL       = -61,   // System fatal error
    PWR_NOSYS       = -60,   // Module or function not present
    PWR_INVAL       = -59,   // Invalid parameter/argument
    PWR_BADOP       = -58,   // Operation not possible in current context
    PWR_AGAIN       = -57,   // Not ready, try again later
    PWR_NOMEM       = -56,   // Out of memory
    PWR_MESSAGE     = -55,   // Received unknown message

    // Errors that are related to the Riv env.
    PWR_RV_NOT_SUPPORTED = -51, //
    PWR_RV_MEMORY_ERR    = -50, //
    PWR_RV_INTERNAL_ERR  = -49, //
    PWR_RV_FATAL         = -48 //

};

#endif //_LCC_H_