__type.h

Go to the documentation of this file.

/*****************************************************************************
 *   Copyright(C)2009-2022 by VSF Team                                       *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the "License");          *
 *  you may not use this file except in compliance with the License.         *
 *  You may obtain a copy of the License at                                  *
 *                                                                           *
 *     http://www.apache.org/licenses/LICENSE-2.0                            *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an "AS IS" BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 ****************************************************************************/
 
#ifndef __COMMON_TYPE_H__
#define __COMMON_TYPE_H__
 
#ifdef __cplusplus
extern "C" {
#endif
 
/*============================ INCLUDES ======================================*/
 
#ifndef ENABLED
#   define ENABLED                              1
#endif
 
#ifndef DISABLED
#   define DISABLED                             0
#endif
 
/* do not modify this */
#include "vsf_usr_cfg.h"
 
/*============================ TYPES =========================================*/
 
typedef enum {
    VSF_ERR_NOT_READY                       =1,     
    VSF_ERR_NONE                            =0,     
    VSF_ERR_UNKNOWN                         =-1,    
    VSF_ERR_NOT_SUPPORT                     =-2,    
    VSF_ERR_NOT_AVAILABLE                   =-4,    
    VSF_ERR_NOT_ACCESSABLE                  =-5,    
    VSF_ERR_NOT_ACCESSIBLE                  = VSF_ERR_NOT_ACCESSABLE,
    VSF_ERR_NOT_ENOUGH_RESOURCES            =-6,    
    VSF_ERR_FAIL                            =-7,    
    VSF_ERR_INVALID_PARAMETER               =-8,    
    VSF_ERR_INVALID_RANGE                   =-9,    
    VSF_ERR_INVALID_PTR                     =-10,   
    VSF_ERR_INVALID_KEY                     =-11,   
    VSF_ERR_IO                              =-12,   
    VSF_ERR_ALREADY_EXISTS                  =-13,   
    VSF_ERR_REQ_ALREADY_REGISTERED          =-13,   
    VSF_ERR_BUG                             =-14,   
    VSF_ERR_OVERRUN                         =-15,   
    VSF_ERR_PROVIDED_RESOURCE_NOT_SUFFICIENT
                                            =-17,   
    VSF_ERR_PROVIDED_RESOURCE_NOT_ALIGNED
                                            =-18,   
    VSF_ERR_TIMEOUT                         =-19,
    VSF_ERR_BUSY                            =-20,
} vsf_err_t;
 
#ifndef __FSM_RT_TYPE__
#define __FSM_RT_TYPE__
typedef enum {
    fsm_rt_err                              = -1,    
    fsm_rt_cpl                              = 0,     
    fsm_rt_on_going                         = 1,     
    fsm_rt_yield                            = 1,
    fsm_rt_wait_for_obj                     = 2,     
    fsm_rt_wait_for_evt                     = 2,
    fsm_rt_wfe                              = 2,
    fsm_rt_asyn                             = 3,     
    fsm_rt_user                             = 4
} fsm_rt_t;
 
#endif
 
/*============================ INCLUDES ======================================*/
 
#if !defined(__USE_LOCAL_LIBC__)
#   include <ctype.h>
#   include <stdlib.h>
#   include <string.h>
#   include <stddef.h>
#   include <assert.h>
#else
#   undef __USE_LOCAL_LIBC__
#endif
 
/*============================ MACROS ========================================*/
 
#ifndef VSF_ASSERT
#   if VSF_USE_TRACE == ENABLED
// do not extern vsf_trace_assert as a normal function, maybe it's a static inline function
//extern void vsf_trace_assert(const char *expr, const char *file, int line, const char *func);
#       include "service/trace/vsf_trace.h"
#       define VSF_ASSERT(__EXPR)                                               \
    ((__EXPR)                                                                   \
    ? (void)0                                                                   \
    : vsf_trace_assert(#__EXPR, __FILE__, __LINE__, __FUNCTION__))
#   else
#       define VSF_ASSERT                   assert
#   endif
#endif
 
#if !defined(__STDC_VERSION__) || __STDC_VERSION__ < 199901L
#   ifndef __VSF_STR
#       define __VSF_STR(__STRING)          #__STRING
#   endif
#   ifndef VSF_STR
#       define VSF_STR(__STRING)            __VSF_STR(__STRING)
#   endif
#else
#   ifndef __VSF_STR
#       define __VSF_STR(...)               #__VA_ARGS__
#   endif
#   ifndef VSF_STR
#       define VSF_STR(...)                 __VSF_STR(__VA_ARGS__)
#   endif
#endif
 
#define vsf_max(__a, __b)                   (((__a) > (__b)) ? (__a) : (__b))
#define vsf_min(__a, __b)                   (((__a) < (__b)) ? (__a) : (__b))
 
#ifndef dimof
#   define dimof(__arr)                     (sizeof(__arr) / sizeof((__arr)[0]))
#endif
 
// use offsetof from compiler if available for constexpr feature in cpp
#if __IS_COMPILER_GCC__ || __IS_COMPILER_LLVM__
#   define vsf_offset_of(__type, __member)  __builtin_offsetof(__type, __member)
#else
#   define vsf_offset_of(__type, __member)  (uintptr_t)(&(((__type *)0)->__member))
#endif
#define vsf_container_of(__ptr, __type, __member)                               \
        ((__type *)((uintptr_t)(__ptr) - vsf_offset_of(__type, __member)))
#define vsf_safe_container_of(__ptr, __type, __member)                          \
        (__ptr ? vsf_container_of(__ptr, __type, __member) : NULL)
 
#ifndef VSF_COMPATIBILITY
#   define VSF_COMPATIBILITY                ENABLED
#endif
#if VSF_COMPATIBILITY == ENABLED
#   ifndef container_of
#       define container_of                 vsf_container_of
#   endif
#   ifndef safe_container_of
#       define safe_container_of            vsf_safe_container_of
#   endif
#endif
 
static inline int vsf_sign(int x)
{
    return ((int)((int)((int)(x) > 0) - (int)((int)(x) < 0)));
}
 
#define vsf_abs(__num)                      (((__num) < 0) ? (-(__num)) : (__num))
 
#define VSF_BIT(__N)                        (1UL << (__N))
#define VSF_BITMASK(__N)                    (VSF_BIT(__N) - 1)
#define VSF_UNUSED_PARAM(__VAL)             (void)(__VAL)
 
#define VSF_STATIC_ASSERT(__COND)                                               \
            typedef int VSF_MACRO_SAFE_NAME(STATIC_ASSERT)[(__COND) * 2 - 1]
 
// will be removed later
#ifdef __VSF_COMPAT__
#   define min                              vsf_min
#   define max                              vsf_max
#   define __STR                            __VSF_STR
#   define STR                              VSF_STR
#   define sign                             vsf_sign
#endif
 
/*============================ MACROFIED FUNCTIONS ===========================*/
/*============================ TYPES =========================================*/
 
#if __IS_COMPILER_IAR__
#   pragma diag_suppress=pe301
#endif
 
 
#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 201112L && !defined(__cplusplus)
typedef uint_least32_t char32_t;
typedef uint_least16_t char16_t;
#endif
 
 
#if __IS_COMPILER_IAR__
//#   pragma diag_suppress=pe301
#endif
 
 
#ifndef __REG_TYPE__
#define __REG_TYPE__
 
typedef volatile uint8_t            reg8_t;
typedef volatile uint16_t           reg16_t;
typedef volatile uint32_t           reg32_t;
 
#define __REG_CONNECT(__A, __B)     __A##__B
#define __REG_RSVD_NAME(__NAME)     __REG_CONNECT(__unused_, __NAME)
 
#define ____REG_RSVD(__NAME, __BIT)                                             \
        reg##__BIT##_t              __NAME : __BIT;
#define ____REG_RSVD_N(__NAME, __BIT, __N)                                      \
        reg##__BIT##_t              __NAME[__N];
#define __REG_RSVD(__BIT)           ____REG_RSVD(REG_RSVD_NAME, __BIT)
#define __REG_RSVD_N(__BIT, __N)    ____REG_RSVD_N(REG_RSVD_NAME, __BIT, (__N))
 
#define REG_RSVD_NAME               __REG_RSVD_NAME(__LINE__)
#define REG_RSVD(__BIT)             __REG_RSVD(__BIT)
#define REG_RSVD_N(__BIT, __N)      __REG_RSVD_N(__BIT, (__N))
 
#define REG_RSVD_U8                 REG_RSVD(8)
#define REG_RSVD_U16                REG_RSVD(16)
#define REG_RSVD_U32                REG_RSVD(32)
 
#define REG_RSVD_U8N(__N)           REG_RSVD_N(8, (__N))
#define REG_RSVD_U16N(__N)          REG_RSVD_N(16, (__N))
#define REG_RSVD_U32N(__N)          REG_RSVD_N(32, (__N))
 
#define REG8_RSVD_N(__N)            REG_RSVD_U8N(__N)
#define REG8_RSVD_B(__BYTE_CNT)     REG8_RSVD_N(__BYTE_CNT)
#define REG8_RSVD_8B                REG8_RSVD_B(8)
#define REG8_RSVD_16B               REG8_RSVD_B(16)
#define REG8_RSVD_32B               REG8_RSVD_B(32)
#define REG8_RSVD_64B               REG8_RSVD_B(64)
#define REG8_RSVD_128B              REG8_RSVD_B(128)
#define REG8_RSVD_256B              REG8_RSVD_B(256)
#define REG8_RSVD_512B              REG8_RSVD_B(512)
#define REG8_RSVD_1K                REG8_RSVD_B(1024)
#define REG8_RSVD_2K                REG8_RSVD_B(2048)
#define REG8_RSVD_4K                REG8_RSVD_B(4096)
#define REG8_RSVD_8K                REG8_RSVD_B(8192)
#define REG8_RSVD_16K               REG8_RSVD_B(16 * 1024)
#define REG8_RSVD_32K               REG8_RSVD_B(32 * 1024)
#define REG8_RSVD_64K               REG8_RSVD_B(64 * 1024)
#define REG8_RSVD_128K              REG8_RSVD_B(128 * 1024)
#define REG8_RSVD_256K              REG8_RSVD_B(256 * 1024)
#define REG8_RSVD_512K              REG8_RSVD_B(512 * 1024)
#define REG8_RSVD_1M                REG8_RSVD_B(1024 * 1024)
 
#define REG16_RSVD_N(__N)           REG_RSVD_U16N(__N)
// __BYTE_CNT MUST be multiple of 2
#define REG16_RSVD_B(__BYTE_CNT)    REG16_RSVD_N(__BYTE_CNT >> 1)
#define REG16_RSVD_8B               REG16_RSVD_B(8)
#define REG16_RSVD_16B              REG16_RSVD_B(16)
#define REG16_RSVD_32B              REG16_RSVD_B(32)
#define REG16_RSVD_64B              REG16_RSVD_B(64)
#define REG16_RSVD_128B             REG16_RSVD_B(128)
#define REG16_RSVD_256B             REG16_RSVD_B(256)
#define REG16_RSVD_512B             REG16_RSVD_B(512)
#define REG16_RSVD_1K               REG16_RSVD_B(1024)
#define REG16_RSVD_2K               REG16_RSVD_B(2048)
#define REG16_RSVD_4K               REG16_RSVD_B(4096)
#define REG16_RSVD_8K               REG16_RSVD_B(8192)
#define REG16_RSVD_16K              REG16_RSVD_B(16 * 1024)
#define REG16_RSVD_32K              REG16_RSVD_B(32 * 1024)
#define REG16_RSVD_64K              REG16_RSVD_B(64 * 1024)
#define REG16_RSVD_128K             REG16_RSVD_B(128 * 1024)
#define REG16_RSVD_256K             REG16_RSVD_B(256 * 1024)
#define REG16_RSVD_512K             REG16_RSVD_B(512 * 1024)
#define REG16_RSVD_1M               REG16_RSVD_B(1024 * 1024)
 
#define REG32_RSVD_N(__N)           REG_RSVD_U32N(__N)
// __BYTE_CNT MUST be multiple of 4
#define REG32_RSVD_B(__BYTE_CNT)    REG_RSVD_U32N(__BYTE_CNT >> 2)
#define REG32_RSVD_8B               REG32_RSVD_B(8)
#define REG32_RSVD_16B              REG32_RSVD_B(16)
#define REG32_RSVD_32B              REG32_RSVD_B(32)
#define REG32_RSVD_64B              REG32_RSVD_B(64)
#define REG32_RSVD_128B             REG32_RSVD_B(128)
#define REG32_RSVD_256B             REG32_RSVD_B(256)
#define REG32_RSVD_512B             REG32_RSVD_B(512)
#define REG32_RSVD_1K               REG32_RSVD_B(1024)
#define REG32_RSVD_2K               REG32_RSVD_B(2048)
#define REG32_RSVD_4K               REG32_RSVD_B(4096)
#define REG32_RSVD_8K               REG32_RSVD_B(8192)
#define REG32_RSVD_16K              REG32_RSVD_B(16 * 1024)
#define REG32_RSVD_32K              REG32_RSVD_B(32 * 1024)
#define REG32_RSVD_64K              REG32_RSVD_B(64 * 1024)
#define REG32_RSVD_128K             REG32_RSVD_B(128 * 1024)
#define REG32_RSVD_256K             REG32_RSVD_B(256 * 1024)
#define REG32_RSVD_512K             REG32_RSVD_B(512 * 1024)
#define REG32_RSVD_1M               REG32_RSVD_B(1024 * 1024)
 
#endif      // __REG_TYPE__
 
 
 
 
/*============================ GLOBAL VARIABLES ==============================*/
/*============================ LOCAL VARIABLES ===============================*/
/*============================ PROTOTYPES ====================================*/
 
#ifdef __cplusplus
}
#endif
 
 
/*============================ Multiple-Entry ================================*/
 
#if !defined(__USE_LOCAL_STDIO__)
//#warning including stdio.h                                                    //! uncomment this for debugging purpose only
#   include <stdio.h>
#else
//#   warning user ignored standard stdio.h                                     //! uncomment this for debugging purpose only
#   undef __USE_LOCAL_STDIO__
#endif
 
#if !defined(__USE_LOCAL_SETJMP__)
//#warning including setjmp.h                                                    //! uncomment this for debugging purpose only
#   include <setjmp.h>
#else
//#   warning user ignored standard setjmp.h                                     //! uncomment this for debugging purpose only
#   undef __USE_LOCAL_SETJMP__
#endif
 
#if !defined(__USE_LOCAL_STDARG__)
//#warning including stdarg.h                                                    //! uncomment this for debugging purpose only
#   include <stdarg.h>
#else
//#   warning user ignored standard stdarg.h                                     //! uncomment this for debugging purpose only
#   undef __USE_LOCAL_STDARG__
#endif
 
#endif // __COMMON_TYPE_H__