tempdrv.c

Go to the documentation of this file.

/***************************************************************************/
#include "em_device.h"
#include "em_system.h"
#include "em_emu.h"
#include "string.h"

#include "tempdrv.h"

typedef struct
{
  TEMPDRV_Callback_t callback;    
  uint8_t temp;                   
} TEMPDRV_CallbackSet_t;

#if defined(_SILICON_LABS_GECKO_INTERNAL_SDID_80)
#define TEMPDRV_ERRATA_FIX
#endif

#ifdef TEMPDRV_ERRATA_FIX
#define TEMPDRV_INT_CALLBACK_DEPTH 1
#define TEMPDRV_
#else
#define TEMPDRV_INT_CALLBACK_DEPTH 0
#endif

#define TEMPDRV_CALLBACK_DEPTH (TEMPDRV_INT_CALLBACK_DEPTH + TEMPDRV_CUSTOM_CALLBACK_DEPTH)
#define TEMPDRV_CUSTOM_CALLBACK_INDEX TEMPDRV_INT_CALLBACK_DEPTH

static TEMPDRV_CallbackSet_t tempdrvHighCallbacks[TEMPDRV_CALLBACK_DEPTH];
static TEMPDRV_CallbackSet_t tempdrvLowCallbacks[TEMPDRV_CALLBACK_DEPTH];
static TEMPDRV_CallbackSet_t nullCallback = {NULL, 0};
static TEMPDRV_CallbackSet_t *highCallback;
static TEMPDRV_CallbackSet_t *lowCallback;

static bool TEMPDRV_InitState = false;
static bool TEMPDRV_EnableState = false;

static int8_t convertToTemp(uint8_t emu);
static uint8_t convertToEmu(int8_t temp);
static void updateInterrupts(void);

// Calibration values to be initialized in TEMPDRV_Init
static int32_t calibrationEMU;
static int32_t calibrationTEMP;
// Fallback calibration values in case DI calibration data not present
static uint8_t fallbackEMU = 0x90;
static uint8_t fallbackTEMP = 25;

#if (EMU_CUSTOM_IRQ_HANDLER == false)
/***************************************************************************/
void EMU_IRQHandler(void)
{
  TEMPDRV_IRQHandler();
}
#endif

/***************************************************************************/
void TEMPDRV_IRQHandler(void)
{
  uint32_t flags = EMU_IntGetEnabled();
  TEMPDRV_Callback_t activeCallback;
  // High EMU value means a decreasing temperature
  if (flags & EMU_IF_TEMPHIGH)
  {
    // High EMU interrupt = Low temp limit
    if (lowCallback->callback != NULL)
    {
      activeCallback = lowCallback->callback;
      memset(lowCallback, 0, sizeof(TEMPDRV_CallbackSet_t));
      activeCallback(TEMPDRV_GetTemp(), TEMPDRV_LIMIT_LOW);
    }
    EMU_IntClear(EMU_IFC_TEMPHIGH);
  }
  else if (flags & EMU_IF_TEMPLOW)
  {
    // Low EMU interrupt = high temp limit
    if (highCallback->callback != NULL)
    {
      activeCallback = highCallback->callback;
      memset(highCallback, 0, sizeof(TEMPDRV_CallbackSet_t));
      activeCallback(TEMPDRV_GetTemp(), TEMPDRV_LIMIT_HIGH);
    }
    EMU_IntClear(EMU_IFC_TEMPLOW);
  }
  updateInterrupts();
}

#if defined(TEMPDRV_ERRATA_FIX)
/* Errata */
typedef enum ErrataState 
{
  ERRATA_LOW     = 0, 
  ERRATA_MID     = 1, 
  ERRATA_HIGH    = 2  
} ErrataState_t;

// These are the temperature limits in degrees Celsius
#define ERRATA_MID_LIMIT   65
#define ERRATA_HIGH_LIMIT  80
#define ERRATA_HYSTERESIS   8

static void errataCallback(int8_t temp, TEMPDRV_LimitType_t limit);
static void errataStateUpdate(int8_t temp);

static TEMPDRV_CallbackSet_t errataLowTemp[3];  // Temperature decrease thresholds
static TEMPDRV_CallbackSet_t errataHighTemp[3]; // Temperature increase thresholds

/***************************************************************************/
static void errataCallback(int8_t temp, TEMPDRV_LimitType_t limit)
{
  (void) limit; // unused
  errataStateUpdate(temp);
}

/***************************************************************************/
static void errataStateUpdate(int8_t temp)
{
  ErrataState_t errataState;
  bool emuLocked = (EMU->LOCK == EMU_LOCK_LOCKKEY_LOCKED);

  // Figure out the current state based on temperature
  if (temp < ERRATA_MID_LIMIT)
  {
    errataState = ERRATA_LOW;
  }
  else if (temp < ERRATA_HIGH_LIMIT)
  {
    errataState = ERRATA_MID;
  }
  else
  {
    errataState = ERRATA_HIGH;
  }

  // Activate callback and thresholds for the current state
  tempdrvHighCallbacks[0] = errataHighTemp[errataState];
  tempdrvLowCallbacks[0] = errataLowTemp[errataState];
  
  if (emuLocked)
  {
    EMU->LOCK = EMU_LOCK_LOCKKEY_UNLOCK;
  }

  switch (errataState)
  {
    case ERRATA_LOW:
      EMU_SetBiasMode(emuBiasMode_1KHz);
      break;
    case ERRATA_MID:
      EMU_SetBiasMode(emuBiasMode_4KHz);
      break;
    case ERRATA_HIGH:
      EMU_SetBiasMode(emuBiasMode_Continuous);
      break;
  }

  if (emuLocked)
  {
    EMU->LOCK = EMU_LOCK_LOCKKEY_LOCK;
  }
}

/***************************************************************************/
static void errataInit(void)
{
  SYSTEM_ChipRevision_TypeDef rev;
  SYSTEM_ChipRevisionGet(&rev);

  /* Rev A temp errata handling */
  if (rev.major == 0x01)
  {
    uint8_t limitLow;
    uint8_t limitHigh;

    // Initialize Low temperature state [*, 65]
    limitHigh = convertToEmu(ERRATA_MID_LIMIT);
    errataHighTemp[ERRATA_LOW].temp = limitHigh;
    errataHighTemp[ERRATA_LOW].callback = errataCallback;
    
    // Initialize Mid temperature state [57, 80]
    limitLow  = convertToEmu(ERRATA_MID_LIMIT - ERRATA_HYSTERESIS);
    limitHigh = convertToEmu(ERRATA_HIGH_LIMIT);
    errataLowTemp[ERRATA_MID].temp = limitLow;
    errataLowTemp[ERRATA_MID].callback = errataCallback;
    errataHighTemp[ERRATA_MID].temp = limitHigh;
    errataHighTemp[ERRATA_MID].callback = errataCallback;
    
    // Initialize High temperature state [72, *]
    limitLow = convertToEmu(ERRATA_HIGH_LIMIT - ERRATA_HYSTERESIS);
    errataLowTemp[ERRATA_HIGH].temp = limitLow;
    errataLowTemp[ERRATA_HIGH].callback = errataCallback;
    
    errataStateUpdate(TEMPDRV_GetTemp());
  }
}
#else // TEMPDRV_ERRATA_FIX

#define errataInit()

#endif // TEMPDRV_ERRATA_FIX

/* Internal Functions */
/***************************************************************************/
static int8_t findCallbackSpace(TEMPDRV_CallbackSet_t *set)
{
  uint8_t index;
  for (index = TEMPDRV_CUSTOM_CALLBACK_INDEX; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    if (set[index].callback==NULL)
    {
      return index;
    }
  }
  // no empty space, return -1
  return -1;
}

/***************************************************************************/
static Ecode_t addCallback(TEMPDRV_CallbackSet_t *set, 
                           int8_t temp, 
                           TEMPDRV_Callback_t callback)
{
  int8_t index = findCallbackSpace(set);
  if (index < 0)
  {
    return ECODE_EMDRV_TEMPDRV_NO_SPACE;
  }
  set[index].temp = convertToEmu(temp);
  set[index].callback = callback;
  updateInterrupts();
  return ECODE_EMDRV_TEMPDRV_OK;
}

/***************************************************************************/
static bool removeCallback(TEMPDRV_CallbackSet_t *set, 
                           TEMPDRV_Callback_t callback)
{
  bool found = false;
  uint8_t index;
  for (index = TEMPDRV_CUSTOM_CALLBACK_INDEX; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    if (set[index].callback == callback)
    {
      set[index].callback = NULL;
      set[index].temp = 0;
      found = true;
    }
  }
  updateInterrupts();
  return found;
}

/***************************************************************************/
static bool checkForDuplicates(TEMPDRV_CallbackSet_t *set, int8_t temp)
{
  uint8_t index;
  uint8_t emu = convertToEmu(temp);
  for (index = TEMPDRV_CUSTOM_CALLBACK_INDEX; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    // filter out only entries with valid callbacks
    if (set[index].callback!=NULL)
    {
      // if duplicate temperature, return true
      if (set[index].temp == emu)
      {
        return true;
      }
    }
  }
  // return false if no duplicate temperatures found
  return false;
}

/***************************************************************************/
static int8_t convertToTemp(uint8_t emu)
{
  int32_t res = (int32_t) calibrationTEMP - ((emu * 8) / 5);
  // Cap conversion results at int8_t bounds
  if (res < -128)
  {
    res = -128;
  }
  else if (res > 127)
  {
    res = 127;
  }
  
  return (int8_t) res;
}

/***************************************************************************/
static uint8_t convertToEmu(int8_t temp)
{
  int32_t res = (int32_t) calibrationEMU -  ((temp * 5) >> 3);
  // Cap conversion results at uint8_t bounds
  if (res > 255)
  {
    res = 255;
  }
  else if (res < 0)
  {
    res = 0;
  }
  return (uint8_t) res;
}

/***************************************************************************/
static void disableInterrupts(void)
{
  EMU_IntClear(EMU_IFC_TEMPLOW | EMU_IFC_TEMPHIGH);
  EMU_IntDisable(EMU_IFC_TEMPLOW | EMU_IFC_TEMPHIGH);
}

/***************************************************************************/
static void updateInterrupts(void)
{
  // Find lowest temperature active high callback
  uint8_t index;
  for (index = 0; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    // filter out only entries with valid callbacks
    if (tempdrvHighCallbacks[index].callback!=NULL)
    {
      if (highCallback->callback == NULL)
      {
        highCallback = &tempdrvHighCallbacks[index];
      }
      else
      {
        if (tempdrvHighCallbacks[index].temp>highCallback->temp)
        {
          highCallback = &tempdrvHighCallbacks[index];
        }
      }
    }
  }
  // If active callback, set and enable interrupt
  if (highCallback->callback != NULL)
  {
    // EMU and TEMP are inversely proportional
    EMU->TEMPLIMITS &= ~_EMU_TEMPLIMITS_TEMPLOW_MASK;
    EMU->TEMPLIMITS |= highCallback->temp << _EMU_TEMPLIMITS_TEMPLOW_SHIFT;
    EMU_IntEnable(EMU_IEN_TEMPLOW);
  }
  else
  {
    EMU_IntDisable(EMU_IEN_TEMPLOW);
  }

  // Find highest temperature active low callback
  for (index = 0; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    // filter out only entries with valid callbacks
    if (tempdrvLowCallbacks[index].callback!=NULL)
    {
      if (lowCallback->callback == NULL)
      {
        lowCallback = &tempdrvLowCallbacks[index];
      }
      else
      {
        if (tempdrvLowCallbacks[index].temp<lowCallback->temp)
        {
          lowCallback = &tempdrvLowCallbacks[index];
        }
      }
    }
  }
  // If active callback, set and enable interrupt
  if (lowCallback->callback!=NULL)
  {
    // EMU and TEMP are inversely proportional
    EMU->TEMPLIMITS &= ~_EMU_TEMPLIMITS_TEMPHIGH_MASK;
    EMU->TEMPLIMITS |= lowCallback->temp << _EMU_TEMPLIMITS_TEMPHIGH_SHIFT;
    EMU_IntEnable(EMU_IEN_TEMPHIGH);
  }
  else
  {
    EMU_IntDisable(EMU_IEN_TEMPHIGH);
  }
}

/* Official API */
/***************************************************************************/
Ecode_t TEMPDRV_Init(void)
{
  uint32_t DItemp, DIemu;

  // Flag up
  TEMPDRV_InitState = true;

  // reset stack state by erasing callbacks
  memset(tempdrvHighCallbacks, 0, sizeof (TEMPDRV_CallbackSet_t) * TEMPDRV_CALLBACK_DEPTH);
  memset(tempdrvLowCallbacks, 0, sizeof (TEMPDRV_CallbackSet_t) * TEMPDRV_CALLBACK_DEPTH);
  highCallback = &nullCallback;
  lowCallback = &nullCallback;

  // Retrieve calibration data from DI page
  DItemp = ((DEVINFO->CAL & _DEVINFO_CAL_TEMP_MASK) >> _DEVINFO_CAL_TEMP_SHIFT);
  DIemu = ((DEVINFO->EMUTEMP & _DEVINFO_EMUTEMP_EMUTEMPROOM_MASK) >> _DEVINFO_EMUTEMP_EMUTEMPROOM_SHIFT);

  if ((DItemp == (_DEVINFO_CAL_TEMP_MASK >> _DEVINFO_CAL_TEMP_SHIFT)) 
   || (DIemu == (_DEVINFO_EMUTEMP_EMUTEMPROOM_MASK >> _DEVINFO_EMUTEMP_EMUTEMPROOM_SHIFT)))
  {
    // Missing DI page calibration data, substitute fixed values
    DItemp = fallbackTEMP;
    DIemu = fallbackEMU;
  }

  // calculate conversion offsets. Based on assumed slope of 5/8
  calibrationEMU = (DIemu) + ((5*(DItemp))/8);
  calibrationTEMP = (DItemp) + (8*(DIemu)/5);

  errataInit();

  disableInterrupts();
  NVIC_ClearPendingIRQ(EMU_IRQn);
  NVIC_EnableIRQ(EMU_IRQn);
  updateInterrupts();

  return ECODE_EMDRV_TEMPDRV_OK;
}

/***************************************************************************/
Ecode_t TEMPDRV_DeInit(void)
{
  TEMPDRV_InitState = false;
  NVIC_DisableIRQ(EMU_IRQn);
  NVIC_ClearPendingIRQ(EMU_IRQn);
  disableInterrupts();
  memset(tempdrvHighCallbacks, 0, sizeof (TEMPDRV_CallbackSet_t) * TEMPDRV_CALLBACK_DEPTH);
  memset(tempdrvLowCallbacks, 0, sizeof (TEMPDRV_CallbackSet_t) * TEMPDRV_CALLBACK_DEPTH);
  return ECODE_EMDRV_TEMPDRV_OK;
}

/***************************************************************************/
Ecode_t TEMPDRV_Enable(bool enable)
{
  if (TEMPDRV_EnableState != enable)
  {
    TEMPDRV_EnableState = enable;
    if (enable)
    {
      updateInterrupts();
    }
    else
    {
      disableInterrupts();
    }
  }
  return ECODE_EMDRV_TEMPDRV_OK;
}

/***************************************************************************/
uint8_t TEMPDRV_GetActiveCallbacks(TEMPDRV_LimitType_t limit)
{
  TEMPDRV_CallbackSet_t *set;

  if (limit == TEMPDRV_LIMIT_HIGH)
  {
    // Define callback set
    set = tempdrvHighCallbacks;
  }
  else if (limit == TEMPDRV_LIMIT_LOW)
  {
    // Define callback set
    set = tempdrvLowCallbacks;
  }
  else
  {
    // Invalid limit
    return 0;
  }
  uint8_t index, count=0;
  for (index = TEMPDRV_CUSTOM_CALLBACK_INDEX; index < TEMPDRV_CALLBACK_DEPTH; index++)
  {
    // filter out only entries with valid callbacks
    if (set[index].callback!=NULL)
    {
      count++;
    }
  }
  return count;
}

/***************************************************************************/
int8_t TEMPDRV_GetTemp(void)
{
  return convertToTemp(EMU->TEMP);
}

/***************************************************************************/
Ecode_t TEMPDRV_RegisterCallback(int8_t temp, 
                                 TEMPDRV_LimitType_t limit, 
                                 TEMPDRV_Callback_t callback)
{
  TEMPDRV_CallbackSet_t *set;
  if (TEMPDRV_InitState == false)
  {
    return ECODE_EMDRV_TEMPDRV_NO_INIT;
  }
  // cannot register null callback
  if (callback == NULL)
  {
    return ECODE_EMDRV_TEMPDRV_PARAM_ERROR;
  }
  if (limit == TEMPDRV_LIMIT_HIGH)
  {
    // current temperature is already higher than requested temperature
    if (TEMPDRV_GetTemp() > temp)
    {
      return ECODE_EMDRV_TEMPDRV_BAD_LIMIT;
    }
    // Define callback set
    set = tempdrvHighCallbacks;
  }
  else if (limit == TEMPDRV_LIMIT_LOW)
  {
    // current temperature is already lower than requested temperature
    if (TEMPDRV_GetTemp() < temp)
    {
      return ECODE_EMDRV_TEMPDRV_BAD_LIMIT;
    }
    // Define callback set
    set = tempdrvLowCallbacks;
  }
  else
  {
    // Invalid limit
    return ECODE_EMDRV_TEMPDRV_PARAM_ERROR;
  }

  // Cannot register duplicate temperature callback
  if (checkForDuplicates(set, temp) == true)
  {
    return ECODE_EMDRV_TEMPDRV_DUP_TEMP;
  }

  return addCallback(set, temp, callback);
}

/***************************************************************************/
Ecode_t TEMPDRV_UnregisterCallback(TEMPDRV_Callback_t callback)
{
  // cannot register null callback
  if (callback == NULL)
  {
    return ECODE_EMDRV_TEMPDRV_PARAM_ERROR;
  }
  if (removeCallback(tempdrvHighCallbacks,callback) == false &&
      removeCallback(tempdrvLowCallbacks,callback) == false)
  {
    return ECODE_EMDRV_TEMPDRV_NO_CALLBACK;
  }
  return ECODE_EMDRV_TEMPDRV_OK;
}

/******** THE REST OF THE FILE IS DOCUMENTATION ONLY !**********************/