#include "hal/vsf_hal_cfg.h"
#include "utilities/vsf_utilities.h"
#include <VSF_ARCH_HEADER>

Data Structures
struct	vsf_protect_region_t

struct	vsf_arch_text_region_t

struct	vsf_arch_heap_statistics_t

struct	vsf_arch_vplt_t

Macros
#define	VSF_ARCH_ASSERT(...) VSF_ASSERT(__VA_ARGS__)

#define	VSF_ARCH_HEADER "./template/template_generic.h"
	check rtos first

#define	VSF_ARCH_SWI_NUM 0

#define	VSF_DEV_SWI_NUM 0

#define	VSF_SWI_NUM (VSF_ARCH_SWI_NUM + VSF_DEV_SWI_NUM)

#define	___constant_swab16(__x)

#define	___constant_swab32(__x)

#define	___constant_swab64(__x)

#define	bswap16 bswap_16

#define	bswap32 bswap_32

#define	bswap64 bswap_64

#define	htobe16

#define	htole16 bswap_16

#define	be16toh

#define	le16toh bswap_16

#define	htobe32

#define	htole32 bswap_32

#define	be32toh

#define	le32toh bswap_32

#define	htobe64

#define	htole64 bswap_64

#define	be64toh

#define	le64toh bswap_64

#define	cpu_to_le16 bswap_16

#define	cpu_to_le32 bswap_32

#define	cpu_to_le64 bswap_64

#define	le16_to_cpu bswap_16

#define	le32_to_cpu bswap_32

#define	le64_to_cpu bswap_64

#define	cpu_to_be16

#define	cpu_to_be32

#define	cpu_to_be64

#define	be16_to_cpu

#define	be32_to_cpu

#define	be64_to_cpu

#define	__constant_cpu_to_le16 ___constant_swab16

#define	__constant_le16_to_cpu ___constant_swab16

#define	__constant_cpu_to_le32 ___constant_swab32

#define	__constant_le32_to_cpu ___constant_swab32

#define	__constant_cpu_to_le64 ___constant_swab64

#define	__constant_le64_to_cpu ___constant_swab64

#define	__constant_cpu_to_be16

#define	__constant_be16_to_cpu

#define	__constant_cpu_to_be32

#define	__constant_be32_to_cpu

#define	__constant_cpu_to_be64

#define	__constant_be64_to_cpu

#define	DECLARE_ENDIAN_FUNC(__bitlen)

#define	__vsf_protect_region(__region)

#define	vsf_protect_region(__region) __vsf_protect_region(__region)

#define	vsf_protect_region_exit(__region) continue

#define	vsf_protect_region_simple(__region, ...)

#define	__vsf_interrupt_safe(__code)

#define	vsf_interrupt_safe() vsf_protect_region(&vsf_protect_region_int)

#define	vsf_interrupt_safe_simple(...) vsf_protect_region_simple(&vsf_protect_region_int, __VA_ARGS__)

#define	vsf_protect_interrupt() vsf_disable_interrupt()

#define	vsf_unprotect_interrupt(__state) vsf_set_interrupt(__state)

#define	vsf_protect_none() (0)

#define	vsf_unprotect_none(__state) VSF_UNUSED_PARAM(__state)

#define	vsf_protect_int vsf_protect_interrupt

#define	vsf_unprotect_int vsf_unprotect_interrupt

#define	__vsf_protect(__type) vsf_protect_##__type

#define	__vsf_unprotect(__type) vsf_unprotect_##__type

#define	vsf_protect(__type) __vsf_protect(__type)

#define	vsf_unprotect(__type) __vsf_unprotect(__type)

#define	vsf_atom64_op(__ptr, ...)

#define	vsf_atom32_op(__ptr, ...)

#define	vsf_atom16_op(__ptr, ...)

#define	vsf_atom8_op(__ptr, ...)

#define	vsf_atom_add(__bitlen, __ptr, __value) VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ + (__value))

#define	vsf_atom_dec(__bitlen, __ptr, __value) vsf_atom_add(__bitlen, (__ptr), - (__value))

#define	vsf_atom_or(__bitlen, __ptr, __value) VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ \| (__value))

#define	vsf_atom_and(__bitlen, __ptr, __value) VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ & (__value))

#define	vsf_atom_xor(__bitlen, __ptr, __value) VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ ^ (__value))

#define	vsf_atom_xchg(__bitlen, __ptr, __new_value) VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), (__new_value))

#define	vsf_arch_host_invoke_ctx_t(__name) VSF_MCONNECT(__name, _ctx_t)

#define	declare_vsf_arch_host_invoke(__name)

#define	dcl_vsf_arch_host_invoke declare_vsf_arch_host_invoke

#define	define_vsf_arch_host_invoke(__name, ...)

#define	def_vsf_arch_host_invoke define_vsf_arch_host_invoke

#define	implement_vsf_arch_host_invoke(__name)

#define	imp_vsf_arch_host_invoke implement_vsf_arch_host_invoke

#define	initialize_vsf_arch_host_invoke(__name, __priority)

#define	init_vsf_arch_host_invoke initialize_vsf_arch_host_invoke

#define	vsf_arch_host_invoke_nb(__name, __eda_ptr, __ctx_ptr)

#define	vsf_arch_host_invoke_get_result_nb(__name, __ctx_ptr)

#define	vsf_arch_host_invoke_in_thread(__name, __ctx_ptr)

different models to implement systimer
#define	VSF_SYSTIMER_IMPL_NONE 0

#define	VSF_SYSTIMER_IMPL_REQUEST_RESPONSE 1

#define	VSF_SYSTIMER_IMPL_WITH_NORMAL_TIMER 2

#define	VSF_SYSTIMER_IMPL_WITH_COMP_TIMER 3

#define	VSF_SYSTIMER_IMPL_TICK_MODE 4

Typedefs
typedef void	vsf_irq_handler_t(void *p)

typedef vsf_irq_handler_t	vsf_swi_handler_t

typedef uintalu_t	vsf_protect_t

typedef struct vsf_protect_region_t	vsf_protect_region_t

typedef struct vsf_arch_text_region_t	vsf_arch_text_region_t

typedef struct vsf_arch_heap_statistics_t	vsf_arch_heap_statistics_t

typedef struct vsf_arch_vplt_t	vsf_arch_vplt_t

Functions
void *	vsf_arch_heap_malloc (uint_fast32_t size, uint_fast32_t alignment)

void *	vsf_arch_heap_realloc (void *buffer, uint_fast32_t size)

void	vsf_arch_heap_free (void *buffer)

unsigned int	vsf_arch_heap_alignment (void)

uint_fast32_t	vsf_arch_heap_size (void *buffer)

void	vsf_arch_heap_statistics (vsf_arch_heap_statistics_t *statistics)

int_fast8_t	vsf_ffs32 (uint_fast32_t)

int_fast8_t	vsf_ffz32 (uint_fast32_t)

int_fast8_t	vsf_msb32 (uint_fast32_t)

uint_fast8_t	vsf_clz32 (uint_fast32_t)

uint_fast16_t	bswap_16 (uint_fast16_t)

uint_fast32_t	bswap_32 (uint_fast32_t)

vsf_err_t	vsf_swi_init (uint_fast8_t idx, vsf_arch_prio_t priority, vsf_swi_handler_t handler, void param)

void	vsf_swi_trigger (uint_fast8_t idx)

void	vsf_arch_swi_trigger (uint_fast8_t idx)
	trigger a software interrupt !

vsf_arch_prio_t	vsf_set_base_priority (vsf_arch_prio_t priority)

vsf_arch_prio_t	vsf_get_base_priority (void)

int	vsf_get_interrupt_id (void)

vsf_gint_state_t	vsf_get_interrupt (void)

vsf_gint_state_t	vsf_set_interrupt (vsf_gint_state_t level)

vsf_gint_state_t	vsf_disable_interrupt (void)

vsf_gint_state_t	vsf_enable_interrupt (void)

void	vsf_arch_sleep (uint_fast32_t mode)
	arch sleep, will enable global interrupt for wakeup !

void	vsf_arch_reset (void)

void	vsf_arch_shutdown (void)

void	vsf_arch_main (void)

Variables
const vsf_protect_region_t	vsf_protect_region_int

const vsf_protect_region_t	vsf_protect_region_none

__VSF_VPLT_DECORATOR__ vsf_arch_vplt_t	vsf_arch_vplt

Macro Definition Documentation

◆ VSF_SYSTIMER_IMPL_NONE

#define VSF_SYSTIMER_IMPL_NONE 0

◆ VSF_SYSTIMER_IMPL_REQUEST_RESPONSE

#define VSF_SYSTIMER_IMPL_REQUEST_RESPONSE 1

◆ VSF_SYSTIMER_IMPL_WITH_NORMAL_TIMER

#define VSF_SYSTIMER_IMPL_WITH_NORMAL_TIMER 2

◆ VSF_SYSTIMER_IMPL_WITH_COMP_TIMER

#define VSF_SYSTIMER_IMPL_WITH_COMP_TIMER 3

◆ VSF_SYSTIMER_IMPL_TICK_MODE

#define VSF_SYSTIMER_IMPL_TICK_MODE 4

◆ VSF_ARCH_ASSERT

#define VSF_ARCH_ASSERT ( ... ) VSF_ASSERT(__VA_ARGS__)

◆ VSF_ARCH_HEADER

#define VSF_ARCH_HEADER "./template/template_generic.h"

check rtos first

◆ VSF_ARCH_SWI_NUM

#define VSF_ARCH_SWI_NUM 0

◆ VSF_DEV_SWI_NUM

#define VSF_DEV_SWI_NUM 0

◆ VSF_SWI_NUM

#define VSF_SWI_NUM (VSF_ARCH_SWI_NUM + VSF_DEV_SWI_NUM)

◆ ___constant_swab16

#define ___constant_swab16 ( __x )

Value:

    ((uint16_t)(                                    \
    (((uint16_t)(__x) & (uint16_t)0x00FFU) << 8) |                              \
    (((uint16_t)(__x) & (uint16_t)0xFF00U) >> 8)))

◆ ___constant_swab32

#define ___constant_swab32 ( __x )

Value:

    ((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)))

◆ ___constant_swab64

#define ___constant_swab64 ( __x )

Value:

    ((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)))

◆ bswap16

#define bswap16 bswap_16

◆ bswap32

#define bswap32 bswap_32

◆ bswap64

#define bswap64 bswap_64

◆ htobe16

#define htobe16

◆ htole16

#define htole16 bswap_16

◆ be16toh

#define be16toh

◆ le16toh

#define le16toh bswap_16

◆ htobe32

#define htobe32

◆ htole32

#define htole32 bswap_32

◆ be32toh

#define be32toh

◆ le32toh

#define le32toh bswap_32

◆ htobe64

#define htobe64

◆ htole64

#define htole64 bswap_64

◆ be64toh

#define be64toh

◆ le64toh

#define le64toh bswap_64

◆ cpu_to_le16

#define cpu_to_le16 bswap_16

◆ cpu_to_le32

#define cpu_to_le32 bswap_32

◆ cpu_to_le64

#define cpu_to_le64 bswap_64

◆ le16_to_cpu

#define le16_to_cpu bswap_16

◆ le32_to_cpu

#define le32_to_cpu bswap_32

◆ le64_to_cpu

#define le64_to_cpu bswap_64

◆ cpu_to_be16

#define cpu_to_be16

◆ cpu_to_be32

#define cpu_to_be32

◆ cpu_to_be64

#define cpu_to_be64

◆ be16_to_cpu

#define be16_to_cpu

◆ be32_to_cpu

#define be32_to_cpu

◆ be64_to_cpu

#define be64_to_cpu

◆ __constant_cpu_to_le16

#define __constant_cpu_to_le16 ___constant_swab16

◆ __constant_le16_to_cpu

#define __constant_le16_to_cpu ___constant_swab16

◆ __constant_cpu_to_le32

#define __constant_cpu_to_le32 ___constant_swab32

◆ __constant_le32_to_cpu

#define __constant_le32_to_cpu ___constant_swab32

◆ __constant_cpu_to_le64

#define __constant_cpu_to_le64 ___constant_swab64

◆ __constant_le64_to_cpu

#define __constant_le64_to_cpu ___constant_swab64

◆ __constant_cpu_to_be16

#define __constant_cpu_to_be16

◆ __constant_be16_to_cpu

#define __constant_be16_to_cpu

◆ __constant_cpu_to_be32

#define __constant_cpu_to_be32

◆ __constant_be32_to_cpu

#define __constant_be32_to_cpu

◆ __constant_cpu_to_be64

#define __constant_cpu_to_be64

◆ __constant_be64_to_cpu

#define __constant_be64_to_cpu

◆ DECLARE_ENDIAN_FUNC

#define DECLARE_ENDIAN_FUNC ( __bitlen )

Value:

extern uint_fast##__bitlen##_t cpu_to_le##__bitlen##p(uint##__bitlen##_t *);    \
extern uint_fast##__bitlen##_t cpu_to_be##__bitlen##p(uint##__bitlen##_t *);    \
extern uint_fast##__bitlen##_t le##__bitlen##_to_cpup(uint##__bitlen##_t *);    \
extern uint_fast##__bitlen##_t be##__bitlen##_to_cpup(uint##__bitlen##_t *);    \
extern void cpu_to_le##__bitlen##s(uint##__bitlen##_t *);                       \
extern void cpu_to_be##__bitlen##s(uint##__bitlen##_t *);                       \
extern void le##__bitlen##_to_cpus(uint##__bitlen##_t *);                       \
extern void be##__bitlen##_to_cpus(uint##__bitlen##_t *);                       \
extern uint_fast##__bitlen##_t get_unaligned_cpu##__bitlen(const void *);       \
extern uint_fast##__bitlen##_t get_unaligned_le##__bitlen(const void *);        \
extern uint_fast##__bitlen##_t get_unaligned_be##__bitlen(const void *);        \
extern void put_unaligned_cpu##__bitlen(uint_fast##__bitlen##_t, void *);       \
extern void put_unaligned_le##__bitlen(uint_fast##__bitlen##_t, void *);        \
extern void put_unaligned_be##__bitlen(uint_fast##__bitlen##_t, void *);

◆ __vsf_protect_region

#define __vsf_protect_region ( __region )

Value:

    for (vsf_protect_t VSF_MACRO_SAFE_NAME(protect_status),                     \
            VSF_MACRO_SAFE_NAME(local_cnt) = 1;                                 \
        (((__region) != NULL) && VSF_MACRO_SAFE_NAME(local_cnt)--) ?            \
            ((VSF_MACRO_SAFE_NAME(protect_status) = (__region)->enter()), true) : false;\
        (__region)->leave(VSF_MACRO_SAFE_NAME(protect_status)))

◆ vsf_protect_region

#define vsf_protect_region ( __region ) __vsf_protect_region(__region)

◆ vsf_protect_region_exit

#define vsf_protect_region_exit ( __region ) continue

◆ vsf_protect_region_simple

#define vsf_protect_region_simple	(	__region,
		...
	)

Value:

        do {                                                                    \
            if (__region != NULL) {                                             \
                vsf_protect_t VSF_MACRO_SAFE_NAME(protect_status) = (__region)->enter();\
                    __VA_ARGS__;                                                \
                (__region)->leave(VSF_MACRO_SAFE_NAME(protect_status));         \
            }                                                                   \
        } while (0);

◆ __vsf_interrupt_safe

#define __vsf_interrupt_safe ( __code )

Value:

        {                                                                       \
            vsf_gint_state_t VSF_MACRO_SAFE_NAME(gint_state) = vsf_disable_interrupt();\
                __code;                                                         \
            vsf_set_interrupt(VSF_MACRO_SAFE_NAME(gint_state));                 \
        }

Note: TODO: looks like the following macro, i.e. __vsf_interrupt_safe is deprecated, should remove it when sufficient time passed. (start from Jan 01 2021)

◆ vsf_interrupt_safe

#define vsf_interrupt_safe ( ) vsf_protect_region(&vsf_protect_region_int)

◆ vsf_interrupt_safe_simple

#define vsf_interrupt_safe_simple ( ... ) vsf_protect_region_simple(&vsf_protect_region_int, __VA_ARGS__)

◆ vsf_protect_interrupt

#define vsf_protect_interrupt ( ) vsf_disable_interrupt()

◆ vsf_unprotect_interrupt

#define vsf_unprotect_interrupt ( __state ) vsf_set_interrupt(__state)

◆ vsf_protect_none

#define vsf_protect_none ( ) (0)

◆ vsf_unprotect_none

#define vsf_unprotect_none ( __state ) VSF_UNUSED_PARAM(__state)

◆ vsf_protect_int

#define vsf_protect_int vsf_protect_interrupt

◆ vsf_unprotect_int

#define vsf_unprotect_int vsf_unprotect_interrupt

◆ __vsf_protect

#define __vsf_protect ( __type ) vsf_protect_##__type

◆ __vsf_unprotect

#define __vsf_unprotect ( __type ) vsf_unprotect_##__type

◆ vsf_protect

#define vsf_protect ( __type ) __vsf_protect(__type)

◆ vsf_unprotect

#define vsf_unprotect ( __type ) __vsf_unprotect(__type)

◆ vsf_atom64_op

#define vsf_atom64_op	(	__ptr,
		...
	)

Value:

        ({                                                                      \
            vsf_protect_t VSF_MACRO_SAFE_NAME(orig) = vsf_protect_int();        \
            int64_t _ = (*(int64_t *)(__ptr));                                  \
            *(int64_t *)(__ptr) = (__VA_ARGS__);                                \
            vsf_unprotect_int(VSF_MACRO_SAFE_NAME(orig));                       \
            _;                                                                  \
        })

◆ vsf_atom32_op

#define vsf_atom32_op	(	__ptr,
		...
	)

Value:

        ({                                                                      \
            vsf_protect_t VSF_MACRO_SAFE_NAME(orig) = vsf_protect_int();        \
            int32_t _ = (*(int32_t *)(__ptr));                                  \
            *(int32_t *)(__ptr) = (__VA_ARGS__);                                \
            vsf_unprotect_int(VSF_MACRO_SAFE_NAME(orig));                       \
            _;                                                                  \
        })

◆ vsf_atom16_op

#define vsf_atom16_op	(	__ptr,
		...
	)

Value:

        ({                                                                      \
            vsf_protect_t VSF_MACRO_SAFE_NAME(orig) = vsf_protect_int();        \
            int16_t _ = (*(int16_t *)(__ptr));                                  \
            *(int16_t *)(__ptr) = (__VA_ARGS__);                                \
            vsf_unprotect_int(VSF_MACRO_SAFE_NAME(orig));                       \
            _;                                                                  \
        })

◆ vsf_atom8_op

#define vsf_atom8_op	(	__ptr,
		...
	)

Value:

        ({                                                                      \
            vsf_protect_t VSF_MACRO_SAFE_NAME(orig) = vsf_protect_int();        \
            int8_t _ = (*(int8_t *)(__ptr));                                    \
            *(int8_t *)(__ptr) = (__VA_ARGS__);                                 \
            vsf_unprotect_int(VSF_MACRO_SAFE_NAME(orig));                       \
            _;                                                                  \
        })

◆ vsf_atom_add

#define vsf_atom_add	(	__bitlen,
		__ptr,
		__value
	)	VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ + (__value))

◆ vsf_atom_dec

#define vsf_atom_dec	(	__bitlen,
		__ptr,
		__value
	)	vsf_atom_add(__bitlen, (__ptr), - (__value))

◆ vsf_atom_or

#define vsf_atom_or	(	__bitlen,
		__ptr,
		__value
	)	VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ \| (__value))

◆ vsf_atom_and

#define vsf_atom_and	(	__bitlen,
		__ptr,
		__value
	)	VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ & (__value))

◆ vsf_atom_xor

#define vsf_atom_xor	(	__bitlen,
		__ptr,
		__value
	)	VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), _ ^ (__value))

◆ vsf_atom_xchg

#define vsf_atom_xchg	(	__bitlen,
		__ptr,
		__new_value
	)	VSF_MCONNECT(vsf_atom, __bitlen, _op)((__ptr), (__new_value))

◆ vsf_arch_host_invoke_ctx_t

#define vsf_arch_host_invoke_ctx_t ( __name ) VSF_MCONNECT(__name, _ctx_t)

◆ declare_vsf_arch_host_invoke

#define declare_vsf_arch_host_invoke ( __name )

Value:

        typedef struct vsf_arch_host_invoke_ctx_t(__name)                       \
                vsf_arch_host_invoke_ctx_t(__name);                             \
        typedef struct VSF_MCONNECT(__name, _t) VSF_MCONNECT(__name, _t);       \
        extern void VSF_MCONNECT(__name, _callback_t)                           \
                (vsf_arch_host_invoke_ctx_t(__name) *ctx);                      \
        extern VSF_MCONNECT(__name, _t) VSF_MCONNECT(__name, _instance);

◆ dcl_vsf_arch_host_invoke

#define dcl_vsf_arch_host_invoke declare_vsf_arch_host_invoke

◆ define_vsf_arch_host_invoke

#define define_vsf_arch_host_invoke	(	__name,
		...
	)

Value:

        typedef struct vsf_arch_host_invoke_ctx_t(__name) {                     \
            int __dummy;                                                        \
            __VA_ARGS__                                                         \
        } vsf_arch_host_invoke_ctx_t(__name);                                   \
        typedef struct VSF_MCONNECT(__name, _t) {                               \
            implement(vsf_arch_irq_thread_t);                                   \
            vsf_arch_irq_request_t request;                                     \
            vsf_eda_t *caller;                                                  \
            vsf_arch_host_invoke_ctx_t(__name) ctx;                             \
        } VSF_MCONNECT(__name, _t);

◆ def_vsf_arch_host_invoke

#define def_vsf_arch_host_invoke define_vsf_arch_host_invoke

◆ implement_vsf_arch_host_invoke

#define implement_vsf_arch_host_invoke ( __name )

Value:

        VSF_MCONNECT(__name, _t) VSF_MCONNECT(__name, _instance);               \
        extern void VSF_MCONNECT(__name, _callback_t)                           \
                (vsf_arch_host_invoke_ctx_t(__name) *ctx);                      \
        static void VSF_MCONNECT(__name, _thread)(void *arg)                    \
        {                                                                       \
            vsf_eda_t *caller;                                                  \
            VSF_MCONNECT(__name, _t) *ctx = arg;                                \
            __vsf_arch_irq_set_background(&ctx->use_as__vsf_arch_irq_thread_t); \
            while (1) {                                                         \
                __vsf_arch_irq_request_pend(&ctx->request);                     \
                VSF_MCONNECT(__name, _callback_t)(&ctx->ctx);                   \
                                                                                \
                __vsf_arch_irq_start(&ctx->use_as__vsf_arch_irq_thread_t);      \
                    caller = ctx->caller;                                       \
                    if (caller != NULL) {                                       \
                        ctx->caller = NULL;                                     \
                        vsf_eda_post_evt(caller, VSF_EVT_USER);                 \
                    }                                                           \
                __vsf_arch_irq_end(&ctx->use_as__vsf_arch_irq_thread_t, false); \
            }                                                                   \
        }                                                                       \
        void VSF_MCONNECT(__name, _callback_t)(vsf_arch_host_invoke_ctx_t(__name) *_)

◆ imp_vsf_arch_host_invoke

#define imp_vsf_arch_host_invoke implement_vsf_arch_host_invoke

◆ initialize_vsf_arch_host_invoke

#define initialize_vsf_arch_host_invoke	(	__name,
		__priority
	)

Value:

        do {                                                                    \
            memset(&VSF_MCONNECT(__name, _instance), 0,                         \
                    sizeof(VSF_MCONNECT(__name, _t)));                          \
            __vsf_arch_irq_request_init(&VSF_MCONNECT(__name, _instance).request);\
            __vsf_arch_irq_init(                                                \
                    &VSF_MCONNECT(__name, _instance).use_as__vsf_arch_irq_thread_t,\
                    VSF_STR(__name), VSF_MCONNECT(__name, _thread), (__priority));\
        } while (0)

◆ init_vsf_arch_host_invoke

#define init_vsf_arch_host_invoke initialize_vsf_arch_host_invoke

◆ vsf_arch_host_invoke_nb

#define vsf_arch_host_invoke_nb	(	__name,
		__eda_ptr,
		__ctx_ptr
	)

Value:

        do {                                                                    \
            VSF_MCONNECT(__name, _instance).ctx = *(__ctx_ptr);                 \
            VSF_MCONNECT(__name, _instance).caller = (__eda_ptr);               \
            __vsf_arch_irq_request_send(&VSF_MCONNECT(__name, _instance).request);\
        } while (0)

◆ vsf_arch_host_invoke_get_result_nb

#define vsf_arch_host_invoke_get_result_nb	(	__name,
		__ctx_ptr
	)

Value:

        do {                                                                    \
            *(__ctx_ptr) = VSF_MCONNECT(__name, _instance).ctx;                 \
        } while (0)

◆ vsf_arch_host_invoke_in_thread

#define vsf_arch_host_invoke_in_thread	(	__name,
		__ctx_ptr
	)

Value:

        do {                                                                    \
            vsf_eda_t VSF_MACRO_SAFE_NAME(eda) = vsf_eda_get_cur();             \
            VSF_ARCH_ASSERT(VSF_MACRO_SAFE_NAME(eda) != NULL);                  \
            vsf_arch_host_invoke_nb(__name, VSF_MACRO_SAFE_NAME(eda), (__ctx_ptr));\
            vsf_thread_wfe(VSF_EVT_USER);                                       \
            vsf_arch_host_invoke_get_result_nb(__name, __ctx_ptr);              \
        } while (0)

Typedef Documentation

◆ vsf_irq_handler_t

typedef void vsf_irq_handler_t(void *p)

◆ vsf_swi_handler_t

typedef vsf_irq_handler_t vsf_swi_handler_t

◆ vsf_protect_t

typedef uintalu_t vsf_protect_t

◆ vsf_protect_region_t

typedef struct vsf_protect_region_t vsf_protect_region_t

◆ vsf_arch_text_region_t

typedef struct vsf_arch_text_region_t vsf_arch_text_region_t

◆ vsf_arch_heap_statistics_t

typedef struct vsf_arch_heap_statistics_t vsf_arch_heap_statistics_t

◆ vsf_arch_vplt_t

typedef struct vsf_arch_vplt_t vsf_arch_vplt_t

Function Documentation

◆ vsf_arch_heap_malloc()

void * vsf_arch_heap_malloc	(	uint_fast32_t	size,
		uint_fast32_t	alignment
	)

extern

◆ vsf_arch_heap_realloc()

void * vsf_arch_heap_realloc	(	void *	buffer,
		uint_fast32_t	size
	)

extern

◆ vsf_arch_heap_free()

void vsf_arch_heap_free ( void * buffer )

extern

◆ vsf_arch_heap_alignment()

unsigned int vsf_arch_heap_alignment ( void )

extern

◆ vsf_arch_heap_size()

uint_fast32_t vsf_arch_heap_size ( void * buffer )

extern

◆ vsf_arch_heap_statistics()

void vsf_arch_heap_statistics ( vsf_arch_heap_statistics_t * statistics )

extern

◆ vsf_ffs32()

int_fast8_t vsf_ffs32 ( uint_fast32_t a )

extern

◆ vsf_ffz32()

int_fast8_t vsf_ffz32 ( uint_fast32_t a )

extern

◆ vsf_msb32()

int_fast8_t vsf_msb32 ( uint_fast32_t a )

extern

◆ vsf_clz32()

uint_fast8_t vsf_clz32 ( uint_fast32_t a )

extern

◆ bswap_16()

uint_fast16_t bswap_16 ( uint_fast16_t value16 )

extern

◆ bswap_32()

uint_fast32_t bswap_32 ( uint_fast32_t value32 )

extern

◆ vsf_swi_init()

vsf_err_t vsf_swi_init	(	uint_fast8_t	idx,
		vsf_arch_prio_t	priority,
		vsf_swi_handler_t *	handler,
		void *	param
	)

extern

◆ vsf_swi_trigger()

void vsf_swi_trigger ( uint_fast8_t idx )

extern

◆ vsf_arch_swi_trigger()

void vsf_arch_swi_trigger ( uint_fast8_t idx )

extern

trigger a software interrupt !

Parameters

idx	the index of the software interrupt

todo: the code is simplified, we need to verify its reilability

◆ vsf_set_base_priority()

vsf_arch_prio_t vsf_set_base_priority ( vsf_arch_prio_t priority )

extern

◆ vsf_get_base_priority()

vsf_arch_prio_t vsf_get_base_priority ( void )

extern

◆ vsf_get_interrupt_id()

int vsf_get_interrupt_id ( void )

extern

◆ vsf_get_interrupt()

vsf_gint_state_t vsf_get_interrupt ( void )

extern

◆ vsf_set_interrupt()

vsf_gint_state_t vsf_set_interrupt ( vsf_gint_state_t level )

extern

◆ vsf_disable_interrupt()

vsf_gint_state_t vsf_disable_interrupt ( void )

extern

◆ vsf_enable_interrupt()

vsf_gint_state_t vsf_enable_interrupt ( void )

extern

◆ vsf_arch_sleep()

void vsf_arch_sleep ( uint32_t mode )

extern

arch sleep, will enable global interrupt for wakeup !

Parameters

mode	the mode of sleep !

Returns: void

◆ vsf_arch_reset()

void vsf_arch_reset ( void )

extern

◆ vsf_arch_shutdown()

void vsf_arch_shutdown ( void )

extern

◆ vsf_arch_main()

void vsf_arch_main ( void )

extern

Variable Documentation

◆ vsf_protect_region_int

const vsf_protect_region_t vsf_protect_region_int

extern

◆ vsf_protect_region_none

const vsf_protect_region_t vsf_protect_region_none

extern

◆ vsf_arch_vplt

__VSF_VPLT_DECORATOR__ vsf_arch_vplt_t vsf_arch_vplt

extern

Data Structures

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ VSF_SYSTIMER_IMPL_NONE

◆ VSF_SYSTIMER_IMPL_REQUEST_RESPONSE

◆ VSF_SYSTIMER_IMPL_WITH_NORMAL_TIMER

◆ VSF_SYSTIMER_IMPL_WITH_COMP_TIMER

◆ VSF_SYSTIMER_IMPL_TICK_MODE

◆ VSF_ARCH_ASSERT

◆ VSF_ARCH_HEADER

◆ VSF_ARCH_SWI_NUM

◆ VSF_DEV_SWI_NUM

◆ VSF_SWI_NUM

◆ ___constant_swab16

◆ ___constant_swab32

◆ ___constant_swab64

◆ bswap16

◆ bswap32

◆ bswap64

◆ htobe16

◆ htole16

◆ be16toh

◆ le16toh

◆ htobe32

◆ htole32

◆ be32toh

◆ le32toh

◆ htobe64

◆ htole64

◆ be64toh

◆ le64toh

◆ cpu_to_le16

◆ cpu_to_le32

◆ cpu_to_le64

◆ le16_to_cpu

◆ le32_to_cpu

◆ le64_to_cpu

◆ cpu_to_be16

◆ cpu_to_be32

◆ cpu_to_be64

◆ be16_to_cpu

◆ be32_to_cpu

◆ be64_to_cpu

◆ __constant_cpu_to_le16

◆ __constant_le16_to_cpu

◆ __constant_cpu_to_le32

◆ __constant_le32_to_cpu

◆ __constant_cpu_to_le64

◆ __constant_le64_to_cpu

◆ __constant_cpu_to_be16

◆ __constant_be16_to_cpu

◆ __constant_cpu_to_be32

◆ __constant_be32_to_cpu

◆ __constant_cpu_to_be64

◆ __constant_be64_to_cpu

◆ DECLARE_ENDIAN_FUNC

◆ __vsf_protect_region

◆ vsf_protect_region

◆ vsf_protect_region_exit

◆ vsf_protect_region_simple

◆ __vsf_interrupt_safe

◆ vsf_interrupt_safe

◆ vsf_interrupt_safe_simple

◆ vsf_protect_interrupt

◆ vsf_unprotect_interrupt

◆ vsf_protect_none

◆ vsf_unprotect_none

◆ vsf_protect_int

◆ vsf_unprotect_int

◆ __vsf_protect

◆ __vsf_unprotect

◆ vsf_protect

◆ vsf_unprotect

◆ vsf_atom64_op

◆ vsf_atom32_op

◆ vsf_atom16_op

◆ vsf_atom8_op