1461 lines
55 KiB
C
1461 lines
55 KiB
C
/*
|
|
* Copyright (c) 2006-2024, RT-Thread Development Team
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*
|
|
* Change Logs:
|
|
* Date Author Notes
|
|
* 2007-01-10 Bernard the first version
|
|
* 2008-07-12 Bernard remove all rt_int8, rt_uint32_t etc typedef
|
|
* 2010-10-26 yi.qiu add module support
|
|
* 2010-11-10 Bernard add cleanup callback function in thread exit.
|
|
* 2011-05-09 Bernard use builtin va_arg in GCC 4.x
|
|
* 2012-11-16 Bernard change RT_NULL from ((void*)0) to 0.
|
|
* 2012-12-29 Bernard change the RT_USING_MEMPOOL location and add
|
|
* RT_USING_MEMHEAP condition.
|
|
* 2012-12-30 Bernard add more control command for graphic.
|
|
* 2013-01-09 Bernard change version number.
|
|
* 2015-02-01 Bernard change version number to v2.1.0
|
|
* 2017-08-31 Bernard change version number to v3.0.0
|
|
* 2017-11-30 Bernard change version number to v3.0.1
|
|
* 2017-12-27 Bernard change version number to v3.0.2
|
|
* 2018-02-24 Bernard change version number to v3.0.3
|
|
* 2018-04-25 Bernard change version number to v3.0.4
|
|
* 2018-05-31 Bernard change version number to v3.1.0
|
|
* 2018-09-04 Bernard change version number to v3.1.1
|
|
* 2018-09-14 Bernard apply Apache License v2.0 to RT-Thread Kernel
|
|
* 2018-10-13 Bernard change version number to v4.0.0
|
|
* 2018-10-02 Bernard add 64bit arch support
|
|
* 2018-11-22 Jesven add smp member to struct rt_thread
|
|
* add struct rt_cpu
|
|
* add smp relevant macros
|
|
* 2019-01-27 Bernard change version number to v4.0.1
|
|
* 2019-05-17 Bernard change version number to v4.0.2
|
|
* 2019-12-20 Bernard change version number to v4.0.3
|
|
* 2020-08-10 Meco Man add macro for struct rt_device_ops
|
|
* 2020-10-23 Meco Man define maximum value of ipc type
|
|
* 2021-03-19 Meco Man add security devices
|
|
* 2021-05-10 armink change version number to v4.0.4
|
|
* 2021-11-19 Meco Man change version number to v4.1.0
|
|
* 2021-12-21 Meco Man re-implement RT_UNUSED
|
|
* 2022-01-01 Gabriel improve hooking method
|
|
* 2022-01-07 Gabriel move some __on_rt_xxxxx_hook to dedicated c source files
|
|
* 2022-01-12 Meco Man remove RT_THREAD_BLOCK
|
|
* 2022-04-20 Meco Man change version number to v4.1.1
|
|
* 2022-04-21 THEWON add macro RT_VERSION_CHECK
|
|
* 2022-06-29 Meco Man add RT_USING_LIBC and standard libc headers
|
|
* 2022-08-16 Meco Man change version number to v5.0.0
|
|
* 2022-09-12 Meco Man define rt_ssize_t
|
|
* 2022-12-20 Meco Man add const name for rt_object
|
|
* 2023-04-01 Chushicheng change version number to v5.0.1
|
|
* 2023-05-20 Bernard add stdc atomic detection.
|
|
* 2023-09-15 xqyjlj perf rt_hw_interrupt_disable/enable
|
|
* 2023-10-10 Chushicheng change version number to v5.1.0
|
|
* 2023-10-11 zmshahaha move specific devices related and driver to components/drivers
|
|
* 2023-11-21 Meco Man add RT_USING_NANO macro
|
|
* 2023-11-17 xqyjlj add process group and session support
|
|
* 2023-12-01 Shell Support of dynamic device
|
|
* 2023-12-18 xqyjlj add rt_always_inline
|
|
* 2023-12-22 Shell Support hook list
|
|
* 2024-01-18 Shell Seperate basical types to a rttypes.h
|
|
* Seperate the compiler portings to rtcompiler.h
|
|
* 2024-03-30 Meco Man update version number to v5.2.0
|
|
*/
|
|
|
|
#ifndef __RT_DEF_H__
|
|
#define __RT_DEF_H__
|
|
|
|
#include "rtsched.h"
|
|
#include "rttypes.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* @addtogroup BasicDef
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/* RT-Thread version information */
|
|
#define RT_VERSION_MAJOR 5 /**< Major version number (X.x.x) */
|
|
#define RT_VERSION_MINOR 2 /**< Minor version number (x.X.x) */
|
|
#define RT_VERSION_PATCH 0 /**< Patch version number (x.x.X) */
|
|
|
|
/* e.g. #if (RTTHREAD_VERSION >= RT_VERSION_CHECK(4, 1, 0) */
|
|
#define RT_VERSION_CHECK(major, minor, revise) ((major * 10000) + (minor * 100) + revise)
|
|
|
|
/* RT-Thread version */
|
|
#define RTTHREAD_VERSION RT_VERSION_CHECK(RT_VERSION_MAJOR, RT_VERSION_MINOR, RT_VERSION_PATCH)
|
|
|
|
|
|
/**@}*/
|
|
|
|
/* maximum value of base type */
|
|
#ifdef RT_USING_LIBC
|
|
#define RT_UINT8_MAX UINT8_MAX /**< Maximum number of UINT8 */
|
|
#define RT_UINT16_MAX UINT16_MAX /**< Maximum number of UINT16 */
|
|
#define RT_UINT32_MAX UINT32_MAX /**< Maximum number of UINT32 */
|
|
#define RT_UINT64_MAX UINT64_MAX /**< Maximum number of UINT64 */
|
|
#else
|
|
#define RT_UINT8_MAX 0xff /**< Maximum number of UINT8 */
|
|
#define RT_UINT16_MAX 0xffff /**< Maximum number of UINT16 */
|
|
#define RT_UINT32_MAX 0xffffffff /**< Maximum number of UINT32 */
|
|
#define RT_UINT64_MAX 0xffffffffffffffff
|
|
#endif /* RT_USING_LIBC */
|
|
|
|
#define RT_TICK_MAX RT_UINT32_MAX /**< Maximum number of tick */
|
|
|
|
/* maximum value of ipc type */
|
|
#define RT_SEM_VALUE_MAX RT_UINT16_MAX /**< Maximum number of semaphore .value */
|
|
#define RT_MUTEX_VALUE_MAX RT_UINT16_MAX /**< Maximum number of mutex .value */
|
|
#define RT_MUTEX_HOLD_MAX RT_UINT8_MAX /**< Maximum number of mutex .hold */
|
|
#define RT_MB_ENTRY_MAX RT_UINT16_MAX /**< Maximum number of mailbox .entry */
|
|
#define RT_MQ_ENTRY_MAX RT_UINT16_MAX /**< Maximum number of message queue .entry */
|
|
|
|
/* Common Utilities */
|
|
|
|
#define RT_UNUSED(x) ((void)x)
|
|
|
|
/* compile time assertion */
|
|
#define RT_STATIC_ASSERT(name, expn) typedef char _static_assert_##name[(expn)?1:-1]
|
|
|
|
/* Compiler Related Definitions */
|
|
#include "rtcompiler.h"
|
|
|
|
/* initialization export */
|
|
#ifdef RT_USING_COMPONENTS_INIT
|
|
typedef int (*init_fn_t)(void);
|
|
#ifdef _MSC_VER
|
|
#pragma section("rti_fn$f",read)
|
|
#ifdef RT_DEBUGING_AUTO_INIT
|
|
struct rt_init_desc
|
|
{
|
|
const char* level;
|
|
const init_fn_t fn;
|
|
const char* fn_name;
|
|
};
|
|
#define INIT_EXPORT(fn, level) \
|
|
const char __rti_level_##fn[] = ".rti_fn." level; \
|
|
const char __rti_##fn##_name[] = #fn; \
|
|
__declspec(allocate("rti_fn$f")) \
|
|
rt_used const struct rt_init_desc __rt_init_msc_##fn = \
|
|
{__rti_level_##fn, fn, __rti_##fn##_name};
|
|
#else
|
|
struct rt_init_desc
|
|
{
|
|
const char* level;
|
|
const init_fn_t fn;
|
|
};
|
|
#define INIT_EXPORT(fn, level) \
|
|
const char __rti_level_##fn[] = ".rti_fn." level; \
|
|
__declspec(allocate("rti_fn$f")) \
|
|
rt_used const struct rt_init_desc __rt_init_msc_##fn = \
|
|
{__rti_level_##fn, fn };
|
|
#endif /* RT_DEBUGING_AUTO_INIT */
|
|
#else
|
|
#ifdef RT_DEBUGING_AUTO_INIT
|
|
struct rt_init_desc
|
|
{
|
|
const char* fn_name;
|
|
const init_fn_t fn;
|
|
};
|
|
#define INIT_EXPORT(fn, level) \
|
|
const char __rti_##fn##_name[] = #fn; \
|
|
rt_used const struct rt_init_desc __rt_init_desc_##fn rt_section(".rti_fn." level) = \
|
|
{ __rti_##fn##_name, fn};
|
|
#else
|
|
#define INIT_EXPORT(fn, level) \
|
|
rt_used const init_fn_t __rt_init_##fn rt_section(".rti_fn." level) = fn
|
|
#endif /* RT_DEBUGING_AUTO_INIT */
|
|
#endif /* _MSC_VER */
|
|
#else
|
|
#define INIT_EXPORT(fn, level)
|
|
#endif /* RT_USING_COMPONENTS_INIT */
|
|
|
|
/* board init routines will be called in board_init() function */
|
|
#define INIT_BOARD_EXPORT(fn) INIT_EXPORT(fn, "1")
|
|
|
|
/* init cpu, memory, interrupt-controller, bus... */
|
|
#define INIT_CORE_EXPORT(fn) INIT_EXPORT(fn, "1.0")
|
|
/* init pci/pcie, usb platform driver... */
|
|
#define INIT_FRAMEWORK_EXPORT(fn) INIT_EXPORT(fn, "1.1")
|
|
/* init platform, user code... */
|
|
#define INIT_PLATFORM_EXPORT(fn) INIT_EXPORT(fn, "1.2")
|
|
/* init sys-timer, clk, pinctrl... */
|
|
#define INIT_SUBSYS_EARLY_EXPORT(fn) INIT_EXPORT(fn, "1.3.0")
|
|
#define INIT_SUBSYS_EXPORT(fn) INIT_EXPORT(fn, "1.3.1")
|
|
/* init early drivers */
|
|
#define INIT_DRIVER_EARLY_EXPORT(fn) INIT_EXPORT(fn, "1.4")
|
|
|
|
/* pre/device/component/env/app init routines will be called in init_thread */
|
|
/* components pre-initialization (pure software initialization) */
|
|
#define INIT_PREV_EXPORT(fn) INIT_EXPORT(fn, "2")
|
|
/* device initialization */
|
|
#define INIT_DEVICE_EXPORT(fn) INIT_EXPORT(fn, "3")
|
|
/* components initialization (dfs, lwip, ...) */
|
|
#define INIT_COMPONENT_EXPORT(fn) INIT_EXPORT(fn, "4")
|
|
/* environment initialization (mount disk, ...) */
|
|
#define INIT_ENV_EXPORT(fn) INIT_EXPORT(fn, "5")
|
|
/* application initialization (rtgui application etc ...) */
|
|
#define INIT_APP_EXPORT(fn) INIT_EXPORT(fn, "6")
|
|
|
|
/* init after mount fs */
|
|
#define INIT_FS_EXPORT(fn) INIT_EXPORT(fn, "6.0")
|
|
/* init in secondary_cpu_c_start */
|
|
#define INIT_SECONDARY_CPU_EXPORT(fn) INIT_EXPORT(fn, "7")
|
|
|
|
#if !defined(RT_USING_FINSH)
|
|
/* define these to empty, even if not include finsh.h file */
|
|
#define FINSH_FUNCTION_EXPORT(name, desc)
|
|
#define FINSH_FUNCTION_EXPORT_ALIAS(name, alias, desc)
|
|
|
|
#define MSH_CMD_EXPORT(command, desc)
|
|
#define MSH_CMD_EXPORT_ALIAS(command, alias, desc)
|
|
#elif !defined(FINSH_USING_SYMTAB)
|
|
#define FINSH_FUNCTION_EXPORT_CMD(name, cmd, desc)
|
|
#endif
|
|
|
|
/* event length */
|
|
#define RT_EVENT_LENGTH 32
|
|
|
|
/* memory management option */
|
|
#define RT_MM_PAGE_SIZE 4096
|
|
#define RT_MM_PAGE_MASK (RT_MM_PAGE_SIZE - 1)
|
|
#define RT_MM_PAGE_BITS 12
|
|
|
|
/* kernel malloc definitions */
|
|
#ifndef RT_KERNEL_MALLOC
|
|
#define RT_KERNEL_MALLOC(sz) rt_malloc(sz)
|
|
#endif /* RT_KERNEL_MALLOC */
|
|
|
|
#ifndef RT_KERNEL_FREE
|
|
#define RT_KERNEL_FREE(ptr) rt_free(ptr)
|
|
#endif /* RT_KERNEL_FREE */
|
|
|
|
#ifndef RT_KERNEL_REALLOC
|
|
#define RT_KERNEL_REALLOC(ptr, size) rt_realloc(ptr, size)
|
|
#endif /* RT_KERNEL_REALLOC */
|
|
|
|
/**
|
|
* @addtogroup Error
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/* RT-Thread error code definitions */
|
|
#if defined(RT_USING_LIBC) && !defined(RT_USING_NANO)
|
|
/* POSIX error code compatible */
|
|
#define RT_EOK 0 /**< There is no error */
|
|
#define RT_ERROR 255 /**< A generic/unknown error happens */
|
|
#define RT_ETIMEOUT ETIMEDOUT /**< Timed out */
|
|
#define RT_EFULL ENOSPC /**< The resource is full */
|
|
#define RT_EEMPTY ENODATA /**< The resource is empty */
|
|
#define RT_ENOMEM ENOMEM /**< No memory */
|
|
#define RT_ENOSYS ENOSYS /**< Function not implemented */
|
|
#define RT_EBUSY EBUSY /**< Busy */
|
|
#define RT_EIO EIO /**< IO error */
|
|
#define RT_EINTR EINTR /**< Interrupted system call */
|
|
#define RT_EINVAL EINVAL /**< Invalid argument */
|
|
#define RT_ENOENT ENOENT /**< No entry */
|
|
#define RT_ENOSPC ENOSPC /**< No space left */
|
|
#define RT_EPERM EPERM /**< Operation not permitted */
|
|
#define RT_EFAULT EFAULT /**< Bad address */
|
|
#define RT_ENOBUFS ENOBUFS /**< No buffer space is available */
|
|
#define RT_ESCHEDISR 253 /**< scheduler failure in isr context */
|
|
#define RT_ESCHEDLOCKED 252 /**< scheduler failure in critical region */
|
|
#define RT_ETRAP 254 /**< Trap event */
|
|
#else
|
|
#define RT_EOK 0 /**< There is no error */
|
|
#define RT_ERROR 1 /**< A generic/unknown error happens */
|
|
#define RT_ETIMEOUT 2 /**< Timed out */
|
|
#define RT_EFULL 3 /**< The resource is full */
|
|
#define RT_EEMPTY 4 /**< The resource is empty */
|
|
#define RT_ENOMEM 5 /**< No memory */
|
|
#define RT_ENOSYS 6 /**< Function not implemented */
|
|
#define RT_EBUSY 7 /**< Busy */
|
|
#define RT_EIO 8 /**< IO error */
|
|
#define RT_EINTR 9 /**< Interrupted system call */
|
|
#define RT_EINVAL 10 /**< Invalid argument */
|
|
#define RT_ENOENT 11 /**< No entry */
|
|
#define RT_ENOSPC 12 /**< No space left */
|
|
#define RT_EPERM 13 /**< Operation not permitted */
|
|
#define RT_ETRAP 14 /**< Trap event */
|
|
#define RT_EFAULT 15 /**< Bad address */
|
|
#define RT_ENOBUFS 16 /**< No buffer space is available */
|
|
#define RT_ESCHEDISR 17 /**< scheduler failure in isr context */
|
|
#define RT_ESCHEDLOCKED 18 /**< scheduler failure in critical region */
|
|
#endif /* defined(RT_USING_LIBC) && !defined(RT_USING_NANO) */
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @ingroup BasicDef
|
|
*
|
|
* @def RT_IS_ALIGN(addr, align)
|
|
* Return true(1) or false(0).
|
|
* RT_IS_ALIGN(128, 4) is judging whether 128 aligns with 4.
|
|
* The result is 1, which means 128 aligns with 4.
|
|
* @note If the address is NULL, false(0) will be returned
|
|
*/
|
|
#define RT_IS_ALIGN(addr, align) ((!(addr & (align - 1))) && (addr != RT_NULL))
|
|
|
|
/**
|
|
* @ingroup BasicDef
|
|
*
|
|
* @def RT_ALIGN(size, align)
|
|
* Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
|
|
* would return 16.
|
|
*/
|
|
#define RT_ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1))
|
|
|
|
/**
|
|
* @ingroup BasicDef
|
|
*
|
|
* @def RT_ALIGN_DOWN(size, align)
|
|
* Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4)
|
|
* would return 12.
|
|
*/
|
|
#define RT_ALIGN_DOWN(size, align) ((size) & ~((align) - 1))
|
|
|
|
/**
|
|
* @addtogroup KernelObject
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/*
|
|
* kernel object macros
|
|
*/
|
|
#define RT_OBJECT_FLAG_MODULE 0x80 /**< is module object. */
|
|
|
|
/**
|
|
* Base structure of Kernel object
|
|
*/
|
|
struct rt_object
|
|
{
|
|
#if RT_NAME_MAX > 0
|
|
char name[RT_NAME_MAX]; /**< dynamic name of kernel object */
|
|
#else
|
|
const char *name; /**< static name of kernel object */
|
|
#endif /* RT_NAME_MAX > 0 */
|
|
rt_uint8_t type; /**< type of kernel object */
|
|
rt_uint8_t flag; /**< flag of kernel object */
|
|
|
|
#ifdef RT_USING_MODULE
|
|
void * module_id; /**< id of application module */
|
|
#endif /* RT_USING_MODULE */
|
|
|
|
#ifdef RT_USING_SMART
|
|
rt_atomic_t lwp_ref_count; /**< ref count for lwp */
|
|
#endif /* RT_USING_SMART */
|
|
|
|
rt_list_t list; /**< list node of kernel object */
|
|
};
|
|
typedef struct rt_object *rt_object_t; /**< Type for kernel objects. */
|
|
|
|
/**
|
|
* iterator of rt_object_for_each()
|
|
*
|
|
* data is the data passing in to rt_object_for_each(). iterator can return
|
|
* RT_EOK to continue the iteration; or any positive value to break the loop
|
|
* successfully; or any negative errno to break the loop on failure.
|
|
*/
|
|
typedef rt_err_t (*rt_object_iter_t)(rt_object_t object, void *data);
|
|
|
|
/**
|
|
* The object type can be one of the follows with specific
|
|
* macros enabled:
|
|
* - Thread
|
|
* - Semaphore
|
|
* - Mutex
|
|
* - Event
|
|
* - MailBox
|
|
* - MessageQueue
|
|
* - MemHeap
|
|
* - MemPool
|
|
* - Device
|
|
* - Timer
|
|
* - Module
|
|
* - Unknown
|
|
* - Static
|
|
*/
|
|
enum rt_object_class_type
|
|
{
|
|
RT_Object_Class_Null = 0x00, /**< The object is not used. */
|
|
RT_Object_Class_Thread = 0x01, /**< The object is a thread. */
|
|
RT_Object_Class_Semaphore = 0x02, /**< The object is a semaphore. */
|
|
RT_Object_Class_Mutex = 0x03, /**< The object is a mutex. */
|
|
RT_Object_Class_Event = 0x04, /**< The object is a event. */
|
|
RT_Object_Class_MailBox = 0x05, /**< The object is a mail box. */
|
|
RT_Object_Class_MessageQueue = 0x06, /**< The object is a message queue. */
|
|
RT_Object_Class_MemHeap = 0x07, /**< The object is a memory heap. */
|
|
RT_Object_Class_MemPool = 0x08, /**< The object is a memory pool. */
|
|
RT_Object_Class_Device = 0x09, /**< The object is a device. */
|
|
RT_Object_Class_Timer = 0x0a, /**< The object is a timer. */
|
|
RT_Object_Class_Module = 0x0b, /**< The object is a module. */
|
|
RT_Object_Class_Memory = 0x0c, /**< The object is a memory. */
|
|
RT_Object_Class_Channel = 0x0d, /**< The object is a channel */
|
|
RT_Object_Class_ProcessGroup = 0x0e, /**< The object is a process group */
|
|
RT_Object_Class_Session = 0x0f, /**< The object is a session */
|
|
RT_Object_Class_Custom = 0x10, /**< The object is a custom object */
|
|
RT_Object_Class_Unknown = 0x11, /**< The object is unknown. */
|
|
RT_Object_Class_Static = 0x80 /**< The object is a static object. */
|
|
};
|
|
|
|
/**
|
|
* The information of the kernel object
|
|
*/
|
|
struct rt_object_information
|
|
{
|
|
enum rt_object_class_type type; /**< object class type */
|
|
rt_list_t object_list; /**< object list */
|
|
rt_size_t object_size; /**< object size */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
|
|
/**
|
|
* The hook function call macro
|
|
*/
|
|
#ifndef RT_USING_HOOK
|
|
#define RT_OBJECT_HOOK_CALL(func, argv)
|
|
|
|
#else
|
|
|
|
/**
|
|
* @brief Add hook point in the routines
|
|
* @note Usage:
|
|
* void foo() {
|
|
* do_something();
|
|
*
|
|
* RT_OBJECT_HOOK_CALL(foo);
|
|
*
|
|
* do_other_things();
|
|
* }
|
|
*/
|
|
#define _RT_OBJECT_HOOK_CALL(func, argv) __ON_HOOK_ARGS(func, argv)
|
|
#define RT_OBJECT_HOOK_CALL(func, argv) _RT_OBJECT_HOOK_CALL(func, argv)
|
|
|
|
#ifdef RT_HOOK_USING_FUNC_PTR
|
|
#define __ON_HOOK_ARGS(__hook, argv) do {if ((__hook) != RT_NULL) __hook argv; } while (0)
|
|
#else
|
|
#define __ON_HOOK_ARGS(__hook, argv)
|
|
#endif /* RT_HOOK_USING_FUNC_PTR */
|
|
#endif /* RT_USING_HOOK */
|
|
|
|
#ifdef RT_USING_HOOKLIST
|
|
|
|
/**
|
|
* @brief Add declaration for hook list types.
|
|
*
|
|
* @note Usage:
|
|
* This is typically used in your header. In foo.h using this like:
|
|
*
|
|
* ```foo.h
|
|
* typedef void (*bar_hook_proto_t)(arguments...);
|
|
* RT_OBJECT_HOOKLIST_DECLARE(bar_hook_proto_t, bar_myhook);
|
|
* ```
|
|
*/
|
|
#define RT_OBJECT_HOOKLIST_DECLARE(handler_type, name) \
|
|
typedef struct name##_hooklistnode \
|
|
{ \
|
|
handler_type handler; \
|
|
rt_list_t list_node; \
|
|
} *name##_hooklistnode_t; \
|
|
extern volatile rt_ubase_t name##_nested; \
|
|
void name##_sethook(name##_hooklistnode_t node); \
|
|
void name##_rmhook(name##_hooklistnode_t node)
|
|
|
|
/**
|
|
* @brief Add declaration for hook list node.
|
|
*
|
|
* @note Usage
|
|
* You can add a hook like this.
|
|
*
|
|
* ```addhook.c
|
|
* void myhook(arguments...) { do_something(); }
|
|
* RT_OBJECT_HOOKLIST_DEFINE_NODE(bar_myhook, myhook_node, myhook);
|
|
*
|
|
* void addhook(void)
|
|
* {
|
|
* bar_myhook_sethook(myhook);
|
|
* }
|
|
* ```
|
|
*
|
|
* BTW, you can also find examples codes under
|
|
* `examples/utest/testcases/kernel/hooklist_tc.c`.
|
|
*/
|
|
#define RT_OBJECT_HOOKLIST_DEFINE_NODE(hookname, nodename, hooker_handler) \
|
|
struct hookname##_hooklistnode nodename = { \
|
|
.handler = hooker_handler, \
|
|
.list_node = RT_LIST_OBJECT_INIT(nodename.list_node), \
|
|
};
|
|
|
|
/**
|
|
* @note Usage
|
|
* Add this macro to the source file where your hook point is inserted.
|
|
*/
|
|
#define RT_OBJECT_HOOKLIST_DEFINE(name) \
|
|
static rt_list_t name##_hooklist = RT_LIST_OBJECT_INIT(name##_hooklist); \
|
|
static struct rt_spinlock name##lock = RT_SPINLOCK_INIT; \
|
|
volatile rt_ubase_t name##_nested = 0; \
|
|
void name##_sethook(name##_hooklistnode_t node) \
|
|
{ \
|
|
rt_ubase_t level = rt_spin_lock_irqsave(&name##lock); \
|
|
while (name##_nested) \
|
|
{ \
|
|
rt_spin_unlock_irqrestore(&name##lock, level); \
|
|
level = rt_spin_lock_irqsave(&name##lock); \
|
|
} \
|
|
rt_list_insert_before(&name##_hooklist, &node->list_node); \
|
|
rt_spin_unlock_irqrestore(&name##lock, level); \
|
|
} \
|
|
void name##_rmhook(name##_hooklistnode_t node) \
|
|
{ \
|
|
rt_ubase_t level = rt_spin_lock_irqsave(&name##lock); \
|
|
while (name##_nested) \
|
|
{ \
|
|
rt_spin_unlock_irqrestore(&name##lock, level); \
|
|
level = rt_spin_lock_irqsave(&name##lock); \
|
|
} \
|
|
rt_list_remove(&node->list_node); \
|
|
rt_spin_unlock_irqrestore(&name##lock, level); \
|
|
}
|
|
|
|
/**
|
|
* @brief Add hook list point in the routines. Multiple hookers in the list will
|
|
* be called one by one starting from head node.
|
|
*
|
|
* @note Usage:
|
|
* void foo() {
|
|
* do_something();
|
|
*
|
|
* RT_OBJECT_HOOKLIST_CALL(foo);
|
|
*
|
|
* do_other_things();
|
|
* }
|
|
*/
|
|
#define _RT_OBJECT_HOOKLIST_CALL(nodetype, nested, list, lock, argv) \
|
|
do \
|
|
{ \
|
|
nodetype iter, next; \
|
|
rt_ubase_t level = rt_spin_lock_irqsave(&lock); \
|
|
nested += 1; \
|
|
rt_spin_unlock_irqrestore(&lock, level); \
|
|
if (!rt_list_isempty(&list)) \
|
|
{ \
|
|
rt_list_for_each_entry_safe(iter, next, &list, list_node) \
|
|
{ \
|
|
iter->handler argv; \
|
|
} \
|
|
} \
|
|
level = rt_spin_lock_irqsave(&lock); \
|
|
nested -= 1; \
|
|
rt_spin_unlock_irqrestore(&lock, level); \
|
|
} while (0)
|
|
#define RT_OBJECT_HOOKLIST_CALL(name, argv) \
|
|
_RT_OBJECT_HOOKLIST_CALL(name##_hooklistnode_t, name##_nested, \
|
|
name##_hooklist, name##lock, argv)
|
|
|
|
#else
|
|
|
|
#define RT_OBJECT_HOOKLIST_DECLARE(handler_type, name)
|
|
#define RT_OBJECT_HOOKLIST_DEFINE_NODE(hookname, nodename, hooker_handler)
|
|
#define RT_OBJECT_HOOKLIST_DEFINE(name)
|
|
#define RT_OBJECT_HOOKLIST_CALL(name, argv)
|
|
#endif /* RT_USING_HOOKLIST */
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @addtogroup Clock
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/**
|
|
* clock & timer macros
|
|
*/
|
|
#define RT_TIMER_FLAG_DEACTIVATED 0x0 /**< timer is deactive */
|
|
#define RT_TIMER_FLAG_ACTIVATED 0x1 /**< timer is active */
|
|
#define RT_TIMER_FLAG_ONE_SHOT 0x0 /**< one shot timer */
|
|
#define RT_TIMER_FLAG_PERIODIC 0x2 /**< periodic timer */
|
|
|
|
#define RT_TIMER_FLAG_HARD_TIMER 0x0 /**< hard timer,the timer's callback function will be called in tick isr. */
|
|
#define RT_TIMER_FLAG_SOFT_TIMER 0x4 /**< soft timer,the timer's callback function will be called in timer thread. */
|
|
#define RT_TIMER_FLAG_THREAD_TIMER \
|
|
(0x8 | RT_TIMER_FLAG_HARD_TIMER) /**< thread timer that cooperates with scheduler directly */
|
|
|
|
#define RT_TIMER_CTRL_SET_TIME 0x0 /**< set timer control command */
|
|
#define RT_TIMER_CTRL_GET_TIME 0x1 /**< get timer control command */
|
|
#define RT_TIMER_CTRL_SET_ONESHOT 0x2 /**< change timer to one shot */
|
|
#define RT_TIMER_CTRL_SET_PERIODIC 0x3 /**< change timer to periodic */
|
|
#define RT_TIMER_CTRL_GET_STATE 0x4 /**< get timer run state active or deactive*/
|
|
#define RT_TIMER_CTRL_GET_REMAIN_TIME 0x5 /**< get the remaining hang time */
|
|
#define RT_TIMER_CTRL_GET_FUNC 0x6 /**< get timer timeout func */
|
|
#define RT_TIMER_CTRL_SET_FUNC 0x7 /**< set timer timeout func */
|
|
#define RT_TIMER_CTRL_GET_PARM 0x8 /**< get timer parameter */
|
|
#define RT_TIMER_CTRL_SET_PARM 0x9 /**< get timer parameter */
|
|
|
|
#ifndef RT_TIMER_SKIP_LIST_LEVEL
|
|
#define RT_TIMER_SKIP_LIST_LEVEL 1
|
|
#endif
|
|
|
|
/* 1 or 3 */
|
|
#ifndef RT_TIMER_SKIP_LIST_MASK
|
|
#define RT_TIMER_SKIP_LIST_MASK 0x3 /**< Timer skips the list mask */
|
|
#endif
|
|
|
|
/**
|
|
* timeout handler of rt_timer
|
|
*/
|
|
typedef void (*rt_timer_func_t)(void *parameter);
|
|
|
|
/**
|
|
* timer structure
|
|
*/
|
|
struct rt_timer
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
|
|
rt_list_t row[RT_TIMER_SKIP_LIST_LEVEL];
|
|
|
|
rt_timer_func_t timeout_func; /**< timeout function */
|
|
void *parameter; /**< timeout function's parameter */
|
|
|
|
rt_tick_t init_tick; /**< timer timeout tick */
|
|
rt_tick_t timeout_tick; /**< timeout tick */
|
|
};
|
|
typedef struct rt_timer *rt_timer_t;
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @addtogroup Signal
|
|
*/
|
|
/**@{*/
|
|
|
|
#ifdef RT_USING_SIGNALS
|
|
#define RT_SIG_MAX 32
|
|
typedef unsigned long rt_sigset_t;
|
|
typedef siginfo_t rt_siginfo_t;
|
|
typedef void (*rt_sighandler_t)(int signo);
|
|
#endif /* RT_USING_SIGNALS */
|
|
/**@}*/
|
|
|
|
/**
|
|
* @addtogroup Thread
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/*
|
|
* Thread
|
|
*/
|
|
|
|
/*
|
|
* thread state definitions
|
|
*/
|
|
#define RT_THREAD_INIT 0x00 /**< Initialized status */
|
|
#define RT_THREAD_CLOSE 0x01 /**< Closed status */
|
|
#define RT_THREAD_READY 0x02 /**< Ready status */
|
|
#define RT_THREAD_RUNNING 0x03 /**< Running status */
|
|
|
|
/*
|
|
* for rt_thread_suspend_with_flag()
|
|
*/
|
|
enum
|
|
{
|
|
RT_INTERRUPTIBLE = 0,
|
|
RT_KILLABLE,
|
|
RT_UNINTERRUPTIBLE,
|
|
};
|
|
|
|
#define RT_THREAD_SUSPEND_MASK 0x04
|
|
#define RT_SIGNAL_COMMON_WAKEUP_MASK 0x02
|
|
#define RT_SIGNAL_KILL_WAKEUP_MASK 0x01
|
|
|
|
#define RT_THREAD_SUSPEND_INTERRUPTIBLE (RT_THREAD_SUSPEND_MASK) /**< Suspend interruptable 0x4 */
|
|
#define RT_THREAD_SUSPEND RT_THREAD_SUSPEND_INTERRUPTIBLE
|
|
#define RT_THREAD_SUSPEND_KILLABLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK) /**< Suspend with killable 0x6 */
|
|
#define RT_THREAD_SUSPEND_UNINTERRUPTIBLE (RT_THREAD_SUSPEND_MASK | RT_SIGNAL_COMMON_WAKEUP_MASK | RT_SIGNAL_KILL_WAKEUP_MASK) /**< Suspend with uninterruptable 0x7 */
|
|
#define RT_THREAD_STAT_MASK 0x07
|
|
|
|
#define RT_THREAD_STAT_YIELD 0x08 /**< indicate whether remaining_tick has been reloaded since last schedule */
|
|
#define RT_THREAD_STAT_YIELD_MASK RT_THREAD_STAT_YIELD
|
|
|
|
#define RT_THREAD_STAT_SIGNAL 0x10 /**< task hold signals */
|
|
#define RT_THREAD_STAT_SIGNAL_READY (RT_THREAD_STAT_SIGNAL | RT_THREAD_READY)
|
|
#define RT_THREAD_STAT_SIGNAL_WAIT 0x20 /**< task is waiting for signals */
|
|
#define RT_THREAD_STAT_SIGNAL_PENDING 0x40 /**< signals is held and it has not been procressed */
|
|
#define RT_THREAD_STAT_SIGNAL_MASK 0xf0
|
|
|
|
/**
|
|
* thread control command definitions
|
|
*/
|
|
#define RT_THREAD_CTRL_STARTUP 0x00 /**< Startup thread. */
|
|
#define RT_THREAD_CTRL_CLOSE 0x01 /**< Close thread. */
|
|
#define RT_THREAD_CTRL_CHANGE_PRIORITY 0x02 /**< Change thread priority. */
|
|
#define RT_THREAD_CTRL_INFO 0x03 /**< Get thread information. */
|
|
#define RT_THREAD_CTRL_BIND_CPU 0x04 /**< Set thread bind cpu. */
|
|
|
|
/**
|
|
* CPU usage statistics data
|
|
*/
|
|
struct rt_cpu_usage_stats
|
|
{
|
|
rt_ubase_t user;
|
|
rt_ubase_t system;
|
|
rt_ubase_t irq;
|
|
rt_ubase_t idle;
|
|
};
|
|
typedef struct rt_cpu_usage_stats *rt_cpu_usage_stats_t;
|
|
|
|
#ifdef RT_USING_SMP
|
|
|
|
#define RT_CPU_DETACHED RT_CPUS_NR /**< The thread not running on cpu. */
|
|
#define RT_CPU_MASK ((1 << RT_CPUS_NR) - 1) /**< All CPUs mask bit. */
|
|
|
|
#ifndef RT_SCHEDULE_IPI
|
|
#define RT_SCHEDULE_IPI 0
|
|
#endif /* RT_SCHEDULE_IPI */
|
|
|
|
#ifndef RT_STOP_IPI
|
|
#define RT_STOP_IPI 1
|
|
#endif /* RT_STOP_IPI */
|
|
|
|
#define _SCHEDULER_CONTEXT(fileds) fileds
|
|
|
|
/**
|
|
* CPUs definitions
|
|
*
|
|
*/
|
|
struct rt_cpu
|
|
{
|
|
/**
|
|
* protected by:
|
|
* - other cores: accessing from other coress is undefined behaviour
|
|
* - local core: rt_enter_critical()/rt_exit_critical()
|
|
*/
|
|
_SCHEDULER_CONTEXT(
|
|
struct rt_thread *current_thread;
|
|
|
|
rt_uint8_t irq_switch_flag:1;
|
|
rt_uint8_t sched_lock_flag:1;
|
|
#ifndef ARCH_USING_HW_THREAD_SELF
|
|
rt_uint8_t critical_switch_flag:1;
|
|
#endif /* ARCH_USING_HW_THREAD_SELF */
|
|
|
|
rt_uint8_t current_priority;
|
|
rt_list_t priority_table[RT_THREAD_PRIORITY_MAX];
|
|
#if RT_THREAD_PRIORITY_MAX > 32
|
|
rt_uint32_t priority_group;
|
|
rt_uint8_t ready_table[32];
|
|
#else
|
|
rt_uint32_t priority_group;
|
|
#endif /* RT_THREAD_PRIORITY_MAX > 32 */
|
|
|
|
rt_atomic_t tick; /**< Passing tickes on this core */
|
|
);
|
|
|
|
struct rt_thread *idle_thread;
|
|
rt_atomic_t irq_nest;
|
|
|
|
#ifdef RT_USING_SMART
|
|
struct rt_spinlock spinlock;
|
|
#endif /* RT_USING_SMART */
|
|
#ifdef RT_USING_CPU_USAGE_TRACER
|
|
struct rt_cpu_usage_stats cpu_stat;
|
|
#endif /* RT_USING_CPU_USAGE_TRACER */
|
|
};
|
|
|
|
#else /* !RT_USING_SMP */
|
|
struct rt_cpu
|
|
{
|
|
struct rt_thread *current_thread;
|
|
struct rt_thread *idle_thread;
|
|
|
|
#ifdef RT_USING_CPU_USAGE_TRACER
|
|
struct rt_cpu_usage_stats cpu_stat;
|
|
#endif /* RT_USING_CPU_USAGE_TRACER */
|
|
};
|
|
|
|
#endif /* RT_USING_SMP */
|
|
|
|
typedef struct rt_cpu *rt_cpu_t;
|
|
/* Noted: As API to reject writing to this variable from application codes */
|
|
#define rt_current_thread rt_thread_self()
|
|
|
|
struct rt_thread;
|
|
|
|
#ifdef RT_USING_SMART
|
|
typedef rt_err_t (*rt_wakeup_func_t)(void *object, struct rt_thread *thread);
|
|
|
|
struct rt_wakeup
|
|
{
|
|
rt_wakeup_func_t func;
|
|
void *user_data;
|
|
};
|
|
|
|
#define _LWP_NSIG 64
|
|
|
|
#ifdef ARCH_CPU_64BIT
|
|
#define _LWP_NSIG_BPW 64
|
|
#else
|
|
#define _LWP_NSIG_BPW 32
|
|
#endif
|
|
|
|
#define _LWP_NSIG_WORDS (RT_ALIGN(_LWP_NSIG, _LWP_NSIG_BPW) / _LWP_NSIG_BPW)
|
|
|
|
typedef void (*lwp_sighandler_t)(int);
|
|
typedef void (*lwp_sigaction_t)(int signo, siginfo_t *info, void *context);
|
|
|
|
typedef struct {
|
|
unsigned long sig[_LWP_NSIG_WORDS];
|
|
} lwp_sigset_t;
|
|
|
|
#if _LWP_NSIG <= 64
|
|
#define lwp_sigmask(signo) ((lwp_sigset_t){.sig = {[0] = ((long)(1u << ((signo)-1)))}})
|
|
#define lwp_sigset_init(mask) ((lwp_sigset_t){.sig = {[0] = (long)(mask)}})
|
|
#endif /* _LWP_NSIG <= 64 */
|
|
|
|
struct lwp_sigaction {
|
|
union {
|
|
void (*_sa_handler)(int);
|
|
void (*_sa_sigaction)(int, siginfo_t *, void *);
|
|
} __sa_handler;
|
|
lwp_sigset_t sa_mask;
|
|
int sa_flags;
|
|
void (*sa_restorer)(void);
|
|
};
|
|
|
|
typedef struct lwp_siginfo_ext {
|
|
union {
|
|
/* for SIGCHLD */
|
|
struct {
|
|
int status;
|
|
clock_t utime;
|
|
clock_t stime;
|
|
} sigchld;
|
|
};
|
|
} *lwp_siginfo_ext_t;
|
|
|
|
typedef struct lwp_siginfo {
|
|
rt_list_t node;
|
|
|
|
struct {
|
|
int signo;
|
|
int code;
|
|
|
|
int from_tid;
|
|
pid_t from_pid;
|
|
} ksiginfo;
|
|
|
|
/* the signal specified extension field */
|
|
struct lwp_siginfo_ext *ext;
|
|
} *lwp_siginfo_t;
|
|
|
|
typedef struct lwp_sigqueue {
|
|
rt_list_t siginfo_list;
|
|
lwp_sigset_t sigset_pending;
|
|
} *lwp_sigqueue_t;
|
|
|
|
struct lwp_thread_signal {
|
|
lwp_sigset_t sigset_mask;
|
|
struct lwp_sigqueue sig_queue;
|
|
};
|
|
|
|
struct rt_user_context
|
|
{
|
|
void *sp;
|
|
void *pc;
|
|
void *flag;
|
|
|
|
void *ctx;
|
|
};
|
|
#endif /* RT_USING_SMART */
|
|
|
|
typedef void (*rt_thread_cleanup_t)(struct rt_thread *tid);
|
|
|
|
/**
|
|
* Thread structure
|
|
*/
|
|
|
|
struct rt_thread
|
|
{
|
|
struct rt_object parent;
|
|
|
|
/* stack point and entry */
|
|
void *sp; /**< stack point */
|
|
void *entry; /**< entry */
|
|
void *parameter; /**< parameter */
|
|
void *stack_addr; /**< stack address */
|
|
rt_uint32_t stack_size; /**< stack size */
|
|
|
|
/* error code */
|
|
rt_err_t error; /**< error code */
|
|
|
|
#ifdef RT_USING_SMP
|
|
rt_atomic_t cpus_lock_nest; /**< cpus lock count */
|
|
#endif
|
|
|
|
RT_SCHED_THREAD_CTX
|
|
struct rt_timer thread_timer; /**< built-in thread timer */
|
|
rt_thread_cleanup_t cleanup; /**< cleanup function when thread exit */
|
|
|
|
#ifdef RT_USING_MUTEX
|
|
/* object for IPC */
|
|
rt_list_t taken_object_list;
|
|
rt_object_t pending_object;
|
|
#endif /* RT_USING_MUTEX */
|
|
|
|
#ifdef RT_USING_EVENT
|
|
/* thread event */
|
|
rt_uint32_t event_set;
|
|
rt_uint8_t event_info;
|
|
#endif /* RT_USING_EVENT */
|
|
|
|
#ifdef RT_USING_SIGNALS
|
|
rt_sigset_t sig_pending; /**< the pending signals */
|
|
rt_sigset_t sig_mask; /**< the mask bits of signal */
|
|
|
|
#ifndef RT_USING_SMP
|
|
void *sig_ret; /**< the return stack pointer from signal */
|
|
#endif /* RT_USING_SMP */
|
|
rt_sighandler_t *sig_vectors; /**< vectors of signal handler */
|
|
void *si_list; /**< the signal infor list */
|
|
#endif /* RT_USING_SIGNALS */
|
|
|
|
#ifdef RT_USING_CPU_USAGE
|
|
rt_uint64_t duration_tick; /**< cpu usage tick */
|
|
#endif /* RT_USING_CPU_USAGE */
|
|
|
|
#ifdef RT_USING_PTHREADS
|
|
void *pthread_data; /**< the handle of pthread data, adapt 32/64bit */
|
|
#endif /* RT_USING_PTHREADS */
|
|
|
|
/* light weight process if present */
|
|
#ifdef RT_USING_SMART
|
|
void *msg_ret; /**< the return msg */
|
|
|
|
void *lwp; /**< the lwp reference */
|
|
/* for user create */
|
|
void *user_entry;
|
|
void *user_stack;
|
|
rt_uint32_t user_stack_size;
|
|
rt_uint32_t *kernel_sp; /**< kernel stack point */
|
|
rt_list_t sibling; /**< next thread of same process */
|
|
|
|
struct lwp_thread_signal signal; /**< lwp signal for user-space thread */
|
|
struct rt_user_context user_ctx; /**< user space context */
|
|
struct rt_wakeup wakeup_handle; /**< wakeup handle for IPC */
|
|
rt_atomic_t exit_request; /**< pending exit request of thread */
|
|
int tid; /**< thread ID used by process */
|
|
int tid_ref_count; /**< reference of tid */
|
|
void *susp_recycler; /**< suspended recycler on this thread */
|
|
void *robust_list; /**< pi lock, very carefully, it's a userspace list!*/
|
|
|
|
#ifndef ARCH_MM_MMU
|
|
lwp_sighandler_t signal_handler[32];
|
|
#else
|
|
int step_exec;
|
|
int debug_attach_req;
|
|
int debug_ret_user;
|
|
int debug_suspend;
|
|
struct rt_hw_exp_stack *regs;
|
|
void *thread_idr; /** lwp thread indicator */
|
|
int *clear_child_tid;
|
|
#endif /* ARCH_MM_MMU */
|
|
#endif /* RT_USING_SMART */
|
|
|
|
#ifdef RT_USING_CPU_USAGE_TRACER
|
|
rt_ubase_t user_time; /**< Ticks on user */
|
|
rt_ubase_t system_time; /**< Ticks on system */
|
|
#endif /* RT_USING_CPU_USAGE_TRACER */
|
|
|
|
#ifdef RT_USING_MEM_PROTECTION
|
|
void *mem_regions;
|
|
#ifdef RT_USING_HW_STACK_GUARD
|
|
void *stack_buf;
|
|
#endif /* RT_USING_HW_STACK_GUARD */
|
|
#endif /* RT_USING_MEM_PROTECTION */
|
|
|
|
struct rt_spinlock spinlock;
|
|
rt_ubase_t user_data; /**< private user data beyond this thread */
|
|
};
|
|
typedef struct rt_thread *rt_thread_t;
|
|
|
|
#ifdef RT_USING_SMART
|
|
#define LWP_IS_USER_MODE(t) ((t)->user_ctx.ctx == RT_NULL)
|
|
#else
|
|
#define LWP_IS_USER_MODE(t) (0)
|
|
#endif /* RT_USING_SMART */
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @addtogroup IPC
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/**
|
|
* IPC flags and control command definitions
|
|
*/
|
|
#define RT_IPC_FLAG_FIFO 0x00 /**< FIFOed IPC. @ref IPC. */
|
|
#define RT_IPC_FLAG_PRIO 0x01 /**< PRIOed IPC. @ref IPC. */
|
|
|
|
#define RT_IPC_CMD_UNKNOWN 0x00 /**< unknown IPC command */
|
|
#define RT_IPC_CMD_RESET 0x01 /**< reset IPC object */
|
|
#define RT_IPC_CMD_GET_STATE 0x02 /**< get the state of IPC object */
|
|
#define RT_IPC_CMD_SET_VLIMIT 0x03 /**< set max limit value of IPC value */
|
|
|
|
#define RT_WAITING_FOREVER -1 /**< Block forever until get resource. */
|
|
#define RT_WAITING_NO 0 /**< Non-block. */
|
|
|
|
/**
|
|
* Base structure of IPC object
|
|
*/
|
|
struct rt_ipc_object
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
|
|
rt_list_t suspend_thread; /**< threads pended on this resource */
|
|
};
|
|
|
|
#ifdef RT_USING_SEMAPHORE
|
|
/**
|
|
* Semaphore structure
|
|
*/
|
|
struct rt_semaphore
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from ipc_object */
|
|
|
|
rt_uint16_t value; /**< value of semaphore. */
|
|
rt_uint16_t max_value;
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_semaphore *rt_sem_t;
|
|
#endif /* RT_USING_SEMAPHORE */
|
|
|
|
#ifdef RT_USING_MUTEX
|
|
/**
|
|
* Mutual exclusion (mutex) structure
|
|
*/
|
|
struct rt_mutex
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from ipc_object */
|
|
|
|
rt_uint8_t ceiling_priority; /**< the priority ceiling of mutexe */
|
|
rt_uint8_t priority; /**< the maximal priority for pending thread */
|
|
rt_uint8_t hold; /**< numbers of thread hold the mutex */
|
|
rt_uint8_t reserved; /**< reserved field */
|
|
|
|
struct rt_thread *owner; /**< current owner of mutex */
|
|
rt_list_t taken_list; /**< the object list taken by thread */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_mutex *rt_mutex_t;
|
|
#endif /* RT_USING_MUTEX */
|
|
|
|
#ifdef RT_USING_EVENT
|
|
/**
|
|
* flag definitions in event
|
|
*/
|
|
#define RT_EVENT_FLAG_AND 0x01 /**< logic and */
|
|
#define RT_EVENT_FLAG_OR 0x02 /**< logic or */
|
|
#define RT_EVENT_FLAG_CLEAR 0x04 /**< clear flag */
|
|
|
|
/*
|
|
* event structure
|
|
*/
|
|
struct rt_event
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from ipc_object */
|
|
|
|
rt_uint32_t set; /**< event set */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_event *rt_event_t;
|
|
#endif /* RT_USING_EVENT */
|
|
|
|
#ifdef RT_USING_MAILBOX
|
|
/**
|
|
* mailbox structure
|
|
*/
|
|
struct rt_mailbox
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from ipc_object */
|
|
|
|
rt_ubase_t *msg_pool; /**< start address of message buffer */
|
|
|
|
rt_uint16_t size; /**< size of message pool */
|
|
|
|
rt_uint16_t entry; /**< index of messages in msg_pool */
|
|
rt_uint16_t in_offset; /**< input offset of the message buffer */
|
|
rt_uint16_t out_offset; /**< output offset of the message buffer */
|
|
|
|
rt_list_t suspend_sender_thread; /**< sender thread suspended on this mailbox */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_mailbox *rt_mailbox_t;
|
|
#endif /* RT_USING_MAILBOX */
|
|
|
|
#ifdef RT_USING_MESSAGEQUEUE
|
|
/**
|
|
* message queue structure
|
|
*/
|
|
struct rt_messagequeue
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from ipc_object */
|
|
|
|
void *msg_pool; /**< start address of message queue */
|
|
|
|
rt_uint16_t msg_size; /**< message size of each message */
|
|
rt_uint16_t max_msgs; /**< max number of messages */
|
|
|
|
rt_uint16_t entry; /**< index of messages in the queue */
|
|
|
|
void *msg_queue_head; /**< list head */
|
|
void *msg_queue_tail; /**< list tail */
|
|
void *msg_queue_free; /**< pointer indicated the free node of queue */
|
|
|
|
rt_list_t suspend_sender_thread; /**< sender thread suspended on this message queue */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_messagequeue *rt_mq_t;
|
|
#endif /* RT_USING_MESSAGEQUEUE */
|
|
|
|
/**@}*/
|
|
|
|
/**
|
|
* @addtogroup MM
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
#ifdef RT_USING_HEAP
|
|
/*
|
|
* memory structure
|
|
*/
|
|
struct rt_memory
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
const char * algorithm; /**< Memory management algorithm name */
|
|
rt_ubase_t address; /**< memory start address */
|
|
rt_size_t total; /**< memory size */
|
|
rt_size_t used; /**< size used */
|
|
rt_size_t max; /**< maximum usage */
|
|
};
|
|
typedef struct rt_memory *rt_mem_t;
|
|
#endif /* RT_USING_HEAP */
|
|
|
|
/*
|
|
* memory management
|
|
* heap & partition
|
|
*/
|
|
|
|
#ifdef RT_USING_SMALL_MEM
|
|
typedef rt_mem_t rt_smem_t;
|
|
#endif /* RT_USING_SMALL_MEM */
|
|
|
|
#ifdef RT_USING_SLAB
|
|
typedef rt_mem_t rt_slab_t;
|
|
#endif /* RT_USING_SLAB */
|
|
|
|
#ifdef RT_USING_MEMHEAP
|
|
/**
|
|
* memory item on the heap
|
|
*/
|
|
struct rt_memheap_item
|
|
{
|
|
rt_uint32_t magic; /**< magic number for memheap */
|
|
struct rt_memheap *pool_ptr; /**< point of pool */
|
|
|
|
struct rt_memheap_item *next; /**< next memheap item */
|
|
struct rt_memheap_item *prev; /**< prev memheap item */
|
|
|
|
struct rt_memheap_item *next_free; /**< next free memheap item */
|
|
struct rt_memheap_item *prev_free; /**< prev free memheap item */
|
|
#ifdef RT_USING_MEMTRACE
|
|
rt_uint8_t owner_thread_name[4]; /**< owner thread name */
|
|
#endif /* RT_USING_MEMTRACE */
|
|
};
|
|
|
|
/**
|
|
* Base structure of memory heap object
|
|
*/
|
|
struct rt_memheap
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
|
|
void *start_addr; /**< pool start address and size */
|
|
|
|
rt_size_t pool_size; /**< pool size */
|
|
rt_size_t available_size; /**< available size */
|
|
rt_size_t max_used_size; /**< maximum allocated size */
|
|
|
|
struct rt_memheap_item *block_list; /**< used block list */
|
|
|
|
struct rt_memheap_item *free_list; /**< free block list */
|
|
struct rt_memheap_item free_header; /**< free block list header */
|
|
|
|
struct rt_semaphore lock; /**< semaphore lock */
|
|
rt_bool_t locked; /**< External lock mark */
|
|
};
|
|
#endif /* RT_USING_MEMHEAP */
|
|
|
|
#ifdef RT_USING_MEMPOOL
|
|
/**
|
|
* Base structure of Memory pool object
|
|
*/
|
|
struct rt_mempool
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
|
|
void *start_address; /**< memory pool start */
|
|
rt_size_t size; /**< size of memory pool */
|
|
|
|
rt_size_t block_size; /**< size of memory blocks */
|
|
rt_uint8_t *block_list; /**< memory blocks list */
|
|
|
|
rt_size_t block_total_count; /**< numbers of memory block */
|
|
rt_size_t block_free_count; /**< numbers of free memory block */
|
|
|
|
rt_list_t suspend_thread; /**< threads pended on this resource */
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_mempool *rt_mp_t;
|
|
#endif /* RT_USING_MEMPOOL */
|
|
|
|
/**@}*/
|
|
|
|
#ifdef RT_USING_DEVICE
|
|
/**
|
|
* @addtogroup Device
|
|
*/
|
|
|
|
/**@{*/
|
|
|
|
/**
|
|
* device (I/O) class type
|
|
*/
|
|
enum rt_device_class_type
|
|
{
|
|
RT_Device_Class_Char = 0, /**< character device */
|
|
RT_Device_Class_Block, /**< block device */
|
|
RT_Device_Class_NetIf, /**< net interface */
|
|
RT_Device_Class_MTD, /**< memory device */
|
|
RT_Device_Class_CAN, /**< CAN device */
|
|
RT_Device_Class_RTC, /**< RTC device */
|
|
RT_Device_Class_Sound, /**< Sound device */
|
|
RT_Device_Class_Graphic, /**< Graphic device */
|
|
RT_Device_Class_I2CBUS, /**< I2C bus device */
|
|
RT_Device_Class_USBDevice, /**< USB slave device */
|
|
RT_Device_Class_USBHost, /**< USB host bus */
|
|
RT_Device_Class_USBOTG, /**< USB OTG bus */
|
|
RT_Device_Class_SPIBUS, /**< SPI bus device */
|
|
RT_Device_Class_SPIDevice, /**< SPI device */
|
|
RT_Device_Class_SDIO, /**< SDIO bus device */
|
|
RT_Device_Class_PM, /**< PM pseudo device */
|
|
RT_Device_Class_Pipe, /**< Pipe device */
|
|
RT_Device_Class_Portal, /**< Portal device */
|
|
RT_Device_Class_Timer, /**< Timer device */
|
|
RT_Device_Class_Miscellaneous, /**< Miscellaneous device */
|
|
RT_Device_Class_Sensor, /**< Sensor device */
|
|
RT_Device_Class_Touch, /**< Touch device */
|
|
RT_Device_Class_PHY, /**< PHY device */
|
|
RT_Device_Class_Security, /**< Security device */
|
|
RT_Device_Class_WLAN, /**< WLAN device */
|
|
RT_Device_Class_Pin, /**< Pin device */
|
|
RT_Device_Class_ADC, /**< ADC device */
|
|
RT_Device_Class_DAC, /**< DAC device */
|
|
RT_Device_Class_WDT, /**< WDT device */
|
|
RT_Device_Class_PWM, /**< PWM device */
|
|
RT_Device_Class_Bus, /**< Bus device */
|
|
RT_Device_Class_Unknown /**< unknown device */
|
|
};
|
|
|
|
/**
|
|
* device flags definitions
|
|
*/
|
|
#define RT_DEVICE_FLAG_DEACTIVATE 0x000 /**< device is not not initialized */
|
|
|
|
#define RT_DEVICE_FLAG_RDONLY 0x001 /**< read only */
|
|
#define RT_DEVICE_FLAG_WRONLY 0x002 /**< write only */
|
|
#define RT_DEVICE_FLAG_RDWR 0x003 /**< read and write */
|
|
|
|
#define RT_DEVICE_FLAG_REMOVABLE 0x004 /**< removable device */
|
|
#define RT_DEVICE_FLAG_STANDALONE 0x008 /**< standalone device */
|
|
#define RT_DEVICE_FLAG_ACTIVATED 0x010 /**< device is activated */
|
|
#define RT_DEVICE_FLAG_SUSPENDED 0x020 /**< device is suspended */
|
|
#define RT_DEVICE_FLAG_STREAM 0x040 /**< stream mode */
|
|
#define RT_DEVICE_FLAG_DYNAMIC 0x080 /**< device is determined when open() */
|
|
|
|
#define RT_DEVICE_FLAG_INT_RX 0x100 /**< INT mode on Rx */
|
|
#define RT_DEVICE_FLAG_DMA_RX 0x200 /**< DMA mode on Rx */
|
|
#define RT_DEVICE_FLAG_INT_TX 0x400 /**< INT mode on Tx */
|
|
#define RT_DEVICE_FLAG_DMA_TX 0x800 /**< DMA mode on Tx */
|
|
|
|
#define RT_DEVICE_OFLAG_CLOSE 0x000 /**< device is closed */
|
|
#define RT_DEVICE_OFLAG_RDONLY 0x001 /**< read only access */
|
|
#define RT_DEVICE_OFLAG_WRONLY 0x002 /**< write only access */
|
|
#define RT_DEVICE_OFLAG_RDWR 0x003 /**< read and write */
|
|
#define RT_DEVICE_OFLAG_OPEN 0x008 /**< device is opened */
|
|
#define RT_DEVICE_OFLAG_MASK 0xf0f /**< mask of open flag */
|
|
|
|
/**
|
|
* general device commands
|
|
* 0x01 - 0x1F general device control commands
|
|
* 0x20 - 0x3F udevice control commands
|
|
* 0x40 - special device control commands
|
|
*/
|
|
#define RT_DEVICE_CTRL_RESUME 0x01 /**< resume device */
|
|
#define RT_DEVICE_CTRL_SUSPEND 0x02 /**< suspend device */
|
|
#define RT_DEVICE_CTRL_CONFIG 0x03 /**< configure device */
|
|
#define RT_DEVICE_CTRL_CLOSE 0x04 /**< close device */
|
|
#define RT_DEVICE_CTRL_NOTIFY_SET 0x05 /**< set notify func */
|
|
#define RT_DEVICE_CTRL_SET_INT 0x06 /**< set interrupt */
|
|
#define RT_DEVICE_CTRL_CLR_INT 0x07 /**< clear interrupt */
|
|
#define RT_DEVICE_CTRL_GET_INT 0x08 /**< get interrupt status */
|
|
#define RT_DEVICE_CTRL_CONSOLE_OFLAG 0x09 /**< get console open flag */
|
|
#define RT_DEVICE_CTRL_MASK 0x1f /**< mask for contrl commands */
|
|
|
|
/**
|
|
* device control
|
|
*/
|
|
#define RT_DEVICE_CTRL_BASE(Type) ((RT_Device_Class_##Type + 1) * 0x100)
|
|
|
|
typedef struct rt_driver *rt_driver_t;
|
|
typedef struct rt_device *rt_device_t;
|
|
|
|
#ifdef RT_USING_DEVICE_OPS
|
|
/**
|
|
* operations set for device object
|
|
*/
|
|
struct rt_device_ops
|
|
{
|
|
/* common device interface */
|
|
rt_err_t (*init) (rt_device_t dev);
|
|
rt_err_t (*open) (rt_device_t dev, rt_uint16_t oflag);
|
|
rt_err_t (*close) (rt_device_t dev);
|
|
rt_ssize_t (*read) (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
|
|
rt_ssize_t (*write) (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
|
|
rt_err_t (*control)(rt_device_t dev, int cmd, void *args);
|
|
};
|
|
#endif /* RT_USING_DEVICE_OPS */
|
|
|
|
/**
|
|
* WaitQueue structure
|
|
*/
|
|
struct rt_wqueue
|
|
{
|
|
rt_uint32_t flag;
|
|
rt_list_t waiting_list;
|
|
struct rt_spinlock spinlock;
|
|
};
|
|
typedef struct rt_wqueue rt_wqueue_t;
|
|
|
|
#ifdef RT_USING_DM
|
|
struct rt_driver;
|
|
struct rt_bus;
|
|
#endif /* RT_USING_DM */
|
|
|
|
/**
|
|
* Device structure
|
|
*/
|
|
struct rt_device
|
|
{
|
|
struct rt_object parent; /**< inherit from rt_object */
|
|
|
|
#ifdef RT_USING_DM
|
|
struct rt_bus *bus; /**< the bus mounting to */
|
|
rt_list_t node; /**< to mount on bus */
|
|
struct rt_driver *drv; /**< driver for powering the device */
|
|
#ifdef RT_USING_OFW
|
|
void *ofw_node; /**< ofw node get from device tree */
|
|
#endif /* RT_USING_OFW */
|
|
void *power_domain_unit;
|
|
#endif /* RT_USING_DM */
|
|
|
|
enum rt_device_class_type type; /**< device type */
|
|
rt_uint16_t flag; /**< device flag */
|
|
rt_uint16_t open_flag; /**< device open flag */
|
|
|
|
rt_uint8_t ref_count; /**< reference count */
|
|
rt_uint8_t device_id; /**< 0 - 255 */
|
|
|
|
/* device call back */
|
|
rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
|
|
rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
|
|
|
|
#ifdef RT_USING_DEVICE_OPS
|
|
const struct rt_device_ops *ops;
|
|
#else
|
|
/* common device interface */
|
|
rt_err_t (*init) (rt_device_t dev);
|
|
rt_err_t (*open) (rt_device_t dev, rt_uint16_t oflag);
|
|
rt_err_t (*close) (rt_device_t dev);
|
|
rt_ssize_t (*read) (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
|
|
rt_ssize_t (*write) (rt_device_t dev, rt_off_t pos, const void *buffer, rt_size_t size);
|
|
rt_err_t (*control)(rt_device_t dev, int cmd, void *args);
|
|
#endif /* RT_USING_DEVICE_OPS */
|
|
|
|
#ifdef RT_USING_POSIX_DEVIO
|
|
const struct dfs_file_ops *fops;
|
|
struct rt_wqueue wait_queue;
|
|
#endif /* RT_USING_POSIX_DEVIO */
|
|
|
|
rt_err_t (*readlink)
|
|
(rt_device_t dev, char *buf, int len); /**< for dynamic device */
|
|
|
|
void *user_data; /**< device private data */
|
|
};
|
|
|
|
/**
|
|
* Notify structure
|
|
*/
|
|
struct rt_device_notify
|
|
{
|
|
void (*notify)(rt_device_t dev);
|
|
struct rt_device *dev;
|
|
};
|
|
|
|
#ifdef RT_USING_SMART
|
|
struct rt_channel
|
|
{
|
|
struct rt_ipc_object parent; /**< inherit from object */
|
|
struct rt_thread *reply; /**< the thread will be reply */
|
|
struct rt_spinlock slock; /**< spinlock of this channel */
|
|
rt_list_t wait_msg; /**< the wait queue of sender msg */
|
|
rt_list_t wait_thread; /**< the wait queue of sender thread */
|
|
rt_wqueue_t reader_queue; /**< channel poll queue */
|
|
rt_uint8_t stat; /**< the status of this channel */
|
|
rt_ubase_t ref;
|
|
};
|
|
typedef struct rt_channel *rt_channel_t;
|
|
#endif /* RT_USING_SMART */
|
|
|
|
/**@}*/
|
|
#endif /* RT_USING_DEVICE */
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
#ifdef __cplusplus
|
|
/* RT-Thread definitions for C++ */
|
|
namespace rtthread {
|
|
|
|
enum TICK_WAIT {
|
|
WAIT_NONE = 0,
|
|
WAIT_FOREVER = -1,
|
|
};
|
|
|
|
}
|
|
|
|
#endif /* __cplusplus */
|
|
|
|
#endif /* __RT_DEF_H__ */
|