/**
* \file
*
* \brief Commonly used includes, types and macros.
*
* Copyright (c) 2009-2018 Microchip Technology Inc. and its subsidiaries.
*
* \asf_license_start
*
* \page License
*
* Subject to your compliance with these terms, you may use Microchip
* software and any derivatives exclusively with Microchip products.
* It is your responsibility to comply with third party license terms applicable
* to your use of third party software (including open source software) that
* may accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES,
* WHETHER EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE,
* INCLUDING ANY IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY,
* AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT WILL MICROCHIP BE
* LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE, INCIDENTAL OR CONSEQUENTIAL
* LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND WHATSOEVER RELATED TO THE
* SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS BEEN ADVISED OF THE
* POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE FULLEST EXTENT
* ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN ANY WAY
* RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*
* \asf_license_stop
*
*/
/*
* Support and FAQ: visit Microchip Support
*/
#ifndef _COMPILER_AVR32_H_
#define _COMPILER_AVR32_H_
/**
* \defgroup group_avr32_utils Compiler abstraction layer and code utilities
*
* Compiler abstraction layer and code utilities for 32-bit AVR.
* This module provides various abstraction layers and utilities to make code compatible between different compilers.
*
* \{
*/
#if (defined __ICCAVR32__)
# include
#endif
#include "preprocessor.h"
#include
#include
#include "header_files/uc3d_defines_fix.h"
#include "header_files/uc3l3_l4_defines_fix.h"
//_____ D E C L A R A T I O N S ____________________________________________
#ifdef __AVR32_ABI_COMPILER__ // Automatically defined when compiling for AVR32, not when assembling.
#include
#include
#include
#include
#if (defined __ICCAVR32__)
/*! \name Compiler Keywords
*
* Port of some keywords from GNU GCC for AVR32 to IAR Embedded Workbench for Atmel AVR32.
*/
//! @{
#define __asm__ asm
#define __inline__ inline
#define __volatile__
//! @}
#endif
/**
* \def UNUSED
* \brief Marking \a v as a unused parameter or value.
*/
#define UNUSED(v) (void)(v)
/**
* \def unused
* \brief Marking \a v as a unused parameter or value.
*/
#define unused(v) do { (void)(v); } while(0)
/**
* \def barrier
* \brief Memory barrier
*/
#if defined(__GNUC__)
# define barrier() asm volatile("" ::: "memory")
#elif defined(__ICCAVR32__)
# define barrier() __asm__ __volatile__ ("")
#endif
/**
* \brief Emit the compiler pragma \a arg.
*
* \param arg The pragma directive as it would appear after \e \#pragma
* (i.e. not stringified).
*/
#define COMPILER_PRAGMA(arg) _Pragma(#arg)
/**
* \def COMPILER_PACK_SET(alignment)
* \brief Set maximum alignment for subsequent struct and union
* definitions to \a alignment.
*/
#define COMPILER_PACK_SET(alignment) COMPILER_PRAGMA(pack(alignment))
/**
* \def COMPILER_PACK_RESET()
* \brief Set default alignment for subsequent struct and union
* definitions.
*/
#define COMPILER_PACK_RESET() COMPILER_PRAGMA(pack())
/**
* \brief Set aligned boundary.
*/
#if (defined __GNUC__)
#define COMPILER_ALIGNED(a) __attribute__((__aligned__(a)))
#elif (defined __ICCAVR32__)
#define COMPILER_ALIGNED(a) COMPILER_PRAGMA(data_alignment = a)
#endif
/**
* \brief Set word-aligned boundary.
*/
#if (defined __GNUC__)
#define COMPILER_WORD_ALIGNED __attribute__((__aligned__(4)))
#elif (defined __ICCAVR32__)
#define COMPILER_WORD_ALIGNED COMPILER_PRAGMA(data_alignment = 4)
#endif
/**
* \name System Register Access
* @{
*/
#if defined(__GNUC__) || defined(__DOXYGEN__)
/**
* \brief Get value of system register
*
* \param reg Address of the system register of which to get the value.
*
* \return Value of system register \a reg.
*/
# define sysreg_read(reg) __builtin_mfsr(reg)
/**
* \name Tag functions as deprecated
*
* Tagging a function as deprecated will produce a warning when and only
* when the function is called.
*
* Usage is to add the __DEPRECATED__ symbol before the function definition.
* E.g.:
* __DEPRECATED__ uint8_t some_deprecated_function (void)
* {
* ...
* }
*
* \note Only supported by GCC 3.1 and above, no IAR support
* @{
*/
#if ((defined __GNUC__) && (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >=1)))
#define __DEPRECATED__ __attribute__((__deprecated__))
#else
#define __DEPRECATED__
#endif
//! @}
/**
* \brief Set value of system register
*
* \param reg Address of the system register of which to set the value.
* \param val Value to set the system register \a reg to.
*/
# define sysreg_write(reg, val) __builtin_mtsr(reg, val)
#elif defined(__ICCAVR32__)
# define sysreg_read(reg) __get_system_register(reg)
# define sysreg_write(reg, val) __set_system_register(reg, val)
#endif
// Deprecated definitions
#define Get_system_register(reg) sysreg_read(reg)
#define Set_system_register(reg, val) sysreg_write(reg, val)
//! @}
#include "interrupt.h"
/*! \name Usual Types
*/
//! @{
typedef unsigned char Bool; //!< Boolean.
#ifndef __cplusplus
#if !defined(__bool_true_false_are_defined)
typedef unsigned char bool; //!< Boolean.
#endif
#endif
typedef int8_t S8 ; //!< 8-bit signed integer.
typedef uint8_t U8 ; //!< 8-bit unsigned integer.
typedef int16_t S16; //!< 16-bit signed integer.
typedef uint16_t U16; //!< 16-bit unsigned integer.
typedef uint16_t le16_t;
typedef uint16_t be16_t;
typedef int32_t S32; //!< 32-bit signed integer.
typedef uint32_t U32; //!< 32-bit unsigned integer.
typedef uint32_t le32_t;
typedef uint32_t be32_t;
typedef signed long long int S64; //!< 64-bit signed integer.
typedef unsigned long long int U64; //!< 64-bit unsigned integer.
typedef float F32; //!< 32-bit floating-point number.
typedef double F64; //!< 64-bit floating-point number.
typedef uint32_t iram_size_t;
//! @}
/*! \name Status Types
*/
//! @{
typedef bool Status_bool_t; //!< Boolean status.
typedef U8 Status_t; //!< 8-bit-coded status.
//! @}
/*! \name Aliasing Aggregate Types
*/
//! @{
//! 16-bit union.
typedef union
{
S16 s16 ;
U16 u16 ;
S8 s8 [2];
U8 u8 [2];
} Union16;
//! 32-bit union.
typedef union
{
S32 s32 ;
U32 u32 ;
S16 s16[2];
U16 u16[2];
S8 s8 [4];
U8 u8 [4];
} Union32;
//! 64-bit union.
typedef union
{
S64 s64 ;
U64 u64 ;
S32 s32[2];
U32 u32[2];
S16 s16[4];
U16 u16[4];
S8 s8 [8];
U8 u8 [8];
} Union64;
//! Union of pointers to 64-, 32-, 16- and 8-bit unsigned integers.
typedef union
{
S64 *s64ptr;
U64 *u64ptr;
S32 *s32ptr;
U32 *u32ptr;
S16 *s16ptr;
U16 *u16ptr;
S8 *s8ptr ;
U8 *u8ptr ;
} UnionPtr;
//! Union of pointers to volatile 64-, 32-, 16- and 8-bit unsigned integers.
typedef union
{
volatile S64 *s64ptr;
volatile U64 *u64ptr;
volatile S32 *s32ptr;
volatile U32 *u32ptr;
volatile S16 *s16ptr;
volatile U16 *u16ptr;
volatile S8 *s8ptr ;
volatile U8 *u8ptr ;
} UnionVPtr;
//! Union of pointers to constant 64-, 32-, 16- and 8-bit unsigned integers.
typedef union
{
const S64 *s64ptr;
const U64 *u64ptr;
const S32 *s32ptr;
const U32 *u32ptr;
const S16 *s16ptr;
const U16 *u16ptr;
const S8 *s8ptr ;
const U8 *u8ptr ;
} UnionCPtr;
//! Union of pointers to constant volatile 64-, 32-, 16- and 8-bit unsigned integers.
typedef union
{
const volatile S64 *s64ptr;
const volatile U64 *u64ptr;
const volatile S32 *s32ptr;
const volatile U32 *u32ptr;
const volatile S16 *s16ptr;
const volatile U16 *u16ptr;
const volatile S8 *s8ptr ;
const volatile U8 *u8ptr ;
} UnionCVPtr;
//! Structure of pointers to 64-, 32-, 16- and 8-bit unsigned integers.
typedef struct
{
S64 *s64ptr;
U64 *u64ptr;
S32 *s32ptr;
U32 *u32ptr;
S16 *s16ptr;
U16 *u16ptr;
S8 *s8ptr ;
U8 *u8ptr ;
} StructPtr;
//! Structure of pointers to volatile 64-, 32-, 16- and 8-bit unsigned integers.
typedef struct
{
volatile S64 *s64ptr;
volatile U64 *u64ptr;
volatile S32 *s32ptr;
volatile U32 *u32ptr;
volatile S16 *s16ptr;
volatile U16 *u16ptr;
volatile S8 *s8ptr ;
volatile U8 *u8ptr ;
} StructVPtr;
//! Structure of pointers to constant 64-, 32-, 16- and 8-bit unsigned integers.
typedef struct
{
const S64 *s64ptr;
const U64 *u64ptr;
const S32 *s32ptr;
const U32 *u32ptr;
const S16 *s16ptr;
const U16 *u16ptr;
const S8 *s8ptr ;
const U8 *u8ptr ;
} StructCPtr;
//! Structure of pointers to constant volatile 64-, 32-, 16- and 8-bit unsigned integers.
typedef struct
{
const volatile S64 *s64ptr;
const volatile U64 *u64ptr;
const volatile S32 *s32ptr;
const volatile U32 *u32ptr;
const volatile S16 *s16ptr;
const volatile U16 *u16ptr;
const volatile S8 *s8ptr ;
const volatile U8 *u8ptr ;
} StructCVPtr;
//! @}
#endif // __AVR32_ABI_COMPILER__
//_____ M A C R O S ________________________________________________________
/*! \name Usual Constants
*/
//! @{
#define DISABLE 0
#define ENABLE 1
#ifndef __cplusplus
#if !defined(__bool_true_false_are_defined)
#define false 0
#define true 1
#endif
#endif
#define PASS 0
#define FAIL 1
#define LOW 0
#define HIGH 1
//! @}
#ifdef __AVR32_ABI_COMPILER__ // Automatically defined when compiling for AVR32, not when assembling.
//! \name Optimization Control
//@{
/**
* \def likely(exp)
* \brief The expression \a exp is likely to be true
*/
#ifndef likely
# define likely(exp) (exp)
#endif
/**
* \def unlikely(exp)
* \brief The expression \a exp is unlikely to be true
*/
#ifndef unlikely
# define unlikely(exp) (exp)
#endif
/**
* \def is_constant(exp)
* \brief Determine if an expression evaluates to a constant value.
*
* \param exp Any expression
*
* \return true if \a exp is constant, false otherwise.
*/
#ifdef __GNUC__
# define is_constant(exp) __builtin_constant_p(exp)
#else
# define is_constant(exp) (0)
#endif
//! @}
/*! \name Bit-Field Handling
*/
//! @{
/*! \brief Reads the bits of a value specified by a given bit-mask.
*
* \param value Value to read bits from.
* \param mask Bit-mask indicating bits to read.
*
* \return Read bits.
*/
#define Rd_bits( value, mask) ((value) & (mask))
/*! \brief Writes the bits of a C lvalue specified by a given bit-mask.
*
* \param lvalue C lvalue to write bits to.
* \param mask Bit-mask indicating bits to write.
* \param bits Bits to write.
*
* \return Resulting value with written bits.
*/
#define Wr_bits(lvalue, mask, bits) ((lvalue) = ((lvalue) & ~(mask)) |\
((bits ) & (mask)))
/*! \brief Tests the bits of a value specified by a given bit-mask.
*
* \param value Value of which to test bits.
* \param mask Bit-mask indicating bits to test.
*
* \return \c 1 if at least one of the tested bits is set, else \c 0.
*/
#define Tst_bits( value, mask) (Rd_bits(value, mask) != 0)
/*! \brief Clears the bits of a C lvalue specified by a given bit-mask.
*
* \param lvalue C lvalue of which to clear bits.
* \param mask Bit-mask indicating bits to clear.
*
* \return Resulting value with cleared bits.
*/
#define Clr_bits(lvalue, mask) ((lvalue) &= ~(mask))
/*! \brief Sets the bits of a C lvalue specified by a given bit-mask.
*
* \param lvalue C lvalue of which to set bits.
* \param mask Bit-mask indicating bits to set.
*
* \return Resulting value with set bits.
*/
#define Set_bits(lvalue, mask) ((lvalue) |= (mask))
/*! \brief Toggles the bits of a C lvalue specified by a given bit-mask.
*
* \param lvalue C lvalue of which to toggle bits.
* \param mask Bit-mask indicating bits to toggle.
*
* \return Resulting value with toggled bits.
*/
#define Tgl_bits(lvalue, mask) ((lvalue) ^= (mask))
/*! \brief Reads the bit-field of a value specified by a given bit-mask.
*
* \param value Value to read a bit-field from.
* \param mask Bit-mask indicating the bit-field to read.
*
* \return Read bit-field.
*/
#define Rd_bitfield( value, mask) (Rd_bits( value, mask) >> ctz(mask))
/*! \brief Writes the bit-field of a C lvalue specified by a given bit-mask.
*
* \param lvalue C lvalue to write a bit-field to.
* \param mask Bit-mask indicating the bit-field to write.
* \param bitfield Bit-field to write.
*
* \return Resulting value with written bit-field.
*/
#define Wr_bitfield(lvalue, mask, bitfield) (Wr_bits(lvalue, mask, (U32)(bitfield) << ctz(mask)))
//! @}
/*! \brief This macro makes the CPU take a small break for a few cycles. This should
* be used when waiting for an event. It will reduce the internal bus load.
*
* "sub pc, pc, -4" (or "sub pc, -2") forces the IF stage to wait until the result
* of the calculation before it can fetch the next instruction. This makes sure
* there are nothing stuck in the LS pipe when you start a new iteration and guarantee
* to flush the pipeline without having any other effect.
* (A nop doesn't have any effect on the IF stage.)
*/
#if (defined __GNUC__)
# define cpu_relax() __asm__ __volatile__("sub pc, pc, -4" ::: "memory", "cc")
#elif (defined __ICCAVR32__)
# define cpu_relax() __asm__ __volatile__("sub pc, pc, -4")
#endif
/*! \brief This macro is used to test fatal errors.
*
* The macro tests if the expression is false. If it is, a fatal error is
* detected and the application hangs up. If TEST_SUITE_DEFINE_ASSERT_MACRO
* is defined, a unit test version of the macro is used, to allow execution
* of further tests after a false expression.
*
* \param expr Expression to evaluate and supposed to be nonzero.
*/
#if defined(_ASSERT_ENABLE_)
# if defined(TEST_SUITE_DEFINE_ASSERT_MACRO)
// Assert() is defined in unit_test/suite.h
# include "unit_test/suite.h"
# else
# define Assert(expr) \
{\
if (!(expr)) while (true);\
}
# endif
#else
# define Assert(expr) ((void) 0)
#endif
/*! \name Zero-Bit Counting
*
* Under AVR32-GCC, __builtin_clz and __builtin_ctz behave like macros when
* applied to constant expressions (values known at compile time), so they are
* more optimized than the use of the corresponding assembly instructions and
* they can be used as constant expressions e.g. to initialize objects having
* static storage duration, and like the corresponding assembly instructions
* when applied to non-constant expressions (values unknown at compile time), so
* they are more optimized than an assembly periphrasis. Hence, clz and ctz
* ensure a possible and optimized behavior for both constant and non-constant
* expressions.
*/
//! @{
/*! \brief Counts the leading zero bits of the given value considered as a 32-bit integer.
*
* \param u Value of which to count the leading zero bits.
*
* \return The count of leading zero bits in \a u.
*/
#if (defined __GNUC__)
#define clz(u) ((u) ? __builtin_clz(u) : 32)
#elif (defined __ICCAVR32__)
#if (__VER__ == 330) && (__SUBVERSION__ <= 1)
// __count_leading_zeros is broken and returns a value which is offset by
// -32 when called with a constant parameter.
#define clz(v) (0 == v ? 32 : (31 & __count_leading_zeros(v)))
#else
#define clz(v) __count_leading_zeros(v)
#endif
#endif
/*! \brief Counts the trailing zero bits of the given value considered as a 32-bit integer.
*
* \param u Value of which to count the trailing zero bits.
*
* \return The count of trailing zero bits in \a u.
*/
#if (defined __GNUC__)
#define ctz(u) ((u) ? __builtin_ctz(u) : 32)
#elif (defined __ICCAVR32__)
#define ctz(u) __count_trailing_zeros(u)
#endif
//! @}
//! \name Logarithmic functions
//! @{
/**
* \internal
* Undefined function. Will cause a link failure if ilog2() is called
* with an invalid constant value.
*/
int_fast8_t ilog2_undefined(void);
/**
* \brief Calculate the base-2 logarithm of a number rounded down to
* the nearest integer.
*
* \param x A 32-bit value
* \return The base-2 logarithm of \a x, or -1 if \a x is 0.
*/
static inline int_fast8_t ilog2(uint32_t x)
{
if (is_constant(x))
return ((x) & (1ULL << 31) ? 31 :
(x) & (1ULL << 30) ? 30 :
(x) & (1ULL << 29) ? 29 :
(x) & (1ULL << 28) ? 28 :
(x) & (1ULL << 27) ? 27 :
(x) & (1ULL << 26) ? 26 :
(x) & (1ULL << 25) ? 25 :
(x) & (1ULL << 24) ? 24 :
(x) & (1ULL << 23) ? 23 :
(x) & (1ULL << 22) ? 22 :
(x) & (1ULL << 21) ? 21 :
(x) & (1ULL << 20) ? 20 :
(x) & (1ULL << 19) ? 19 :
(x) & (1ULL << 18) ? 18 :
(x) & (1ULL << 17) ? 17 :
(x) & (1ULL << 16) ? 16 :
(x) & (1ULL << 15) ? 15 :
(x) & (1ULL << 14) ? 14 :
(x) & (1ULL << 13) ? 13 :
(x) & (1ULL << 12) ? 12 :
(x) & (1ULL << 11) ? 11 :
(x) & (1ULL << 10) ? 10 :
(x) & (1ULL << 9) ? 9 :
(x) & (1ULL << 8) ? 8 :
(x) & (1ULL << 7) ? 7 :
(x) & (1ULL << 6) ? 6 :
(x) & (1ULL << 5) ? 5 :
(x) & (1ULL << 4) ? 4 :
(x) & (1ULL << 3) ? 3 :
(x) & (1ULL << 2) ? 2 :
(x) & (1ULL << 1) ? 1 :
(x) & (1ULL << 0) ? 0 :
ilog2_undefined());
return 31 - clz(x);
}
//! @}
/*! \name Bit Reversing
*/
//! @{
/*! \brief Reverses the bits of \a u8.
*
* \param u8 U8 of which to reverse the bits.
*
* \return Value resulting from \a u8 with reversed bits.
*/
#define bit_reverse8(u8) ((U8)(bit_reverse32((U8)(u8)) >> 24))
/*! \brief Reverses the bits of \a u16.
*
* \param u16 U16 of which to reverse the bits.
*
* \return Value resulting from \a u16 with reversed bits.
*/
#define bit_reverse16(u16) ((U16)(bit_reverse32((U16)(u16)) >> 16))
/*! \brief Reverses the bits of \a u32.
*
* \param u32 U32 of which to reverse the bits.
*
* \return Value resulting from \a u32 with reversed bits.
*/
#if (defined __GNUC__)
#define bit_reverse32(u32) \
(\
{\
unsigned int __value = (U32)(u32);\
__asm__ ("brev\t%0" : "+r" (__value) : : "cc");\
(U32)__value;\
}\
)
#elif (defined __ICCAVR32__)
#define bit_reverse32(u32) ((U32)__bit_reverse((U32)(u32)))
#endif
/*! \brief Reverses the bits of \a u64.
*
* \param u64 U64 of which to reverse the bits.
*
* \return Value resulting from \a u64 with reversed bits.
*/
#define bit_reverse64(u64) ((U64)(((U64)bit_reverse32((U64)(u64) >> 32)) |\
((U64)bit_reverse32((U64)(u64)) << 32)))
//! @}
/*! \name Alignment
*/
//! @{
/*! \brief Tests alignment of the number \a val with the \a n boundary.
*
* \param val Input value.
* \param n Boundary.
*
* \return \c 1 if the number \a val is aligned with the \a n boundary, else \c 0.
*/
#define Test_align(val, n ) (!Tst_bits( val, (n) - 1 ) )
/*! \brief Gets alignment of the number \a val with respect to the \a n boundary.
*
* \param val Input value.
* \param n Boundary.
*
* \return Alignment of the number \a val with respect to the \a n boundary.
*/
#define Get_align( val, n ) ( Rd_bits( val, (n) - 1 ) )
/*! \brief Sets alignment of the lvalue number \a lval to \a alg with respect to the \a n boundary.
*
* \param lval Input/output lvalue.
* \param n Boundary.
* \param alg Alignment.
*
* \return New value of \a lval resulting from its alignment set to \a alg with respect to the \a n boundary.
*/
#define Set_align(lval, n, alg) ( Wr_bits(lval, (n) - 1, alg) )
/*! \brief Aligns the number \a val with the upper \a n boundary.
*
* \param val Input value.
* \param n Boundary.
*
* \return Value resulting from the number \a val aligned with the upper \a n boundary.
*/
#define Align_up( val, n ) (((val) + ((n) - 1)) & ~((n) - 1))
/*! \brief Aligns the number \a val with the lower \a n boundary.
*
* \param val Input value.
* \param n Boundary.
*
* \return Value resulting from the number \a val aligned with the lower \a n boundary.
*/
#define Align_down(val, n ) ( (val) & ~((n) - 1))
//! @}
/*! \name Mathematics
*
* The same considerations as for clz and ctz apply here but AVR32-GCC does not
* provide built-in functions to access the assembly instructions abs, min and
* max and it does not produce them by itself in most cases, so two sets of
* macros are defined here:
* - Abs, Min and Max to apply to constant expressions (values known at
* compile time);
* - abs, min and max to apply to non-constant expressions (values unknown at
* compile time).
*/
//! @{
/*! \brief Takes the absolute value of \a a.
*
* \param a Input value.
*
* \return Absolute value of \a a.
*
* \note More optimized if only used with values known at compile time.
*/
#define Abs(a) (((a) < 0 ) ? -(a) : (a))
/*! \brief Takes the minimal value of \a a and \a b.
*
* \param a Input value.
* \param b Input value.
*
* \return Minimal value of \a a and \a b.
*
* \note More optimized if only used with values known at compile time.
*/
#define Min(a, b) (((a) < (b)) ? (a) : (b))
/*! \brief Takes the maximal value of \a a and \a b.
*
* \param a Input value.
* \param b Input value.
*
* \return Maximal value of \a a and \a b.
*
* \note More optimized if only used with values known at compile time.
*/
#define Max(a, b) (((a) > (b)) ? (a) : (b))
/*! \brief Takes the absolute value of \a a.
*
* \param a Input value.
*
* \return Absolute value of \a a.
*
* \note More optimized if only used with values unknown at compile time.
*/
#if (defined __GNUC__)
#define abs(a) \
(\
{\
int __value = (a);\
__asm__ ("abs\t%0" : "+r" (__value) : : "cc");\
__value;\
}\
)
#elif (defined __ICCAVR32__)
#define abs(a) Abs(a)
#endif
/*! \brief Takes the minimal value of \a a and \a b.
*
* \param a Input value.
* \param b Input value.
*
* \return Minimal value of \a a and \a b.
*
* \note More optimized if only used with values unknown at compile time.
*/
#if (defined __GNUC__)
#define min(a, b) \
(\
{\
int __value, __arg_a = (a), __arg_b = (b);\
__asm__ ("min\t%0, %1, %2" : "=r" (__value) : "r" (__arg_a), "r" (__arg_b));\
__value;\
}\
)
#elif (defined __ICCAVR32__)
#define min(a, b) __min(a, b)
#endif
/*! \brief Takes the maximal value of \a a and \a b.
*
* \param a Input value.
* \param b Input value.
*
* \return Maximal value of \a a and \a b.
*
* \note More optimized if only used with values unknown at compile time.
*/
#if (defined __GNUC__)
#define max(a, b) \
(\
{\
int __value, __arg_a = (a), __arg_b = (b);\
__asm__ ("max\t%0, %1, %2" : "=r" (__value) : "r" (__arg_a), "r" (__arg_b));\
__value;\
}\
)
#elif (defined __ICCAVR32__)
#define max(a, b) __max(a, b)
#endif
//! @}
/*! \brief Calls the routine at address \a addr.
*
* It generates a long call opcode.
*
* For example, `Long_call(0x80000000)' generates a software reset on a UC3 if
* it is invoked from the CPU supervisor mode.
*
* \param addr Address of the routine to call.
*
* \note It may be used as a long jump opcode in some special cases.
*/
#define Long_call(addr) ((*(void (*)(void))(addr))())
/*! \brief Resets the CPU by software.
*
* \warning It shall not be called from the CPU application mode.
*/
#if (defined __GNUC__)
#define Reset_CPU() \
(\
{\
__asm__ __volatile__ (\
"lddpc r9, 3f\n\t"\
"mfsr r8, %[SR]\n\t"\
"bfextu r8, r8, %[SR_M_OFFSET], %[SR_M_SIZE]\n\t"\
"cp.w r8, 0b001\n\t"\
"breq 0f\n\t"\
"sub r8, pc, $ - 1f\n\t"\
"pushm r8-r9\n\t"\
"rete\n"\
"0:\n\t"\
"mtsr %[SR], r9\n"\
"1:\n\t"\
"mov r0, 0\n\t"\
"mov r1, 0\n\t"\
"mov r2, 0\n\t"\
"mov r3, 0\n\t"\
"mov r4, 0\n\t"\
"mov r5, 0\n\t"\
"mov r6, 0\n\t"\
"mov r7, 0\n\t"\
"mov r8, 0\n\t"\
"mov r9, 0\n\t"\
"mov r10, 0\n\t"\
"mov r11, 0\n\t"\
"mov r12, 0\n\t"\
"mov sp, 0\n\t"\
"stdsp sp[0], sp\n\t"\
"ldmts sp, sp\n\t"\
"mov lr, 0\n\t"\
"lddpc pc, 2f\n\t"\
".balign 4\n"\
"2:\n\t"\
".word _start\n"\
"3:\n\t"\
".word %[RESET_SR]"\
:\
: [SR] "i" (AVR32_SR),\
[SR_M_OFFSET] "i" (AVR32_SR_M_OFFSET),\
[SR_M_SIZE] "i" (AVR32_SR_M_SIZE),\
[RESET_SR] "i" (AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | (AVR32_SR_M_SUP << AVR32_SR_M_OFFSET))\
);\
}\
)
#elif (defined __ICCAVR32__)
#define Reset_CPU() \
{\
extern void *volatile __program_start;\
__asm__ __volatile__ (\
"mov r7, LWRD(__program_start)\n\t"\
"orh r7, HWRD(__program_start)\n\t"\
"mov r9, LWRD("ASTRINGZ(AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | (AVR32_SR_M_SUP << AVR32_SR_M_OFFSET))")\n\t"\
"orh r9, HWRD("ASTRINGZ(AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | (AVR32_SR_M_SUP << AVR32_SR_M_OFFSET))")\n\t"\
"mfsr r8, "ASTRINGZ(AVR32_SR)"\n\t"\
"bfextu r8, r8, "ASTRINGZ(AVR32_SR_M_OFFSET)", "ASTRINGZ(AVR32_SR_M_SIZE)"\n\t"\
"cp.w r8, 001b\n\t"\
"breq $ + 10\n\t"\
"sub r8, pc, -12\n\t"\
"pushm r8-r9\n\t"\
"rete\n\t"\
"mtsr "ASTRINGZ(AVR32_SR)", r9\n\t"\
"mov r0, 0\n\t"\
"mov r1, 0\n\t"\
"mov r2, 0\n\t"\
"mov r3, 0\n\t"\
"mov r4, 0\n\t"\
"mov r5, 0\n\t"\
"mov r6, 0\n\t"\
"st.w r0[4], r7\n\t"\
"mov r7, 0\n\t"\
"mov r8, 0\n\t"\
"mov r9, 0\n\t"\
"mov r10, 0\n\t"\
"mov r11, 0\n\t"\
"mov r12, 0\n\t"\
"mov sp, 0\n\t"\
"stdsp sp[0], sp\n\t"\
"ldmts sp, sp\n\t"\
"mov lr, 0\n\t"\
"ld.w pc, lr[4]"\
);\
__program_start;\
}
#endif
/*! \name CPU Status Register Access
*/
//! @{
/*! \brief Tells whether exceptions are globally enabled.
*
* \return \c 1 if exceptions are globally enabled, else \c 0.
*/
#define Is_global_exception_enabled() (!Tst_bits(Get_system_register(AVR32_SR), AVR32_SR_EM_MASK))
/*! \brief Disables exceptions globally.
*/
#if (defined __GNUC__)
#define Disable_global_exception() ({__asm__ __volatile__ ("ssrf\t%0" : : "i" (AVR32_SR_EM_OFFSET));})
#elif (defined __ICCAVR32__)
#define Disable_global_exception() (__set_status_flag(AVR32_SR_EM_OFFSET))
#endif
/*! \brief Enables exceptions globally.
*/
#if (defined __GNUC__)
#define Enable_global_exception() ({__asm__ __volatile__ ("csrf\t%0" : : "i" (AVR32_SR_EM_OFFSET));})
#elif (defined __ICCAVR32__)
#define Enable_global_exception() (__clear_status_flag(AVR32_SR_EM_OFFSET))
#endif
//! @}
/*! \name Debug Register Access
*/
//! @{
/*! \brief Gets the value of the \a dbgreg debug register.
*
* \param dbgreg Address of the debug register of which to get the value.
*
* \return Value of the \a dbgreg debug register.
*/
#if (defined __GNUC__)
#define Get_debug_register(dbgreg) __builtin_mfdr(dbgreg)
#elif (defined __ICCAVR32__)
#define Get_debug_register(dbgreg) __get_debug_register(dbgreg)
#endif
/*! \brief Sets the value of the \a dbgreg debug register to \a value.
*
* \param dbgreg Address of the debug register of which to set the value.
* \param value Value to set the \a dbgreg debug register to.
*/
#if (defined __GNUC__)
#define Set_debug_register(dbgreg, value) __builtin_mtdr(dbgreg, value)
#elif (defined __ICCAVR32__)
#define Set_debug_register(dbgreg, value) __set_debug_register(dbgreg, value)
#endif
//! @}
/*! \name Force Assembly Inline Code Section
*/
//! @{
#if (defined __GNUC__)
#define __always_inline inline __attribute__((__always_inline__))
#elif (defined __ICCAVR32__)
#define __always_inline _Pragma("inline=forced")
#endif
//! @}
/*! \name MCU Endianism Handling
* AVR32 is MCU big endianism.
*/
//! @{
#define MSB(u16) (((U8 *)&(u16))[0]) //!< Most significant byte of \a u16.
#define LSB(u16) (((U8 *)&(u16))[1]) //!< Least significant byte of \a u16.
#define MSH(u32) (((U16 *)&(u32))[0]) //!< Most significant half-word of \a u32.
#define LSH(u32) (((U16 *)&(u32))[1]) //!< Least significant half-word of \a u32.
#define MSB0W(u32) (((U8 *)&(u32))[0]) //!< Most significant byte of 1st rank of \a u32.
#define MSB1W(u32) (((U8 *)&(u32))[1]) //!< Most significant byte of 2nd rank of \a u32.
#define MSB2W(u32) (((U8 *)&(u32))[2]) //!< Most significant byte of 3rd rank of \a u32.
#define MSB3W(u32) (((U8 *)&(u32))[3]) //!< Most significant byte of 4th rank of \a u32.
#define LSB3W(u32) MSB0W(u32) //!< Least significant byte of 4th rank of \a u32.
#define LSB2W(u32) MSB1W(u32) //!< Least significant byte of 3rd rank of \a u32.
#define LSB1W(u32) MSB2W(u32) //!< Least significant byte of 2nd rank of \a u32.
#define LSB0W(u32) MSB3W(u32) //!< Least significant byte of 1st rank of \a u32.
#define MSW(u64) (((U32 *)&(u64))[0]) //!< Most significant word of \a u64.
#define LSW(u64) (((U32 *)&(u64))[1]) //!< Least significant word of \a u64.
#define MSH0(u64) (((U16 *)&(u64))[0]) //!< Most significant half-word of 1st rank of \a u64.
#define MSH1(u64) (((U16 *)&(u64))[1]) //!< Most significant half-word of 2nd rank of \a u64.
#define MSH2(u64) (((U16 *)&(u64))[2]) //!< Most significant half-word of 3rd rank of \a u64.
#define MSH3(u64) (((U16 *)&(u64))[3]) //!< Most significant half-word of 4th rank of \a u64.
#define LSH3(u64) MSH0(u64) //!< Least significant half-word of 4th rank of \a u64.
#define LSH2(u64) MSH1(u64) //!< Least significant half-word of 3rd rank of \a u64.
#define LSH1(u64) MSH2(u64) //!< Least significant half-word of 2nd rank of \a u64.
#define LSH0(u64) MSH3(u64) //!< Least significant half-word of 1st rank of \a u64.
#define MSB0D(u64) (((U8 *)&(u64))[0]) //!< Most significant byte of 1st rank of \a u64.
#define MSB1D(u64) (((U8 *)&(u64))[1]) //!< Most significant byte of 2nd rank of \a u64.
#define MSB2D(u64) (((U8 *)&(u64))[2]) //!< Most significant byte of 3rd rank of \a u64.
#define MSB3D(u64) (((U8 *)&(u64))[3]) //!< Most significant byte of 4th rank of \a u64.
#define MSB4D(u64) (((U8 *)&(u64))[4]) //!< Most significant byte of 5th rank of \a u64.
#define MSB5D(u64) (((U8 *)&(u64))[5]) //!< Most significant byte of 6th rank of \a u64.
#define MSB6D(u64) (((U8 *)&(u64))[6]) //!< Most significant byte of 7th rank of \a u64.
#define MSB7D(u64) (((U8 *)&(u64))[7]) //!< Most significant byte of 8th rank of \a u64.
#define LSB7D(u64) MSB0D(u64) //!< Least significant byte of 8th rank of \a u64.
#define LSB6D(u64) MSB1D(u64) //!< Least significant byte of 7th rank of \a u64.
#define LSB5D(u64) MSB2D(u64) //!< Least significant byte of 6th rank of \a u64.
#define LSB4D(u64) MSB3D(u64) //!< Least significant byte of 5th rank of \a u64.
#define LSB3D(u64) MSB4D(u64) //!< Least significant byte of 4th rank of \a u64.
#define LSB2D(u64) MSB5D(u64) //!< Least significant byte of 3rd rank of \a u64.
#define LSB1D(u64) MSB6D(u64) //!< Least significant byte of 2nd rank of \a u64.
#define LSB0D(u64) MSB7D(u64) //!< Least significant byte of 1st rank of \a u64.
#define LE16(x) Swap16(x)
#define le16_to_cpu(x) swap16(x)
#define cpu_to_le16(x) swap16(x)
#define LE16_TO_CPU(x) Swap16(x)
#define CPU_TO_LE16(x) Swap16(x)
#define be16_to_cpu(x) (x)
#define cpu_to_be16(x) (x)
#define BE16_TO_CPU(x) (x)
#define CPU_TO_BE16(x) (x)
#define le32_to_cpu(x) swap32(x)
#define cpu_to_le32(x) swap32(x)
#define LE32_TO_CPU(x) Swap32(x)
#define CPU_TO_LE32(x) Swap32(x)
#define be32_to_cpu(x) (x)
#define cpu_to_be32(x) (x)
#define BE32_TO_CPU(x) (x)
#define CPU_TO_BE32(x) (x)
//! @}
/*! \name Endianism Conversion
*
* The same considerations as for clz and ctz apply here but AVR32-GCC's
* __builtin_bswap_16 and __builtin_bswap_32 do not behave like macros when
* applied to constant expressions, so two sets of macros are defined here:
* - Swap16, Swap32 and Swap64 to apply to constant expressions (values known
* at compile time);
* - swap16, swap32 and swap64 to apply to non-constant expressions (values
* unknown at compile time).
*/
//! @{
/*! \brief Toggles the endianism of \a u16 (by swapping its bytes).
*
* \param u16 U16 of which to toggle the endianism.
*
* \return Value resulting from \a u16 with toggled endianism.
*
* \note More optimized if only used with values known at compile time.
*/
#define Swap16(u16) ((U16)(((U16)(u16) >> 8) |\
((U16)(u16) << 8)))
/*! \brief Toggles the endianism of \a u32 (by swapping its bytes).
*
* \param u32 U32 of which to toggle the endianism.
*
* \return Value resulting from \a u32 with toggled endianism.
*
* \note More optimized if only used with values known at compile time.
*/
#define Swap32(u32) ((U32)(((U32)Swap16((U32)(u32) >> 16)) |\
((U32)Swap16((U32)(u32)) << 16)))
/*! \brief Toggles the endianism of \a u64 (by swapping its bytes).
*
* \param u64 U64 of which to toggle the endianism.
*
* \return Value resulting from \a u64 with toggled endianism.
*
* \note More optimized if only used with values known at compile time.
*/
#define Swap64(u64) ((U64)(((U64)Swap32((U64)(u64) >> 32)) |\
((U64)Swap32((U64)(u64)) << 32)))
/*! \brief Toggles the endianism of \a u16 (by swapping its bytes).
*
* \param u16 U16 of which to toggle the endianism.
*
* \return Value resulting from \a u16 with toggled endianism.
*
* \note More optimized if only used with values unknown at compile time.
*/
#if (defined __GNUC__)
# if (!defined __OPTIMIZE_SIZE__) || !__OPTIMIZE_SIZE__
#define swap16(u16) ((U16)__builtin_bswap_16((U16)(u16)))
# else
// swap_16 must be not used when GCC's -Os command option is used
#define swap16(u16) Swap16(u16)
# endif
#elif (defined __ICCAVR32__)
#define swap16(u16) ((U16)__swap_bytes_in_halfwords((U16)(u16)))
#endif
/*! \brief Toggles the endianism of \a u32 (by swapping its bytes).
*
* \param u32 U32 of which to toggle the endianism.
*
* \return Value resulting from \a u32 with toggled endianism.
*
* \note More optimized if only used with values unknown at compile time.
*/
#if (defined __GNUC__)
#define swap32(u32) ((U32)__builtin_bswap_32((U32)(u32)))
#elif (defined __ICCAVR32__)
#define swap32(u32) ((U32)__swap_bytes((U32)(u32)))
#endif
/*! \brief Toggles the endianism of \a u64 (by swapping its bytes).
*
* \param u64 U64 of which to toggle the endianism.
*
* \return Value resulting from \a u64 with toggled endianism.
*
* \note More optimized if only used with values unknown at compile time.
*/
#define swap64(u64) ((U64)(((U64)swap32((U64)(u64) >> 32)) |\
((U64)swap32((U64)(u64)) << 32)))
//! @}
/*! \name Target Abstraction
*/
//! @{
#define _GLOBEXT_ extern //!< extern storage-class specifier.
#define _CONST_TYPE_ const //!< const type qualifier.
#define _MEM_TYPE_SLOW_ //!< Slow memory type.
#define _MEM_TYPE_MEDFAST_ //!< Fairly fast memory type.
#define _MEM_TYPE_FAST_ //!< Fast memory type.
typedef U8 Byte; //!< 8-bit unsigned integer.
#define memcmp_ram2ram memcmp //!< Target-specific memcmp of RAM to RAM.
#define memcmp_code2ram memcmp //!< Target-specific memcmp of RAM to NVRAM.
#define memcpy_ram2ram memcpy //!< Target-specific memcpy from RAM to RAM.
#define memcpy_code2ram memcpy //!< Target-specific memcpy from NVRAM to RAM.
#define LSB0(u32) LSB0W(u32) //!< Least significant byte of 1st rank of \a u32.
#define LSB1(u32) LSB1W(u32) //!< Least significant byte of 2nd rank of \a u32.
#define LSB2(u32) LSB2W(u32) //!< Least significant byte of 3rd rank of \a u32.
#define LSB3(u32) LSB3W(u32) //!< Least significant byte of 4th rank of \a u32.
#define MSB3(u32) MSB3W(u32) //!< Most significant byte of 4th rank of \a u32.
#define MSB2(u32) MSB2W(u32) //!< Most significant byte of 3rd rank of \a u32.
#define MSB1(u32) MSB1W(u32) //!< Most significant byte of 2nd rank of \a u32.
#define MSB0(u32) MSB0W(u32) //!< Most significant byte of 1st rank of \a u32.
//! @}
/**
* \brief Calculate \f$ \left\lceil \frac{a}{b} \right\rceil \f$ using
* integer arithmetic.
*
* \param a An integer
* \param b Another integer
*
* \return (\a a / \a b) rounded up to the nearest integer.
*/
#define div_ceil(a, b) (((a) + (b) - 1) / (b))
#if (defined __GNUC__)
#define SHORTENUM __attribute__ ((packed))
#elif (defined __ICCAVR32__)
#define SHORTENUM /**/
#endif
#define FUNC_PTR void *
#if (defined __GNUC__)
#define FLASH_DECLARE(x) const x
#elif (defined __ICCAVR32__)
#define FLASH_DECLARE(x) x
#endif
#if (defined __GNUC__)
#define FLASH_EXTERN(x) extern const x
#elif (defined __ICCAVR32__)
#define FLASH_EXTERN(x) extern x
#endif
/*Program Memory Space Storage abstraction definition*/
#if (defined __GNUC__)
#define CMD_ID_OCTET (0)
#elif (defined __ICCAVR32__)
#define CMD_ID_OCTET (3)
#endif
/* Converting of values from CPU endian to little endian. */
#define CPU_ENDIAN_TO_LE16(x) swap16(x)
#define CPU_ENDIAN_TO_LE32(x) swap32(x)
#define CPU_ENDIAN_TO_LE64(x) swap64(x)
/* Converting of values from little endian to CPU endian. */
#define LE16_TO_CPU_ENDIAN(x) swap16(x)
#define LE32_TO_CPU_ENDIAN(x) swap32(x)
#define LE64_TO_CPU_ENDIAN(x) swap64(x)
/* Converting of constants from CPU endian to little endian. */
#define CCPU_ENDIAN_TO_LE16(x) ((uint16_t)(\
(((uint16_t)(x) & (uint16_t)0x00ffU) << 8) | \
(((uint16_t)(x) & (uint16_t)0xff00U) >> 8)))
#define CCPU_ENDIAN_TO_LE32(x) ((uint32_t)(\
(((uint32_t)(x) & (uint32_t)0x000000ffUL) << 24) | \
(((uint32_t)(x) & (uint32_t)0x0000ff00UL) << 8) | \
(((uint32_t)(x) & (uint32_t)0x00ff0000UL) >> 8) | \
(((uint32_t)(x) & (uint32_t)0xff000000UL) >> 24)))
#define CCPU_ENDIAN_TO_LE64(x) ((uint64_t)(\
(((uint64_t)(x) & (uint64_t)0x00000000000000ffULL) << 56) | \
(((uint64_t)(x) & (uint64_t)0x000000000000ff00ULL) << 40) | \
(((uint64_t)(x) & (uint64_t)0x0000000000ff0000ULL) << 24) | \
(((uint64_t)(x) & (uint64_t)0x00000000ff000000ULL) << 8) | \
(((uint64_t)(x) & (uint64_t)0x000000ff00000000ULL) >> 8) | \
(((uint64_t)(x) & (uint64_t)0x0000ff0000000000ULL) >> 24) | \
(((uint64_t)(x) & (uint64_t)0x00ff000000000000ULL) >> 40) | \
(((uint64_t)(x) & (uint64_t)0xff00000000000000ULL) >> 56)))
/* Converting of constants from little endian to CPU endian. */
#define CLE16_TO_CPU_ENDIAN(x) CCPU_ENDIAN_TO_LE16(x)
#define CLE32_TO_CPU_ENDIAN(x) CCPU_ENDIAN_TO_LE32(x)
#define CLE64_TO_CPU_ENDIAN(x) CCPU_ENDIAN_TO_LE64(x)
/**
* Address copy from the source to the Destination Memory
*/
#define ADDR_COPY_DST_SRC_16(dst, src) memcpy((&(dst)), (&(src)), sizeof(uint16_t))
#define ADDR_COPY_DST_SRC_64(dst, src) do {dst=src;}while(0)
#define MEMCPY_ENDIAN memcpy_be
#ifndef FREERTOS_USED
#if (EXT_BOARD != SPB104)
#ifndef BIG_ENDIAN
#define BIG_ENDIAN
#endif
#endif
#endif
/* Converts a 8 Byte array into a 64-Bit value */
static inline uint64_t convert_byte_array_to_64_bit(uint8_t *data)
{
union
{
uint64_t u64;
uint8_t u8[8];
}long_addr;
uint8_t index;
for (index = 0; index <= 7; index++)
{
long_addr.u8[index] = *data++;
}
return long_addr.u64;
}
/* Converts a 64-Bit value into a 2 Byte array */
#define convert_64_bit_to_byte_array(value, data) \
memcpy((data), (&(value)), sizeof(uint64_t))
/* Converts a 2 Byte array into a 16-Bit value */
static inline uint16_t convert_byte_array_to_16_bit(uint8_t *data)
{
return (data[1] | ((uint16_t)data[0] << 8));
}
/* Converts a 16-Bit value into a 2 Byte array */
static inline void convert_16_bit_to_byte_array(uint16_t value, uint8_t *data)
{
data[1] = value & 0xFF;
data[0] = (value >> 8) & 0xFF;
}
/* Converts a 8 Byte array into a 32-Bit value */
static inline uint32_t convert_byte_array_to_32_bit(uint8_t *data)
{
union
{
uint32_t u32;
uint8_t u8[8];
}long_addr;
uint8_t index;
for (index = 0; index < 4; index++)
{
long_addr.u8[index] = *data++;
}
return long_addr.u32;
}
/* Converts a 32-Bit value into a 2 Byte array */
#define convert_32_bit_to_byte_array(value, data) \
memcpy((data), (&(value)), sizeof(uint32_t))
/* Converts a 16-Bit value into a 2 Byte array */
static inline void convert_spec_16_bit_to_byte_array(uint16_t value, uint8_t *data)
{
data[0] = value & 0xFF;
data[1] = (value >> 8) & 0xFF;
}
/* Converts a 16-Bit value into a 2 Byte array */
static inline void convert_16_bit_to_byte_address(uint64_t value, uint8_t *data)
{
data[1] = (value >> 48) & 0xFF;
data[0] = (value >> 56) & 0xFF;
}
#define PGM_READ_BYTE(x) *(x)
#define PGM_READ_WORD(x) *(x)
#define PGM_READ_BLOCK(dst, src, len) memcpy((dst), (src), (len))
#if (defined __GNUC__)
#define nop() do { __asm__ __volatile__ ("nop"); } while (0)
#elif (defined __ICCAVR32__)
#define nop() __no_operation()
#endif
/* Copy char s2[n] to s1[n] in any order */
static inline void *memcpy_be(void *s1, const void *s2, char n)
{
char *su1 = (char *)s1;
const char *su2 = (const char *)s2;
signed char count = 0x00, count1 = 0x00;
if ((n - 1) == 0)
{
*(su1 + count1) = *(su2 + count);
}
for (count = (n - 1), count1 = 0; count >= 0;)
{
*(su1 + count1++) = *(su2 + count--);
}
return (s1);
}
/**
* \}
*/
#endif // __AVR32_ABI_COMPILER__
#endif // _COMPILER_AVR32_H_