Steve Karg
253 lines
7.1 KiB
C
253 lines
7.1 KiB
C
/**
|
|
* \file
|
|
*
|
|
* \brief Sleep manager
|
|
*
|
|
* Copyright (c) 2010 - 2013 Atmel Corporation. All rights reserved.
|
|
*
|
|
* \asf_license_start
|
|
*
|
|
* \page License
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
*
|
|
* 3. The name of Atmel may not be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* 4. This software may only be redistributed and used in connection with an
|
|
* Atmel microcontroller product.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR IMPLIED
|
|
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE
|
|
* EXPRESSLY AND SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
|
|
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
* \asf_license_stop
|
|
*
|
|
*/
|
|
#ifndef SLEEPMGR_H
|
|
#define SLEEPMGR_H
|
|
|
|
#include <compiler.h>
|
|
#include <parts.h>
|
|
|
|
#if (SAM3S || SAM3U || SAM3N || SAM3XA || SAM4S || SAM4E)
|
|
# include "sam/sleepmgr.h"
|
|
#elif XMEGA
|
|
# include "xmega/sleepmgr.h"
|
|
#elif UC3
|
|
# include "uc3/sleepmgr.h"
|
|
#elif SAM4L
|
|
# include "sam4l/sleepmgr.h"
|
|
#else
|
|
# error Unsupported device.
|
|
#endif
|
|
|
|
/**
|
|
* \defgroup sleepmgr_group Sleep manager
|
|
*
|
|
* The sleep manager is a service for ensuring that the device is not put to
|
|
* sleep in deeper sleep modes than the system (e.g., peripheral drivers,
|
|
* services or the application) allows at any given time.
|
|
*
|
|
* It is based on the use of lock counting for the individual sleep modes, and
|
|
* will put the device to sleep in the shallowest sleep mode that has a non-zero
|
|
* lock count. The drivers/services/application can change these counts by use
|
|
* of \ref sleepmgr_lock_mode and \ref sleepmgr_unlock_mode.
|
|
* Refer to \ref sleepmgr_mode for a list of the sleep modes available for
|
|
* locking, and the device datasheet for information on their effect.
|
|
*
|
|
* The application must supply the file \ref conf_sleepmgr.h.
|
|
*
|
|
* For the sleep manager to be enabled, the symbol \ref CONFIG_SLEEPMGR_ENABLE
|
|
* must be defined, e.g., in \ref conf_sleepmgr.h. If this symbol is not
|
|
* defined, the functions are replaced with dummy functions and no RAM is used.
|
|
*
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* \def CONFIG_SLEEPMGR_ENABLE
|
|
* \brief Configuration symbol for enabling the sleep manager
|
|
*
|
|
* If this symbol is not defined, the functions of this service are replaced
|
|
* with dummy functions. This is useful for reducing code size and execution
|
|
* time if the sleep manager is not needed in the application.
|
|
*
|
|
* This symbol may be defined in \ref conf_sleepmgr.h.
|
|
*/
|
|
#if defined(__DOXYGEN__) && !defined(CONFIG_SLEEPMGR_ENABLE)
|
|
# define CONFIG_SLEEPMGR_ENABLE
|
|
#endif
|
|
|
|
/**
|
|
* \enum sleepmgr_mode
|
|
* \brief Sleep mode locks
|
|
*
|
|
* Identifiers for the different sleep mode locks.
|
|
*/
|
|
|
|
/**
|
|
* \brief Initialize the lock counts
|
|
*
|
|
* Sets all lock counts to 0, except the very last one, which is set to 1. This
|
|
* is done to simplify the algorithm for finding the deepest allowable sleep
|
|
* mode in \ref sleepmgr_enter_sleep.
|
|
*/
|
|
static inline void
|
|
sleepmgr_init (void)
|
|
{
|
|
#ifdef CONFIG_SLEEPMGR_ENABLE
|
|
uint8_t i;
|
|
|
|
for (i = 0; i < SLEEPMGR_NR_OF_MODES - 1; i++)
|
|
{
|
|
sleepmgr_locks[i] = 0;
|
|
}
|
|
sleepmgr_locks[SLEEPMGR_NR_OF_MODES - 1] = 1;
|
|
#endif /* CONFIG_SLEEPMGR_ENABLE */
|
|
}
|
|
|
|
/**
|
|
* \brief Increase lock count for a sleep mode
|
|
*
|
|
* Increases the lock count for \a mode to ensure that the sleep manager does
|
|
* not put the device to sleep in the deeper sleep modes.
|
|
*
|
|
* \param mode Sleep mode to lock.
|
|
*/
|
|
static inline void
|
|
sleepmgr_lock_mode (enum sleepmgr_mode mode)
|
|
{
|
|
#ifdef CONFIG_SLEEPMGR_ENABLE
|
|
irqflags_t flags;
|
|
|
|
Assert (sleepmgr_locks[mode] < 0xff);
|
|
|
|
// Enter a critical section
|
|
flags = cpu_irq_save ();
|
|
|
|
++sleepmgr_locks[mode];
|
|
|
|
// Leave the critical section
|
|
cpu_irq_restore (flags);
|
|
#else
|
|
UNUSED (mode);
|
|
#endif /* CONFIG_SLEEPMGR_ENABLE */
|
|
}
|
|
|
|
/**
|
|
* \brief Decrease lock count for a sleep mode
|
|
*
|
|
* Decreases the lock count for \a mode. If the lock count reaches 0, the sleep
|
|
* manager can put the device to sleep in the deeper sleep modes.
|
|
*
|
|
* \param mode Sleep mode to unlock.
|
|
*/
|
|
static inline void
|
|
sleepmgr_unlock_mode (enum sleepmgr_mode mode)
|
|
{
|
|
#ifdef CONFIG_SLEEPMGR_ENABLE
|
|
irqflags_t flags;
|
|
|
|
Assert (sleepmgr_locks[mode]);
|
|
|
|
// Enter a critical section
|
|
flags = cpu_irq_save ();
|
|
|
|
--sleepmgr_locks[mode];
|
|
|
|
// Leave the critical section
|
|
cpu_irq_restore (flags);
|
|
#else
|
|
UNUSED (mode);
|
|
#endif /* CONFIG_SLEEPMGR_ENABLE */
|
|
}
|
|
|
|
/**
|
|
* \brief Retrieves the deepest allowable sleep mode
|
|
*
|
|
* Searches through the sleep mode lock counts, starting at the shallowest sleep
|
|
* mode, until the first non-zero lock count is found. The deepest allowable
|
|
* sleep mode is then returned.
|
|
*/
|
|
static inline enum sleepmgr_mode
|
|
sleepmgr_get_sleep_mode (void)
|
|
{
|
|
enum sleepmgr_mode sleep_mode = SLEEPMGR_ACTIVE;
|
|
|
|
#ifdef CONFIG_SLEEPMGR_ENABLE
|
|
uint8_t *lock_ptr = sleepmgr_locks;
|
|
|
|
// Find first non-zero lock count, starting with the shallowest modes.
|
|
while (!(*lock_ptr))
|
|
{
|
|
lock_ptr++;
|
|
sleep_mode++;
|
|
}
|
|
|
|
// Catch the case where one too many sleepmgr_unlock_mode() call has been
|
|
// performed on the deepest sleep mode.
|
|
Assert ((uintptr_t) (lock_ptr - sleepmgr_locks) < SLEEPMGR_NR_OF_MODES);
|
|
|
|
#endif /* CONFIG_SLEEPMGR_ENABLE */
|
|
|
|
return sleep_mode;
|
|
}
|
|
|
|
/**
|
|
* \fn sleepmgr_enter_sleep
|
|
* \brief Go to sleep in the deepest allowed mode
|
|
*
|
|
* Searches through the sleep mode lock counts, starting at the shallowest sleep
|
|
* mode, until the first non-zero lock count is found. The device is then put to
|
|
* sleep in the sleep mode that corresponds to the lock.
|
|
*
|
|
* \note This function enables interrupts before going to sleep, and will leave
|
|
* them enabled upon return. This also applies if sleep is skipped due to ACTIVE
|
|
* mode being locked.
|
|
*/
|
|
|
|
static inline void
|
|
sleepmgr_enter_sleep (void)
|
|
{
|
|
#ifdef CONFIG_SLEEPMGR_ENABLE
|
|
enum sleepmgr_mode sleep_mode;
|
|
|
|
cpu_irq_disable ();
|
|
|
|
// Find the deepest allowable sleep mode
|
|
sleep_mode = sleepmgr_get_sleep_mode ();
|
|
// Return right away if first mode (ACTIVE) is locked.
|
|
if (sleep_mode == SLEEPMGR_ACTIVE)
|
|
{
|
|
cpu_irq_enable ();
|
|
return;
|
|
}
|
|
// Enter the deepest allowable sleep mode with interrupts enabled
|
|
sleepmgr_sleep (sleep_mode);
|
|
#else
|
|
cpu_irq_enable ();
|
|
#endif /* CONFIG_SLEEPMGR_ENABLE */
|
|
}
|
|
|
|
|
|
//! @}
|
|
|
|
#endif /* SLEEPMGR_H */
|