See Common PLATFORM_HEADER Configuration for detailed documentation.

License#

Copyright 2018 Silicon Laboratories Inc. www.silabs.com

The licensor of this software is Silicon Laboratories Inc. Your use of this software is governed by the terms of Silicon Labs Master Software License Agreement (MSLA) available at www.silabs.com/about-us/legal/master-software-license-agreement. This software is distributed to you in Source Code format and is governed by the sections of the MSLA applicable to Source Code.

/***************************************************************************/
#ifndef __PLATFORMCOMMON_H__
#define __PLATFORMCOMMON_H__

#ifndef PLATCOMMONOKTOINCLUDE
//  This header should only be included by a PLATFORM_HEADER
  #error  platform-common.h should not be included directly
#endif

// Many of the common definitions must be explicitly enabled by the
//  particular PLATFORM_HEADER being used

#ifndef DOXYGEN_SHOULD_SKIP_THIS
// The XAP2b compiler uses these macros to enable and disable placement
// in zero-page memory.  All other platforms do not have zero-page memory
// so these macros define to nothing.
#ifndef _HAL_USING_XAP2B_PRAGMAS_
  #define XAP2B_PAGEZERO_ON
  #define XAP2B_PAGEZERO_OFF
#endif
#endif //DOXYGEN_SHOULD_SKIP_THIS

#ifdef _HAL_USE_COMMON_PGM_


  #define PGM     const

  #define PGM_P   const char *

  #define PGM_PU  const unsigned char *

  #define PGM_NO_CONST
#endif //_HAL_USE_COMMON_PGM_

#ifdef _HAL_USE_COMMON_DIVMOD_


  #define halCommonUDiv32By16(x, y) ((uint16_t) (((uint32_t) (x)) / ((uint16_t) (y))))

  #define halCommonSDiv32By16(x, y) ((int16_t) (((int32_t) (x)) / ((int16_t) (y))))

  #define halCommonUMod32By16(x, y) ((uint16_t) (((uint32_t) (x)) % ((uint16_t) (y))))

  #define halCommonSMod32By16(x, y) ((int16_t) (((int32_t) (x)) % ((int16_t) (y))))
#endif //_HAL_USE_COMMON_DIVMOD_

#ifdef _HAL_USE_COMMON_MEMUTILS_


void halCommonMemMove(void *dest, const void *src, uint16_t bytes);

void halCommonMemSet(void *dest, uint8_t val, uint16_t bytes);

int16_t halCommonMemCompare(const void *source0, const void *source1, uint16_t bytes);

int8_t halCommonMemPGMCompare(const void *source0, const void PGM_NO_CONST *source1, uint16_t bytes);

void halCommonMemPGMCopy(void* dest, const void PGM_NO_CONST *source, uint16_t bytes);

  #define MEMSET(d, v, l)  halCommonMemSet(d, v, l)
  #define MEMCOPY(d, s, l) halCommonMemMove(d, s, l)
  #define MEMMOVE(d, s, l) halCommonMemMove(d, s, l)
  #define MEMPGMCOPY(d, s, l) halCommonMemPGMCopy(d, s, l)
  #define MEMCOMPARE(s0, s1, l) halCommonMemCompare(s0, s1, l)
  #define MEMPGMCOMPARE(s0, s1, l) halCommonMemPGMCompare(s0, s1, l)

#else

#include <string.h>
  #define MEMSET(d, v, l)  memset(d, v, l)
  #define MEMCOPY(d, s, l) memcpy(d, s, l)
  #define MEMMOVE(d, s, l) memmove(d, s, l)
  #define MEMPGMCOPY(d, s, l) memcpy(d, s, l)
  #define MEMCOMPARE(s0, s1, l) memcmp(s0, s1, l)
  #define MEMPGMCOMPARE(s0, s1, l) memcmp(s0, s1, l)
#endif //_HAL_USE_COMMON_MEMUTILS_

//  The following sections are common on all platforms


#define TRUE  1

#define FALSE 0

#ifndef NULL

#define NULL ((void *)0)
#endif



#define BIT(x) (1U << (x))  // Unsigned avoids compiler warnings re BIT(15)

#define BIT32(x) (((uint32_t) 1) << (x))

#define SETBIT(reg, bit)      (reg) |= BIT(bit)

#define SETBITS(reg, bits)    (reg) |= (bits)

#define CLEARBIT(reg, bit)    (reg) &= ~(BIT(bit))

#define CLEARBITS(reg, bits)  (reg) &= ~(bits)

#define READBIT(reg, bit)     ((reg) & (BIT(bit)))

#define READBITS(reg, bits)   ((reg) & (bits))




#define LOW_BYTE(n)                     ((uint8_t)(n))

#define HIGH_BYTE(n)                    LOW_BYTE((n) >> 8)

#define HIGH_LOW_TO_INT(high, low) (        \
    ((uint16_t) (((uint16_t) (high)) << 8)) \
    + ((uint16_t) ((low) & 0xFFu))          \
    )

#define INT8U_TO_INT32U(byte3, byte2, byte1, byte0) ( \
    (((uint32_t) (byte3)) << 24)                      \
    + (((uint32_t) (byte2)) << 16)                    \
    + (((uint32_t) (byte1)) << 8)                     \
    + ((uint32_t) ((byte0) & 0xFFu))                  \
    )

#define BYTE_0(n)                    ((uint8_t)(n))

#define BYTE_1(n)                    BYTE_0((n) >> 8)

#define BYTE_2(n)                    BYTE_0((n) >> 16)

#define BYTE_3(n)                    BYTE_0((n) >> 24)

#define BYTE_4(n)                    BYTE_0((n) >> 32)

#define BYTE_5(n)                    BYTE_0((n) >> 40)

#define BYTE_6(n)                    BYTE_0((n) >> 48)

#define BYTE_7(n)                    BYTE_0((n) >> 56)

#define COUNTOF(a) (sizeof(a) / sizeof(a[0]))




#define elapsedTimeInt8u(oldTime, newTime) \
  ((uint8_t) ((uint8_t)(newTime) - (uint8_t)(oldTime)))

#define elapsedTimeInt16u(oldTime, newTime) \
  ((uint16_t) ((uint16_t)(newTime) - (uint16_t)(oldTime)))

#define elapsedTimeInt32u(oldTime, newTime) \
  ((uint32_t) ((uint32_t)(newTime) - (uint32_t)(oldTime)))

#define MAX_INT8U_VALUE       (0xFF)
#define HALF_MAX_INT8U_VALUE  (0x80)
#define timeGTorEqualInt8u(t1, t2) \
  (elapsedTimeInt8u(t2, t1) <= (HALF_MAX_INT8U_VALUE))

#define MAX_INT16U_VALUE      (0xFFFF)
#define HALF_MAX_INT16U_VALUE (0x8000)
#define timeGTorEqualInt16u(t1, t2) \
  (elapsedTimeInt16u(t2, t1) <= (HALF_MAX_INT16U_VALUE))

#define MAX_INT32U_VALUE      (0xFFFFFFFFUL)
#define HALF_MAX_INT32U_VALUE (0x80000000UL)
#define timeGTorEqualInt32u(t1, t2) \
  (elapsedTimeInt32u(t2, t1) <= (HALF_MAX_INT32U_VALUE))




#ifndef UNUSED_VAR

#define UNUSED_VAR(x) (void)(x)
#endif

#ifdef DEBUG_OFF
// On March 17, 2014, DEBUG_OFF was deprecated and replaced by DEBUG_STRIPPED.
// Some builds still attempt to use DEBUG_OFF and as a result there are
// failures.  On 2016-10-04 implemented a little bandaid here to define
// DEBUG_STRIPPED when debugging is meant to be "off".
  #define DEBUG_STRIPPED
#endif

#ifndef DEBUG_LEVEL
  #if defined(DEBUG) && defined(DEBUG_STRIPPED)
    #error "DEBUG and DEBUG_OFF cannot be both be defined!"
  #elif defined(DEBUG)
    #define DEBUG_LEVEL FULL_DEBUG
  #elif defined(DEBUG_STRIPPED)
    #define DEBUG_LEVEL NO_DEBUG
  #else
    #define DEBUG_LEVEL BASIC_DEBUG
  #endif
#endif

#ifndef STATIC_ASSERT
  #define STATIC_ASSERT(__condition, __errorstr)
#endif


#endif //__PLATFORMCOMMON_H__