1361 lines
62 KiB
C
1361 lines
62 KiB
C
/*
|
|
*********************************************************************************************************
|
|
* uC/LIB
|
|
* Custom Library Modules
|
|
*
|
|
* Copyright 2004-2021 Silicon Laboratories Inc. www.silabs.com
|
|
*
|
|
* SPDX-License-Identifier: APACHE-2.0
|
|
*
|
|
* This software is subject to an open source license and is distributed by
|
|
* Silicon Laboratories Inc. pursuant to the terms of the Apache License,
|
|
* Version 2.0 available at www.apache.org/licenses/LICENSE-2.0.
|
|
*
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
*
|
|
* CORE CUSTOM LIBRARY MODULE
|
|
*
|
|
* Filename : lib_def.h
|
|
* Version : V1.39.01
|
|
*********************************************************************************************************
|
|
* Note(s) : (1) Assumes the following versions (or more recent) of software modules are included in
|
|
* the project build :
|
|
*
|
|
* (a) uC/CPU V1.29.00
|
|
*
|
|
*
|
|
* (2) NO compiler-supplied standard library functions are used in library or product software.
|
|
*
|
|
* (a) ALL standard library functions are implemented in the custom library modules :
|
|
*
|
|
* (1) \<Custom Library Directory>\lib_*.*
|
|
*
|
|
* (2) \<Custom Library Directory>\Ports\<cpu>\<compiler>\lib*_a.*
|
|
*
|
|
* where
|
|
* <Custom Library Directory> directory path for custom library software
|
|
* <cpu> directory name for specific processor (CPU)
|
|
* <compiler> directory name for specific compiler
|
|
*
|
|
* (b) Product-specific library functions are implemented in individual products.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* MODULE
|
|
*
|
|
* Note(s) : (1) This library definition header file is protected from multiple pre-processor inclusion
|
|
* through use of the library definition module present pre-processor macro definition.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#ifndef LIB_DEF_MODULE_PRESENT
|
|
#define LIB_DEF_MODULE_PRESENT
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* CUSTOM LIBRARY MODULE VERSION NUMBER
|
|
*
|
|
* Note(s) : (1) (a) The custom library module software version is denoted as follows :
|
|
*
|
|
* Vx.yy.zz
|
|
*
|
|
* where
|
|
* V denotes 'Version' label
|
|
* x denotes major software version revision number
|
|
* yy denotes minor software version revision number
|
|
* zz denotes sub-minor software version revision number
|
|
*
|
|
* (b) The software version label #define is formatted as follows :
|
|
*
|
|
* ver = x.yyzz * 100 * 100
|
|
*
|
|
* where
|
|
* ver denotes software version number scaled as an integer value
|
|
* x.yyzz denotes software version number, where the unscaled integer
|
|
* portion denotes the major version number & the unscaled
|
|
* fractional portion denotes the (concatenated) minor
|
|
* version numbers
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define LIB_VERSION 13901u /* See Note #1. */
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* INCLUDE FILES
|
|
*
|
|
* Note(s) : (1) The custom library software files are located in the following directories :
|
|
*
|
|
* (a) \<Custom Library Directory>\lib_*.*
|
|
*
|
|
* where
|
|
* <Custom Library Directory> directory path for custom library software
|
|
*
|
|
* (2) CPU-configuration software files are located in the following directories :
|
|
*
|
|
* (a) \<CPU-Compiler Directory>\cpu_*.*
|
|
* (b) \<CPU-Compiler Directory>\<cpu>\<compiler>\cpu*.*
|
|
*
|
|
* where
|
|
* <CPU-Compiler Directory> directory path for common CPU-compiler software
|
|
* <cpu> directory name for specific processor (CPU)
|
|
* <compiler> directory name for specific compiler
|
|
*
|
|
* (3) Compiler MUST be configured to include as additional include path directories :
|
|
*
|
|
* (a) '\<Custom Library Directory>\' directory See Note #1a
|
|
*
|
|
* (b) (1) '\<CPU-Compiler Directory>\' directory See Note #2a
|
|
* (2) '\<CPU-Compiler Directory>\<cpu>\<compiler>\' directory See Note #2b
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#include <cpu_def.h>
|
|
#include <cpu.h>
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* STANDARD DEFINES
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_NULL 0
|
|
|
|
|
|
/* ----------------- BOOLEAN DEFINES ------------------ */
|
|
#define DEF_FALSE 0u
|
|
#define DEF_TRUE 1u
|
|
|
|
#define DEF_NO 0u
|
|
#define DEF_YES 1u
|
|
|
|
#define DEF_DISABLED 0u
|
|
#define DEF_ENABLED 1u
|
|
|
|
#define DEF_INACTIVE 0u
|
|
#define DEF_ACTIVE 1u
|
|
|
|
#define DEF_INVALID 0u
|
|
#define DEF_VALID 1u
|
|
|
|
#define DEF_OFF 0u
|
|
#define DEF_ON 1u
|
|
|
|
#define DEF_CLR 0u
|
|
#define DEF_SET 1u
|
|
|
|
#define DEF_FAIL 0u
|
|
#define DEF_OK 1u
|
|
|
|
|
|
/* ------------------- BIT DEFINES -------------------- */
|
|
#define DEF_BIT_NONE 0x00u
|
|
|
|
#define DEF_BIT_00 0x01u
|
|
#define DEF_BIT_01 0x02u
|
|
#define DEF_BIT_02 0x04u
|
|
#define DEF_BIT_03 0x08u
|
|
#define DEF_BIT_04 0x10u
|
|
#define DEF_BIT_05 0x20u
|
|
#define DEF_BIT_06 0x40u
|
|
#define DEF_BIT_07 0x80u
|
|
|
|
#define DEF_BIT_08 0x0100u
|
|
#define DEF_BIT_09 0x0200u
|
|
#define DEF_BIT_10 0x0400u
|
|
#define DEF_BIT_11 0x0800u
|
|
#define DEF_BIT_12 0x1000u
|
|
#define DEF_BIT_13 0x2000u
|
|
#define DEF_BIT_14 0x4000u
|
|
#define DEF_BIT_15 0x8000u
|
|
|
|
#define DEF_BIT_16 0x00010000u
|
|
#define DEF_BIT_17 0x00020000u
|
|
#define DEF_BIT_18 0x00040000u
|
|
#define DEF_BIT_19 0x00080000u
|
|
#define DEF_BIT_20 0x00100000u
|
|
#define DEF_BIT_21 0x00200000u
|
|
#define DEF_BIT_22 0x00400000u
|
|
#define DEF_BIT_23 0x00800000u
|
|
|
|
#define DEF_BIT_24 0x01000000u
|
|
#define DEF_BIT_25 0x02000000u
|
|
#define DEF_BIT_26 0x04000000u
|
|
#define DEF_BIT_27 0x08000000u
|
|
#define DEF_BIT_28 0x10000000u
|
|
#define DEF_BIT_29 0x20000000u
|
|
#define DEF_BIT_30 0x40000000u
|
|
#define DEF_BIT_31 0x80000000u
|
|
#define DEF_BIT_32 0x0000000100000000u
|
|
#define DEF_BIT_33 0x0000000200000000u
|
|
#define DEF_BIT_34 0x0000000400000000u
|
|
#define DEF_BIT_35 0x0000000800000000u
|
|
#define DEF_BIT_36 0x0000001000000000u
|
|
#define DEF_BIT_37 0x0000002000000000u
|
|
#define DEF_BIT_38 0x0000004000000000u
|
|
#define DEF_BIT_39 0x0000008000000000u
|
|
|
|
#define DEF_BIT_40 0x0000010000000000u
|
|
#define DEF_BIT_41 0x0000020000000000u
|
|
#define DEF_BIT_42 0x0000040000000000u
|
|
#define DEF_BIT_43 0x0000080000000000u
|
|
#define DEF_BIT_44 0x0000100000000000u
|
|
#define DEF_BIT_45 0x0000200000000000u
|
|
#define DEF_BIT_46 0x0000400000000000u
|
|
#define DEF_BIT_47 0x0000800000000000u
|
|
|
|
#define DEF_BIT_48 0x0001000000000000u
|
|
#define DEF_BIT_49 0x0002000000000000u
|
|
#define DEF_BIT_50 0x0004000000000000u
|
|
#define DEF_BIT_51 0x0008000000000000u
|
|
#define DEF_BIT_52 0x0010000000000000u
|
|
#define DEF_BIT_53 0x0020000000000000u
|
|
#define DEF_BIT_54 0x0040000000000000u
|
|
#define DEF_BIT_55 0x0080000000000000u
|
|
|
|
#define DEF_BIT_56 0x0100000000000000u
|
|
#define DEF_BIT_57 0x0200000000000000u
|
|
#define DEF_BIT_58 0x0400000000000000u
|
|
#define DEF_BIT_59 0x0800000000000000u
|
|
#define DEF_BIT_60 0x1000000000000000u
|
|
#define DEF_BIT_61 0x2000000000000000u
|
|
#define DEF_BIT_62 0x4000000000000000u
|
|
#define DEF_BIT_63 0x8000000000000000u
|
|
|
|
|
|
/* ------------------ ALIGN DEFINES ------------------- */
|
|
#define DEF_ALIGN_MAX_NBR_OCTETS 4096u
|
|
|
|
|
|
/* ------------------ OCTET DEFINES ------------------- */
|
|
#define DEF_OCTET_NBR_BITS 8u
|
|
#define DEF_OCTET_MASK 0xFFu
|
|
|
|
#define DEF_OCTET_TO_BIT_NBR_BITS 3u
|
|
#define DEF_OCTET_TO_BIT_SHIFT DEF_OCTET_TO_BIT_NBR_BITS
|
|
#define DEF_OCTET_TO_BIT_MASK 0x07u
|
|
|
|
|
|
#define DEF_NIBBLE_NBR_BITS 4u
|
|
#define DEF_NIBBLE_MASK 0x0Fu
|
|
|
|
|
|
/* --------------- NUMBER BASE DEFINES ---------------- */
|
|
#define DEF_NBR_BASE_BIN 2u
|
|
#define DEF_NBR_BASE_OCT 8u
|
|
#define DEF_NBR_BASE_DEC 10u
|
|
#define DEF_NBR_BASE_HEX 16u
|
|
|
|
|
|
/* ----------------- INTEGER DEFINES ------------------ */
|
|
#define DEF_INT_08_NBR_BITS 8u
|
|
#define DEF_INT_08_MASK 0xFFu
|
|
|
|
#define DEF_INT_08U_MIN_VAL 0u
|
|
#define DEF_INT_08U_MAX_VAL 255u
|
|
|
|
#define DEF_INT_08S_MIN_VAL_ONES_CPL (-127)
|
|
#define DEF_INT_08S_MAX_VAL_ONES_CPL 127
|
|
|
|
#define DEF_INT_08S_MIN_VAL (DEF_INT_08S_MIN_VAL_ONES_CPL - 1)
|
|
#define DEF_INT_08S_MAX_VAL DEF_INT_08S_MAX_VAL_ONES_CPL
|
|
|
|
#define DEF_INT_08U_NBR_DIG_MIN 1u
|
|
#define DEF_INT_08U_NBR_DIG_MAX 3u
|
|
|
|
#define DEF_INT_08S_NBR_DIG_MIN 3u
|
|
#define DEF_INT_08S_NBR_DIG_MAX 3u
|
|
|
|
|
|
|
|
#define DEF_INT_16_NBR_BITS 16u
|
|
#define DEF_INT_16_MASK 0xFFFFu
|
|
|
|
#define DEF_INT_16U_MIN_VAL 0u
|
|
#define DEF_INT_16U_MAX_VAL 65535u
|
|
|
|
#define DEF_INT_16S_MIN_VAL_ONES_CPL (-32767)
|
|
#define DEF_INT_16S_MAX_VAL_ONES_CPL 32767
|
|
|
|
#define DEF_INT_16S_MIN_VAL (DEF_INT_16S_MIN_VAL_ONES_CPL - 1)
|
|
#define DEF_INT_16S_MAX_VAL DEF_INT_16S_MAX_VAL_ONES_CPL
|
|
|
|
#define DEF_INT_16U_NBR_DIG_MIN 1u
|
|
#define DEF_INT_16U_NBR_DIG_MAX 5u
|
|
|
|
#define DEF_INT_16S_NBR_DIG_MIN 5u
|
|
#define DEF_INT_16S_NBR_DIG_MAX 5u
|
|
|
|
|
|
|
|
#define DEF_INT_32_NBR_BITS 32u
|
|
#define DEF_INT_32_MASK 0xFFFFFFFFu
|
|
|
|
#define DEF_INT_32U_MIN_VAL 0u
|
|
#define DEF_INT_32U_MAX_VAL 4294967295u
|
|
|
|
#define DEF_INT_32S_MIN_VAL_ONES_CPL (-2147483647)
|
|
#define DEF_INT_32S_MAX_VAL_ONES_CPL 2147483647
|
|
|
|
#define DEF_INT_32S_MIN_VAL (DEF_INT_32S_MIN_VAL_ONES_CPL - 1)
|
|
#define DEF_INT_32S_MAX_VAL DEF_INT_32S_MAX_VAL_ONES_CPL
|
|
|
|
#define DEF_INT_32U_NBR_DIG_MIN 1u
|
|
#define DEF_INT_32U_NBR_DIG_MAX 10u
|
|
|
|
#define DEF_INT_32S_NBR_DIG_MIN 10u
|
|
#define DEF_INT_32S_NBR_DIG_MAX 10u
|
|
|
|
|
|
|
|
#define DEF_INT_64_NBR_BITS 64u
|
|
#define DEF_INT_64_MASK 0xFFFFFFFFFFFFFFFFu
|
|
|
|
#define DEF_INT_64U_MIN_VAL 0u
|
|
#define DEF_INT_64U_MAX_VAL 18446744073709551615u
|
|
|
|
#define DEF_INT_64S_MIN_VAL_ONES_CPL (-9223372036854775807)
|
|
#define DEF_INT_64S_MAX_VAL_ONES_CPL 9223372036854775807
|
|
|
|
#define DEF_INT_64S_MIN_VAL (DEF_INT_64S_MIN_VAL_ONES_CPL - 1)
|
|
#define DEF_INT_64S_MAX_VAL DEF_INT_64S_MAX_VAL_ONES_CPL
|
|
|
|
#define DEF_INT_64U_NBR_DIG_MIN 1u
|
|
#define DEF_INT_64U_NBR_DIG_MAX 20u
|
|
|
|
#define DEF_INT_64S_NBR_DIG_MIN 19u
|
|
#define DEF_INT_64S_NBR_DIG_MAX 19u
|
|
|
|
|
|
/* --------------- CPU INTEGER DEFINES ---------------- */
|
|
#define DEF_INT_CPU_NBR_BITS (CPU_CFG_DATA_SIZE * DEF_OCTET_NBR_BITS)
|
|
#define DEF_INT_CPU_NBR_BITS_MAX (CPU_CFG_DATA_SIZE_MAX * DEF_OCTET_NBR_BITS)
|
|
|
|
|
|
|
|
#if (DEF_INT_CPU_NBR_BITS == DEF_INT_08_NBR_BITS)
|
|
|
|
|
|
#define DEF_INT_CPU_MASK DEF_INT_08_MASK
|
|
|
|
#define DEF_INT_CPU_U_MIN_VAL DEF_INT_08U_MIN_VAL
|
|
#define DEF_INT_CPU_U_MAX_VAL DEF_INT_08U_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL DEF_INT_08S_MIN_VAL
|
|
#define DEF_INT_CPU_S_MAX_VAL DEF_INT_08S_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL_ONES_CPL DEF_INT_08S_MIN_VAL_ONES_CPL
|
|
#define DEF_INT_CPU_S_MAX_VAL_ONES_CPL DEF_INT_08S_MAX_VAL_ONES_CPL
|
|
|
|
|
|
|
|
#elif (DEF_INT_CPU_NBR_BITS == DEF_INT_16_NBR_BITS)
|
|
|
|
|
|
#define DEF_INT_CPU_MASK DEF_INT_16_MASK
|
|
|
|
#define DEF_INT_CPU_U_MIN_VAL DEF_INT_16U_MIN_VAL
|
|
#define DEF_INT_CPU_U_MAX_VAL DEF_INT_16U_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL DEF_INT_16S_MIN_VAL
|
|
#define DEF_INT_CPU_S_MAX_VAL DEF_INT_16S_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL_ONES_CPL DEF_INT_16S_MIN_VAL_ONES_CPL
|
|
#define DEF_INT_CPU_S_MAX_VAL_ONES_CPL DEF_INT_16S_MAX_VAL_ONES_CPL
|
|
|
|
|
|
|
|
#elif (DEF_INT_CPU_NBR_BITS == DEF_INT_32_NBR_BITS)
|
|
|
|
|
|
#define DEF_INT_CPU_MASK DEF_INT_32_MASK
|
|
|
|
#define DEF_INT_CPU_U_MIN_VAL DEF_INT_32U_MIN_VAL
|
|
#define DEF_INT_CPU_U_MAX_VAL DEF_INT_32U_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL DEF_INT_32S_MIN_VAL
|
|
#define DEF_INT_CPU_S_MAX_VAL DEF_INT_32S_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL_ONES_CPL DEF_INT_32S_MIN_VAL_ONES_CPL
|
|
#define DEF_INT_CPU_S_MAX_VAL_ONES_CPL DEF_INT_32S_MAX_VAL_ONES_CPL
|
|
|
|
|
|
|
|
#elif (DEF_INT_CPU_NBR_BITS == DEF_INT_64_NBR_BITS)
|
|
|
|
|
|
#define DEF_INT_CPU_MASK DEF_INT_64_MASK
|
|
|
|
#define DEF_INT_CPU_U_MIN_VAL DEF_INT_64U_MIN_VAL
|
|
#define DEF_INT_CPU_U_MAX_VAL DEF_INT_64U_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL DEF_INT_64S_MIN_VAL
|
|
#define DEF_INT_CPU_S_MAX_VAL DEF_INT_64S_MAX_VAL
|
|
|
|
#define DEF_INT_CPU_S_MIN_VAL_ONES_CPL DEF_INT_64S_MIN_VAL_ONES_CPL
|
|
#define DEF_INT_CPU_S_MAX_VAL_ONES_CPL DEF_INT_64S_MAX_VAL_ONES_CPL
|
|
|
|
|
|
|
|
#else
|
|
|
|
#error "CPU_CFG_DATA_SIZE illegally #defined in 'cpu.h' "
|
|
#error " [See 'cpu.h CONFIGURATION ERRORS']"
|
|
|
|
#endif
|
|
|
|
|
|
/* ------------------- TIME DEFINES ------------------- */
|
|
#define DEF_TIME_NBR_DAY_PER_WK 7u
|
|
#define DEF_TIME_NBR_DAY_PER_YR 365u
|
|
#define DEF_TIME_NBR_DAY_PER_YR_LEAP 366u
|
|
|
|
#define DEF_TIME_NBR_HR_PER_DAY 24u
|
|
#define DEF_TIME_NBR_HR_PER_WK (DEF_TIME_NBR_HR_PER_DAY * DEF_TIME_NBR_DAY_PER_WK )
|
|
#define DEF_TIME_NBR_HR_PER_YR (DEF_TIME_NBR_HR_PER_DAY * DEF_TIME_NBR_DAY_PER_YR )
|
|
#define DEF_TIME_NBR_HR_PER_YR_LEAP (DEF_TIME_NBR_HR_PER_DAY * DEF_TIME_NBR_DAY_PER_YR_LEAP)
|
|
|
|
#define DEF_TIME_NBR_MIN_PER_HR 60u
|
|
#define DEF_TIME_NBR_MIN_PER_DAY (DEF_TIME_NBR_MIN_PER_HR * DEF_TIME_NBR_HR_PER_DAY )
|
|
#define DEF_TIME_NBR_MIN_PER_WK (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_WK )
|
|
#define DEF_TIME_NBR_MIN_PER_YR (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_YR )
|
|
#define DEF_TIME_NBR_MIN_PER_YR_LEAP (DEF_TIME_NBR_MIN_PER_DAY * DEF_TIME_NBR_DAY_PER_YR_LEAP)
|
|
|
|
#define DEF_TIME_NBR_SEC_PER_MIN 60u
|
|
#define DEF_TIME_NBR_SEC_PER_HR (DEF_TIME_NBR_SEC_PER_MIN * DEF_TIME_NBR_MIN_PER_HR )
|
|
#define DEF_TIME_NBR_SEC_PER_DAY (DEF_TIME_NBR_SEC_PER_HR * DEF_TIME_NBR_HR_PER_DAY )
|
|
#define DEF_TIME_NBR_SEC_PER_WK (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_WK )
|
|
#define DEF_TIME_NBR_SEC_PER_YR (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_YR )
|
|
#define DEF_TIME_NBR_SEC_PER_YR_LEAP (DEF_TIME_NBR_SEC_PER_DAY * DEF_TIME_NBR_DAY_PER_YR_LEAP)
|
|
|
|
#define DEF_TIME_NBR_mS_PER_SEC 1000u
|
|
#define DEF_TIME_NBR_uS_PER_SEC 1000000u
|
|
#define DEF_TIME_NBR_nS_PER_SEC 1000000000u
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* ERROR CODES
|
|
*
|
|
* Note(s) : (1) All library error codes are #define'd in 'lib_def.h';
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
typedef enum lib_err {
|
|
|
|
LIB_ERR_NONE = 0u,
|
|
|
|
LIB_MEM_ERR_NONE = 10000u,
|
|
LIB_MEM_ERR_NULL_PTR = 10001u, /* Ptr arg(s) passed NULL ptr(s). */
|
|
|
|
LIB_MEM_ERR_INVALID_MEM_SIZE = 10100u, /* Invalid mem size. */
|
|
LIB_MEM_ERR_INVALID_MEM_ALIGN = 10101u, /* Invalid mem align. */
|
|
LIB_MEM_ERR_INVALID_SEG_SIZE = 10110u, /* Invalid mem seg size. */
|
|
LIB_MEM_ERR_INVALID_SEG_OVERLAP = 10111u, /* Invalid mem seg overlaps other mem seg(s). */
|
|
LIB_MEM_ERR_INVALID_SEG_EXISTS = 10112u, /* Invalid mem seg already exists. */
|
|
LIB_MEM_ERR_INVALID_POOL = 10120u, /* Invalid mem pool. */
|
|
LIB_MEM_ERR_INVALID_BLK_NBR = 10130u, /* Invalid mem pool blk nbr. */
|
|
LIB_MEM_ERR_INVALID_BLK_SIZE = 10131u, /* Invalid mem pool blk size. */
|
|
LIB_MEM_ERR_INVALID_BLK_ALIGN = 10132u, /* Invalid mem pool blk align. */
|
|
LIB_MEM_ERR_INVALID_BLK_IX = 10133u, /* Invalid mem pool ix. */
|
|
LIB_MEM_ERR_INVALID_BLK_ADDR = 10135u, /* Invalid mem pool blk addr. */
|
|
LIB_MEM_ERR_INVALID_BLK_ADDR_IN_POOL = 10136u, /* Mem pool blk addr already in mem pool. */
|
|
|
|
LIB_MEM_ERR_SEG_EMPTY = 10200u, /* Mem seg empty; i.e. NO avail mem in seg. */
|
|
LIB_MEM_ERR_SEG_OVF = 10201u, /* Mem seg ovf; i.e. req'd mem ovfs rem mem in seg. */
|
|
LIB_MEM_ERR_POOL_FULL = 10205u, /* Mem pool full; i.e. all mem blks avail in mem pool. */
|
|
LIB_MEM_ERR_POOL_EMPTY = 10206u, /* Mem pool empty; i.e. NO mem blks avail in mem pool. */
|
|
LIB_MEM_ERR_POOL_UNLIMITED = 10207u, /* Mem pool is unlimited. */
|
|
|
|
LIB_MEM_ERR_HEAP_EMPTY = 10210u, /* Heap seg empty; i.e. NO avail mem in heap. */
|
|
LIB_MEM_ERR_HEAP_OVF = 10211u, /* Heap seg ovf; i.e. req'd mem ovfs rem mem in heap. */
|
|
LIB_MEM_ERR_HEAP_NOT_FOUND = 10215u, /* Heap seg NOT found. */
|
|
|
|
LIB_MEM_ERR_ADDR_OVF = 10300u /* Memory allocation exceeds address space. */
|
|
} LIB_ERR;
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DATA TYPES
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* GLOBAL VARIABLES
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* TRACING
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/* Trace level, default to TRACE_LEVEL_OFF. */
|
|
#ifndef TRACE_LEVEL_OFF
|
|
#define TRACE_LEVEL_OFF 0u
|
|
#endif
|
|
|
|
#ifndef TRACE_LEVEL_INFO
|
|
#define TRACE_LEVEL_INFO 1u
|
|
#endif
|
|
|
|
#ifndef TRACE_LEVEL_DBG
|
|
#define TRACE_LEVEL_DBG 2u
|
|
#endif
|
|
|
|
#ifndef TRACE_LEVEL_LOG
|
|
#define TRACE_LEVEL_LOG 3u
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* BIT MACRO'S
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT()
|
|
*
|
|
* Description : Create bit mask with single, specified bit set.
|
|
*
|
|
* Argument(s) : bit Bit number of bit to set.
|
|
*
|
|
* Return(s) : Bit mask with single, specified bit set.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'bit' SHOULD be a non-negative integer.
|
|
*
|
|
* (2) (a) 'bit' values that overflow the target CPU &/or compiler environment (e.g. negative
|
|
* or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT(bit) (1uL << (bit))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BITxx()
|
|
*
|
|
* Description : Create bit mask of specified bit size with single, specified bit set.
|
|
*
|
|
* Argument(s) : bit Bit number of bit to set.
|
|
*
|
|
* Return(s) : Bit mask with single, specified bit set.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'bit' SHOULD be a non-negative integer.
|
|
*
|
|
* (2) (a) 'bit' values that overflow the target CPU &/or compiler environment (e.g. negative
|
|
* or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
|
|
*
|
|
* (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
|
|
* bit constant '1' is cast to specified integer data type size.
|
|
*
|
|
* (3) Ideally, DEF_BITxx() macro's should be named DEF_BIT_xx(); however, these names already
|
|
* previously-released for bit constant #define's (see 'STANDARD DEFINES BIT DEFINES').
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT08(bit) ((CPU_INT08U)((CPU_INT08U)1u << (bit)))
|
|
|
|
#define DEF_BIT16(bit) ((CPU_INT16U)((CPU_INT16U)1u << (bit)))
|
|
|
|
#define DEF_BIT32(bit) ((CPU_INT32U)((CPU_INT32U)1u << (bit)))
|
|
|
|
#define DEF_BIT64(bit) ((CPU_INT64U)((CPU_INT64U)1u << (bit)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_MASK()
|
|
*
|
|
* Description : Shift a bit mask.
|
|
*
|
|
* Argument(s) : bit_mask Bit mask to shift.
|
|
*
|
|
* bit_shift Number of bit positions to left-shift bit mask.
|
|
*
|
|
* Return(s) : Shifted bit mask.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) (a) 'bit_mask' SHOULD be an unsigned integer.
|
|
*
|
|
* (b) 'bit_shift' SHOULD be a non-negative integer.
|
|
*
|
|
* (2) 'bit_shift' values that overflow the target CPU &/or compiler environment (e.g. negative
|
|
* or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_MASK(bit_mask, bit_shift) ((bit_mask) << (bit_shift))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_MASK_xx()
|
|
*
|
|
* Description : Shift a bit mask of specified bit size.
|
|
*
|
|
* Argument(s) : bit_mask Bit mask to shift.
|
|
*
|
|
* bit_shift Number of bit positions to left-shift bit mask.
|
|
*
|
|
* Return(s) : Shifted bit mask.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) (a) 'bit_mask' SHOULD be an unsigned integer.
|
|
*
|
|
* (b) 'bit_shift' SHOULD be a non-negative integer.
|
|
*
|
|
* (2) 'bit_shift' values that overflow the target CPU &/or compiler environment (e.g. negative
|
|
* or greater-than-CPU-data-size values) MAY generate compiler warnings &/or errors.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_MASK_08(bit_mask, bit_shift) ((CPU_INT08U)((CPU_INT08U)(bit_mask) << (bit_shift)))
|
|
|
|
#define DEF_BIT_MASK_16(bit_mask, bit_shift) ((CPU_INT16U)((CPU_INT16U)(bit_mask) << (bit_shift)))
|
|
|
|
#define DEF_BIT_MASK_32(bit_mask, bit_shift) ((CPU_INT32U)((CPU_INT32U)(bit_mask) << (bit_shift)))
|
|
|
|
#define DEF_BIT_MASK_64(bit_mask, bit_shift) ((CPU_INT64U)((CPU_INT64U)(bit_mask) << (bit_shift)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_FIELD()
|
|
*
|
|
* Description : Create & shift a contiguous bit field.
|
|
*
|
|
* Argument(s) : bit_field Number of contiguous bits to set in the bit field.
|
|
*
|
|
* bit_shift Number of bit positions to left-shift bit field.
|
|
*
|
|
* Return(s) : Shifted bit field.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'bit_field' & 'bit_shift' SHOULD be non-negative integers.
|
|
*
|
|
* (2) (a) 'bit_field'/'bit_shift' values that overflow the target CPU &/or compiler
|
|
* environment (e.g. negative or greater-than-CPU-data-size values) MAY generate
|
|
* compiler warnings &/or errors.
|
|
*
|
|
* (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
|
|
* bit constant '1' is suffixed with 'L'ong integer modifier.
|
|
*
|
|
* This may still be insufficient for CPUs &/or compilers that support 'long long'
|
|
* integer data types, in which case 'LL' integer modifier should be suffixed.
|
|
* However, since almost all 16- & 32-bit CPUs & compilers support 'long' integer
|
|
* data types but many may NOT support 'long long' integer data types, only 'long'
|
|
* integer data types & modifiers are supported.
|
|
*
|
|
* See also 'DEF_BIT_FIELD_xx() Note #1b'.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_FIELD(bit_field, bit_shift) ((((bit_field) >= DEF_INT_CPU_NBR_BITS) ? (DEF_INT_CPU_U_MAX_VAL) \
|
|
: (DEF_BIT(bit_field) - 1uL)) \
|
|
<< (bit_shift))
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_FIELD_xx()
|
|
*
|
|
* Description : Create & shift a contiguous bit field of specified bit size.
|
|
*
|
|
* Argument(s) : bit_field Number of contiguous bits to set in the bit field.
|
|
*
|
|
* bit_shift Number of bit positions to left-shift bit field.
|
|
*
|
|
* Return(s) : Shifted bit field.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'bit_field' & 'bit_shift' SHOULD be non-negative integers.
|
|
*
|
|
* (2) (a) 'bit_field'/'bit_shift' values that overflow the target CPU &/or compiler
|
|
* environment (e.g. negative or greater-than-CPU-data-size values) MAY generate
|
|
* compiler warnings &/or errors.
|
|
*
|
|
* (b) To avoid overflowing any target CPU &/or compiler's integer data type, unsigned
|
|
* bit constant '1' is cast to specified integer data type size.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_FIELD_08(bit_field, bit_shift) ((CPU_INT08U)((((CPU_INT08U)(bit_field) >= (CPU_INT08U)DEF_INT_08_NBR_BITS) ? (CPU_INT08U)(DEF_INT_08U_MAX_VAL) \
|
|
: (CPU_INT08U)(DEF_BIT08(bit_field) - (CPU_INT08U)1u)) \
|
|
<< (bit_shift)))
|
|
|
|
#define DEF_BIT_FIELD_16(bit_field, bit_shift) ((CPU_INT16U)((((CPU_INT16U)(bit_field) >= (CPU_INT16U)DEF_INT_16_NBR_BITS) ? (CPU_INT16U)(DEF_INT_16U_MAX_VAL) \
|
|
: (CPU_INT16U)(DEF_BIT16(bit_field) - (CPU_INT16U)1u)) \
|
|
<< (bit_shift)))
|
|
|
|
#define DEF_BIT_FIELD_32(bit_field, bit_shift) ((CPU_INT32U)((((CPU_INT32U)(bit_field) >= (CPU_INT32U)DEF_INT_32_NBR_BITS) ? (CPU_INT32U)(DEF_INT_32U_MAX_VAL) \
|
|
: (CPU_INT32U)(DEF_BIT32(bit_field) - (CPU_INT32U)1u)) \
|
|
<< (bit_shift)))
|
|
|
|
#define DEF_BIT_FIELD_64(bit_field, bit_shift) ((CPU_INT64U)((((CPU_INT64U)(bit_field) >= (CPU_INT64U)DEF_INT_64_NBR_BITS) ? (CPU_INT64U)(DEF_INT_64U_MAX_VAL) \
|
|
: (CPU_INT64U)(DEF_BIT64(bit_field) - (CPU_INT64U)1u)) \
|
|
<< (bit_shift)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_SET()
|
|
*
|
|
* Description : Set specified bit(s) in a value.
|
|
*
|
|
* Argument(s) : val Value to modify by setting specified bit(s).
|
|
*
|
|
* mask Mask of bits to set.
|
|
*
|
|
* Return(s) : Modified value with specified bit(s) set.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_SET(val, mask) ((val) = ((val) | (mask)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_SET_xx()
|
|
*
|
|
* Description : Set specified bit(s) in a value of specified bit size.
|
|
*
|
|
* Argument(s) : val Value to modify by setting specified bit(s).
|
|
*
|
|
* mask Mask of bits to set.
|
|
*
|
|
* Return(s) : Modified value with specified bit(s) set.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*
|
|
* (2) These macros are deprecated and should be replaced by the DEF_BIT_SET macro.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_SET_08(val, mask) (CPU_INT08U)DEF_BIT_SET((val), (CPU_INT08U)(mask))
|
|
|
|
#define DEF_BIT_SET_16(val, mask) (CPU_INT16U)DEF_BIT_SET((val), (CPU_INT16U)(mask))
|
|
|
|
#define DEF_BIT_SET_32(val, mask) (CPU_INT32U)DEF_BIT_SET((val), (CPU_INT32U)(mask))
|
|
|
|
#define DEF_BIT_SET_64(val, mask) (CPU_INT64U)DEF_BIT_SET((val), (CPU_INT64U)(mask))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_CLR_xx()
|
|
*
|
|
* Description : Clear specified bit(s) in a value of specified bit size.
|
|
*
|
|
* Argument(s) : val Value to modify by clearing specified bit(s).
|
|
*
|
|
* mask Mask of bits to clear.
|
|
*
|
|
* Return(s) : Modified value with specified bit(s) clear.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_CLR_08(val, mask) ((val) = (CPU_INT08U)(((CPU_INT08U)(val)) & (CPU_INT08U)(~((CPU_INT08U)(mask)))))
|
|
|
|
#define DEF_BIT_CLR_16(val, mask) ((val) = (CPU_INT16U)(((CPU_INT16U)(val)) & (CPU_INT16U)(~((CPU_INT16U)(mask)))))
|
|
|
|
#define DEF_BIT_CLR_32(val, mask) ((val) = (CPU_INT32U)(((CPU_INT32U)(val)) & (CPU_INT32U)(~((CPU_INT32U)(mask)))))
|
|
|
|
#define DEF_BIT_CLR_64(val, mask) ((val) = (CPU_INT64U)(((CPU_INT64U)(val)) & (CPU_INT64U)(~((CPU_INT64U)(mask)))))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_CLR()
|
|
*
|
|
* Description : Clear specified bit(s) in a value.
|
|
*
|
|
* Argument(s) : val Value to modify by clearing specified bit(s).
|
|
*
|
|
* mask Mask of bits to clear.
|
|
*
|
|
* Return(s) : Modified value with specified bit(s) clear.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_08)
|
|
|
|
#define DEF_BIT_CLR(val, mask) ((sizeof((val)) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08((val), (mask)) : 0)
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_16)
|
|
|
|
#define DEF_BIT_CLR(val, mask) ((sizeof((val)) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16((val), (mask)) : 0))
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_32)
|
|
|
|
#define DEF_BIT_CLR(val, mask) ((sizeof((val)) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32((val), (mask)) : 0)))
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_64)
|
|
|
|
#define DEF_BIT_CLR(val, mask) ((sizeof((val)) == CPU_WORD_SIZE_08) ? DEF_BIT_CLR_08((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_16) ? DEF_BIT_CLR_16((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_32) ? DEF_BIT_CLR_32((val), (mask)) : \
|
|
((sizeof((val)) == CPU_WORD_SIZE_64) ? DEF_BIT_CLR_64((val), (mask)) : 0))))
|
|
|
|
#else
|
|
|
|
#error "CPU_CFG_DATA_SIZE_MAX illegally #defined in 'cpu.h' "
|
|
#error " [See 'cpu.h CONFIGURATION ERRORS']"
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_TOGGLE()
|
|
*
|
|
* Description : Toggles specified bit(s) in a value.
|
|
*
|
|
* Argument(s) : val Value to modify by toggling specified bit(s).
|
|
*
|
|
* mask Mask of bits to toggle.
|
|
*
|
|
* Return(s) : Modified value with specified bit(s) toggled.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_TOGGLE(val, mask) ((val) ^= (mask))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_FIELD_RD()
|
|
*
|
|
* Description : Reads a 'val' field, masked and shifted, given by mask 'field_mask'.
|
|
*
|
|
* Argument(s) : val Value to read from.
|
|
*
|
|
* field_mask Mask of field to read. See note #1, #2 and #3.
|
|
*
|
|
* Return(s) : Field value, masked and right-shifted to bit position 0.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'field_mask' argument must NOT be 0.
|
|
*
|
|
* (2) 'field_mask' argument must contain a mask with contiguous set bits.
|
|
*
|
|
* (3) 'val' & 'field_mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_FIELD_RD(val, field_mask) (((val) & (field_mask)) / ((field_mask) & ((~(field_mask)) + 1u)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_FIELD_ENC()
|
|
*
|
|
* Description : Encodes given 'field_val' at position given by mask 'field_mask'.
|
|
*
|
|
* Argument(s) : field_val Value to encode.
|
|
*
|
|
* field_mask Mask of field to read. See note #1 and #2.
|
|
*
|
|
* Return(s) : Field value, masked and left-shifted to field position.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'field_mask' argument must contain a mask with contiguous set bits.
|
|
*
|
|
* (2) 'field_val' & 'field_mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_FIELD_ENC(field_val, field_mask) (((field_val) * ((field_mask) & ((~(field_mask)) + 1u))) & (field_mask))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_FIELD_WR()
|
|
*
|
|
* Description : Writes 'field_val' field at position given by mask 'field_mask' in variable 'var'.
|
|
*
|
|
* Argument(s) : var Variable to write field to. See note #2.
|
|
*
|
|
* field_val Desired value for field. See note #2.
|
|
*
|
|
* field_mask Mask of field to write to. See note #1 and #2.
|
|
*
|
|
* Return(s) : None.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'field_mask' argument must contain a mask with contiguous set bits.
|
|
*
|
|
* (2) 'var', 'field_val' & 'field_mask' SHOULD be unsigned integers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_FIELD_WR(var, field_val, field_mask) (var) = (((var) & ~(field_mask)) | DEF_BIT_FIELD_ENC((field_val), (field_mask)))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_IS_SET()
|
|
*
|
|
* Description : Determine if specified bit(s) in a value are set.
|
|
*
|
|
* Argument(s) : val Value to check for specified bit(s) set.
|
|
*
|
|
* mask Mask of bits to check if set (see Note #2).
|
|
*
|
|
* Return(s) : DEF_YES, if ALL specified bit(s) are set in value.
|
|
*
|
|
* DEF_NO, if ALL specified bit(s) are NOT set in value.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*
|
|
* (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_IS_SET(val, mask) (((((val) & (mask)) == (mask)) && \
|
|
((mask) != 0u)) ? (DEF_YES) : (DEF_NO))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_IS_CLR()
|
|
*
|
|
* Description : Determine if specified bit(s) in a value are clear.
|
|
*
|
|
* Argument(s) : val Value to check for specified bit(s) clear.
|
|
*
|
|
* mask Mask of bits to check if clear (see Note #2).
|
|
*
|
|
* Return(s) : DEF_YES, if ALL specified bit(s) are clear in value.
|
|
*
|
|
* DEF_NO, if ALL specified bit(s) are NOT clear in value.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*
|
|
* (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_IS_CLR(val, mask) (((((val) & (mask)) == 0u) && \
|
|
((mask) != 0u)) ? (DEF_YES) : (DEF_NO))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_IS_SET_ANY()
|
|
*
|
|
* Description : Determine if any specified bit(s) in a value are set.
|
|
*
|
|
* Argument(s) : val Value to check for specified bit(s) set.
|
|
*
|
|
* mask Mask of bits to check if set (see Note #2).
|
|
*
|
|
* Return(s) : DEF_YES, if ANY specified bit(s) are set in value.
|
|
*
|
|
* DEF_NO, if ALL specified bit(s) are NOT set in value.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*
|
|
* (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_IS_SET_ANY(val, mask) ((((val) & (mask)) == 0u) ? (DEF_NO ) : (DEF_YES))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_BIT_IS_CLR_ANY()
|
|
*
|
|
* Description : Determine if any specified bit(s) in a value are clear.
|
|
*
|
|
* Argument(s) : val Value to check for specified bit(s) clear.
|
|
*
|
|
* mask Mask of bits to check if clear (see Note #2).
|
|
*
|
|
* Return(s) : DEF_YES, if ANY specified bit(s) are clear in value.
|
|
*
|
|
* DEF_NO, if ALL specified bit(s) are NOT clear in value.
|
|
*
|
|
* Note(s) : (1) 'val' & 'mask' SHOULD be unsigned integers.
|
|
*
|
|
* (2) NULL 'mask' allowed; returns 'DEF_NO' since NO mask bits specified.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_BIT_IS_CLR_ANY(val, mask) ((((val) & (mask)) == (mask)) ? (DEF_NO ) : (DEF_YES))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* VALUE MACRO'S
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_CHK_VAL_MIN()
|
|
*
|
|
* Description : Validate a value as greater than or equal to a specified minimum value.
|
|
*
|
|
* Argument(s) : val Value to validate.
|
|
*
|
|
* val_min Minimum value to test.
|
|
*
|
|
* Return(s) : DEF_OK, Value is greater than or equal to minimum value.
|
|
*
|
|
* DEF_FAIL, otherwise.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) DEF_CHK_VAL_MIN() avoids directly comparing any two values if only one of the values
|
|
* is negative since the negative value might be incorrectly promoted to an arbitrary
|
|
* unsigned value if the other value to compare is unsigned.
|
|
*
|
|
* (2) Validation of values is limited to the range supported by the compiler &/or target
|
|
* environment. All other values that underflow/overflow the supported range will
|
|
* modulo/wrap into the supported range as arbitrary signed or unsigned values.
|
|
*
|
|
* Therefore, any values that underflow the most negative signed value or overflow
|
|
* the most positive unsigned value supported by the compiler &/or target environment
|
|
* cannot be validated :
|
|
*
|
|
* ( N-1 N ]
|
|
* ( -(2 ) , 2 - 1 ]
|
|
* ( ]
|
|
*
|
|
* where
|
|
* N Number of data word bits supported by the compiler
|
|
* &/or target environment
|
|
*
|
|
* (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
|
|
* range since many compilers do NOT always correctly handle this value.
|
|
*
|
|
* (3) 'val' and 'val_min' are compared to 1 instead of 0 to avoid warning generated for
|
|
* unsigned numbers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_CHK_VAL_MIN(val, val_min) (((!(((val) >= 1) && ((val_min) < 1))) && \
|
|
((((val_min) >= 1) && ((val) < 1)) || \
|
|
((val) < (val_min)))) ? DEF_FAIL : DEF_OK)
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_CHK_VAL_MAX()
|
|
*
|
|
* Description : Validate a value as less than or equal to a specified maximum value.
|
|
*
|
|
* Argument(s) : val Value to validate.
|
|
*
|
|
* val_max Maximum value to test.
|
|
*
|
|
* Return(s) : DEF_OK, Value is less than or equal to maximum value.
|
|
*
|
|
* DEF_FAIL, otherwise.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) DEF_CHK_VAL_MAX() avoids directly comparing any two values if only one of the values
|
|
* is negative since the negative value might be incorrectly promoted to an arbitrary
|
|
* unsigned value if the other value to compare is unsigned.
|
|
*
|
|
* (2) Validation of values is limited to the range supported by the compiler &/or target
|
|
* environment. All other values that underflow/overflow the supported range will
|
|
* modulo/wrap into the supported range as arbitrary signed or unsigned values.
|
|
*
|
|
* Therefore, any values that underflow the most negative signed value or overflow
|
|
* the most positive unsigned value supported by the compiler &/or target environment
|
|
* cannot be validated :
|
|
*
|
|
* ( N-1 N ]
|
|
* ( -(2 ) , 2 - 1 ]
|
|
* ( ]
|
|
*
|
|
* where
|
|
* N Number of data word bits supported by the compiler
|
|
* &/or target environment
|
|
*
|
|
* (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
|
|
* range since many compilers do NOT always correctly handle this value.
|
|
*
|
|
* (3) 'val' and 'val_max' are compared to 1 instead of 0 to avoid warning generated for
|
|
* unsigned numbers.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_CHK_VAL_MAX(val, val_max) (((!(((val_max) >= 1) && ((val) < 1))) && \
|
|
((((val) >= 1) && ((val_max) < 1)) || \
|
|
((val) > (val_max)))) ? DEF_FAIL : DEF_OK)
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_CHK_VAL()
|
|
*
|
|
* Description : Validate a value as greater than or equal to a specified minimum value & less than or
|
|
* equal to a specified maximum value.
|
|
*
|
|
* Argument(s) : val Value to validate.
|
|
*
|
|
* val_min Minimum value to test.
|
|
*
|
|
* val_max Maximum value to test.
|
|
*
|
|
* Return(s) : DEF_OK, Value is greater than or equal to minimum value AND
|
|
* less than or equal to maximum value.
|
|
*
|
|
* DEF_FAIL, otherwise.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) DEF_CHK_VAL() avoids directly comparing any two values if only one of the values
|
|
* is negative since the negative value might be incorrectly promoted to an arbitrary
|
|
* unsigned value if the other value to compare is unsigned.
|
|
*
|
|
* (2) Validation of values is limited to the range supported by the compiler &/or target
|
|
* environment. All other values that underflow/overflow the supported range will
|
|
* modulo/wrap into the supported range as arbitrary signed or unsigned values.
|
|
*
|
|
* Therefore, any values that underflow the most negative signed value or overflow
|
|
* the most positive unsigned value supported by the compiler &/or target environment
|
|
* cannot be validated :
|
|
*
|
|
* ( N-1 N ]
|
|
* ( -(2 ) , 2 - 1 ]
|
|
* ( ]
|
|
*
|
|
* where
|
|
* N Number of data word bits supported by the compiler
|
|
* &/or target environment
|
|
*
|
|
* (a) Note that the most negative value, -2^(N-1), is NOT included in the supported
|
|
* range since many compilers do NOT always correctly handle this value.
|
|
*
|
|
* (3) DEF_CHK_VAL() does NOT validate that the maximum value ('val_max') is greater than
|
|
* or equal to the minimum value ('val_min').
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_CHK_VAL(val, val_min, val_max) (((DEF_CHK_VAL_MIN((val), (val_min)) == DEF_FAIL) || \
|
|
(DEF_CHK_VAL_MAX((val), (val_max)) == DEF_FAIL)) ? DEF_FAIL : DEF_OK)
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_GET_U_MAX_VAL()
|
|
*
|
|
* Description : Get the maximum unsigned value that can be represented in an unsigned integer variable
|
|
* of the same data type size as an object.
|
|
*
|
|
* Argument(s) : obj Object or data type to return maximum unsigned value (see Note #1).
|
|
*
|
|
* Return(s) : Maximum unsigned integer value that can be represented by the object, if NO error(s).
|
|
*
|
|
* 0, otherwise.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : (1) 'obj' SHOULD be an integer object or data type but COULD also be a character or
|
|
* pointer object or data type.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#if (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_08)
|
|
|
|
#define DEF_GET_U_MAX_VAL(obj) ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL : 0)
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_16)
|
|
|
|
#define DEF_GET_U_MAX_VAL(obj) ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL : 0))
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_32)
|
|
|
|
#define DEF_GET_U_MAX_VAL(obj) ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL : 0)))
|
|
|
|
|
|
#elif (CPU_CFG_DATA_SIZE_MAX == CPU_WORD_SIZE_64)
|
|
|
|
#define DEF_GET_U_MAX_VAL(obj) ((sizeof(obj) == CPU_WORD_SIZE_08) ? DEF_INT_08U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_16) ? DEF_INT_16U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_32) ? DEF_INT_32U_MAX_VAL : \
|
|
((sizeof(obj) == CPU_WORD_SIZE_64) ? DEF_INT_64U_MAX_VAL : 0))))
|
|
|
|
#else
|
|
|
|
#error "CPU_CFG_DATA_SIZE_MAX illegally #defined in 'cpu.h' "
|
|
#error " [See 'cpu.h CONFIGURATION ERRORS']"
|
|
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* MATH MACRO'S
|
|
*
|
|
* Note(s) : (1) Ideally, ALL mathematical macro's & functions SHOULD be defined in the custom mathematics
|
|
* library ('lib_math.*'). #### However, to maintain backwards compatibility with previously-
|
|
* released modules, mathematical macro & function definitions should only be moved to the
|
|
* custom mathematics library once all previously-released modules are updated to include the
|
|
* custom mathematics library.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_MIN()
|
|
*
|
|
* Description : Determine the minimum of two values.
|
|
*
|
|
* Argument(s) : a First value.
|
|
*
|
|
* b Second value.
|
|
*
|
|
* Return(s) : Minimum of the two values.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : none.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_MIN(a, b) (((a) < (b)) ? (a) : (b))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_MAX()
|
|
*
|
|
* Description : Determine the maximum of two values.
|
|
*
|
|
* Argument(s) : a First value.
|
|
*
|
|
* b Second value.
|
|
*
|
|
* Return(s) : Maximum of the two values.
|
|
*
|
|
* Note(s) : none.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_MAX(a, b) (((a) > (b)) ? (a) : (b))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* DEF_ABS()
|
|
*
|
|
* Description : Determine the absolute value of a value.
|
|
*
|
|
* Argument(s) : a Value to calculate absolute value.
|
|
*
|
|
* Return(s) : Absolute value of the value.
|
|
*
|
|
* Caller(s) : Application.
|
|
*
|
|
* Note(s) : none.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#define DEF_ABS(a) (((a) < 0) ? (-(a)) : (a))
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* FUNCTION PROTOTYPES
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* CONFIGURATION ERRORS
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* LIBRARY CONFIGURATION ERRORS
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
/* See 'lib_def.h Note #1a'. */
|
|
#if (CPU_CORE_VERSION < 12900u)
|
|
#error "CPU_CORE_VERSION [SHOULD be >= V1.29.00]"
|
|
#endif
|
|
|
|
|
|
/*
|
|
*********************************************************************************************************
|
|
* MODULE END
|
|
*
|
|
* Note(s) : (1) See 'lib_def.h MODULE'.
|
|
*********************************************************************************************************
|
|
*/
|
|
|
|
#endif /* End of lib def module include. */
|