Hibernate_api

Macros
#define	DELAY_USECS   95
#define	LOOP_CYCLES   3
#define	HIBERNATE_WAKE_IO   CLASS_IS_TM4C129
#define	HIBERNATE_CLOCK_OUTPUT   CLASS_IS_TM4C129

Functions
static void	_HibernateWriteComplete (void)
void	HibernateEnableExpClk (uint32_t ui32HibClk)
void	HibernateDisable (void)
void	HibernateClockConfig (uint32_t ui32Config)
void	HibernateRTCEnable (void)
void	HibernateRTCDisable (void)
void	HibernateBatCheckStart (void)
uint32_t	HibernateBatCheckDone (void)
void	HibernateWakeSet (uint32_t ui32WakeFlags)
uint32_t	HibernateWakeGet (void)
void	HibernateLowBatSet (uint32_t ui32LowBatFlags)
uint32_t	HibernateLowBatGet (void)
void	HibernateRTCSet (uint32_t ui32RTCValue)
uint32_t	HibernateRTCGet (void)
void	HibernateRTCMatchSet (uint32_t ui32Match, uint32_t ui32Value)
uint32_t	HibernateRTCMatchGet (uint32_t ui32Match)
void	HibernateRTCSSMatchSet (uint32_t ui32Match, uint32_t ui32Value)
uint32_t	HibernateRTCSSMatchGet (uint32_t ui32Match)
uint32_t	HibernateRTCSSGet (void)
void	HibernateRTCTrimSet (uint32_t ui32Trim)
uint32_t	HibernateRTCTrimGet (void)
void	HibernateDataSet (uint32_t *pui32Data, uint32_t ui32Count)
void	HibernateDataGet (uint32_t *pui32Data, uint32_t ui32Count)
void	HibernateRequest (void)
void	HibernateIntEnable (uint32_t ui32IntFlags)
void	HibernateIntDisable (uint32_t ui32IntFlags)
static uint32_t	_HibernateIntNumberGet (void)
void	HibernateIntRegister (void(*pfnHandler)(void))
void	HibernateIntUnregister (void)
uint32_t	HibernateIntStatus (bool bMasked)
void	HibernateIntClear (uint32_t ui32IntFlags)
uint32_t	HibernateIsActive (void)
void	HibernateGPIORetentionEnable (void)
void	HibernateGPIORetentionDisable (void)
bool	HibernateGPIORetentionGet (void)
void	HibernateCounterMode (uint32_t ui32Config)
static void	_HibernateCalendarSet (uint32_t ui32Reg, struct tm *psTime)
void	HibernateCalendarSet (struct tm *psTime)
int	HibernateCalendarGet (struct tm *psTime)
void	HibernateCalendarMatchSet (uint32_t ui32Index, struct tm *psTime)
void	HibernateCalendarMatchGet (uint32_t ui32Index, struct tm *psTime)
void	HibernateTamperEventsConfig (uint32_t ui32Config)
void	HibernateTamperEnable (void)
void	HibernateTamperDisable (void)
void	HibernateTamperIOEnable (uint32_t ui32Input, uint32_t ui32Config)
void	HibernateTamperIODisable (uint32_t ui32Input)
void	HibernateTamperEventsClear (void)
void	HibernateTamperEventsClearNoLock (void)
void	HibernateTamperUnLock (void)
void	HibernateTamperLock (void)
uint32_t	HibernateTamperStatusGet (void)
bool	HibernateTamperEventsGet (uint32_t ui32Index, uint32_t *pui32RTC, uint32_t *pui32Event)
void	HibernateTamperExtOscRecover (void)
bool	HibernateTamperExtOscValid (void)

Detailed Description

Macro Definition Documentation

#define DELAY_USECS   95

Definition at line 64 of file hibernate.c.

#define HIBERNATE_CLOCK_OUTPUT   CLASS_IS_TM4C129

Definition at line 87 of file hibernate.c.

Referenced by HibernateClockConfig().

#define HIBERNATE_WAKE_IO   CLASS_IS_TM4C129

Definition at line 79 of file hibernate.c.

Referenced by HibernateWakeGet(), and HibernateWakeSet().

#define LOOP_CYCLES   3

Definition at line 71 of file hibernate.c.

Function Documentation

static void _HibernateCalendarSet ( uint32_t  ui32Reg, struct tm *  psTime  )

static

Definition at line 1465 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_CAL0, HIB_CAL0_AMPM, HIB_CAL1_DOM_M, HIB_CAL1_DOM_S, HIB_CAL1_DOW_S, HIB_CAL1_MON_S, HIB_CAL1_YEAR_S, HIB_CALCTL, HIB_CALCTL_CAL24, HIB_CALCTL_CALEN, HIB_CALLD0, HIB_CALLD0_HR_M, HIB_CALLD0_HR_S, HIB_CALLD0_MIN_M, HIB_CALLD0_MIN_S, HIB_CALLD0_SEC_M, HIB_CALLD0_SEC_S, HIB_CALLD1, HIB_CALM0, HIB_CALM1, HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, and HWREG.

Referenced by HibernateCalendarMatchSet(), and HibernateCalendarSet().

{
    uint32_t ui32Time, ui32Date;

    ASSERT(HWREG(HIB_CALCTL) & HIB_CALCTL_CALEN);

    //
    // Minutes and seconds are consistent in all modes.
    //
    ui32Time = (((psTime->tm_min << HIB_CALLD0_MIN_S) & HIB_CALLD0_MIN_M) |
                ((psTime->tm_sec << HIB_CALLD0_SEC_S) & HIB_CALLD0_SEC_M));

    //
    // 24 Hour time is used directly for Calendar set.
    //
    if(HWREG(HIB_CALCTL) & HIB_CALCTL_CAL24)
    {
        ui32Time |= (psTime->tm_hour << HIB_CALLD0_HR_S);

        //
        // for Calendar match, if it is every hour, AMPM bit should be clear
        //
        if((ui32Reg == HIB_CALM0) && (psTime->tm_hour == 0xFF) )
        {
            //
            // clear AMPM bit
            //
            ui32Time &= ~HIB_CAL0_AMPM;
        }
    }
    else
    {
        //
        // In AM/PM time hours have to be capped at 12.
        // If the hours are all 1s, it means the match for the hour is
        // always true.  We need to set 1F in the hw field.
        //
        if(psTime->tm_hour == 0xFF)
        {
            //
            // Match every hour.
            //
            ui32Time |= HIB_CALLD0_HR_M;
        }
        else if(psTime->tm_hour >= 12)
        {
            //
            // Need to set the PM bit if it is noon or later.
            //
            ui32Time |= (((psTime->tm_hour - 12) << HIB_CALLD0_HR_S) |
                         HIB_CAL0_AMPM);
        }
        else
        {
            //
            // All other times are normal and AM.
            //
            ui32Time |= (psTime->tm_hour << HIB_CALLD0_HR_S);
        }
    }

    //
    // Create the date in the correct register format.
    //
    if(ui32Reg == HIB_CAL0)
    {
        //
        // We must add 1 to the month, since the time structure lists
        // the month from 0 to 11 and the HIB lists it from 1 to 12.
        //
        ui32Date = ((psTime->tm_mday << HIB_CAL1_DOM_S) |
                    ((psTime->tm_mon + 1) << HIB_CAL1_MON_S) |
                    (psTime->tm_wday << HIB_CAL1_DOW_S) |
                    ((psTime->tm_year - 100) << HIB_CAL1_YEAR_S));
    }
    else
    {
        //
        // Wday, month and year are not included in the match
        // Functionality.
        //
        if(psTime->tm_mday == 0xFF)
        {
            //
            // program 0 to match every day
            //
            ui32Date = 0 << HIB_CAL1_DOM_M;
        }
        else
        {
            ui32Date = (psTime->tm_mday << HIB_CAL1_DOM_S);
        }
    }

    //
    // Load register requires unlock.
    //
    if(ui32Reg == HIB_CAL0)
    {
        //
        // Unlock the hibernate counter load registers.
        //
        HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
        _HibernateWriteComplete();
    }

    //
    // Set the requested time and date.
    //
    if(ui32Reg == HIB_CAL0)
    {
        HWREG(HIB_CALLD0) = ui32Time;
        _HibernateWriteComplete();
        HWREG(HIB_CALLD1) = ui32Date;
        _HibernateWriteComplete();
    }
    else
    {
        HWREG(HIB_CALM0) = ui32Time;
        _HibernateWriteComplete();
        HWREG(HIB_CALM1) = ui32Date;
        _HibernateWriteComplete();
    }

    //
    // Load register requires unlock.
    //
    if(ui32Reg == HIB_CAL0)
    {
        //
        // Lock the hibernate counter load registers.
        //
        HWREG(HIB_LOCK) = 0;
        _HibernateWriteComplete();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static uint32_t _HibernateIntNumberGet ( void  )

static

Returns the hibernate module interrupt number.

This function returns the interrupt number for the hibernate module.

Returns

Returns a hibernate interrupt number or 0 if the interrupt does not exist.

Definition at line 1103 of file hibernate.c.

References CLASS_IS_TM4C129, INT_HIBERNATE_TM4C123, and INT_HIBERNATE_TM4C129.

Referenced by HibernateIntRegister(), and HibernateIntUnregister().

{
    uint32_t ui32Int;

    //
    // Find the valid interrupt number for the hibernate module.
    //
    if(CLASS_IS_TM4C129)
    {
        ui32Int = INT_HIBERNATE_TM4C129;
    }
    else
    {
        ui32Int = INT_HIBERNATE_TM4C123;
    }

    return(ui32Int);
}

Here is the caller graph for this function:

static void _HibernateWriteComplete ( void  )

static

Definition at line 107 of file hibernate.c.

References HIB_CTL, HIB_CTL_WRC, and HWREG.

Referenced by _HibernateCalendarSet(), HibernateBatCheckStart(), HibernateClockConfig(), HibernateCounterMode(), HibernateDataSet(), HibernateDisable(), HibernateEnableExpClk(), HibernateGPIORetentionDisable(), HibernateGPIORetentionEnable(), HibernateIntClear(), HibernateIntDisable(), HibernateIntEnable(), HibernateLowBatSet(), HibernateRequest(), HibernateRTCDisable(), HibernateRTCEnable(), HibernateRTCMatchSet(), HibernateRTCSet(), HibernateRTCSSMatchSet(), HibernateRTCTrimSet(), HibernateTamperDisable(), HibernateTamperEnable(), HibernateTamperEventsClear(), HibernateTamperEventsClearNoLock(), HibernateTamperEventsConfig(), HibernateTamperExtOscRecover(), HibernateTamperIODisable(), HibernateTamperIOEnable(), HibernateTamperLock(), HibernateTamperUnLock(), and HibernateWakeSet().

{
    //
    // Spin until the write complete bit is set.
    //
    while(!(HWREG(HIB_CTL) & HIB_CTL_WRC))
    {
    }
}

Here is the caller graph for this function:

uint32_t HibernateBatCheckDone

(

void

)

Determines whether or not a forced battery check has completed.

This function determines whether the forced battery check initiated by a call to the HibernateBatCheckStart() function has completed. This function returns a non-zero value until the battery level check has completed. Once this function returns a value of zero, the Hibernation module has completed the battery check and the HibernateIntStatus() function can be used to check if the battery was low by checking if the value returned has the HIBERNATE_INT_LOW_BAT set.

Returns

The value is zero when the battery level check has completed or non-zero if the check is still in process.

Definition at line 379 of file hibernate.c.

References HIB_CTL, HIB_CTL_BATCHK, and HWREG.

{
    //
    // Read the current state of the battery check.
    //
    return(HWREG(HIB_CTL) & HIB_CTL_BATCHK);
}

void HibernateBatCheckStart

(

void

)

Forces the Hibernation module to initiate a check of the battery voltage.

This function forces the Hibernation module to initiate a check of the battery voltage immediately rather than waiting for the next check interval to pass. After calling this function, the application should call the HibernateBatCheckDone() function and wait for the function to return a zero value before calling the HibernateIntStatus() to check if the return code has the HIBERNATE_INT_LOW_BAT set. If HIBERNATE_INT_LOW_BAT is set, the battery level is low. The application can also enable the HIBERNATE_INT_LOW_BAT interrupt and wait for an interrupt to indicate that the battery level is low.

Note

A hibernation request is held off if a battery check is in progress.

Returns

None.

Definition at line 349 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_BATCHK, and HWREG.

{
    //
    // Initiated a forced battery check.
    //
    HWREG(HIB_CTL) |= HIB_CTL_BATCHK;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

int HibernateCalendarGet

(

struct tm *

psTime

)

Returns the Hibernation module's date and time in calendar mode.

Parameters

psTime

is the structure that is filled with the current date and time.

This function returns the current date and time in the structure provided by the psTime parameter. Regardless of the calendar mode, the psTime parameter uses a 24-hour representation of the time. This function can only be called when the Hibernation module is configured in calendar mode using the HibernateCounterMode() function with one of the calendar modes.

The only case where this function fails and returns a non-zero value is when the function detects that the counter is passing from the last second of the day to the first second of the next day. This exception must be handled in the application by waiting at least one second before calling again to get the updated calendar information.

Note

The hibernate calendar mode is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

Returns zero if the time and date were read successfully and returns a non-zero value if the psTime structure was not updated.

Definition at line 1661 of file hibernate.c.

References ASSERT, HIB_CAL0, HIB_CAL0_AMPM, HIB_CAL0_HR_M, HIB_CAL0_HR_S, HIB_CAL0_MIN_M, HIB_CAL0_MIN_S, HIB_CAL0_SEC_M, HIB_CAL0_SEC_S, HIB_CAL0_VALID, HIB_CAL1, HIB_CAL1_DOM_M, HIB_CAL1_DOM_S, HIB_CAL1_DOW_M, HIB_CAL1_DOW_S, HIB_CAL1_MON_M, HIB_CAL1_MON_S, HIB_CAL1_VALID, HIB_CAL1_YEAR_M, HIB_CAL1_YEAR_S, HIB_CALCTL, HIB_CALCTL_CAL24, HIB_CALCTL_CALEN, and HWREG.

{
    uint32_t ui32Date, ui32Time;

    ASSERT(HWREG(HIB_CALCTL) & HIB_CALCTL_CALEN);

    //
    // Wait for the value to be valid, this should never be more than a few
    // loops and should never hang.
    //
    do
    {
        ui32Date = HWREG(HIB_CAL1);
    }
    while((ui32Date & HIB_CAL1_VALID) == 0);

    //
    // Wait for the value to be valid, this should never be more than a few
    // loops and should never hang.
    //
    do
    {
        ui32Time = HWREG(HIB_CAL0);
    }
    while((ui32Time & HIB_CAL0_VALID) == 0);

    //
    // The date changed after reading the time so fail this call and let the
    // application call again since it knows how int32_t to wait until another
    // second passes.
    //
    if(ui32Date != HWREG(HIB_CAL1))
    {
        return(-1);
    }

    //
    // Populate the date and time fields in the psTime structure.
    // We must subtract 1 from the month, since the time structure lists
    // the month from 0 to 11 and the HIB lists it from 1 to 12.
    //
    psTime->tm_min = (ui32Time & HIB_CAL0_MIN_M) >> HIB_CAL0_MIN_S;
    psTime->tm_sec = (ui32Time & HIB_CAL0_SEC_M) >> HIB_CAL0_SEC_S;
    psTime->tm_mon = (((ui32Date & HIB_CAL1_MON_M) >> HIB_CAL1_MON_S) - 1);
    psTime->tm_mday = (ui32Date & HIB_CAL1_DOM_M) >> HIB_CAL1_DOM_S;
    psTime->tm_wday = (ui32Date & HIB_CAL1_DOW_M) >> HIB_CAL1_DOW_S;
    psTime->tm_year = ((ui32Date & HIB_CAL1_YEAR_M) >> HIB_CAL1_YEAR_S) + 100;
    psTime->tm_hour = (ui32Time & HIB_CAL0_HR_M) >> HIB_CAL0_HR_S;

    //
    // Fix up the hour in the non-24-hour mode and the time is in PM.
    //
    if(((HWREG(HIB_CALCTL) & HIB_CALCTL_CAL24) == 0) &&
       (ui32Time & HIB_CAL0_AMPM))
    {
        psTime->tm_hour += 12;
    }

    return(0);
}

void HibernateCalendarMatchGet	(	uint32_t	ui32Index,
		struct tm *	psTime
	)

Returns the Hibernation module's date and time match value in calendar mode.

Parameters

ui32Index	indicates which match register to access.
psTime	is the structure to fill with the current date and time match value.

This function returns the current date and time match value in the structure provided by the psTime parameter. Regardless of the mode, the psTime parameter uses a 24-hour clock representation of time. This function can only be called when the Hibernation module is configured in calendar mode using the HibernateCounterMode() function. The ui32Index value is reserved for future use and should always be zero.

Note

The hibernate calendar mode is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

Returns zero if the time and date match value were read successfully and returns a non-zero value if the psTime structure was not updated.

Definition at line 1785 of file hibernate.c.

References ASSERT, HIB_CAL0_AMPM, HIB_CAL0_HR_M, HIB_CAL0_HR_S, HIB_CAL0_MIN_M, HIB_CAL0_MIN_S, HIB_CAL0_SEC_M, HIB_CAL0_SEC_S, HIB_CAL1_DOM_M, HIB_CAL1_DOM_S, HIB_CALCTL, HIB_CALCTL_CAL24, HIB_CALCTL_CALEN, HIB_CALM0, HIB_CALM1, and HWREG.

{
    uint32_t ui32Date, ui32Time;

    ASSERT(HWREG(HIB_CALCTL) & HIB_CALCTL_CALEN);

    //
    // Get the date field.
    //
    ui32Date = HWREG(HIB_CALM1);

    //
    // Get the time field.
    //
    ui32Time = HWREG(HIB_CALM0);

    //
    // Populate the date and time fields in the psTime structure.
    //
    if((ui32Time & HIB_CAL0_MIN_M) == HIB_CAL0_MIN_M)
    {
        //
        // Match every minute
        //
        psTime->tm_min = 0xFF;
    }
    else
    {
        psTime->tm_min = (ui32Time & HIB_CAL0_MIN_M) >> HIB_CAL0_MIN_S;
    }

    if((ui32Time & HIB_CAL0_SEC_M) == HIB_CAL0_SEC_M)
    {
        //
        // Match every second
        //
        psTime->tm_sec = 0xFF;
    }
    else
    {
        psTime->tm_sec = (ui32Time & HIB_CAL0_SEC_M) >> HIB_CAL0_SEC_S;
    }

    if((ui32Time & HIB_CAL0_HR_M) == HIB_CAL0_HR_M)
    {
        //
        // Match every hour
        //
        psTime->tm_hour = 0xFF;
    }
    else
    {
        psTime->tm_hour = (ui32Time & HIB_CAL0_HR_M) >> HIB_CAL0_HR_S;
    }

    if((ui32Date & HIB_CAL1_DOM_M) == 0)
    {
        //
        // Match every day
        //
        psTime->tm_mday = 0xFF;
    }
    else
    {
        psTime->tm_mday = (ui32Date & HIB_CAL1_DOM_M) >> HIB_CAL1_DOM_S;
    }

    //
    // Fix up the hour in the non-24-hour mode and the time is in PM.
    //
    if(((HWREG(HIB_CALCTL) & HIB_CALCTL_CAL24) == 0) &&
       (ui32Time & HIB_CAL0_AMPM))
    {
        psTime->tm_hour += 12;
    }
}

void HibernateCalendarMatchSet	(	uint32_t	ui32Index,
		struct tm *	psTime
	)

Sets the Hibernation module's date and time match value in calendar mode.

Parameters

ui32Index	indicates which match register to access.
psTime	is the structure that holds all of the information to set the current date and time match values.

This function uses the psTime parameter to set the current date and time match value in the Hibernation module's calendar. Regardless of the mode, the psTime parameter uses a 24-hour clock representation of time. This function can only be called when the Hibernation module is configured in calendar mode using the HibernateCounterMode() function. The ui32Index value is reserved for future use and should always be zero. Calendar match can be enabled for every day, every hour, every minute or every second, setting any of these fields to 0xFF causes a match for that field. For example, setting the day of month field to 0xFF results in a calendar match daily at the same time.

Note

The hibernate calendar mode is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

None.

Definition at line 1750 of file hibernate.c.

References _HibernateCalendarSet(), and HIB_CALM0.

{
    //
    // Set the Match value.
    //
    _HibernateCalendarSet(HIB_CALM0, psTime);
}

Here is the call graph for this function:

void HibernateCalendarSet

(

struct tm *

psTime

)

Sets the Hibernation module's date and time in calendar mode.

Parameters

psTime

is the structure that holds the information for the current date and time.

This function uses the psTime parameter to set the current date and time when the Hibernation module is in calendar mode. Regardless of whether 24-hour or 12-hour mode is in use, the psTime structure uses a 24-hour representation of the time. This function can only be called when the hibernate counter is configured in calendar mode using the HibernateCounterMode() function with one of the calendar modes.

Note

The hibernate calendar mode is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

None.

Definition at line 1624 of file hibernate.c.

References _HibernateCalendarSet(), and HIB_CAL0.

{
    //
    // Load a new date/time.
    //
    _HibernateCalendarSet(HIB_CAL0, psTime);
}

Here is the call graph for this function:

void HibernateClockConfig

(

uint32_t

ui32Config

)

Configures the clock input for the Hibernation module.

Parameters

ui32Config

is one of the possible configuration options for the clock input listed below.

This function is used to configure the clock input for the Hibernation module. The ui32Config parameter can be one of the following values:

• HIBERNATE_OSC_DISABLE specifies that the internal oscillator is powered off. This option is used when an externally supplied oscillator is connected to the XOSC0 pin or to save power when the LFIOSC is used in devices that have an LFIOSC in the Hibernation module.
• HIBERNATE_OSC_HIGHDRIVE specifies a higher drive strength when a 24-pF filter capacitor is used with a crystal.
• HIBERNATE_OSC_LOWDRIVE specifies a lower drive strength when a 12-pF filter capacitor is used with a crystal.

On some devices, there is an option to use an internal low frequency oscillator (LFIOSC) as the clock source for the Hibernation module. Because of the low accuracy of this oscillator, this option should not be used when the system requires a real time counter. Adding the HIBERNATE_OSC_LFIOSC value enables the LFIOSC as the clock source to the Hibernation module.

• HIBERNATE_OSC_LFIOSC enables the Hibernation module's internal low frequency oscillator as the clock to the Hibernation module.

This ui32Config also configures how the clock output from the hibernation is used to clock other peripherals in the system. The ALT clock settings allow clocking a subset of the peripherals. See the hibernate section in the datasheet to determine which peripherals can be clocked by the ALT clock outputs from the Hibernation module. The ui32Config parameter can have any combination of the following values:

• HIBERNATE_OUT_SYSCLK enables the hibernate clock output to the system clock.

The HIBERNATE_OSC_DISABLE option is used to disable and power down the internal oscillator if an external clock source or no clock source is used instead of a 32.768-kHz crystal. In the case where an external crystal is used, either the HIBERNATE_OSC_HIGHDRIVE or HIBERNATE_OSC_LOWDRIVE is used. These settings optimizes the oscillator drive strength to match the size of the filter capacitor that is used with the external crystal circuit.

Returns

None.

Definition at line 225 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_CC, HIB_CTL, HIB_CTL_CLK32EN, HIBERNATE_CLOCK_OUTPUT, HIBERNATE_OSC_DISABLE, HIBERNATE_OSC_HIGHDRIVE, HIBERNATE_OSC_LFIOSC, HIBERNATE_OSC_LOWDRIVE, HIBERNATE_OUT_ALT1CLK, HIBERNATE_OUT_SYSCLK, and HWREG.

{
    uint32_t ui32HIBCtl;

    ASSERT((ui32Config & ~(HIBERNATE_OSC_HIGHDRIVE | HIBERNATE_OSC_LOWDRIVE |
                           HIBERNATE_OSC_DISABLE)) == 0);

    ui32HIBCtl = HWREG(HIB_CTL);

    //
    // Clear the current configuration bits.
    //
    ui32HIBCtl &= ~(HIBERNATE_OSC_HIGHDRIVE | HIBERNATE_OSC_LOWDRIVE |
                    HIBERNATE_OSC_LFIOSC | HIBERNATE_OSC_DISABLE);

    //
    // Set the new configuration bits.
    //
    ui32HIBCtl |= ui32Config & (HIBERNATE_OSC_HIGHDRIVE |
                                HIBERNATE_OSC_LOWDRIVE |
                                HIBERNATE_OSC_LFIOSC |
                                HIBERNATE_OSC_DISABLE);

    //
    // Must be sure that the 32KHz clock is enabled if the hibernate is about
    // to switch to it.
    //
    if(ui32Config & HIBERNATE_OSC_LFIOSC)
    {
        ui32HIBCtl |= HIB_CTL_CLK32EN;
    }

    //
    // Set the hibernation clocking configuration.
    //
    HWREG(HIB_CTL) = ui32HIBCtl;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();

    //
    // Write the output clock configuration for devices that support
    // controlling the output clocks from the hibernate module.
    //
    if(HIBERNATE_CLOCK_OUTPUT)
    {
        HWREG(HIB_CC) = ui32Config & (HIBERNATE_OUT_SYSCLK |
                                      HIBERNATE_OUT_ALT1CLK);
    }
}

Here is the call graph for this function:

void HibernateCounterMode

(

uint32_t

ui32Config

)

Configures the Hibernation module's internal counter mode.

Parameters

ui32Config

is the configuration to use for the Hibernation module's counter.

This function configures the Hibernate module's counter mode to operate as a standard RTC counter or to operate in a calendar mode. The ui32Config parameter is used to provide the configuration for the counter and must include only one of the following values:

• HIBERNATE_COUNTER_24HR specifies 24-hour calendar mode.
• HIBERNATE_COUNTER_12HR specifies 12-hour AM/PM calendar mode.
• HIBERNATE_COUNTER_RTC specifies RTC counter mode.

The HibernateCalendar functions can only be called when either HIBERNATE_COUNTER_24HR or HIBERNATE_COUNTER_12HR is specified.

Example: Configure hibernate counter to 24-hour calendar mode.

//!
//! //
//! // Configure the hibernate module counter to 24-hour calendar mode.
//! //
//! HibernateCounterMode(HIBERNATE_COUNTER_24HR);
//!
//! 

\note The hibernate calendar mode is not available on all Tiva
devices.  Please consult the data sheet to determine if the device you are
using supports this feature in the Hibernation module.

\return None.  

Definition at line 1446 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CALCTL, and HWREG.

{
    //
    // Set the requested configuration.
    //
    HWREG(HIB_CALCTL) = ui32Config;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateDataGet	(	uint32_t *	pui32Data,
		uint32_t	ui32Count
	)

Reads a set of data from the battery-backed memory of the Hibernation module.

Parameters

pui32Data	points to a location where the data that is read from the Hibernation module is stored.
ui32Count	is the count of 32-bit words to read.

This function retrieves a set of data from the Hibernation module battery-backed memory that was previously stored with the HibernateDataSet() function. The caller must ensure that pui32Data points to a large enough memory block to hold all the data that is read from the battery-backed memory.

Returns

None.

Definition at line 929 of file hibernate.c.

References ASSERT, HIB_DATA, and HWREG.

{
    uint32_t ui32Idx;

    //
    // Check the arguments.
    //
    ASSERT(ui32Count <= 64);
    ASSERT(pui32Data != 0);

    //
    // Loop through all the words to be restored, reading one at a time.
    //
    for(ui32Idx = 0; ui32Idx < ui32Count; ui32Idx++)
    {
        //
        // Read a word from the battery-backed storage area.  No delay is
        // required between reads.
        //
        pui32Data[ui32Idx] = HWREG(HIB_DATA + (ui32Idx * 4));
    }
}

void HibernateDataSet	(	uint32_t *	pui32Data,
		uint32_t	ui32Count
	)

Stores data in the battery-backed memory of the Hibernation module.

Parameters

pui32Data	points to the data that the caller wants to store in the memory of the Hibernation module.
ui32Count	is the count of 32-bit words to store.

Stores a set of data in the Hibernation module battery-backed memory. This memory is preserved when the power to the processor is turned off and can be used to store application state information that is needed when the processor wakes. Up to 16 32-bit words can be stored in the battery-backed memory. The data can be restored by calling the HibernateDataGet() function.

Returns

None.

Definition at line 883 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_DATA, and HWREG.

{
    uint32_t ui32Idx;

    //
    // Check the arguments.
    //
    ASSERT(ui32Count <= 64);
    ASSERT(pui32Data != 0);

    //
    // Loop through all the words to be stored, storing one at a time.
    //
    for(ui32Idx = 0; ui32Idx < ui32Count; ui32Idx++)
    {
        //
        // Write a word to the battery-backed storage area.
        //
        HWREG(HIB_DATA + (ui32Idx * 4)) = pui32Data[ui32Idx];

        //
        // Wait for write completion
        //
        _HibernateWriteComplete();
    }
}

Here is the call graph for this function:

void HibernateDisable

(

void

)

Disables the Hibernation module for operation.

This function disables the Hibernation module. After this function is called, none of the Hibernation module features are available.

Returns

None.

Definition at line 160 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_CLK32EN, and HWREG.

{
    //
    // Turn off the clock enable bit.
    //
    HWREG(HIB_CTL) &= ~HIB_CTL_CLK32EN;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateEnableExpClk

(

uint32_t

ui32HibClk

)

Enables the Hibernation module for operation.

Parameters

ui32HibClk

is the rate of the clock supplied to the Hibernation module.

This function enables the Hibernation module for operation. This function should be called before any of the Hibernation module features are used.

The peripheral clock is the same as the processor clock. This value is returned by SysCtlClockGet(), or it can be explicitly hard-coded if it is constant and known (to save the code/execution overhead of a call to SysCtlClockGet()).

Returns

None.

Definition at line 136 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_CLK32EN, and HWREG.

{
    //
    // Turn on the clock enable bit.
    //
    HWREG(HIB_CTL) |= HIB_CTL_CLK32EN;

    //
    // Wait for write complete following register load (above).
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateGPIORetentionDisable

(

void

)

Disables GPIO retention after wake from hibernation.

This function disables the retention of the GPIO pin state during hibernation and allows the GPIO pins to be controlled by the system. If the HibernateGPIORetentionEnable() function is called before entering hibernation, this function must be called after returning from hibernation to allow the GPIO pins to be controlled by GPIO module.

Note

The hibernate GPIO retention setting is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

None.

Definition at line 1365 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_RETCLR, HIB_CTL_VDD3ON, and HWREG.

{
    //
    // Reset the GPIO configuration after waking from hibernate and disable
    // the hibernate power to the pads.
    //
    HWREG(HIB_CTL) &= ~(HIB_CTL_RETCLR | HIB_CTL_VDD3ON);

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateGPIORetentionEnable

(

void

)

Enables GPIO retention after wake from hibernation.

This function enables the GPIO pin state to be maintained during hibernation and remain active even when waking from hibernation. The GPIO module itself is reset upon entering hibernation and no longer controls the output pins. To maintain the current output level after waking from hibernation, the GPIO module must be reconfigured and then the HibernateGPIORetentionDisable() function must be called to return control of the GPIO pin to the GPIO module.

Note

The hibernation GPIO retention setting is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

None.

Definition at line 1334 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_RETCLR, HIB_CTL_VDD3ON, and HWREG.

{
    //
    // Enable power to the pads and enable GPIO retention during hibernate.
    //
    HWREG(HIB_CTL) |= HIB_CTL_VDD3ON | HIB_CTL_RETCLR;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

bool HibernateGPIORetentionGet

(

void

)

Returns the current setting for GPIO retention.

This function returns the current setting for GPIO retention in the hibernate module.

Note

The hibernation GPIO retention setting is not available on all Tiva devices. Please consult the data sheet to determine if the device you are using supports this feature in the Hibernation module.

Returns

Returns true if GPIO retention is enabled and false if GPIO retention is disabled.

Definition at line 1395 of file hibernate.c.

References HIB_CTL, HIB_CTL_RETCLR, HIB_CTL_VDD3ON, and HWREG.

{
    //
    // Read the current GPIO retention configuration.
    //
    if((HWREG(HIB_CTL) & (HIB_CTL_RETCLR | HIB_CTL_VDD3ON)) ==
       (HIB_CTL_RETCLR | HIB_CTL_VDD3ON))
    {
        return(true);
    }
    return(false);
}

void HibernateIntClear

(

uint32_t

ui32IntFlags

)

Clears pending interrupts from the Hibernation module.

Parameters

ui32IntFlags

is the bit mask of the interrupts to be cleared.

This function clears the specified interrupt sources. This function must be called within the interrupt handler or else the handler is called again upon exit.

The ui32IntFlags parameter has the same definition as the ui32IntFlags parameter to the HibernateIntEnable() function.

Note

Because there is a write buffer in the Cortex-M processor, it may take several clock cycles before the interrupt source is actually cleared. Therefore, it is recommended that the interrupt source be cleared early in the interrupt handler (as opposed to the very last action) to avoid returning from the interrupt handler before the interrupt source is actually cleared. Failure to do so may result in the interrupt handler being immediately reentered (because the interrupt controller still sees the interrupt source asserted).

Returns

None.

Definition at line 1261 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_IC, HIBERNATE_INT_GPIO_WAKE, HIBERNATE_INT_LOW_BAT, HIBERNATE_INT_PIN_WAKE, HIBERNATE_INT_RESET_WAKE, HIBERNATE_INT_RTC_MATCH_0, HIBERNATE_INT_VDDFAIL, HIBERNATE_INT_WR_COMPLETE, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(!(ui32IntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT |
                              HIBERNATE_INT_VDDFAIL |
                              HIBERNATE_INT_RESET_WAKE |
                              HIBERNATE_INT_GPIO_WAKE |
                              HIBERNATE_INT_RTC_MATCH_0 |
                              HIBERNATE_INT_WR_COMPLETE)));

    //
    // Write the specified interrupt bits into the interrupt clear register.
    //
    HWREG(HIB_IC) |= ui32IntFlags;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateIntDisable

(

uint32_t

ui32IntFlags

)

Disables interrupts for the Hibernation module.

Parameters

ui32IntFlags

is the bit mask of the interrupts to be disabled.

This function disables the specified interrupt sources from the Hibernation module.

The ui32IntFlags parameter has the same definition as the ui32IntFlags parameter to the HibernateIntEnable() function.

Returns

None.

Definition at line 1069 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_IM, HIBERNATE_INT_GPIO_WAKE, HIBERNATE_INT_LOW_BAT, HIBERNATE_INT_PIN_WAKE, HIBERNATE_INT_RESET_WAKE, HIBERNATE_INT_RTC_MATCH_0, HIBERNATE_INT_VDDFAIL, HIBERNATE_INT_WR_COMPLETE, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(!(ui32IntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT |
                              HIBERNATE_INT_VDDFAIL |
                              HIBERNATE_INT_RESET_WAKE |
                              HIBERNATE_INT_GPIO_WAKE |
                              HIBERNATE_INT_RTC_MATCH_0 |
                              HIBERNATE_INT_WR_COMPLETE)));

    //
    // Clear the specified interrupt mask bits.
    //
    HWREG(HIB_IM) &= ~ui32IntFlags;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateIntEnable

(

uint32_t

ui32IntFlags

)

Enables interrupts for the Hibernation module.

Parameters

ui32IntFlags

is the bit mask of the interrupts to be enabled.

This function enables the specified interrupt sources from the Hibernation module.

The ui32IntFlags parameter must be the logical OR of any combination of the following:

• HIBERNATE_INT_WR_COMPLETE - write complete interrupt
• HIBERNATE_INT_PIN_WAKE - wake from pin interrupt
• HIBERNATE_INT_LOW_BAT - low-battery interrupt
• HIBERNATE_INT_RTC_MATCH_0 - RTC match 0 interrupt
• HIBERNATE_INT_VDDFAIL - supply failure interrupt.
• HIBERNATE_INT_RESET_WAKE - wake from reset pin interrupt
• HIBERNATE_INT_GPIO_WAKE - wake from GPIO pin or reset pin interrupt.

Note

The HIBERNATE_INT_RESET_WAKE, HIBERNATE_INT_GPIO_WAKE, and HIBERNATE_INT_VDDFAIL settings are not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if these interrupt sources are available.

Returns

None.

Definition at line 1030 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_IM, HIBERNATE_INT_GPIO_WAKE, HIBERNATE_INT_LOW_BAT, HIBERNATE_INT_PIN_WAKE, HIBERNATE_INT_RESET_WAKE, HIBERNATE_INT_RTC_MATCH_0, HIBERNATE_INT_VDDFAIL, HIBERNATE_INT_WR_COMPLETE, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(!(ui32IntFlags & ~(HIBERNATE_INT_PIN_WAKE | HIBERNATE_INT_LOW_BAT |
                              HIBERNATE_INT_VDDFAIL |
                              HIBERNATE_INT_RESET_WAKE |
                              HIBERNATE_INT_GPIO_WAKE |
                              HIBERNATE_INT_RTC_MATCH_0 |
                              HIBERNATE_INT_WR_COMPLETE)));

    //
    // Set the specified interrupt mask bits.
    //
    HWREG(HIB_IM) |= ui32IntFlags;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateIntRegister

(

void(*)(void)

pfnHandler

)

Registers an interrupt handler for the Hibernation module interrupt.

Parameters

pfnHandler

points to the function to be called when a hibernation interrupt occurs.

This function registers the interrupt handler in the system interrupt controller. The interrupt is enabled at the global level, but individual interrupt sources must still be enabled with a call to HibernateIntEnable().

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 1141 of file hibernate.c.

References _HibernateIntNumberGet(), ASSERT, IntEnable(), and IntRegister().

{
    uint32_t ui32Int;

    //
    // Get the interrupt number for the Hibernate module.
    //
    ui32Int = _HibernateIntNumberGet();

    ASSERT(ui32Int != 0);

    //
    // Register the interrupt handler.
    //
    IntRegister(ui32Int, pfnHandler);

    //
    // Enable the hibernate module interrupt.
    //
    IntEnable(ui32Int);
}

Here is the call graph for this function:

uint32_t HibernateIntStatus

(

bool

bMasked

)

Gets the current interrupt status of the Hibernation module.

Parameters

bMasked

is false to retrieve the raw interrupt status, and true to retrieve the masked interrupt status.

This function returns the interrupt status of the Hibernation module. The caller can use this function to determine the cause of a hibernation interrupt. Either the masked or raw interrupt status can be returned.

Note

A wake from reset pin also signals a wake from GPIO pin with the value returned being HIBERNATE_INT_GPIO_WAKE | HIBERNATE_INT_RESET_WAKE. Hence a wake from reset pin should take priority over wake from GPIO pin.

Returns

Returns the interrupt status as a bit field with the values as described in the HibernateIntEnable() function.

Definition at line 1220 of file hibernate.c.

References HIB_MIS, HIB_RIS, and HWREG.

{
    //
    // Read and return the Hibernation module raw or masked interrupt status.
    //
    if(bMasked == true)
    {
        return(HWREG(HIB_MIS));
    }
    else
    {
        return(HWREG(HIB_RIS));
    }
}

void HibernateIntUnregister

(

void

)

Unregisters an interrupt handler for the Hibernation module interrupt.

This function unregisters the interrupt handler in the system interrupt controller. The interrupt is disabled at the global level, and the interrupt handler is no longer called.

See also

IntRegister() for important information about registering interrupt handlers.

Returns

None.

Definition at line 1178 of file hibernate.c.

References _HibernateIntNumberGet(), ASSERT, IntDisable(), and IntUnregister().

{
    uint32_t ui32Int;

    //
    // Get the interrupt number for the Hibernate module.
    //
    ui32Int = _HibernateIntNumberGet();

    ASSERT(ui32Int != 0);

    //
    // Disable the hibernate interrupt.
    //
    IntDisable(ui32Int);

    //
    // Unregister the interrupt handler.
    //
    IntUnregister(ui32Int);
}

Here is the call graph for this function:

uint32_t HibernateIsActive

(

void

)

Checks to see if the Hibernation module is already powered up.

This function queries the control register to determine if the module is already active. This function can be called at a power-on reset to help determine if the reset is due to a wake from hibernation or a cold start. If the Hibernation module is already active, then it does not need to be re-enabled, and its status can be queried immediately.

The software application should also use the HibernateIntStatus() function to read the raw interrupt status to determine the cause of the wake. The HibernateDataGet() function can be used to restore state. These combinations of functions can be used by the software to determine if the processor is waking from hibernation and the appropriate action to take as a result.

Returns

Returns true if the module is already active, and false if not.

Definition at line 1306 of file hibernate.c.

References HIB_CTL, HIB_CTL_CLK32EN, and HWREG.

{
    //
    // Read the control register, and return true if the module is enabled.
    //
    return(HWREG(HIB_CTL) & HIB_CTL_CLK32EN ? 1 : 0);
}

uint32_t HibernateLowBatGet

(

void

)

Gets the currently configured low-battery detection behavior.

This function returns a value representing the currently configured low battery detection behavior.

The return value is a combination of the values described in the HibernateLowBatSet() function.

Returns

Returns a value indicating the configured low-battery detection.

Definition at line 607 of file hibernate.c.

References HIB_CTL, HIB_CTL_VBATSEL_M, HIBERNATE_LOW_BAT_ABORT, and HWREG.

{
    //
    // Read the supported low bat bits from the control register and return
    // those bits to the caller.
    //
    return(HWREG(HIB_CTL) & (HIB_CTL_VBATSEL_M | HIBERNATE_LOW_BAT_ABORT));
}

void HibernateLowBatSet

(

uint32_t

ui32LowBatFlags

)

Configures the low-battery detection.

Parameters

ui32LowBatFlags

specifies behavior of low-battery detection.

This function enables the low-battery detection and whether hibernation is allowed if a low battery is detected. If low-battery detection is enabled, then a low-battery condition is indicated in the raw interrupt status register, which can be enabled to trigger an interrupt. Optionally, hibernation can be aborted if a low battery condition is detected.

The ui32LowBatFlags parameter is one of the following values:

• HIBERNATE_LOW_BAT_DETECT - detect a low-battery condition
• HIBERNATE_LOW_BAT_ABORT - detect a low-battery condition and abort hibernation if low-battery is detected

The other setting in the ui32LowBatFlags allows the caller to set one of the following voltage level trigger values :

• HIBERNATE_LOW_BAT_1_9V - voltage low level is 1.9 V
• HIBERNATE_LOW_BAT_2_1V - voltage low level is 2.1 V
• HIBERNATE_LOW_BAT_2_3V - voltage low level is 2.3 V
• HIBERNATE_LOW_BAT_2_5V - voltage low level is 2.5 V

Example: Abort hibernate if the voltage level is below 2.1 V.

//! HibernateLowBatSet(HIBERNATE_LOW_BAT_ABORT | HIBERNATE_LOW_BAT_2_1V);
//! 

\return None.  

Definition at line 571 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_CTL, HIB_CTL_VBATSEL_M, HIBERNATE_LOW_BAT_ABORT, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(!(ui32LowBatFlags &
             ~(HIB_CTL_VBATSEL_M | HIBERNATE_LOW_BAT_ABORT)));

    //
    // Set the low-battery detect and abort bits in the control register,
    // according to the parameter.
    //
    HWREG(HIB_CTL) = (ui32LowBatFlags |
                      (HWREG(HIB_CTL) & ~(HIB_CTL_VBATSEL_M |
                                          HIBERNATE_LOW_BAT_ABORT)));

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateRequest

(

void

)

Requests hibernation mode.

This function requests the Hibernation module to disable the external regulator, thus removing power from the processor and all peripherals. The Hibernation module remains powered from the battery or auxiliary power supply.

The Hibernation module re-enables the external regulator when one of the configured wake conditions occurs (such as RTC match or external WAKE pin). When the power is restored, the processor goes through a power-on reset although the Hibernation module is not reset. The processor can retrieve saved state information with the HibernateDataGet() function. Prior to calling the function to request hibernation mode, the conditions for waking must have already been set by using the HibernateWakeSet() function.

Note that this function may return because some time may elapse before the power is actually removed, or it may not be removed at all. For this reason, the processor continues to execute instructions for some time, and the caller should be prepared for this function to return. There are various reasons why the power may not be removed. For example, if the HibernateLowBatSet() function was used to configure an abort if low battery is detected, then the power is not removed if the battery voltage is too low. There may be other reasons related to the external circuit design, that a request for hibernation may not actually occur.

For all these reasons, the caller must be prepared for this function to return. The simplest way to handle it is to just enter an infinite loop and wait for the power to be removed.

Returns

None.

Definition at line 988 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_HIBREQ, and HWREG.

{
    //
    // Set the bit in the control register to cut main power to the processor.
    //
    HWREG(HIB_CTL) |= HIB_CTL_HIBREQ;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateRTCDisable

(

void

)

Disables the RTC feature of the Hibernation module.

This function disables the RTC in the Hibernation module. After calling this function, the RTC features of the Hibernation module are not available.

Returns

None.

Definition at line 316 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_RTCEN, and HWREG.

{
    //
    // Turn off the RTC enable bit.
    //
    HWREG(HIB_CTL) &= ~HIB_CTL_RTCEN;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateRTCEnable

(

void

)

Enables the RTC feature of the Hibernation module.

This function enables the RTC in the Hibernation module. The RTC can be used to wake the processor from hibernation at a certain time, or to generate interrupts at certain times. This function must be called before using any of the RTC features of the Hibernation module.

Returns

None.

Definition at line 291 of file hibernate.c.

References _HibernateWriteComplete(), HIB_CTL, HIB_CTL_RTCEN, and HWREG.

{
    //
    // Turn on the RTC enable bit.
    //
    HWREG(HIB_CTL) |= HIB_CTL_RTCEN;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

uint32_t HibernateRTCGet

(

void

)

Gets the value of the real time clock (RTC) counter.

This function gets the value of the RTC and returns it to the caller.

Returns

Returns the value of the RTC counter in seconds.

Definition at line 665 of file hibernate.c.

References HIB_RTCC, and HWREG.

{
    //
    // Return the value of the RTC counter register to the caller.
    //
    return(HWREG(HIB_RTCC));
}

uint32_t HibernateRTCMatchGet

(

uint32_t

ui32Match

)

Gets the value of the requested RTC match register.

Parameters

ui32Match

is the index of the match register.

This function gets the value of the match register for the RTC. The only value that can be used with the ui32Match parameter is zero, other values are reserved for future use.

Returns

Returns the value of the requested match register.

Definition at line 718 of file hibernate.c.

References ASSERT, HIB_RTCM0, and HWREG.

{
    ASSERT(ui32Match == 0);

    //
    // Return the value of the match register to the caller.
    //
    return(HWREG(HIB_RTCM0));
}

void HibernateRTCMatchSet	(	uint32_t	ui32Match,
		uint32_t	ui32Value
	)

Sets the value of the RTC match register.

Parameters

ui32Match	is the index of the match register.
ui32Value	is the value for the match register.

This function sets a match register for the RTC. The Hibernation module can be configured to wake from hibernation, and/or generate an interrupt when the value of the RTC counter is the same as the match register.

Returns

None.

Definition at line 689 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_RTCM0, and HWREG.

{
    ASSERT(ui32Match == 0);

    //
    // Write the new match value to the match register.
    //
    HWREG(HIB_RTCM0) = ui32Value;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateRTCSet

(

uint32_t

ui32RTCValue

)

Sets the value of the real time clock (RTC) counter.

Parameters

ui32RTCValue

is the new value for the RTC.

This function sets the value of the RTC. The RTC counter contains the count in seconds when a 32.768kHz clock source is in use. The RTC must be enabled by calling HibernateRTCEnable() before calling this function.

Returns

None.

Definition at line 630 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_RTCLD, and HWREG.

{
    //
    // Load register requires unlock.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Write the new RTC value to the RTC load register.
    //
    HWREG(HIB_RTCLD) = ui32RTCValue;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();

    //
    // Unlock.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

uint32_t HibernateRTCSSGet

(

void

)

Returns the current value of the RTC sub second count.

This function returns the current value of the sub second count for the RTC in 1/32768 of a second increments. The only value that can be used with the ui32Match parameter is zero, other values are reserved for future use.

Returns

The current RTC sub second count in 1/32768 seconds.

Definition at line 799 of file hibernate.c.

References HIB_RTCSS, HIB_RTCSS_RTCSSC_M, and HWREG.

{
    //
    // Read the current second RTC count.
    //
    return(HWREG(HIB_RTCSS) & HIB_RTCSS_RTCSSC_M);
}

uint32_t HibernateRTCSSMatchGet

(

uint32_t

ui32Match

)

Returns the value of the requested RTC sub second match register.

Parameters

ui32Match

is the index of the match register.

This function returns the current value of the sub second match register for the RTC. The value returned is in 1/32768 second increments. The only value that can be used with the ui32Match parameter is zero, other values are reserved for future use.

Returns

Returns the value of the requested sub section match register.

Definition at line 776 of file hibernate.c.

References ASSERT, HIB_RTCSS, HIB_RTCSS_RTCSSM_S, and HWREG.

{
    ASSERT(ui32Match == 0);

    //
    // Read the current second RTC count.
    //
    return(HWREG(HIB_RTCSS) >> HIB_RTCSS_RTCSSM_S);
}

void HibernateRTCSSMatchSet	(	uint32_t	ui32Match,
		uint32_t	ui32Value
	)

Sets the value of the RTC sub second match register.

Parameters

ui32Match	is the index of the match register.
ui32Value	is the value for the sub second match register.

This function sets the sub second match register for the RTC in 1/32768 of a second increments. The Hibernation module can be configured to wake from hibernation, and/or generate an interrupt when the value of the RTC counter is the same as the match combined with the sub second match register. The only value that can be used with the ui32Match parameter is zero, other values are reserved for future use.

Returns

None.

Definition at line 746 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_RTCSS, HIB_RTCSS_RTCSSM_S, and HWREG.

{
    ASSERT(ui32Match == 0);

    //
    // Write the new sub second match value to the sub second match register.
    //
    HWREG(HIB_RTCSS) = ui32Value << HIB_RTCSS_RTCSSM_S;

    //
    // Wait for write complete to be signaled on later devices.
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

uint32_t HibernateRTCTrimGet

(

void

)

Gets the value of the RTC pre-divider trim register.

This function gets the value of the pre-divider trim register. This function can be used to get the current value of the trim register prior to making an adjustment by using the HibernateRTCTrimSet() function.

Returns

None.

Definition at line 856 of file hibernate.c.

References HIB_RTCT, and HWREG.

{
    //
    // Return the value of the trim register to the caller.
    //
    return(HWREG(HIB_RTCT));
}

void HibernateRTCTrimSet

(

uint32_t

ui32Trim

)

Sets the value of the RTC pre-divider trim register.

Parameters

ui32Trim

is the new value for the pre-divider trim register.

This function sets the value of the pre-divider trim register. The input time source is divided by the pre-divider to achieve a one-second clock rate. Once every 64 seconds, the value of the pre-divider trim register is applied to the pre-divider to allow fine-tuning of the RTC rate, in order to make corrections to the rate. The software application can make adjustments to the pre-divider trim register to account for variations in the accuracy of the input time source. The nominal value is 0x7FFF, and it can be adjusted up or down in order to fine-tune the RTC rate.

Returns

None.

Definition at line 826 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_RTCT, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(ui32Trim < 0x10000);

    //
    // Write the new trim value to the trim register.
    //
    HWREG(HIB_RTCT) = ui32Trim;

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperDisable

(

void

)

Disables the tamper feature.

This function is used to disable the tamper feature functionality. All other configuration settings are left unmodified, allowing a call to HibernateTamperEnable() to quickly enable the tamper feature with its previous configuration.

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 1986 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPCTL, HIB_TPCTL_TPEN, and HWREG.

{
    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Clear the tamper enable bit.
    //
    HWREG(HIB_TPCTL) &= ~HIB_TPCTL_TPEN;

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperEnable

(

void

)

Enables the tamper feature.

This function is used to enable the tamper feature functionality. This function should only be called after the global configuration is set with a call to HibernateTamperEventsConfig() and the tamper inputs have been configured with a call to HibernateTamperIOEnable().

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 1944 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPCTL, HIB_TPCTL_TPEN, and HWREG.

{
    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Set the tamper enable bit.
    //
    HWREG(HIB_TPCTL) |= HIB_TPCTL_TPEN;

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperEventsClear

(

void

)

Clears the tamper feature events.

This function is used to clear all tamper events. This function always clears the tamper feature event state indicator along with all tamper log entries. Logged event data should be retrieved with HibernateTamperEventsGet() prior to requesting a event clear.

HibernateTamperEventsClear() should be called prior to clearing the system control NMI that resulted from the tamper event.

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2167 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPCTL, HIB_TPCTL_TPCLR, and HWREG.

{
    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Set the tamper event clear bit.
    //
    HWREG(HIB_TPCTL) |= HIB_TPCTL_TPCLR;

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperEventsClearNoLock

(

void

)

Clears the tamper feature events without Unlock and Lock.

This function is used to clear all tamper events without unlock/locking the tamper control registers, so API HibernateTamperUnLock() should be called before this function, and API HibernateTamperLock() should be called after to ensure that tamper control registers are locked.

This function doesn't block until the write is complete. Therefore, care must be taken to ensure the next immediate write will occure only after the write complete bit is set.

This function is used to implement a software workaround in NMI interrupt handler to fix an issue when a new tamper event could be missed during the clear of current tamper event.

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2217 of file hibernate.c.

References _HibernateWriteComplete(), HIB_TPCTL, HIB_TPCTL_TPCLR, and HWREG.

{
    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Set the tamper event clear bit.
    //
    HWREG(HIB_TPCTL) |= HIB_TPCTL_TPCLR;

}

Here is the call graph for this function:

void HibernateTamperEventsConfig

(

uint32_t

ui32Config

)

Configures the tamper feature event response.

Parameters

ui32Config

specifies the configuration options for tamper events.

This function is used to configure the event response options for the tamper feature. The ui32Config parameter provides a combination of the HIBERNATE_TAMPER_EVENTS_* features to set these options. The application should choose from the following set of defines to determine what happens to the system when a tamper event occurs:

• HIBERNATE_TAMPER_EVENTS_ERASE_ALL_HIB_MEM all of the Hibernation module's battery-backed RAM is cleared due to a tamper event
• HIBERNATE_TAMPER_EVENTS_ERASE_HIGH_HIB_MEM the upper half of the Hibernation module's battery-backed RAM is cleared due to a tamper event
• HIBERNATE_TAMPER_EVENTS_ERASE_LOW_HIB_MEM the lower half of the Hibernation module's battery-backed RAM is cleared due to a tamper event
• HIBERNATE_TAMPER_EVENTS_ERASE_NO_HIB_MEM the Hibernation module's battery-backed RAM is not changed due to a tamper event
• HIBERNATE_TAMPER_EVENTS_HIB_WAKE a tamper event wakes the MCU from hibernation
• HIBERNATE_TAMPER_EVENTS_NO_HIB_WAKE a tamper event does not wake the MCU from hibernation

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 1895 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPCTL, HIB_TPCTL_MEMCLR_M, and HWREG.

{
    uint32_t ui32Temp;

    //
    // Mask out the on-event configuration options.
    //
    ui32Temp = (HWREG(HIB_TPCTL) & ~HIB_TPCTL_MEMCLR_M);

    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Set the on-event configuration.
    //
    HWREG(HIB_TPCTL) = (ui32Temp | ui32Config);

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

bool HibernateTamperEventsGet	(	uint32_t	ui32Index,
		uint32_t *	pui32RTC,
		uint32_t *	pui32Event
	)

Returns a tamper log entry.

Parameters

ui32Index	is the index of the log entry to return.
pui32RTC	is a pointer to the memory to store the logged RTC data.
pui32Event	is a pointer to the memory to store the logged tamper event.

This function is used to return a tamper log entry from the hibernate feature. The ui32Index specifies the zero-based index of the log entry to query and has a valid range of 0-3.

When this function returns, the pui32RTC value contains the time value and pui32Event parameter contains the tamper I/O event that triggered this log.

The format of the returned pui32RTC data is dependent on the configuration of the RTC within the Hibernation module. If the RTC is configured for counter mode, the returned data contains counted seconds from the RTC enable. If the RTC is configured for calendar mode, the data returned is formatted as follows:

//! +----------------------------------------------------------------------+
//! |  31:26  |  25:22  |     21:17      |  16:12  |   11:6    |    5:0    |
//! +----------------------------------------------------------------------+
//! |  year   |  month  |  day of month  |  hours  |  minutes  |  seconds  |
//! +----------------------------------------------------------------------+
//! 

The data returned in the \e pui32Events parameter could include any of the
following flags:

- \b HIBERNATE_TAMPER_EVENT_0 indicates a tamper event was triggered on I/O
signal 0
- \b HIBERNATE_TAMPER_EVENT_1 indicates a tamper event was triggered on I/O
signal 1
- \b HIBERNATE_TAMPER_EVENT_2 indicates a tamper event was triggered on I/O
signal 2
- \b HIBERNATE_TAMPER_EVENT_3 indicates a tamper event was triggered on I/O
signal 3
- \b HIBERNATE_TAMPER_EVENT_XOSC indicates an external oscillator failure
triggered the tamper event

\note Tamper event logs are not consumed when read and remain available
until cleared.  Events are only logged if unused log space is available.

\note The hibernate tamper feature is not available on all Tiva
devices.  Please consult the data sheet for the Tiva device that you
are using to determine if this feature is available.

\return Returns \b true if the \e pui32RTC and \e pui32Events were updated
successfully and returns \b false if the values were not updated.  

Definition at line 2416 of file hibernate.c.

References ASSERT, HIB_CAL0, HIB_CAL0_AMPM, HIB_CALCTL, HIB_CALCTL_CAL24, HIB_CALCTL_CALEN, HIB_TPLOG0, and HWREG.

{
    uint32_t ui32Reg;

    //
    // Verify parameters.
    //
    ASSERT(pui32RTC);
    ASSERT(pui32Event);
    ASSERT(ui32Index < 4);

    //
    // Retrieve the event log data for the requested index if available.
    //
    ui32Reg = HWREG(HIB_TPLOG0 + ((ui32Index << 3) + 4));
    if(ui32Reg == 0)
    {
        //
        // No event data is available for this index.
        //
        return(false);
    }

    //
    // Store the event data in the provided location.
    //
    *pui32Event = ui32Reg;

    //
    // Retrieve the calendar information.
    //
    *pui32RTC = HWREG(HIB_TPLOG0 + (ui32Index << 3));

    //
    // Convert the hour to 24hr mode if the Calendar is enabled
    // and in 24hr mode.
    //
    if((HWREG(HIB_CALCTL) & (HIB_CALCTL_CALEN | HIB_CALCTL_CAL24)) ==
       (HIB_CALCTL_CALEN | HIB_CALCTL_CAL24))
    {
        if(HWREG(HIB_CAL0) & HIB_CAL0_AMPM)
        {
            //
            // Add 12 hour since it is PM
            //
            ui32Reg = ((*pui32RTC & 0X0001f000) + (12<<12)) & 0X0001f000;
            *pui32RTC &= ~0X0001f000;
            *pui32RTC |= ui32Reg;
        }
    }

    //
    // Return success.
    //
    return(true);
}

void HibernateTamperExtOscRecover

(

void

)

Attempts to recover the external oscillator.

This function is used to attempt to recover the external oscillator after a HIBERNATE_TAMPER_STATUS_EXT_OSC_FAILED status is reported. This function must not be called if the external oscillator is not used as the hibernation clock input. HibernateTamperExtOscValid() should be called before calling this function.

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2492 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPSTAT, HIB_TPSTAT_XOSCFAIL, and HWREG.

{
    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Set the XOSCFAIL clear bit.
    //
    HWREG(HIB_TPSTAT) |= HIB_TPSTAT_XOSCFAIL;

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

bool HibernateTamperExtOscValid

(

void

)

Reports if the external oscillator signal is active and stable.

This function should be used to verify the external oscillator is active and valid before attempting to recover from a HIBERNATE_TAMPER_STATUS_EXT_OSC_FAILED status by calling HibernateTamperExtOscRecover().

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

Returns true if the external oscillator is both active and stable, otherwise a false indicator is returned.

Definition at line 2535 of file hibernate.c.

References HIBERNATE_TAMPER_STATUS_EXT_OSC_ACTIVE, HIBERNATE_TAMPER_STATUS_EXT_OSC_VALID, and HibernateTamperStatusGet().

{
    if(HibernateTamperStatusGet() & (HIBERNATE_TAMPER_STATUS_EXT_OSC_ACTIVE |
                                     HIBERNATE_TAMPER_STATUS_EXT_OSC_VALID))
    {
        return(true);
    }

    return(false);
}

Here is the call graph for this function:

void HibernateTamperIODisable

(

uint32_t

ui32Input

)

Disables an input to the tamper feature.

Parameters

ui32Input

is the tamper input to disable.

This function is used to disable an input to the tamper feature. The ui32Input parameter specifies the tamper signal to disable and has a valid range of 0-3.

Note

None of the GPIO API functions are needed to configure the tamper pins. The tamper pins configured by using this function overrides any configuration by GPIO APIs.

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2117 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPIO, HIB_TPIO_EN0, and HWREG.

{
    //
    // Verify parameters.
    //
    ASSERT(ui32Input < 4);

    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Clear the I/O enable bit.
    //
    HWREG(HIB_TPIO) &= ((~HIB_TPIO_EN0) << (ui32Input << 3));

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperIOEnable	(	uint32_t	ui32Input,
		uint32_t	ui32Config
	)

Configures an input to the tamper feature.

Parameters

ui32Input	is the tamper input to configure.
ui32Config	holds the configuration options for a given input to the tamper feature.

This function is used to configure an input to the tamper feature. The ui32Input parameter specifies the tamper signal to configure and has a valid range of 0-3. The ui32Config parameter provides the set of tamper features in the HIBERNATE_TAMPER_IO_* values. The values that are valid in the ui32Config parameter are:

• HIBERNATE_TAMPER_IO_MATCH_SHORT configures the trigger to match after 2 hibernation clocks
• HIBERNATE_TAMPER_IO_MATCH_LONG configures the trigger to match after 3071 hibernation clocks
• HIBERNATE_TAMPER_IO_WPU_ENABLED turns on an internal weak pull up
• HIBERNATE_TAMPER_IO_WPU_DISABLED turns off an internal weak pull up
• HIBERNATE_TAMPER_IO_TRIGGER_HIGH sets the tamper event to active high
• HIBERNATE_TAMPER_IO_TRIGGER_LOW sets the tamper event to active low

Note

None of the GPIO API functions are needed to configure the tamper pins. The tamper pins configured by using this function overrides any configuration by GPIO APIs.

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2046 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, HIB_TPIO, HIB_TPIO_EN0, HIB_TPIO_GFLTR0, HIB_TPIO_LEV0, HIB_TPIO_PUEN0, and HWREG.

{
    uint32_t ui32Temp, ui32Mask;

    //
    // Verify parameters.
    //
    ASSERT(ui32Input < 4);

    //
    // Read the current tamper I/O configuration.
    //
    ui32Temp = HWREG(HIB_TPIO);

    //
    // Mask out configuration options for the requested input.
    //
    ui32Mask = (ui32Temp & (~((HIB_TPIO_GFLTR0 | HIB_TPIO_PUEN0 |
                               HIB_TPIO_LEV0 | HIB_TPIO_EN0) <<
                              (ui32Input << 3))));

    //
    // Set tamper I/O configuration for the requested input.
    //
    ui32Temp |= (ui32Mask | ((ui32Config | HIB_TPIO_EN0) << (ui32Input << 3)));

    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();

    //
    // Write to the register.
    //
    HWREG(HIB_TPIO) = ui32Temp;

    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

void HibernateTamperLock

(

void

)

Lock temper registers.

This function is used to lock the temper control registers. This function should be used after calling API HibernateTamperEventsClearNoLock().

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2272 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, and HWREG.

{
    //
    // Wait for write completion.
    //
    _HibernateWriteComplete();

    //
    // Lock the tamper registers.
    //
    HWREG(HIB_LOCK) = 0;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

uint32_t HibernateTamperStatusGet

(

void

)

Returns the current tamper feature status.

This function is used to return the tamper feature status. This function returns one of the values from this group of options:

• HIBERNATE_TAMPER_STATUS_INACTIVE indicates tamper detection is disabled
• HIBERNATE_TAMPER_STATUS_ACTIVE indicates tamper detection is enabled and ready
• HIBERNATE_TAMPER_STATUS_EVENT indicates tamper event was detected

In addition, one of the values is included from this group:

• HIBERNATE_TAMPER_STATUS_EXT_OSC_INACTIVE indicates the external oscillator is not active
• HIBERNATE_TAMPER_STATUS_EXT_OSC_ACTIVE indicates the external oscillator is active

And one of the values is included from this group:

• HIBERNATE_TAMPER_STATUS_EXT_OSC_FAILED indicates the external oscillator signal has transitioned from valid to invalid
• HIBERNATE_TAMPER_STATUS_EXT_OSC_VALID indicates the external oscillator is providing a valid signal

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

Returns a combination of the HIBERNATE_TAMPER_STATUS_* values.

Definition at line 2321 of file hibernate.c.

References HIB_TPSTAT, HIB_TPSTAT_STATE_M, HIB_TPSTAT_XOSCFAIL, HIB_TPSTAT_XOSCST, HIBERNATE_TAMPER_STATUS_EXT_OSC_ACTIVE, HIBERNATE_TAMPER_STATUS_EXT_OSC_VALID, HIBERNATE_TAMPER_STATUS_INACTIVE, and HWREG.

Referenced by HibernateTamperExtOscValid().

{
    uint32_t ui32Status, ui32Reg;

    //
    // Retrieve the raw register value.
    //
    ui32Reg = HWREG(HIB_TPSTAT);

    //
    // Setup the oscillator status indicators.
    //
    ui32Status = (ui32Reg & (HIB_TPSTAT_XOSCST | HIB_TPSTAT_XOSCFAIL));
    ui32Status |= ((ui32Reg & HIB_TPSTAT_XOSCST) ? 0 :
                   HIBERNATE_TAMPER_STATUS_EXT_OSC_ACTIVE);
    ui32Status |= ((ui32Reg & HIB_TPSTAT_XOSCFAIL) ? 0 :
                   HIBERNATE_TAMPER_STATUS_EXT_OSC_VALID);

    //
    // Retrieve the tamper status indicators.
    //
    ui32Status |= ((ui32Reg & HIB_TPSTAT_STATE_M) << 3);

    //
    // The HW shows "disabled" with a zero value, use bit[0] as a flag
    // for this purpose.
    //
    if((ui32Reg & HIB_TPSTAT_STATE_M) == 0)
    {
        ui32Status |= HIBERNATE_TAMPER_STATUS_INACTIVE;
    }

    //
    // Return the API status flags.
    //
    return(ui32Status);
}

Here is the caller graph for this function:

void HibernateTamperUnLock

(

void

)

Unlock temper registers.

This function is used to unlock the temper control registers. This function should be only used before calling API HibernateTamperEventsClearNoLock().

Note

The hibernate tamper feature is not available on all Tiva devices. Please consult the data sheet for the Tiva device that you are using to determine if this feature is available.

Returns

None.

Definition at line 2247 of file hibernate.c.

References _HibernateWriteComplete(), HIB_LOCK, HIB_LOCK_HIBLOCK_KEY, and HWREG.

{
    //
    // Unlock the tamper registers.
    //
    HWREG(HIB_LOCK) = HIB_LOCK_HIBLOCK_KEY;
    _HibernateWriteComplete();
}

Here is the call graph for this function:

uint32_t HibernateWakeGet

(

void

)

Gets the currently configured wake conditions for the Hibernation module.

This function returns the flags representing the wake configuration for the Hibernation module. The return value is a combination of the following flags:

• HIBERNATE_WAKE_PIN - wake when the external wake pin is asserted
• HIBERNATE_WAKE_RTC - wake when the RTC matches occurs
• HIBERNATE_WAKE_LOW_BAT - wake from hibernation due to a low-battery level being detected
• HIBERNATE_WAKE_GPIO - wake when a GPIO pin is asserted
• HIBERNATE_WAKE_RESET - wake when a reset pin is asserted

Note

The HIBERNATE_WAKE_LOW_BAT, HIBERNATE_WAKE_GPIO, and HIBERNATE_WAKE_RESET parameters are only available on some Tiva devices.

On some Tiva devices a tamper event acts as a wake source for the Hibernation module. Refer the function HibernateTamperEventsConfig() to wake from hibernation on a tamper event.

Returns

Returns flags indicating the configured wake conditions.

Definition at line 512 of file hibernate.c.

References HIB_CTL, HIB_IO, HIBERNATE_WAKE_GPIO, HIBERNATE_WAKE_IO, HIBERNATE_WAKE_LOW_BAT, HIBERNATE_WAKE_PIN, HIBERNATE_WAKE_RESET, HIBERNATE_WAKE_RTC, and HWREG.

{
    uint32_t ui32Ctrl;

    //
    // Read the wake bits from the control register and return those bits to
    // the caller.
    //
    if(HIBERNATE_WAKE_IO)
    {
        ui32Ctrl = HWREG(HIB_CTL);
        return((ui32Ctrl & (HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC |
                            HIBERNATE_WAKE_LOW_BAT)) |
               ((HWREG(HIB_IO) << 16) & (HIBERNATE_WAKE_RESET |
                                         HIBERNATE_WAKE_GPIO)));
    }
    else
    {
        return(HWREG(HIB_CTL) & (HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC |
                                 HIBERNATE_WAKE_LOW_BAT));
    }
}

void HibernateWakeSet

(

uint32_t

ui32WakeFlags

)

Configures the wake conditions for the Hibernation module.

Parameters

ui32WakeFlags

specifies which conditions should be used for waking.

This function enables the conditions under which the Hibernation module wakes. The ui32WakeFlags parameter is the logical OR of any combination of the following:

• HIBERNATE_WAKE_PIN - wake when the external wake pin is asserted.
• HIBERNATE_WAKE_RTC - wake when the RTC match occurs.
• HIBERNATE_WAKE_LOW_BAT - wake from hibernate due to a low-battery level being detected.
• HIBERNATE_WAKE_GPIO - wake when a GPIO pin is asserted.
• HIBERNATE_WAKE_RESET - wake when a reset pin is asserted.

If the HIBERNATE_WAKE_GPIO flag is set, then one of the GPIO configuration functions GPIOPinTypeWakeHigh() or GPIOPinTypeWakeLow() must be called to properly configure and enable a GPIO as a wake source for hibernation.

Note

The HIBERNATE_WAKE_GPIO and HIBERNATE_WAKE_RESET parameters are only available on some Tiva devices.

On some Tiva devices a tamper event acts as a wake source for the Hibernation module. Refer the function HibernateTamperEventsConfig() to wake from hibernation on a tamper event.

Returns

None.

Definition at line 420 of file hibernate.c.

References _HibernateWriteComplete(), ASSERT, HIB_CTL, HIB_CTL_VDD3ON, HIB_IO, HIB_IO_IOWRC, HIB_IO_WUUNLK, HIBERNATE_WAKE_GPIO, HIBERNATE_WAKE_IO, HIBERNATE_WAKE_LOW_BAT, HIBERNATE_WAKE_PIN, HIBERNATE_WAKE_RESET, HIBERNATE_WAKE_RTC, and HWREG.

{
    //
    // Check the arguments.
    //
    ASSERT(!(ui32WakeFlags & ~(HIBERNATE_WAKE_PIN | HIBERNATE_WAKE_RTC |
                               HIBERNATE_WAKE_GPIO | HIBERNATE_WAKE_RESET |
                               HIBERNATE_WAKE_LOW_BAT)));

    //
    // Set the specified wake flags in the control register.
    //
    HWREG(HIB_CTL) = (ui32WakeFlags | (HWREG(HIB_CTL) &
                                       ~(HIBERNATE_WAKE_PIN |
                                         HIBERNATE_WAKE_RTC |
                                         HIBERNATE_WAKE_LOW_BAT)));

    //
    // Wait for write completion
    //
    _HibernateWriteComplete();

    //
    // Write the hibernate IO register if requested.
    //
    if(HIBERNATE_WAKE_IO)
    {
        //
        // If the reset or GPIOs are begin used as a wake source then the
        // the VDD3ON needs to be set to allow the pads to remained
        // powered.
        //
        if((ui32WakeFlags & (HIBERNATE_WAKE_RESET | HIBERNATE_WAKE_GPIO)) &&
           ((HWREG(HIB_CTL) & HIB_CTL_VDD3ON) == 0))
        {
            //
            // Make sure that VDD3ON mode is enabled so that the pads can
            // retain their state.
            //
            HWREG(HIB_CTL) |= HIB_CTL_VDD3ON;

            //
            // Wait for write completion
            //
            _HibernateWriteComplete();
        }

        //
        // Set the requested flags.
        //
        HWREG(HIB_IO) = (ui32WakeFlags >> 16) | HIB_IO_WUUNLK;

        //
        // Spin until the write complete bit is set.
        //
        while((HWREG(HIB_IO) & HIB_IO_IOWRC) == 0)
        {
        }

        //
        // Clear the write unlock bit.
        //
        HWREG(HIB_IO) &= ~HIB_IO_WUUNLK;
    }
}

Here is the call graph for this function: