VSF Documented
Macros | Functions | Variables
vsf_thread.h File Reference
#include "kernel/vsf_kernel_cfg.h"
#include "../vsf_eda.h"
#include "./vsf_task.h"
#include "utilities/ooc_class.h"

Go to the source code of this file.

Macros

#define VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE   1
 
#define VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE   0
 
#define VSF_KERNEL_CFG_THREAD_STACK_ALIGN_BIT   3
 
#define __VSF_THREAD_STACK_SAFE_SIZE(__stack)
 
#define __declare_vsf_thread(__name)
 
#define declare_vsf_thread(__name)   __declare_vsf_thread(__name)
 
#define declare_vsf_thread_ex(__name)   __declare_vsf_thread(__name)
 
#define dcl_vsf_thread(__name)   declare_vsf_thread(__name)
 
#define dcl_vsf_thread_ex(__name)   declare_vsf_thread(__name)
 
#define __vsf_thread_set_stack_canery(__thread, __task)    (__thread)->canary = 0xDEADBEEF;
 
#define __vsf_thread_set_stack(__thread, __task, __stack_ptr, __stack_bytesize)
 
#define __vsf_thread_def_stack(__name, __bytesize)
 
#define __vsf_thread_def_stack_member(__name, __bytesize)
 
#define __vsf_thread_imp_stack(__name, __thread, __task)    __vsf_thread_set_stack((__thread), (__task), NULL, (vsf_thread##__name##_stack_bytesize))
 
#define __vsf_eda_call_thread_prepare_stack(__name, __thread)
 
#define __def_vsf_thread(__name, __stack_bytesize, ...)
 
#define __implement_vsf_thread(__name)
 
#define __vsf_eda_call_thread_prepare(__name, __thread_cb)
 
#define vsf_eda_call_thread_prepare(__name, __thread_cb)    __vsf_eda_call_thread_prepare(__name, __thread_cb)
 
#define vsf_eda_call_thread(__thread_cb)    vk_eda_call_thread(&((__thread_cb)->use_as__vsf_thread_cb_t))
 
#define __def_vsf_thread_ex(__name, ...)
 
#define __implement_vsf_thread_ex(__name)
 
#define __vsf_eda_call_thread_prepare_ex__( __name, __thread_cb, __stack, __stack_bytesize)
 
#define vsf_eda_call_thread_prepare_ex( __name, __thread_cb, __stack, __stack_bytesize)
 
#define vsf_eda_call_thread_ex(__thread_cb)    vk_eda_call_thread(&((__thread_cb)->use_as__vsf_thread_cb_t))
 
#define def_vsf_thread(__name, __stack_bytesize, ...)    __def_vsf_thread(__name, (__stack_bytesize), __VA_ARGS__)
 
#define define_vsf_thread(__name, __stack_bytesize, ...)    def_vsf_thread(__name, (__stack_bytesize), __VA_ARGS__)
 
#define def_vsf_thread_ex(__name, ...)    __def_vsf_thread_ex(__name, __VA_ARGS__)
 
#define define_vsf_thread_ex(__name, ...)    def_vsf_thread_ex(__name, __VA_ARGS__)
 
#define end_def_vsf_thread(...)
 
#define end_define_vsf_thread(...)
 
#define implement_vsf_thread(__name)   __implement_vsf_thread(__name)
 
#define implement_vsf_thread_ex(__name)   __implement_vsf_thread_ex(__name)
 
#define imp_vsf_thread(__name)   implement_vsf_thread(__name)
 
#define imp_vsf_thread_ex(__name)   implement_vsf_thread_ex(__name)
 
#define __init_vsf_thread(__name, __task, __pri)    vsf_thread_##__name##_start((__task), (__pri))
 
#define __init_vsf_thread_ex(__name, __task, __pri, __stack, __stack_bytesize)    vsf_thread_##__name##_start((__task), (__pri), (__stack), (__stack_bytesize))
 
#define init_vsf_thread(__name, __task, __pri)    __init_vsf_thread(__name, (__task), (__pri))
 
#define init_vsf_thread_ex(__name, __task, __pri, __stack, __stack_bytesize)    __init_vsf_thread_ex(__name, (__task), (__pri), (__stack), (__stack_bytesize))
 
#define __vsf_thread(__name)   thread_cb_##__name##_t
 
#define vsf_thread(__name)   __vsf_thread(__name)
 
#define vsf_thread_wfm   vsf_thread_wait_for_msg
 
#define vsf_thread_wfe   vsf_thread_wait_for_evt
 
#define vsf_thread_wfem   vsf_thread_wait_for_evt_msg
 
#define __vsf_thread_call_sub(__name, __target, ...)
 
#define vsf_thread_call_sub(__name, __target, ...)    __vsf_thread_call_sub(__name, (__target), (0, ##__VA_ARGS__))
 
#define vsf_thread_call_pt(__name, __target, ...)
 
#define vsf_thread_call_task(__name, __target, ...)    vk_thread_call_task(vsf_task_func(__name), __target, (0, ##__VA_ARGS__))
 
#define vsf_thread_delay_ms(__ms)   vsf_thread_delay(vsf_systimer_ms_to_tick(__ms))
 
#define vsf_thread_delay_us(__us)   vsf_thread_delay(vsf_systimer_us_to_tick(__us))
 
#define vsf_thread_sem_post(__sem)   vsf_eda_sem_post(__sem)
 
#define vsf_thread_sem_pend(__sem, timeout)   __vsf_thread_wait_for_sync(__sem, timeout)
 
#define vsf_thread_trig_set(__trig, ...)   vsf_eda_trig_set(__trig, ##__VA_ARGS__)
 
#define vsf_thread_trig_reset(__trig)   vsf_eda_trig_reset(__trig)
 
#define vsf_thread_trig_pend(__trig, timeout)   __vsf_thread_wait_for_sync(__trig, timeout)
 
#define vsf_thread_mutex_enter(__mtx, timeout)   __vsf_thread_wait_for_sync(&(__mtx)->use_as__vsf_sync_t, timeout)
 

Functions

 declare_class (vsf_thread_t) typedef void vsf_thread_sighandler_t(vsf_thread_t *thread
 
 declare_class (vsf_thread_cb_t) typedef void vsf_thread_entry_t(vsf_thread_cb_t *thread)
 

Variables

int sig
 

Macro Definition Documentation

◆ VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE

#define VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE   1

◆ VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE

#define VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE   0

◆ VSF_KERNEL_CFG_THREAD_STACK_ALIGN_BIT

#define VSF_KERNEL_CFG_THREAD_STACK_ALIGN_BIT   3

◆ __VSF_THREAD_STACK_SAFE_SIZE

#define __VSF_THREAD_STACK_SAFE_SIZE (   __stack)
Value:
( ( ( ((__stack) + VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE - 1) \
/ VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE) \
* VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE) \
+ VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE)
VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE
#define VSF_KERNEL_CFG_THREAD_STACK_PAGE_SIZE
Definition vsf_thread.h:49
VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE
#define VSF_KERNEL_CFG_THREAD_STACK_GUARDIAN_SIZE
Definition vsf_thread.h:52

◆ __declare_vsf_thread

#define __declare_vsf_thread (   __name)
Value:
typedef struct __name __name; \
typedef struct thread_cb_##__name##_t thread_cb_##__name##_t;
__name
#define __name
Definition hci_transport_aic8800.c:552

◆ declare_vsf_thread

#define declare_vsf_thread (   __name)    __declare_vsf_thread(__name)

◆ declare_vsf_thread_ex

#define declare_vsf_thread_ex (   __name)    __declare_vsf_thread(__name)

◆ dcl_vsf_thread

#define dcl_vsf_thread (   __name)    declare_vsf_thread(__name)

◆ dcl_vsf_thread_ex

#define dcl_vsf_thread_ex (   __name)    declare_vsf_thread(__name)

◆ __vsf_thread_set_stack_canery

#define __vsf_thread_set_stack_canery (   __thread,
  __task 
)     (__thread)->canary = 0xDEADBEEF;

◆ __vsf_thread_set_stack

#define __vsf_thread_set_stack (   __thread,
  __task,
  __stack_ptr,
  __stack_bytesize 
)
Value:
(__thread)->use_as__vsf_thread_cb_t.stack = (__stack_ptr); \
(__thread)->use_as__vsf_thread_cb_t.stack_size = (__stack_bytesize);\
__vsf_thread_set_stack_canery(__thread, __task)

◆ __vsf_thread_def_stack

#define __vsf_thread_def_stack (   __name,
  __bytesize 
)
Value:
typedef enum { \
vsf_thread##__name##_stack_bytesize = (__bytesize), \
};
vsf_thread
#define vsf_thread(__name)
Definition vsf_thread.h:364

◆ __vsf_thread_def_stack_member

#define __vsf_thread_def_stack_member (   __name,
  __bytesize 
)

◆ __vsf_thread_imp_stack

#define __vsf_thread_imp_stack (   __name,
  __thread,
  __task 
)     __vsf_thread_set_stack((__thread), (__task), NULL, (vsf_thread##__name##_stack_bytesize))

◆ __vsf_eda_call_thread_prepare_stack

#define __vsf_eda_call_thread_prepare_stack (   __name,
  __thread 
)
Value:
.stack = NULL, \
.stack_size = (vsf_thread##__name##_stack_bytesize),
NULL
#define NULL
Definition stddef.h:52

◆ __def_vsf_thread

#define __def_vsf_thread (   __name,
  __stack_bytesize,
  ... 
)
Value:
__vsf_thread_def_stack(__name, (__stack_bytesize)) \
struct thread_cb_##__name##_t { \
implement(vsf_thread_cb_t) \
__VA_ARGS__ \
__vsf_thread_def_stack_member(__name, (__stack_bytesize)) \
}; \
struct __name { \
implement(vsf_thread_t) \
implement_ex(thread_cb_##__name##_t, param) \
} VSF_CAL_ALIGN(8); \
extern void vsf_thread_##__name##_start(struct __name *task, \
vsf_prio_t priority); \
extern void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis);
VSF_CAL_ALIGN
#define VSF_CAL_ALIGN(__N)
Definition __compiler.h:179
_start
void _start(void)
Definition startup_CMSDK_ARMv8MBL.c:62
vsf_prio_t
vsf_prio_t
Definition vsf_kernel_common.h:37
__vsf_thread_def_stack
#define __vsf_thread_def_stack(__name, __bytesize)
Definition vsf_thread.h:114

◆ __implement_vsf_thread

#define __implement_vsf_thread (   __name)
Value:
void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis); \
void vsf_thread_##__name##_start( struct __name *task, \
vsf_prio_t priority) \
{ \
VSF_KERNEL_ASSERT(NULL != task); \
thread_cb_##__name##_t *__vsf_pthis = &(task->param); \
__vsf_pthis->use_as__vsf_thread_cb_t.entry = (vsf_thread_entry_t *)\
&vsf_thread_##__name##_entry; \
__vsf_thread_imp_stack(__name, __vsf_pthis, task) \
vsf_thread_start( &(task->use_as__vsf_thread_t), \
&(__vsf_pthis->use_as__vsf_thread_cb_t), \
priority); \
} \
void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis)

◆ __vsf_eda_call_thread_prepare

#define __vsf_eda_call_thread_prepare (   __name,
  __thread_cb 
)
Value:
do { \
thread_cb_##__name##_t *__vsf_pthis = (__thread_cb); \
const vsf_thread_prepare_cfg_t cfg = { \
.entry = (vsf_thread_entry_t *) \
&vsf_thread_##__name##_entry, \
__vsf_eda_call_thread_prepare_stack(__name, (__thread_cb)) \
}; \
vk_eda_call_thread_prepare(&(__vsf_pthis->use_as__vsf_thread_cb_t),\
(vsf_thread_prepare_cfg_t *)&cfg);\
} while(0)
__vsf_eda_call_thread_prepare_stack
#define __vsf_eda_call_thread_prepare_stack(__name, __thread)
Definition vsf_thread.h:121

◆ vsf_eda_call_thread_prepare

#define vsf_eda_call_thread_prepare (   __name,
  __thread_cb 
)     __vsf_eda_call_thread_prepare(__name, __thread_cb)

◆ vsf_eda_call_thread

#define vsf_eda_call_thread (   __thread_cb)     vk_eda_call_thread(&((__thread_cb)->use_as__vsf_thread_cb_t))

◆ __def_vsf_thread_ex

#define __def_vsf_thread_ex (   __name,
  ... 
)
Value:
struct thread_cb_##__name##_t { \
implement(vsf_thread_cb_t) \
__VA_ARGS__ \
}; \
struct __name { \
implement(vsf_thread_t) \
implement_ex(thread_cb_##__name##_t, param) \
}; \
extern void vsf_thread_##__name##_start( struct __name *task, \
vsf_prio_t priority, \
void *stack, \
uint_fast32_t size); \
extern void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis);
uint_fast32_t
unsigned int uint_fast32_t
Definition stdint.h:27
size
uint32_t size
Definition vsf_memfs.h:50

◆ __implement_vsf_thread_ex

#define __implement_vsf_thread_ex (   __name)
Value:
void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis); \
void vsf_thread_##__name##_start( struct __name *task, \
vsf_prio_t priority, \
void *stack, \
uint_fast32_t size) \
{ \
VSF_KERNEL_ASSERT(NULL != task && 0 != size && NULL != stack); \
thread_cb_##__name##_t *__vsf_pthis = &(task->param); \
__vsf_pthis->use_as__vsf_thread_cb_t.entry = (vsf_thread_entry_t *)\
&vsf_thread_##__name##_entry; \
__vsf_pthis->use_as__vsf_thread_cb_t.stack = stack; \
__vsf_pthis->use_as__vsf_thread_cb_t.stack_size = size; \
vsf_thread_start( &(task->use_as__vsf_thread_t), \
&(task->param.use_as__vsf_thread_cb_t), \
priority); \
} \
void vsf_thread_##__name##_entry( \
struct thread_cb_##__name##_t *vsf_pthis)

◆ __vsf_eda_call_thread_prepare_ex__

#define __vsf_eda_call_thread_prepare_ex__ (   __name,
  __thread_cb,
  __stack,
  __stack_bytesize 
)
Value:
do { \
VSF_KERNEL_ASSERT((NULL != (__stack)) && (0 != (__size))) \
thread_cb_##__name##_t *__vsf_pthis = (__thread_cb); \
const vsf_thread_prepare_cfg_t cfg = { \
.entry = (vsf_thread_entry_t *) \
&vsf_thread_##__name##_entry, \
.stack = (__stack), \
.stack_size = (__stack_bytesize), \
}; \
vk_eda_call_thread_prepare(&(__vsf_pthis->use_as__vsf_thread_cb_t),\
(vsf_thread_prepare_cfg_t *)&cfg);\
} while(0)

◆ vsf_eda_call_thread_prepare_ex

#define vsf_eda_call_thread_prepare_ex (   __name,
  __thread_cb,
  __stack,
  __stack_bytesize 
)
Value:
__vsf_eda_call_thread_prepare_ex__( __name, \
(__thread_cb), \
(__stack), \
(__stack_bytesize))
__vsf_eda_call_thread_prepare_ex__
#define __vsf_eda_call_thread_prepare_ex__( __name, __thread_cb, __stack, __stack_bytesize)
Definition vsf_thread.h:229

◆ vsf_eda_call_thread_ex

#define vsf_eda_call_thread_ex (   __thread_cb)     vk_eda_call_thread(&((__thread_cb)->use_as__vsf_thread_cb_t))

◆ def_vsf_thread

#define def_vsf_thread (   __name,
  __stack_bytesize,
  ... 
)     __def_vsf_thread(__name, (__stack_bytesize), __VA_ARGS__)

◆ define_vsf_thread

#define define_vsf_thread (   __name,
  __stack_bytesize,
  ... 
)     def_vsf_thread(__name, (__stack_bytesize), __VA_ARGS__)

◆ def_vsf_thread_ex

#define def_vsf_thread_ex (   __name,
  ... 
)     __def_vsf_thread_ex(__name, __VA_ARGS__)

◆ define_vsf_thread_ex

#define define_vsf_thread_ex (   __name,
  ... 
)     def_vsf_thread_ex(__name, __VA_ARGS__)

◆ end_def_vsf_thread

#define end_def_vsf_thread (   ...)

◆ end_define_vsf_thread

#define end_define_vsf_thread (   ...)

◆ implement_vsf_thread

#define implement_vsf_thread (   __name)    __implement_vsf_thread(__name)

◆ implement_vsf_thread_ex

#define implement_vsf_thread_ex (   __name)    __implement_vsf_thread_ex(__name)

◆ imp_vsf_thread

#define imp_vsf_thread (   __name)    implement_vsf_thread(__name)

◆ imp_vsf_thread_ex

#define imp_vsf_thread_ex (   __name)    implement_vsf_thread_ex(__name)

◆ __init_vsf_thread

#define __init_vsf_thread (   __name,
  __task,
  __pri 
)     vsf_thread_##__name##_start((__task), (__pri))

◆ __init_vsf_thread_ex

#define __init_vsf_thread_ex (   __name,
  __task,
  __pri,
  __stack,
  __stack_bytesize 
)     vsf_thread_##__name##_start((__task), (__pri), (__stack), (__stack_bytesize))

◆ init_vsf_thread

#define init_vsf_thread (   __name,
  __task,
  __pri 
)     __init_vsf_thread(__name, (__task), (__pri))

◆ init_vsf_thread_ex

#define init_vsf_thread_ex (   __name,
  __task,
  __pri,
  __stack,
  __stack_bytesize 
)     __init_vsf_thread_ex(__name, (__task), (__pri), (__stack), (__stack_bytesize))

◆ __vsf_thread

#define __vsf_thread (   __name)    thread_cb_##__name##_t

◆ vsf_thread

#define vsf_thread (   __name)    __vsf_thread(__name)

◆ vsf_thread_wfm

#define vsf_thread_wfm   vsf_thread_wait_for_msg

◆ vsf_thread_wfe

#define vsf_thread_wfe   vsf_thread_wait_for_evt

◆ vsf_thread_wfem

#define vsf_thread_wfem   vsf_thread_wait_for_evt_msg

◆ __vsf_thread_call_sub

#define __vsf_thread_call_sub (   __name,
  __target,
  ... 
)
Value:
vk_thread_call_eda( (uintptr_t)(__name), \
(uintptr_t)(__target), \
(0, ##__VA_ARGS__), \
0, \
0)
uintptr_t
uint32_t uintptr_t
Definition stdint.h:38
vk_thread_call_eda
vsf_err_t vk_thread_call_eda(uintptr_t eda_handler, uintptr_t param, size_t local_size, size_t local_buff_size, uintptr_t local_buff)
Definition vsf_thread.c:670

◆ vsf_thread_call_sub

#define vsf_thread_call_sub (   __name,
  __target,
  ... 
)     __vsf_thread_call_sub(__name, (__target), (0, ##__VA_ARGS__))

◆ vsf_thread_call_pt

#define vsf_thread_call_pt (   __name,
  __target,
  ... 
)
Value:
(__target)->fsm_state = 0; \
vsf_thread_call_sub(vsf_pt_func(__name), (__target), (0, ##__VA_ARGS__))
vsf_pt_func
#define vsf_pt_func(__name)
Definition vsf_pt.h:180

◆ vsf_thread_call_task

#define vsf_thread_call_task (   __name,
  __target,
  ... 
)     vk_thread_call_task(vsf_task_func(__name), __target, (0, ##__VA_ARGS__))

◆ vsf_thread_delay_ms

#define vsf_thread_delay_ms (   __ms)    vsf_thread_delay(vsf_systimer_ms_to_tick(__ms))

◆ vsf_thread_delay_us

#define vsf_thread_delay_us (   __us)    vsf_thread_delay(vsf_systimer_us_to_tick(__us))

◆ vsf_thread_sem_post

#define vsf_thread_sem_post (   __sem)    vsf_eda_sem_post(__sem)

◆ vsf_thread_sem_pend

#define vsf_thread_sem_pend (   __sem,
  timeout 
)    __vsf_thread_wait_for_sync(__sem, timeout)

◆ vsf_thread_trig_set

#define vsf_thread_trig_set (   __trig,
  ... 
)    vsf_eda_trig_set(__trig, ##__VA_ARGS__)

◆ vsf_thread_trig_reset

#define vsf_thread_trig_reset (   __trig)    vsf_eda_trig_reset(__trig)

◆ vsf_thread_trig_pend

#define vsf_thread_trig_pend (   __trig,
  timeout 
)    __vsf_thread_wait_for_sync(__trig, timeout)

◆ vsf_thread_mutex_enter

#define vsf_thread_mutex_enter (   __mtx,
  timeout 
)    __vsf_thread_wait_for_sync(&(__mtx)->use_as__vsf_sync_t, timeout)

Function Documentation

◆ declare_class() [1/2]

declare_class ( vsf_thread_t  )

◆ declare_class() [2/2]

declare_class ( vsf_thread_cb_t  )

Variable Documentation

◆ sig

int sig
Generated by doxygen 1.9.8