sleep.c

Go to the documentation of this file.

/***************************************************************************/
/* Chip specific header file(s). */
#include "em_device.h"
#include "em_assert.h"
#include "em_core.h"
#include "em_rmu.h"
#include "em_emu.h"

/* Module header file(s). */
#include "sleep.h"

/* stdlib is needed for NULL definition */
#include <stdlib.h>

/***************************************************************************/
/***************************************************************************/
/*******************************************************************************
 *******************************   MACROS   ************************************
 ******************************************************************************/

/* Number of low energy modes (EM2 and EM3). Note: EM4 sleep/wakeup is handled
 * differently therefore it is not part of the list! */
#define SLEEP_NUMOF_LOW_ENERGY_MODES    2U

/*******************************************************************************
 ******************************   TYPEDEFS   ***********************************
 ******************************************************************************/

/*******************************************************************************
 ******************************   CONSTANTS   **********************************
 ******************************************************************************/

/*******************************************************************************
 *******************************   STATICS   ***********************************
 ******************************************************************************/

/* Callback functions to call before and after sleep. */
static SLEEP_CbFuncPtr_t sleepCallback  = NULL;
static SLEEP_CbFuncPtr_t wakeUpCallback = NULL;

/* Sleep block counter array representing the nested sleep blocks for the low
 * energy modes (EM2/EM3). Array index 0 corresponds to EM2 and index 1
 * to EM3.
 *
 * Note:
 * - EM4 sleep/wakeup is handled differently therefore it is not part of the
 *   list!
 * - Max. number of sleep block nesting is 255. */
static uint8_t sleepBlockCnt[SLEEP_NUMOF_LOW_ENERGY_MODES];

/*******************************************************************************
 ******************************   PROTOTYPES   *********************************
 ******************************************************************************/

static void enterEMx(SLEEP_EnergyMode_t eMode);

/*******************************************************************************
 ***************************   GLOBAL FUNCTIONS   ******************************
 ******************************************************************************/

/***************************************************************************/
void SLEEP_Init(SLEEP_CbFuncPtr_t pSleepCb, SLEEP_CbFuncPtr_t pWakeUpCb)
{
  /* Initialize callback functions. */
  sleepCallback  = pSleepCb;
  wakeUpCallback = pWakeUpCb;

  /* Reset sleep block counters. Note: not using for() saves code! */
  sleepBlockCnt[0U] = 0U;
  sleepBlockCnt[1U] = 0U;

#if (SLEEP_EM4_WAKEUP_CALLBACK_ENABLED == true) \
    && (defined(RMU_RSTCAUSE_EM4WURST) || defined(RMU_RSTCAUSE_EM4RST))
  /* Check if the Init() happened after an EM4 reset. */
#if defined(RMU_RSTCAUSE_EM4WURST)
  if (RMU_ResetCauseGet() & RMU_RSTCAUSE_EM4WURST)
#elif defined(RMU_RSTCAUSE_EM4RST)
  if (RMU_ResetCauseGet() & RMU_RSTCAUSE_EM4RST)
#endif
  {
    /* Clear the cause of the reset. */
    RMU_ResetCauseClear();
    /* Call wakeup callback with EM4 parameter. */
    if (NULL != wakeUpCallback)
    {
      wakeUpCallback(sleepEM4);
    }
  }
#endif
}

/***************************************************************************/
SLEEP_EnergyMode_t SLEEP_Sleep(void)
{
  CORE_DECLARE_IRQ_STATE;
  SLEEP_EnergyMode_t allowedEM;

  /* Critical section to allow sleep blocks in ISRs. */
  CORE_ENTER_CRITICAL();
  allowedEM = SLEEP_LowestEnergyModeGet();

  if ((allowedEM >= sleepEM1) && (allowedEM <= sleepEM3))
  {
    enterEMx(allowedEM);
  }
  else
  {
    allowedEM = sleepEM0;
  }
  CORE_EXIT_CRITICAL();

  return allowedEM;
}

/***************************************************************************/
void SLEEP_ForceSleepInEM4(void)
{
#if (SLEEP_HW_LOW_ENERGY_BLOCK_ENABLED == true)
  /* Unblock the EM2/EM3/EM4 block in the EMU. */
  EMU_EM2UnBlock();
#endif

  /* Request entering to EM4. */
  enterEMx(sleepEM4);
}

/***************************************************************************/
void SLEEP_SleepBlockBegin(SLEEP_EnergyMode_t eMode)
{
  EFM_ASSERT((eMode >= sleepEM2) && (eMode < sleepEM4));
  EFM_ASSERT((sleepBlockCnt[eMode - 2U]) < 255U);

  if ((eMode == sleepEM2) || (eMode == sleepEM3))
  {
    /* Increase the sleep block counter of the selected energy mode. */
    sleepBlockCnt[eMode - 2U]++;

#if (SLEEP_HW_LOW_ENERGY_BLOCK_ENABLED == true)
    /* Block EM2/EM3 sleep if the EM2 block begins. */
    if (eMode == sleepEM2)
    {
      EMU_EM2Block();
    }
#endif
  }
}

/***************************************************************************/
void SLEEP_SleepBlockEnd(SLEEP_EnergyMode_t eMode)
{
  EFM_ASSERT((eMode >= sleepEM2) && (eMode < sleepEM4));

  if ((eMode == sleepEM2) || (eMode == sleepEM3))
  {
    /* Decrease the sleep block counter of the selected energy mode. */
    if (sleepBlockCnt[eMode - 2U] > 0U)
    {
      sleepBlockCnt[eMode - 2U]--;
    }

#if (SLEEP_HW_LOW_ENERGY_BLOCK_ENABLED == true)
    /* Check if the EM2/EM3 block should be unblocked in the EMU. */
    if (0U == sleepBlockCnt[sleepEM2 - 2U])
    {
      EMU_EM2UnBlock();
    }
#endif
  }
}

/***************************************************************************/
SLEEP_EnergyMode_t SLEEP_LowestEnergyModeGet(void)
{
  SLEEP_EnergyMode_t tmpLowestEM = sleepEM1;

  /* Check which is the lowest energy mode that the system can be set to. */
  if (0U == sleepBlockCnt[sleepEM2 - 2U])
  {
    tmpLowestEM = sleepEM2;
    if (0U == sleepBlockCnt[sleepEM3 - 2U])
    {
      tmpLowestEM = sleepEM3;
    }
  }

  /* Compare with the default lowest energy mode setting. */
  if (SLEEP_LOWEST_ENERGY_MODE_DEFAULT < tmpLowestEM)
  {
    tmpLowestEM = SLEEP_LOWEST_ENERGY_MODE_DEFAULT;
  }

  return tmpLowestEM;
}

/***************************************************************************/
static void enterEMx(SLEEP_EnergyMode_t eMode)
{
  EFM_ASSERT((eMode > sleepEM0) && (eMode <= sleepEM4));

  /* Call sleepCallback() before going to sleep. */
  if (NULL != sleepCallback)
  {
    /* Call the callback before going to sleep. */
    sleepCallback(eMode);
  }

  /* Enter the requested energy mode. */
  switch (eMode)
  {
    case sleepEM1:
      EMU_EnterEM1();
      break;

    case sleepEM2:
      EMU_EnterEM2(true);
      break;

    case sleepEM3:
      EMU_EnterEM3(true);
      break;

    case sleepEM4:
      EMU_EnterEM4();
      break;

    default:
      /* Don't do anything, stay in EM0. */
      break;
  }

  /* Call the callback after waking up from sleep. */
  if (NULL != wakeUpCallback)
  {
    wakeUpCallback(eMode);
  }
}