Skip to content

R
rt-thread

BaiXuePrincess / rt-thread
与 Fork 源项目一致

Fork自 RT-Thread / rt-thread

通知 1
Star 0
Fork 0
R
rt-thread
提交 97561047 编写于 作者: B bernard.xiong@gmail.com
浏览文件
操作

Add RT_USING_MEMHEAP_AS_HEAP feature: system can use "heap" memheap as system default memory heap. 

git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2554 bbd45198-f89e-11dd-88c7-29a3b14d5316
上级 7db8d293
隐藏空白更改
内联 并排
Showing with 1041 addition and 909 deletion
include/rtdef.h
浏览文件 @ 97561047
/* /*
* File : rtdef.h * File : rtdef.h
* This file is part of RT-Thread RTOS * This file is part of RT-Thread RTOS
* COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
* *
* The license and distribution terms for this file may be * The license and distribution terms for this file may be
* found in the file LICENSE in this distribution or at * found in the file LICENSE in this distribution or at
* http://www.rt-thread.org/license/LICENSE * http://www.rt-thread.org/license/LICENSE
* *
* Change Logs: * Change Logs:
* Date Author Notes * Date Author Notes
* 2007-01-10 Bernard the first version * 2007-01-10 Bernard the first version
* 2008-07-12 Bernard remove all rt_int8, rt_uint32_t etc typedef * 2008-07-12 Bernard remove all rt_int8, rt_uint32_t etc typedef
* 2010-10-26 yi.qiu add module support * 2010-10-26 yi.qiu add module support
* 2010-11-10 Bernard add cleanup callback function in thread exit. * 2010-11-10 Bernard add cleanup callback function in thread exit.
* 2011-05-09 Bernard use builtin va_arg in GCC 4.x * 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-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.
#ifndef __RT_DEF_H__ */
#define __RT_DEF_H__
#ifndef __RT_DEF_H__
#include <rtconfig.h> #define __RT_DEF_H__
#ifdef __cplusplus #include <rtconfig.h>
extern "C" {
#endif #ifdef __cplusplus
extern "C" {
/** #endif
* @addtogroup BasicDef
*/ /**
* @addtogroup BasicDef
/*@{*/ */
/* RT-Thread version information */ /*@{*/
#define RT_VERSION 1L /**< major version number */
#define RT_SUBVERSION 1L /**< minor version number */ /* RT-Thread version information */
#define RT_REVISION 0L /**< revise version number */ #define RT_VERSION 1L /**< major version number */
#define RT_SUBVERSION 1L /**< minor version number */
/* RT-Thread version */ #define RT_REVISION 0L /**< revise version number */
#define RTTHREAD_VERSION ((RT_VERSION * 10000) + \
(RT_SUBVERSION * 100) + RT_REVISION) /* RT-Thread version */
#define RTTHREAD_VERSION ((RT_VERSION * 10000) + \
/* RT-Thread basic data type definitions */ (RT_SUBVERSION * 100) + RT_REVISION)
typedef signed char rt_int8_t; /**< 8bit integer type */
typedef signed short rt_int16_t; /**< 16bit integer type */ /* RT-Thread basic data type definitions */
typedef signed long rt_int32_t; /**< 32bit integer type */ typedef signed char rt_int8_t; /**< 8bit integer type */
typedef unsigned char rt_uint8_t; /**< 8bit unsigned integer type */ typedef signed short rt_int16_t; /**< 16bit integer type */
typedef unsigned short rt_uint16_t; /**< 16bit unsigned integer type */ typedef signed long rt_int32_t; /**< 32bit integer type */
typedef unsigned long rt_uint32_t; /**< 32bit unsigned integer type */ typedef unsigned char rt_uint8_t; /**< 8bit unsigned integer type */
typedef int rt_bool_t; /**< boolean type */ typedef unsigned short rt_uint16_t; /**< 16bit unsigned integer type */
typedef unsigned long rt_uint32_t; /**< 32bit unsigned integer type */
/* 32bit CPU */ typedef int rt_bool_t; /**< boolean type */
typedef long rt_base_t; /**< Nbit CPU related date type */
typedef unsigned long rt_ubase_t; /**< Nbit unsigned CPU related data type */ /* 32bit CPU */
typedef long rt_base_t; /**< Nbit CPU related date type */
typedef rt_base_t rt_err_t; /**< Type for error number */ typedef unsigned long rt_ubase_t; /**< Nbit unsigned CPU related data type */
typedef rt_uint32_t rt_time_t; /**< Type for time stamp */
typedef rt_uint32_t rt_tick_t; /**< Type for tick count */ typedef rt_base_t rt_err_t; /**< Type for error number */
typedef rt_base_t rt_flag_t; /**< Type for flags */ typedef rt_uint32_t rt_time_t; /**< Type for time stamp */
typedef rt_ubase_t rt_size_t; /**< Type for size number */ typedef rt_uint32_t rt_tick_t; /**< Type for tick count */
typedef rt_ubase_t rt_dev_t; /**< Type for device */ typedef rt_base_t rt_flag_t; /**< Type for flags */
typedef rt_base_t rt_off_t; /**< Type for offset */ typedef rt_ubase_t rt_size_t; /**< Type for size number */
typedef rt_ubase_t rt_dev_t; /**< Type for device */
/* boolean type definitions */ typedef rt_base_t rt_off_t; /**< Type for offset */
#define RT_TRUE 1 /**< boolean true */
#define RT_FALSE 0 /**< boolean fails */ /* boolean type definitions */
#define RT_TRUE 1 /**< boolean true */
/*@}*/ #define RT_FALSE 0 /**< boolean fails */
/* maximum value of base type */ /*@}*/
#define RT_UINT8_MAX 0xff /**< Maxium number of UINT8 */
#define RT_UINT16_MAX 0xffff /**< Maxium number of UINT16 */ /* maximum value of base type */
#define RT_UINT32_MAX 0xffffffff /**< Maxium number of UINT32 */ #define RT_UINT8_MAX 0xff /**< Maxium number of UINT8 */
#define RT_TICK_MAX RT_UINT32_MAX /**< Maxium number of tick */ #define RT_UINT16_MAX 0xffff /**< Maxium number of UINT16 */
#define RT_UINT32_MAX 0xffffffff /**< Maxium number of UINT32 */
/* Compiler Related Definitions */ #define RT_TICK_MAX RT_UINT32_MAX /**< Maxium number of tick */
#ifdef __CC_ARM /* ARM Compiler */
#include <stdarg.h> /* Compiler Related Definitions */
#define SECTION(x) __attribute__((section(x))) #ifdef __CC_ARM /* ARM Compiler */
#define UNUSED __attribute__((unused)) #include <stdarg.h>
#define ALIGN(n) __attribute__((aligned(n))) #define SECTION(x) __attribute__((section(x)))
#define rt_inline static __inline #define UNUSED __attribute__((unused))
/* module compiling */ #define ALIGN(n) __attribute__((aligned(n)))
#ifdef RT_USING_MODULE #define rt_inline static __inline
#define RTT_API __declspec(dllimport) /* module compiling */
#else #ifdef RT_USING_MODULE
#define RTT_API __declspec(dllexport) #define RTT_API __declspec(dllimport)
#endif #else
#define RTT_API __declspec(dllexport)
#elif defined (__IAR_SYSTEMS_ICC__) /* for IAR Compiler */ #endif
#include <stdarg.h>
#define SECTION(x) @ x #elif defined (__IAR_SYSTEMS_ICC__) /* for IAR Compiler */
#define UNUSED #include <stdarg.h>
#define PRAGMA(x) _Pragma(#x) #define SECTION(x) @ x
#define ALIGN(n) PRAGMA(data_alignment=n) #define UNUSED
#define rt_inline static inline #define PRAGMA(x) _Pragma(#x)
#define RTT_API #define ALIGN(n) PRAGMA(data_alignment=n)
#define rt_inline static inline
#elif defined (__GNUC__) /* GNU GCC Compiler */ #define RTT_API
#ifdef RT_USING_NEWLIB
#include <stdarg.h> #elif defined (__GNUC__) /* GNU GCC Compiler */
#else #ifdef RT_USING_NEWLIB
#if __GNUC__ < 4 #include <stdarg.h>
typedef void *__sys_va_list; #else
typedef __sys_va_list va_list; #if __GNUC__ < 4
#define __va_rounded_size(type) \ typedef void *__sys_va_list;
(((sizeof(type) + sizeof(int) - 1) / sizeof(int)) * sizeof(int)) typedef __sys_va_list va_list;
#define va_start(ap, lastarg) \ #define __va_rounded_size(type) \
(ap = ((char *) &(lastarg) + __va_rounded_size(lastarg))) (((sizeof(type) + sizeof(int) - 1) / sizeof(int)) * sizeof(int))
#define va_end(ap) ((void)0) #define va_start(ap, lastarg) \
/* little endian */ (ap = ((char *) &(lastarg) + __va_rounded_size(lastarg)))
#define va_arg(ap, type) \ #define va_end(ap) ((void)0)
(ap = (__sys_va_list) ((char *)(ap) + __va_rounded_size(type)), \ /* little endian */
*((type *) (void *) ((char *)(ap) - __va_rounded_size(type)))) #define va_arg(ap, type) \
#else (ap = (__sys_va_list) ((char *)(ap) + __va_rounded_size(type)), \
typedef __builtin_va_list __gnuc_va_list; *((type *) (void *) ((char *)(ap) - __va_rounded_size(type))))
typedef __gnuc_va_list va_list; #else
#define va_start(v,l) __builtin_va_start(v,l) typedef __builtin_va_list __gnuc_va_list;
#define va_end(v) __builtin_va_end(v) typedef __gnuc_va_list va_list;
#define va_arg(v,l) __builtin_va_arg(v,l) #define va_start(v,l) __builtin_va_start(v,l)
#endif #define va_end(v) __builtin_va_end(v)
#endif #define va_arg(v,l) __builtin_va_arg(v,l)
#endif
#define SECTION(x) __attribute__((section(x))) #endif
#define UNUSED __attribute__((unused))
#define ALIGN(n) __attribute__((aligned(n))) #define SECTION(x) __attribute__((section(x)))
#define rt_inline static __inline #define UNUSED __attribute__((unused))
#define RTT_API #define ALIGN(n) __attribute__((aligned(n)))
#elif defined (__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */ #define rt_inline static __inline
#include <stdarg.h> #define RTT_API
#define SECTION(x) __attribute__((section(x))) #elif defined (__ADSPBLACKFIN__) /* for VisualDSP++ Compiler */
#define UNUSED __attribute__((unused)) #include <stdarg.h>
#define ALIGN(n) __attribute__((aligned(n))) #define SECTION(x) __attribute__((section(x)))
#define rt_inline static inline #define UNUSED __attribute__((unused))
#define RTT_API #define ALIGN(n) __attribute__((aligned(n)))
#elif defined (_MSC_VER) #define rt_inline static inline
#include <stdarg.h> #define RTT_API
#define SECTION(x) #elif defined (_MSC_VER)
#define UNUSED #include <stdarg.h>
#define ALIGN(n) __declspec(align(n)) #define SECTION(x)
#define rt_inline static __inline #define UNUSED
#define RTT_API #define ALIGN(n) __declspec(align(n))
#endif #define rt_inline static __inline
#define RTT_API
/* event length */ #endif
#define RT_EVENT_LENGTH 32
/* event length */
/* memory management option */ #define RT_EVENT_LENGTH 32
#define RT_MM_PAGE_SIZE 4096
#define RT_MM_PAGE_MASK (RT_MM_PAGE_SIZE - 1) /* memory management option */
#define RT_MM_PAGE_BITS 12 #define RT_MM_PAGE_SIZE 4096
#define RT_MM_PAGE_MASK (RT_MM_PAGE_SIZE - 1)
/** #define RT_MM_PAGE_BITS 12
* @addtogroup Error
*/ /**
* @addtogroup Error
/*@{*/ */
/* RT-Thread error code definitions */ /*@{*/
#define RT_EOK 0 /**< There is no error */
#define RT_ERROR 1 /**< A generic error happens */ /* RT-Thread error code definitions */
#define RT_ETIMEOUT 2 /**< Timed out */ #define RT_EOK 0 /**< There is no error */
#define RT_EFULL 3 /**< The resource is full */ #define RT_ERROR 1 /**< A generic error happens */
#define RT_EEMPTY 4 /**< The resource is empty */ #define RT_ETIMEOUT 2 /**< Timed out */
#define RT_ENOMEM 5 /**< No memory */ #define RT_EFULL 3 /**< The resource is full */
#define RT_ENOSYS 6 /**< No system */ #define RT_EEMPTY 4 /**< The resource is empty */
#define RT_EBUSY 7 /**< Busy */ #define RT_ENOMEM 5 /**< No memory */
#define RT_EIO 8 /**< IO error */ #define RT_ENOSYS 6 /**< No system */
#define RT_EBUSY 7 /**< Busy */
/*@}*/ #define RT_EIO 8 /**< IO error */
/** /*@}*/
* @ingroup BasicDef
* /**
* @def RT_ALIGN(size, align) * @ingroup BasicDef
* Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4) *
* would return 16. * @def RT_ALIGN(size, align)
*/ * Return the most contiguous size aligned at specified width. RT_ALIGN(13, 4)
#define RT_ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1)) * would return 16.
*/
/** #define RT_ALIGN(size, align) (((size) + (align) - 1) & ~((align) - 1))
* @ingroup BasicDef
* /**
* @def RT_ALIGN_DOWN(size, align) * @ingroup BasicDef
* Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4) *
* would return 12. * @def RT_ALIGN_DOWN(size, align)
*/ * Return the down number of aligned at specified width. RT_ALIGN_DOWN(13, 4)
#define RT_ALIGN_DOWN(size, align) ((size) & ~((align) - 1)) * would return 12.
*/
/** #define RT_ALIGN_DOWN(size, align) ((size) & ~((align) - 1))
* @ingroup BasicDef
* /**
* @def RT_NULL * @ingroup BasicDef
* Similar as the \c NULL in C library. *
*/ * @def RT_NULL
#define RT_NULL (0) * Similar as the \c NULL in C library.
*/
struct rt_list_node #define RT_NULL (0)
{
struct rt_list_node *next; /**< point to next node. */ struct rt_list_node
struct rt_list_node *prev; /**< point to prev node. */ {
}; struct rt_list_node *next; /**< point to next node. */
typedef struct rt_list_node rt_list_t; /**< Type for lists. */ struct rt_list_node *prev; /**< point to prev node. */
};
/** typedef struct rt_list_node rt_list_t; /**< Type for lists. */
* @addtogroup KernelObject
*/ /**
* @addtogroup KernelObject
/*@{*/ */
/* /*@{*/
* kernel object macros
*/ /*
#define RT_OBJECT_FLAG_MODULE 0x80 /**< is module object. */ * kernel object macros
*/
/** #define RT_OBJECT_FLAG_MODULE 0x80 /**< is module object. */
* Base structure of Kernel object
*/ /**
struct rt_object * Base structure of Kernel object
{ */
char name[RT_NAME_MAX]; /**< name of kernel object */ struct rt_object
rt_uint8_t type; /**< type of kernel object */ {
rt_uint8_t flag; /**< flag of kernel object */ char name[RT_NAME_MAX]; /**< name of kernel object */
rt_uint8_t type; /**< type of kernel object */
#ifdef RT_USING_MODULE rt_uint8_t flag; /**< flag of kernel object */
void *module_id; /**< id of application module */
#endif #ifdef RT_USING_MODULE
rt_list_t list; /**< list node of kernel object */ void *module_id; /**< id of application module */
}; #endif
typedef struct rt_object *rt_object_t; /**< Type for kernel objects. */ rt_list_t list; /**< list node of kernel object */
};
/** typedef struct rt_object *rt_object_t; /**< Type for kernel objects. */
* The object type can be one of the follows with specific
* macros enabled: /**
* - Thread * The object type can be one of the follows with specific
* - Semaphore * macros enabled:
* - Mutex * - Thread
* - Event * - Semaphore
* - MailBox * - Mutex
* - MessageQueue * - Event
* - MemHeap * - MailBox
* - MemPool * - MessageQueue
* - Device * - MemHeap
* - Timer * - MemPool
* - Module * - Device
* - Unknown * - Timer
* - Static * - Module
*/ * - Unknown
enum rt_object_class_type * - Static
{ */
RT_Object_Class_Thread = 0, /**< The object is a thread. */ enum rt_object_class_type
#ifdef RT_USING_SEMAPHORE {
RT_Object_Class_Semaphore, /**< The object is a semaphore. */ RT_Object_Class_Thread = 0, /**< The object is a thread. */
#endif #ifdef RT_USING_SEMAPHORE
#ifdef RT_USING_MUTEX RT_Object_Class_Semaphore, /**< The object is a semaphore. */
RT_Object_Class_Mutex, /**< The object is a mutex. */ #endif
#endif #ifdef RT_USING_MUTEX
#ifdef RT_USING_EVENT RT_Object_Class_Mutex, /**< The object is a mutex. */
RT_Object_Class_Event, /**< The object is a event. */ #endif
#endif #ifdef RT_USING_EVENT
#ifdef RT_USING_MAILBOX RT_Object_Class_Event, /**< The object is a event. */
RT_Object_Class_MailBox, /**< The object is a mail box. */ #endif
#endif #ifdef RT_USING_MAILBOX
#ifdef RT_USING_MESSAGEQUEUE RT_Object_Class_MailBox, /**< The object is a mail box. */
RT_Object_Class_MessageQueue, /**< The object is a message queue. */ #endif
#endif #ifdef RT_USING_MESSAGEQUEUE
#ifdef RT_USING_MEMHEAP RT_Object_Class_MessageQueue, /**< The object is a message queue. */
RT_Object_Class_MemHeap, /**< The object is a memory heap */ #endif
#endif #ifdef RT_USING_MEMHEAP
#ifdef RT_USING_MEMPOOL RT_Object_Class_MemHeap, /**< The object is a memory heap */
RT_Object_Class_MemPool, /**< The object is a memory pool. */ #endif
#endif #ifdef RT_USING_MEMPOOL
#ifdef RT_USING_DEVICE RT_Object_Class_MemPool, /**< The object is a memory pool. */
RT_Object_Class_Device, /**< The object is a device */ #endif
#endif #ifdef RT_USING_DEVICE
RT_Object_Class_Timer, /**< The object is a timer. */ RT_Object_Class_Device, /**< The object is a device */
#ifdef RT_USING_MODULE #endif
RT_Object_Class_Module, /**< The object is a module. */ RT_Object_Class_Timer, /**< The object is a timer. */
#endif #ifdef RT_USING_MODULE
RT_Object_Class_Unknown, /**< The object is unknown. */ RT_Object_Class_Module, /**< The object is a module. */
RT_Object_Class_Static = 0x80 /**< The object is a static object. */ #endif
}; RT_Object_Class_Unknown, /**< 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 * The information of the kernel object
{ */
enum rt_object_class_type type; /**< object class type */ struct rt_object_information
rt_list_t object_list; /**< object list */ {
rt_size_t object_size; /**< object size */ enum rt_object_class_type type; /**< object class type */
}; rt_list_t object_list; /**< object list */
rt_size_t object_size; /**< object size */
/** };
* The hook function call macro
*/ /**
#ifdef RT_USING_HOOK * The hook function call macro
#define RT_OBJECT_HOOK_CALL(func, argv) \ */
do { if ((func) != RT_NULL) func argv; } while (0) #ifdef RT_USING_HOOK
#else #define RT_OBJECT_HOOK_CALL(func, argv) \
#define RT_OBJECT_HOOK_CALL(func, argv) do { if ((func) != RT_NULL) func argv; } while (0)
#endif #else
#define RT_OBJECT_HOOK_CALL(func, argv)
/*@}*/ #endif
/** /*@}*/
* @addtogroup Clock
*/ /**
* @addtogroup Clock
/*@{*/ */
/** /*@{*/
* clock & timer macros
*/ /**
#define RT_TIMER_FLAG_DEACTIVATED 0x0 /**< timer is deactive */ * clock & timer macros
#define RT_TIMER_FLAG_ACTIVATED 0x1 /**< timer is active */ */
#define RT_TIMER_FLAG_ONE_SHOT 0x0 /**< one shot timer */ #define RT_TIMER_FLAG_DEACTIVATED 0x0 /**< timer is deactive */
#define RT_TIMER_FLAG_PERIODIC 0x2 /**< periodic timer */ #define RT_TIMER_FLAG_ACTIVATED 0x1 /**< timer is active */
#define RT_TIMER_FLAG_ONE_SHOT 0x0 /**< one shot 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_PERIODIC 0x2 /**< periodic timer */
#define RT_TIMER_FLAG_SOFT_TIMER 0x4 /**< soft timer,the timer's callback function will be called in timer thread. */
#define RT_TIMER_FLAG_HARD_TIMER 0x0 /**< hard timer,the timer's callback function will be called in tick isr. */
#define RT_TIMER_CTRL_SET_TIME 0x0 /**< set timer control command */ #define RT_TIMER_FLAG_SOFT_TIMER 0x4 /**< soft timer,the timer's callback function will be called in timer thread. */
#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_TIME 0x0 /**< set timer control command */
#define RT_TIMER_CTRL_SET_PERIODIC 0x3 /**< change timer to periodic */ #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 */
* timer structure
*/ /**
struct rt_timer * timer structure
{ */
struct rt_object parent; /**< inherit from rt_object */ struct rt_timer
{
rt_list_t list; /**< the node of timer list */ struct rt_object parent; /**< inherit from rt_object */
void (*timeout_func)(void *parameter); /**< timeout function */ rt_list_t list; /**< the node of timer list */
void *parameter; /**< timeout function's parameter */
void (*timeout_func)(void *parameter); /**< timeout function */
rt_tick_t init_tick; /**< timer timeout tick */ void *parameter; /**< timeout function's parameter */
rt_tick_t timeout_tick; /**< timeout tick */
}; rt_tick_t init_tick; /**< timer timeout tick */
typedef struct rt_timer *rt_timer_t; rt_tick_t timeout_tick; /**< timeout tick */
};
/*@}*/ typedef struct rt_timer *rt_timer_t;
/** /*@}*/
* @addtogroup Thread
*/ /**
* @addtogroup Thread
/*@{*/ */
/* /*@{*/
* Thread
*/ /*
* Thread
/* */
* thread state definitions
*/ /*
#define RT_THREAD_INIT 0x00 /**< Initialized status */ * thread state definitions
#define RT_THREAD_READY 0x01 /**< Ready status */ */
#define RT_THREAD_SUSPEND 0x02 /**< Suspend status */ #define RT_THREAD_INIT 0x00 /**< Initialized status */
#define RT_THREAD_RUNNING 0x03 /**< Running status */ #define RT_THREAD_READY 0x01 /**< Ready status */
#define RT_THREAD_BLOCK RT_THREAD_SUSPEND /**< Blocked status */ #define RT_THREAD_SUSPEND 0x02 /**< Suspend status */
#define RT_THREAD_CLOSE 0x04 /**< Closed status */ #define RT_THREAD_RUNNING 0x03 /**< Running status */
#define RT_THREAD_BLOCK RT_THREAD_SUSPEND /**< Blocked status */
/** #define RT_THREAD_CLOSE 0x04 /**< Closed status */
* thread control command definitions
*/ /**
#define RT_THREAD_CTRL_STARTUP 0x00 /**< Startup thread. */ * thread control command definitions
#define RT_THREAD_CTRL_CLOSE 0x01 /**< Close thread. */ */
#define RT_THREAD_CTRL_CHANGE_PRIORITY 0x02 /**< Change thread priority. */ #define RT_THREAD_CTRL_STARTUP 0x00 /**< Startup thread. */
#define RT_THREAD_CTRL_INFO 0x03 /**< Get thread information. */ #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. */
* Thread structure
*/ /**
struct rt_thread * Thread structure
{ */
/* rt object */ struct rt_thread
char name[RT_NAME_MAX]; /**< the name of thread */ {
rt_uint8_t type; /**< type of object */ /* rt object */
rt_uint8_t flags; /**< thread's flags */ char name[RT_NAME_MAX]; /**< the name of thread */
rt_uint8_t type; /**< type of object */
#ifdef RT_USING_MODULE rt_uint8_t flags; /**< thread's flags */
void *module_id; /**< id of application module */
#endif #ifdef RT_USING_MODULE
void *module_id; /**< id of application module */
rt_list_t list; /**< the object list */ #endif
rt_list_t tlist; /**< the thread list */
rt_list_t list; /**< the object list */
/* stack point and entry */ rt_list_t tlist; /**< the thread list */
void *sp; /**< stack point */
void *entry; /**< entry */ /* stack point and entry */
void *parameter; /**< parameter */ void *sp; /**< stack point */
void *stack_addr; /**< stack address */ void *entry; /**< entry */
rt_uint16_t stack_size; /**< stack size */ void *parameter; /**< parameter */
void *stack_addr; /**< stack address */
/* error code */ rt_uint16_t stack_size; /**< stack size */
rt_err_t error; /**< error code */
/* error code */
rt_uint8_t stat; /**< thread stat */ rt_err_t error; /**< error code */
/* priority */ rt_uint8_t stat; /**< thread stat */
rt_uint8_t current_priority; /**< current priority */
rt_uint8_t init_priority; /**< initialized priority */ /* priority */
#if RT_THREAD_PRIORITY_MAX > 32 rt_uint8_t current_priority; /**< current priority */
rt_uint8_t number; rt_uint8_t init_priority; /**< initialized priority */
rt_uint8_t high_mask; #if RT_THREAD_PRIORITY_MAX > 32
#endif rt_uint8_t number;
rt_uint32_t number_mask; rt_uint8_t high_mask;
#endif
#if defined(RT_USING_EVENT) rt_uint32_t number_mask;
/* thread event */
rt_uint32_t event_set; #if defined(RT_USING_EVENT)
rt_uint8_t event_info; /* thread event */
#endif rt_uint32_t event_set;
rt_uint8_t event_info;
rt_ubase_t init_tick; /**< thread's initialized tick */ #endif
rt_ubase_t remaining_tick; /**< remaining tick */
rt_ubase_t init_tick; /**< thread's initialized tick */
struct rt_timer thread_timer; /**< built-in thread timer */ rt_ubase_t remaining_tick; /**< remaining tick */
void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit */ struct rt_timer thread_timer; /**< built-in thread timer */
rt_uint32_t user_data; /**< private user data beyond this thread */ void (*cleanup)(struct rt_thread *tid); /**< cleanup function when thread exit */
};
typedef struct rt_thread *rt_thread_t; rt_uint32_t user_data; /**< private user data beyond this thread */
};
/*@}*/ typedef struct rt_thread *rt_thread_t;
/** /*@}*/
* @addtogroup IPC
*/ /**
* @addtogroup IPC
/*@{*/ */
/** /*@{*/
* IPC flags and control command definitions
*/ /**
#define RT_IPC_FLAG_FIFO 0x00 /**< FIFOed IPC. @ref IPC. */ * IPC flags and control command definitions
#define RT_IPC_FLAG_PRIO 0x01 /**< PRIOed IPC. @ref IPC. */ */
#define RT_IPC_FLAG_FIFO 0x00 /**< FIFOed IPC. @ref IPC. */
#define RT_IPC_CMD_UNKNOWN 0x00 /**< unknown IPC command */ #define RT_IPC_FLAG_PRIO 0x01 /**< PRIOed IPC. @ref IPC. */
#define RT_IPC_CMD_RESET 0x01 /**< reset IPC object */
#define RT_IPC_CMD_UNKNOWN 0x00 /**< unknown IPC command */
#define RT_WAITING_FOREVER -1 /**< Block forever until get resource. */ #define RT_IPC_CMD_RESET 0x01 /**< reset IPC object */
#define RT_WAITING_NO 0 /**< Non-block. */
#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 * Base structure of IPC object
{ */
struct rt_object parent; /**< inherit from rt_object */ struct rt_ipc_object
{
rt_list_t suspend_thread; /**< threads pended on this resource */ struct rt_object parent; /**< inherit from rt_object */
};
rt_list_t suspend_thread; /**< threads pended on this resource */
#ifdef RT_USING_SEMAPHORE };
/**
* Semaphore structure #ifdef RT_USING_SEMAPHORE
*/ /**
struct rt_semaphore * Semaphore structure
{ */
struct rt_ipc_object parent; /**< inherit from ipc_object */ struct rt_semaphore
{
rt_uint16_t value; /**< value of semaphore. */ struct rt_ipc_object parent; /**< inherit from ipc_object */
};
typedef struct rt_semaphore *rt_sem_t; rt_uint16_t value; /**< value of semaphore. */
#endif };
typedef struct rt_semaphore *rt_sem_t;
#ifdef RT_USING_MUTEX #endif
/**
* Mutual exclusion (mutex) structure #ifdef RT_USING_MUTEX
*/ /**
struct rt_mutex * Mutual exclusion (mutex) structure
{ */
struct rt_ipc_object parent; /**< inherit from ipc_object */ struct rt_mutex
{
rt_uint16_t value; /**< value of mutex */ struct rt_ipc_object parent; /**< inherit from ipc_object */
rt_uint8_t original_priority; /**< priority of last thread hold the mutex */ rt_uint16_t value; /**< value of mutex */
rt_uint8_t hold; /**< numbers of thread hold the mutex */
rt_uint8_t original_priority; /**< priority of last thread hold the mutex */
struct rt_thread *owner; /**< current owner of mutex */ rt_uint8_t hold; /**< numbers of thread hold the mutex */
};
typedef struct rt_mutex *rt_mutex_t; struct rt_thread *owner; /**< current owner of mutex */
#endif };
typedef struct rt_mutex *rt_mutex_t;
#ifdef RT_USING_EVENT #endif
/**
* flag defintions in event #ifdef RT_USING_EVENT
*/ /**
#define RT_EVENT_FLAG_AND 0x01 /**< logic and */ * flag defintions in event
#define RT_EVENT_FLAG_OR 0x02 /**< logic or */ */
#define RT_EVENT_FLAG_CLEAR 0x04 /**< clear flag */ #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 * event structure
{ */
struct rt_ipc_object parent; /**< inherit from ipc_object */ struct rt_event
{
rt_uint32_t set; /**< event set */ struct rt_ipc_object parent; /**< inherit from ipc_object */
};
typedef struct rt_event *rt_event_t; rt_uint32_t set; /**< event set */
#endif };
typedef struct rt_event *rt_event_t;
#ifdef RT_USING_MAILBOX #endif
/**
* mailbox structure #ifdef RT_USING_MAILBOX
*/ /**
struct rt_mailbox * mailbox structure
{ */
struct rt_ipc_object parent; /**< inherit from ipc_object */ struct rt_mailbox
{
rt_uint32_t *msg_pool; /**< start address of message buffer */ struct rt_ipc_object parent; /**< inherit from ipc_object */
rt_uint16_t size; /**< size of message pool */ rt_uint32_t *msg_pool; /**< start address of message buffer */
rt_uint16_t entry; /**< index of messages in msg_pool */ rt_uint16_t size; /**< size of message pool */
rt_uint16_t in_offset; /**< input offset of the message buffer */
rt_uint16_t out_offset; /**< output offset of the message buffer */ rt_uint16_t entry; /**< index of messages in msg_pool */
rt_uint16_t in_offset; /**< input offset of the message buffer */
rt_list_t suspend_sender_thread; /**< sender thread suspended on this mailbox */ rt_uint16_t out_offset; /**< output offset of the message buffer */
};
typedef struct rt_mailbox *rt_mailbox_t; rt_list_t suspend_sender_thread; /**< sender thread suspended on this mailbox */
#endif };
typedef struct rt_mailbox *rt_mailbox_t;
#ifdef RT_USING_MESSAGEQUEUE #endif
/**
* message queue structure #ifdef RT_USING_MESSAGEQUEUE
*/ /**
struct rt_messagequeue * message queue structure
{ */
struct rt_ipc_object parent; /**< inherit from ipc_object */ struct rt_messagequeue
{
void *msg_pool; /**< start address of message queue */ struct rt_ipc_object parent; /**< inherit from ipc_object */
rt_uint16_t msg_size; /**< message size of each message */ void *msg_pool; /**< start address of message queue */
rt_uint16_t max_msgs; /**< max number of messages */
rt_uint16_t msg_size; /**< message size of each message */
rt_uint16_t entry; /**< index of messages in the queue */ rt_uint16_t max_msgs; /**< max number of messages */
void *msg_queue_head; /**< list head */ rt_uint16_t entry; /**< index of messages in the queue */
void *msg_queue_tail; /**< list tail */
void *msg_queue_free; /**< pointer indicated the free node of queue */ void *msg_queue_head; /**< list head */
}; void *msg_queue_tail; /**< list tail */
typedef struct rt_messagequeue *rt_mq_t; void *msg_queue_free; /**< pointer indicated the free node of queue */
#endif };
typedef struct rt_messagequeue *rt_mq_t;
/*@}*/ #endif
#ifdef RT_USING_MEMPOOL /*@}*/
/**
* @addtogroup MM /**
*/ * @addtogroup MM
*/
/*@{*/
/*@{*/
/*
* memory management /*
* heap & partition * memory management
*/ * heap & partition
*/
/**
* memory item on the heap #ifdef RT_USING_MEMHEAP
*/ /**
struct rt_memheap_item * memory item on the heap
{ */
rt_uint32_t magic; /**< magic number for memheap */ struct rt_memheap_item
struct rt_memheap_item *next; /**< next memheap item */ {
struct rt_memheap_item *prev; /**< prev memheap item */ rt_uint32_t magic; /**< magic number for memheap */
struct rt_memheap_item *next_free; /**< next free memheap item */ struct rt_memheap_item *next; /**< next memheap item */
struct rt_memheap_item *prev_free; /**< prev free memheap item */ struct rt_memheap_item *prev; /**< prev memheap item */
struct rt_memheap *pool_ptr; /**< point of pool */ struct rt_memheap *pool_ptr; /**< point of pool */
};
struct rt_memheap_item *next_free; /**< next free memheap item */
/** struct rt_memheap_item *prev_free; /**< prev free memheap item */
* Base structure of memory heap object };
*/
struct rt_memheap /**
{ * Base structure of memory heap object
struct rt_object parent; /**< inherit from rt_object */ */
struct rt_memheap
void *start_addr; /**< pool start address and size */ {
struct rt_object parent; /**< inherit from rt_object */
rt_uint32_t pool_size; /**< pool size */
rt_uint32_t available_size; /**< available size */ void *start_addr; /**< pool start address and size */
struct rt_memheap_item *block_list; /**< used block list */ rt_uint32_t pool_size; /**< pool size */
rt_uint32_t available_size; /**< available size */
struct rt_memheap_item *free_list; /**< free block list */ rt_uint32_t max_used_size; /**< maximum allocated size */
struct rt_memheap_item free_header; /**< free block list header */
struct rt_memheap_item *block_list; /**< used block list */
struct rt_mutex lock; /**< mutex lock */
}; struct rt_memheap_item *free_list; /**< free block list */
struct rt_memheap_item free_header; /**< free block list header */
/**
* Base structure of Memory pool object struct rt_semaphore lock; /**< semaphore lock */
*/ };
struct rt_mempool #endif
{
struct rt_object parent; /**< inherit from rt_object */ #ifdef RT_USING_MEMPOOL
/**
void *start_address; /**< memory pool start */ * Base structure of Memory pool object
rt_size_t size; /**< size of memory pool */ */
struct rt_mempool
rt_size_t block_size; /**< size of memory blocks */ {
rt_uint8_t *block_list; /**< memory blocks list */ struct rt_object parent; /**< inherit from rt_object */
rt_size_t block_total_count; /**< numbers of memory block */ void *start_address; /**< memory pool start */
rt_size_t block_free_count; /**< numbers of free memory block */ rt_size_t size; /**< size of memory pool */
rt_list_t suspend_thread; /**< threads pended on this resource */ rt_size_t block_size; /**< size of memory blocks */
rt_size_t suspend_thread_count; /**< numbers of thread pended on this resource */ rt_uint8_t *block_list; /**< memory blocks list */
};
typedef struct rt_mempool *rt_mp_t; rt_size_t block_total_count; /**< numbers of memory block */
rt_size_t block_free_count; /**< numbers of free memory block */
/*@}*/
#endif rt_list_t suspend_thread; /**< threads pended on this resource */
rt_size_t suspend_thread_count; /**< numbers of thread pended on this resource */
#ifdef RT_USING_DEVICE };
/** typedef struct rt_mempool *rt_mp_t;
* @addtogroup Device #endif
*/
/*@}*/
/*@{*/
#ifdef RT_USING_DEVICE
/** /**
* device (I/O) class type * @addtogroup Device
*/ */
enum rt_device_class_type
{ /*@{*/
RT_Device_Class_Char = 0, /**< character device */
RT_Device_Class_Block, /**< block device */ /**
RT_Device_Class_NetIf, /**< net interface */ * device (I/O) class type
RT_Device_Class_MTD, /**< memory device */ */
RT_Device_Class_CAN, /**< CAN device */ enum rt_device_class_type
RT_Device_Class_RTC, /**< RTC device */ {
RT_Device_Class_Sound, /**< Sound device */ RT_Device_Class_Char = 0, /**< character device */
RT_Device_Class_Graphic, /**< Graphic device */ RT_Device_Class_Block, /**< block device */
RT_Device_Class_I2CBUS, /**< I2C bus device */ RT_Device_Class_NetIf, /**< net interface */
RT_Device_Class_USBDevice, /**< USB slave device */ RT_Device_Class_MTD, /**< memory device */
RT_Device_Class_USBHost, /**< USB host bus */ RT_Device_Class_CAN, /**< CAN device */
RT_Device_Class_SPIBUS, /**< SPI bus device */ RT_Device_Class_RTC, /**< RTC device */
RT_Device_Class_SPIDevice, /**< SPI device */ RT_Device_Class_Sound, /**< Sound device */
RT_Device_Class_SDIO, /**< SDIO bus device */ RT_Device_Class_Graphic, /**< Graphic device */
RT_Device_Class_PM, /**< PM pseudo device */ RT_Device_Class_I2CBUS, /**< I2C bus device */
RT_Device_Class_Unknown /**< unknown device */ RT_Device_Class_USBDevice, /**< USB slave device */
}; RT_Device_Class_USBHost, /**< USB host bus */
RT_Device_Class_SPIBUS, /**< SPI bus device */
/** RT_Device_Class_SPIDevice, /**< SPI device */
* device flags defitions RT_Device_Class_SDIO, /**< SDIO bus device */
*/ RT_Device_Class_PM, /**< PM pseudo device */
#define RT_DEVICE_FLAG_DEACTIVATE 0x000 /**< device is not not initialized */ RT_Device_Class_Unknown /**< unknown device */
};
#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 */ * device flags defitions
*/
#define RT_DEVICE_FLAG_REMOVABLE 0x004 /**< removable device */ #define RT_DEVICE_FLAG_DEACTIVATE 0x000 /**< device is not not initialized */
#define RT_DEVICE_FLAG_STANDALONE 0x008 /**< standalone device */
#define RT_DEVICE_FLAG_ACTIVATED 0x010 /**< device is activated */ #define RT_DEVICE_FLAG_RDONLY 0x001 /**< read only */
#define RT_DEVICE_FLAG_SUSPENDED 0x020 /**< device is suspended */ #define RT_DEVICE_FLAG_WRONLY 0x002 /**< write only */
#define RT_DEVICE_FLAG_STREAM 0x040 /**< stream mode */ #define RT_DEVICE_FLAG_RDWR 0x003 /**< read and write */
#define RT_DEVICE_FLAG_INT_RX 0x100 /**< INT mode on Rx */ #define RT_DEVICE_FLAG_REMOVABLE 0x004 /**< removable device */
#define RT_DEVICE_FLAG_DMA_RX 0x200 /**< DMA mode on Rx */ #define RT_DEVICE_FLAG_STANDALONE 0x008 /**< standalone device */
#define RT_DEVICE_FLAG_INT_TX 0x400 /**< INT mode on Tx */ #define RT_DEVICE_FLAG_ACTIVATED 0x010 /**< device is activated */
#define RT_DEVICE_FLAG_DMA_TX 0x800 /**< DMA mode on Tx */ #define RT_DEVICE_FLAG_SUSPENDED 0x020 /**< device is suspended */
#define RT_DEVICE_FLAG_STREAM 0x040 /**< stream mode */
#define RT_DEVICE_OFLAG_CLOSE 0x000 /**< device is closed */
#define RT_DEVICE_OFLAG_RDONLY 0x001 /**< read only access */ #define RT_DEVICE_FLAG_INT_RX 0x100 /**< INT mode on Rx */
#define RT_DEVICE_OFLAG_WRONLY 0x002 /**< write only access */ #define RT_DEVICE_FLAG_DMA_RX 0x200 /**< DMA mode on Rx */
#define RT_DEVICE_OFLAG_RDWR 0x003 /**< read and write */ #define RT_DEVICE_FLAG_INT_TX 0x400 /**< INT mode on Tx */
#define RT_DEVICE_OFLAG_OPEN 0x008 /**< device is opened */ #define RT_DEVICE_FLAG_DMA_TX 0x800 /**< DMA mode on Tx */
/** #define RT_DEVICE_OFLAG_CLOSE 0x000 /**< device is closed */
* general device commands #define RT_DEVICE_OFLAG_RDONLY 0x001 /**< read only access */
*/ #define RT_DEVICE_OFLAG_WRONLY 0x002 /**< write only access */
#define RT_DEVICE_CTRL_RESUME 0x01 /**< resume device */ #define RT_DEVICE_OFLAG_RDWR 0x003 /**< read and write */
#define RT_DEVICE_CTRL_SUSPEND 0x02 /**< suspend device */ #define RT_DEVICE_OFLAG_OPEN 0x008 /**< device is opened */
/** /**
* special device commands * general device commands
*/ */
#define RT_DEVICE_CTRL_CHAR_STREAM 0x10 /**< stream mode on char device */ #define RT_DEVICE_CTRL_RESUME 0x01 /**< resume device */
#define RT_DEVICE_CTRL_BLK_GETGEOME 0x10 /**< get geometry information */ #define RT_DEVICE_CTRL_SUSPEND 0x02 /**< suspend device */
#define RT_DEVICE_CTRL_BLK_SYNC 0x11 /**< flush data to block device */
#define RT_DEVICE_CTRL_BLK_ERASE 0x12 /**< erase block on block device */ /**
#define RT_DEVICE_CTRL_NETIF_GETMAC 0x10 /**< get mac address */ * special device commands
#define RT_DEVICE_CTRL_MTD_FORMAT 0x10 /**< format a MTD device */ */
#define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /**< get time */ #define RT_DEVICE_CTRL_CHAR_STREAM 0x10 /**< stream mode on char device */
#define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /**< set time */ #define RT_DEVICE_CTRL_BLK_GETGEOME 0x10 /**< get geometry information */
#define RT_DEVICE_CTRL_RTC_GET_ALARM 0x12 /**< get alarm */ #define RT_DEVICE_CTRL_BLK_SYNC 0x11 /**< flush data to block device */
#define RT_DEVICE_CTRL_RTC_SET_ALARM 0x13 /**< set alarm */ #define RT_DEVICE_CTRL_BLK_ERASE 0x12 /**< erase block on block device */
#define RT_DEVICE_CTRL_NETIF_GETMAC 0x10 /**< get mac address */
typedef struct rt_device *rt_device_t; #define RT_DEVICE_CTRL_MTD_FORMAT 0x10 /**< format a MTD device */
/** #define RT_DEVICE_CTRL_RTC_GET_TIME 0x10 /**< get time */
* Device structure #define RT_DEVICE_CTRL_RTC_SET_TIME 0x11 /**< set time */
*/ #define RT_DEVICE_CTRL_RTC_GET_ALARM 0x12 /**< get alarm */
struct rt_device #define RT_DEVICE_CTRL_RTC_SET_ALARM 0x13 /**< set alarm */
{
struct rt_object parent; /**< inherit from rt_object */ typedef struct rt_device *rt_device_t;
/**
enum rt_device_class_type type; /**< device type */ * Device structure
rt_uint16_t flag; /**< device flag */ */
rt_uint16_t open_flag; /**< device open flag */ struct rt_device
{
rt_uint8_t device_id; /**< 0 - 255 */ struct rt_object parent; /**< inherit from rt_object */
/* device call back */ enum rt_device_class_type type; /**< device type */
rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size); rt_uint16_t flag; /**< device flag */
rt_err_t (*tx_complete)(rt_device_t dev, void *buffer); rt_uint16_t open_flag; /**< device open flag */
/* common device interface */ rt_uint8_t device_id; /**< 0 - 255 */
rt_err_t (*init) (rt_device_t dev);
rt_err_t (*open) (rt_device_t dev, rt_uint16_t oflag); /* device call back */
rt_err_t (*close) (rt_device_t dev); rt_err_t (*rx_indicate)(rt_device_t dev, rt_size_t size);
rt_size_t (*read) (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size); rt_err_t (*tx_complete)(rt_device_t dev, void *buffer);
rt_size_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, rt_uint8_t cmd, void *args); /* common device interface */
rt_err_t (*init) (rt_device_t dev);
#ifdef RT_USING_DEVICE_SUSPEND rt_err_t (*open) (rt_device_t dev, rt_uint16_t oflag);
rt_err_t (*suspend) (rt_device_t dev); rt_err_t (*close) (rt_device_t dev);
rt_err_t (*resumed) (rt_device_t dev); rt_size_t (*read) (rt_device_t dev, rt_off_t pos, void *buffer, rt_size_t size);
#endif rt_size_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, rt_uint8_t cmd, void *args);
void *user_data; /**< device private data */
}; #ifdef RT_USING_DEVICE_SUSPEND
rt_err_t (*suspend) (rt_device_t dev);
/** rt_err_t (*resumed) (rt_device_t dev);
* block device geometry structure #endif
*/
struct rt_device_blk_geometry void *user_data; /**< device private data */
{ };
rt_uint32_t sector_count; /**< count of sectors */
rt_uint32_t bytes_per_sector; /**< number of bytes per sector */ /**
rt_uint32_t block_size; /**< size to erase one block */ * block device geometry structure
}; */
struct rt_device_blk_geometry
/** {
* sector arrange struct on block device rt_uint32_t sector_count; /**< count of sectors */
*/ rt_uint32_t bytes_per_sector; /**< number of bytes per sector */
struct rt_device_blk_sectors rt_uint32_t block_size; /**< size to erase one block */
{ };
rt_uint32_t sector_begin; /**< begin sector */
rt_uint32_t sector_end; /**< end sector */ /**
}; * sector arrange struct on block device
*/
/** struct rt_device_blk_sectors
* graphic device control command {
*/ rt_uint32_t sector_begin; /**< begin sector */
#define RTGRAPHIC_CTRL_RECT_UPDATE 0 rt_uint32_t sector_end; /**< end sector */
#define RTGRAPHIC_CTRL_POWERON 1 };
#define RTGRAPHIC_CTRL_POWEROFF 2
#define RTGRAPHIC_CTRL_GET_INFO 3 /**
#define RTGRAPHIC_CTRL_SET_MODE 4 * graphic device control command
#define RTGRAPHIC_CTRL_FILL_RECT 5 */
#define RTGRAPHIC_CTRL_DRAW_RECT 6 #define RTGRAPHIC_CTRL_RECT_UPDATE 0
#define RTGRAPHIC_CTRL_POWERON 1
/* graphic deice */ #define RTGRAPHIC_CTRL_POWEROFF 2
enum #define RTGRAPHIC_CTRL_GET_INFO 3
{ #define RTGRAPHIC_CTRL_SET_MODE 4
RTGRAPHIC_PIXEL_FORMAT_MONO = 0, #define RTGRAPHIC_CTRL_FILL_RECT 5
RTGRAPHIC_PIXEL_FORMAT_GRAY4, #define RTGRAPHIC_CTRL_DRAW_RECT 6
RTGRAPHIC_PIXEL_FORMAT_GRAY16,
RTGRAPHIC_PIXEL_FORMAT_RGB332, /* graphic deice */
RTGRAPHIC_PIXEL_FORMAT_RGB444, enum
RTGRAPHIC_PIXEL_FORMAT_RGB565, {
RTGRAPHIC_PIXEL_FORMAT_RGB565P, RTGRAPHIC_PIXEL_FORMAT_MONO = 0,
RTGRAPHIC_PIXEL_FORMAT_RGB666, RTGRAPHIC_PIXEL_FORMAT_GRAY4,
RTGRAPHIC_PIXEL_FORMAT_RGB888, RTGRAPHIC_PIXEL_FORMAT_GRAY16,
RTGRAPHIC_PIXEL_FORMAT_ARGB888 RTGRAPHIC_PIXEL_FORMAT_RGB332,
}; RTGRAPHIC_PIXEL_FORMAT_RGB444,
RTGRAPHIC_PIXEL_FORMAT_RGB565,
/** RTGRAPHIC_PIXEL_FORMAT_RGB565P,
* build a pixel position according to (x, y) coordinates. RTGRAPHIC_PIXEL_FORMAT_RGB666,
*/ RTGRAPHIC_PIXEL_FORMAT_RGB888,
#define RTGRAPHIC_PIXEL_POSITION(x, y) ((x << 16) | y) RTGRAPHIC_PIXEL_FORMAT_ARGB888
};
/**
* graphic device information structure /**
*/ * build a pixel position according to (x, y) coordinates.
struct rt_device_graphic_info */
{ #define RTGRAPHIC_PIXEL_POSITION(x, y) ((x << 16) | y)
rt_uint8_t pixel_format; /**< graphic format */
rt_uint8_t bits_per_pixel; /**< bits per pixel */ /**
rt_uint16_t reserved; /**< reserved field */ * graphic device information structure
*/
rt_uint16_t width; /**< width of graphic device */ struct rt_device_graphic_info
rt_uint16_t height; /**< height of graphic device */ {
rt_uint8_t pixel_format; /**< graphic format */
rt_uint8_t *framebuffer; /**< frame buffer */ rt_uint8_t bits_per_pixel; /**< bits per pixel */
}; rt_uint16_t reserved; /**< reserved field */
/** rt_uint16_t width; /**< width of graphic device */
* rectangle information structure rt_uint16_t height; /**< height of graphic device */
*/
struct rt_device_rect_info rt_uint8_t *framebuffer; /**< frame buffer */
{ };
rt_uint16_t x; /**< x coordinate */
rt_uint16_t y; /**< y coordinate */ /**
rt_uint16_t width; /**< width */ * rectangle information structure
rt_uint16_t height; /**< height */ */
}; struct rt_device_rect_info
{
/** rt_uint16_t x; /**< x coordinate */
* graphic operations rt_uint16_t y; /**< y coordinate */
*/ rt_uint16_t width; /**< width */
struct rt_device_graphic_ops rt_uint16_t height; /**< height */
{ };
void (*set_pixel) (const char *pixel, int x, int y);
void (*get_pixel) (char *pixel, int x, int y); /**
* graphic operations
void (*draw_hline)(const char *pixel, int x1, int x2, int y); */
void (*draw_vline)(const char *pixel, int x, int y1, int y2); struct rt_device_graphic_ops
{
void (*blit_line) (const char *pixel, int x, int y, rt_size_t size); void (*set_pixel) (const char *pixel, int x, int y);
}; void (*get_pixel) (char *pixel, int x, int y);
#define rt_graphix_ops(device) ((struct rt_device_graphic_ops *)(device->user_data))
void (*draw_hline)(const char *pixel, int x1, int x2, int y);
/*@}*/ void (*draw_vline)(const char *pixel, int x, int y1, int y2);
#endif
void (*blit_line) (const char *pixel, int x, int y, rt_size_t size);
#ifdef RT_USING_MODULE };
/** #define rt_graphix_ops(device) ((struct rt_device_graphic_ops *)(device->user_data))
* @addtogroup Module
*/ /*@}*/
#endif
/*@{*/
#ifdef RT_USING_MODULE
/* /**
* module system * @addtogroup Module
*/ */
#define RT_MODULE_FLAG_WITHENTRY 0x00 /**< with entry point */ /*@{*/
#define RT_MODULE_FLAG_WITHOUTENTRY 0x01 /**< without entry point */
/*
/** * module system
* Application Module structure */
*/
struct rt_module #define RT_MODULE_FLAG_WITHENTRY 0x00 /**< with entry point */
{ #define RT_MODULE_FLAG_WITHOUTENTRY 0x01 /**< without entry point */
struct rt_object parent; /**< inherit from object */
/**
rt_uint8_t *module_space; /**< module memory space */ * Application Module structure
*/
void *module_entry; /**< entry address of module's thread */ struct rt_module
rt_thread_t module_thread; /**< stack size of module's thread */ {
rt_uint32_t stack_size; /**< priority of module's thread */ struct rt_object parent; /**< inherit from object */
rt_uint32_t thread_priority;
rt_uint8_t *module_space; /**< module memory space */
#ifdef RT_USING_SLAB
/* module memory allocator */ void *module_entry; /**< entry address of module's thread */
void *mem_list; /**< module's free memory list */ rt_thread_t module_thread; /**< stack size of module's thread */
void *page_array; /**< module's using pages */ rt_uint32_t stack_size; /**< priority of module's thread */
rt_uint32_t page_cnt; /**< module's using pages count */ rt_uint32_t thread_priority;
#endif
#ifdef RT_USING_SLAB
rt_uint32_t nsym; /**< number of symbol in the module */ /* module memory allocator */
struct rt_module_symtab *symtab; /**< module symbol table */ void *mem_list; /**< module's free memory list */
void *page_array; /**< module's using pages */
rt_uint32_t nref; /**< reference count */ rt_uint32_t page_cnt; /**< module's using pages count */
#endif
/* object in this module, module object is the last basic object type */
struct rt_object_information module_object[RT_Object_Class_Unknown]; rt_uint32_t nsym; /**< number of symbol in the module */
}; struct rt_module_symtab *symtab; /**< module symbol table */
typedef struct rt_module *rt_module_t;
rt_uint32_t nref; /**< reference count */
/*@}*/
#endif /* object in this module, module object is the last basic object type */
struct rt_object_information module_object[RT_Object_Class_Unknown];
#ifdef __cplusplus };
} typedef struct rt_module *rt_module_t;
#endif
/*@}*/
#endif #endif
#ifdef __cplusplus
}
#endif
#endif
src/SConscript
浏览文件 @ 97561047
...@@ -24,6 +24,8 @@ if GetDepend('RT_USING_MEMPOOL') == False: ...@@ -24,6 +24,8 @@ if GetDepend('RT_USING_MEMPOOL') == False:
if GetDepend('RT_USING_MEMHEAP') == False: if GetDepend('RT_USING_MEMHEAP') == False:
SrcRemove(src, ['memheap.c']) SrcRemove(src, ['memheap.c'])
if GetDepend('RT_USING_MEMHEAP_AS_HEAP'):
SrcRemove(src, ['mem.c'])
if GetDepend('RT_USING_DEVICE') == False: if GetDepend('RT_USING_DEVICE') == False:
SrcRemove(src, ['device.c']) SrcRemove(src, ['device.c'])
......
src/idle.c
浏览文件 @ 97561047
...@@ -11,6 +11,7 @@ ...@@ -11,6 +11,7 @@
* Date Author Notes * Date Author Notes
* 2006-03-23 Bernard the first version * 2006-03-23 Bernard the first version
* 2010-11-10 Bernard add cleanup callback function in thread exit. * 2010-11-10 Bernard add cleanup callback function in thread exit.
* 2012-12-29 Bernard fix compiling warning.
*/ */
#include <rthw.h> #include <rthw.h>
...@@ -46,7 +47,7 @@ static void (*rt_thread_idle_hook)(); ...@@ -46,7 +47,7 @@ static void (*rt_thread_idle_hook)();
* *
* @note the hook function must be simple and never be blocked or suspend. * @note the hook function must be simple and never be blocked or suspend.
*/ */
void rt_thread_idle_sethook(void (*hook)()) void rt_thread_idle_sethook(void (*hook)(void))
{ {
rt_thread_idle_hook = hook; rt_thread_idle_hook = hook;
} }
......
src/mem.c
浏览文件 @ 97561047
...@@ -52,6 +52,8 @@ ...@@ -52,6 +52,8 @@
#include <rthw.h> #include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#ifndef RT_USING_MEMHEAP_AS_HEAP
/* #define RT_MEM_DEBUG */ /* #define RT_MEM_DEBUG */
#define RT_MEM_STATS #define RT_MEM_STATS
...@@ -574,4 +576,6 @@ FINSH_FUNCTION_EXPORT(list_mem, list memory usage information) ...@@ -574,4 +576,6 @@ FINSH_FUNCTION_EXPORT(list_mem, list memory usage information)
/*@}*/ /*@}*/
#endif #endif /* end of RT_USING_HEAP */
#endif /* end of RT_USING_MEMHEAP_AS_HEAP */
src/memheap.c
浏览文件 @ 97561047
...@@ -11,8 +11,11 @@ ...@@ -11,8 +11,11 @@
* Date Author Notes * Date Author Notes
* 2012-04-10 Bernard first implementation * 2012-04-10 Bernard first implementation
* 2012-10-16 Bernard add the mutex lock for heap object. * 2012-10-16 Bernard add the mutex lock for heap object.
* 2012-12-29 Bernard memheap can be used as system heap.
* change mutex lock to semaphore lock.
*/ */
#include <rthw.h>
#include <rtthread.h> #include <rtthread.h>
#ifdef RT_USING_MEMHEAP #ifdef RT_USING_MEMHEAP
...@@ -26,7 +29,8 @@ ...@@ -26,7 +29,8 @@
#define RT_MEMHEAP_IS_USED(i) ((i)->magic & RT_MEMHEAP_USED) #define RT_MEMHEAP_IS_USED(i) ((i)->magic & RT_MEMHEAP_USED)
#define RT_MEMHEAP_MINIALLOC 12 #define RT_MEMHEAP_MINIALLOC 12
#define RT_MEMHEAP_SIZE RT_ALIGN(sizeof(struct rt_memheap_item), RT_ALIGN_SIZE) #define RT_MEMHEAP_SIZE RT_ALIGN(sizeof(struct rt_memheap_item), RT_ALIGN_SIZE)
#define MEMITEM_SIZE(item) ((rt_uint32_t)item->next - (rt_uint32_t)item - RT_MEMHEAP_SIZE)
/* /*
* The initialized memory pool will be: * The initialized memory pool will be:
...@@ -54,6 +58,7 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, ...@@ -54,6 +58,7 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap,
memheap->start_addr = start_addr; memheap->start_addr = start_addr;
memheap->pool_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE); memheap->pool_size = RT_ALIGN_DOWN(size, RT_ALIGN_SIZE);
memheap->available_size = memheap->pool_size - (2 * RT_MEMHEAP_SIZE); memheap->available_size = memheap->pool_size - (2 * RT_MEMHEAP_SIZE);
memheap->max_used_size = memheap->pool_size - memheap->available_size;
/* initialize the free list header */ /* initialize the free list header */
item = &(memheap->free_header); item = &(memheap->free_header);
...@@ -101,8 +106,8 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap, ...@@ -101,8 +106,8 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap,
/* not in free list */ /* not in free list */
item->next_free = item->prev_free = RT_NULL; item->next_free = item->prev_free = RT_NULL;
/* initialize mutex lock */ /* initialize semaphore lock */
rt_mutex_init(&(memheap->lock), name, RT_IPC_FLAG_FIFO); rt_sem_init(&(memheap->lock), name, 1, RT_IPC_FLAG_FIFO);
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("memory heap: start addr 0x%08x, size %d, free list header 0x%08x", ("memory heap: start addr 0x%08x, size %d, free list header 0x%08x",
...@@ -137,7 +142,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -137,7 +142,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
if (size < RT_MEMHEAP_MINIALLOC) if (size < RT_MEMHEAP_MINIALLOC)
size = RT_MEMHEAP_MINIALLOC; size = RT_MEMHEAP_MINIALLOC;
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("allocate %d", size)); RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("allocate %d on heap:%8.*s", size, RT_NAME_MAX, heap->parent.name));
if (size < heap->available_size) if (size < heap->available_size)
{ {
...@@ -145,7 +150,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -145,7 +150,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
free_size = 0; free_size = 0;
/* lock memheap */ /* lock memheap */
result = rt_mutex_take(&(heap->lock), RT_WAITING_FOREVER); result = rt_sem_take(&(heap->lock), RT_WAITING_FOREVER);
if (result != RT_EOK) if (result != RT_EOK)
{ {
rt_set_errno(result); rt_set_errno(result);
...@@ -184,7 +189,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -184,7 +189,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
(((rt_uint8_t *)header_ptr) + size + RT_MEMHEAP_SIZE); (((rt_uint8_t *)header_ptr) + size + RT_MEMHEAP_SIZE);
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("split: h[0x%08x] nm[0x%08x] pm[0x%08x] to n[0x%08x]", ("split: block[0x%08x] nextm[0x%08x] prevm[0x%08x] to new[0x%08x]",
header_ptr, header_ptr,
header_ptr->next, header_ptr->next,
header_ptr->prev, header_ptr->prev,
...@@ -213,7 +218,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -213,7 +218,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
new_ptr->prev_free = heap->free_list; new_ptr->prev_free = heap->free_list;
heap->free_list->next_free->prev_free = new_ptr; heap->free_list->next_free->prev_free = new_ptr;
heap->free_list->next_free = new_ptr; heap->free_list->next_free = new_ptr;
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("new ptr: nf 0x%08x, pf 0x%08x", RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("new ptr: next_free 0x%08x, prev_free 0x%08x",
new_ptr->next_free, new_ptr->next_free,
new_ptr->prev_free)); new_ptr->prev_free));
...@@ -221,15 +226,19 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -221,15 +226,19 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
heap->available_size = heap->available_size - heap->available_size = heap->available_size -
size - size -
RT_MEMHEAP_SIZE; RT_MEMHEAP_SIZE;
if (heap->pool_size - heap->available_size > heap->max_used_size)
heap->max_used_size = heap->pool_size - heap->available_size;
} }
else else
{ {
/* decrement the entire free size from the available bytes count. */ /* decrement the entire free size from the available bytes count. */
heap->available_size = heap->available_size - free_size; heap->available_size = heap->available_size - free_size;
if (heap->pool_size - heap->available_size > heap->max_used_size)
heap->max_used_size = heap->pool_size - heap->available_size;
/* remove header_ptr from free list */ /* remove header_ptr from free list */
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("one block: h[0x%08x], nf 0x%08x, pf 0x%08x", ("one block: block[0x%08x], next_free 0x%08x, prev_free 0x%08x",
header_ptr, header_ptr,
header_ptr->next_free, header_ptr->next_free,
header_ptr->prev_free)); header_ptr->prev_free));
...@@ -240,15 +249,15 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -240,15 +249,15 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
header_ptr->prev_free = RT_NULL; header_ptr->prev_free = RT_NULL;
} }
/* release lock */
rt_mutex_release(&(heap->lock));
/* Mark the allocated block as not available. */ /* Mark the allocated block as not available. */
header_ptr->magic |= RT_MEMHEAP_USED; header_ptr->magic |= RT_MEMHEAP_USED;
/* release lock */
rt_sem_release(&(heap->lock));
/* Return a memory address to the caller. */ /* Return a memory address to the caller. */
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("am: m[0x%08x], h[0x%08x], size: %d", ("alloc mem: memory[0x%08x], heap[0x%08x], size: %d",
(void *)((rt_uint8_t *)header_ptr + RT_MEMHEAP_SIZE), (void *)((rt_uint8_t *)header_ptr + RT_MEMHEAP_SIZE),
header_ptr, header_ptr,
size); size);
...@@ -257,7 +266,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size) ...@@ -257,7 +266,7 @@ void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size)
} }
/* release lock */ /* release lock */
rt_mutex_release(&(heap->lock)); rt_sem_release(&(heap->lock));
} }
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("allocate memory: failed\n")); RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("allocate memory: failed\n"));
...@@ -280,7 +289,7 @@ void rt_memheap_free(void *ptr) ...@@ -280,7 +289,7 @@ void rt_memheap_free(void *ptr)
header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)ptr - header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)ptr -
RT_MEMHEAP_SIZE); RT_MEMHEAP_SIZE);
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("free memory: m[0x%08x], h[0x%08x]", RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, ("free memory: memory[0x%08x], block[0x%08x]",
ptr, header_ptr)); ptr, header_ptr));
/* check magic */ /* check magic */
...@@ -290,7 +299,7 @@ void rt_memheap_free(void *ptr) ...@@ -290,7 +299,7 @@ void rt_memheap_free(void *ptr)
heap = header_ptr->pool_ptr; heap = header_ptr->pool_ptr;
/* lock memheap */ /* lock memheap */
result = rt_mutex_take(&(heap->lock), RT_WAITING_FOREVER); result = rt_sem_take(&(heap->lock), RT_WAITING_FOREVER);
if (result != RT_EOK) if (result != RT_EOK)
{ {
rt_set_errno(result); rt_set_errno(result);
...@@ -302,10 +311,7 @@ void rt_memheap_free(void *ptr) ...@@ -302,10 +311,7 @@ void rt_memheap_free(void *ptr)
header_ptr->magic &= ~RT_MEMHEAP_USED; header_ptr->magic &= ~RT_MEMHEAP_USED;
/* Adjust the available number of bytes. */ /* Adjust the available number of bytes. */
heap->available_size = heap->available_size = heap->available_size + MEMITEM_SIZE(header_ptr);
heap->available_size +
((rt_uint32_t)(header_ptr->next) - (rt_uint32_t)header_ptr) -
RT_MEMHEAP_SIZE;
/* Determine if the block can be merged with the previous neighbor. */ /* Determine if the block can be merged with the previous neighbor. */
if (!RT_MEMHEAP_IS_USED(header_ptr->prev)) if (!RT_MEMHEAP_IS_USED(header_ptr->prev))
...@@ -336,7 +342,7 @@ void rt_memheap_free(void *ptr) ...@@ -336,7 +342,7 @@ void rt_memheap_free(void *ptr)
new_ptr = header_ptr->next; new_ptr = header_ptr->next;
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("merge: right node 0x%08x, nf 0x%08x, pf 0x%08x", ("merge: right node 0x%08x, next_free 0x%08x, prev_free 0x%08x",
new_ptr, new_ptr->next_free, new_ptr->prev_free)); new_ptr, new_ptr->next_free, new_ptr->prev_free));
new_ptr->next->prev = header_ptr; new_ptr->next->prev = header_ptr;
...@@ -356,13 +362,125 @@ void rt_memheap_free(void *ptr) ...@@ -356,13 +362,125 @@ void rt_memheap_free(void *ptr)
heap->free_list->next_free = header_ptr; heap->free_list->next_free = header_ptr;
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP, RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("insert to free list: nf 0x%08x, pf 0x%08x", ("insert to free list: next_free 0x%08x, prev_free 0x%08x",
header_ptr->next_free, header_ptr->prev_free)); header_ptr->next_free, header_ptr->prev_free));
} }
/* release lock */ /* release lock */
rt_mutex_release(&(heap->lock)); rt_sem_release(&(heap->lock));
} }
RTM_EXPORT(rt_memheap_free); RTM_EXPORT(rt_memheap_free);
#ifdef RT_USING_MEMHEAP_AS_HEAP
static struct rt_memheap _heap;
void rt_system_heap_init(void *begin_addr, void *end_addr)
{
/* initialize a default heap in the system */
rt_memheap_init(&_heap, "heap", begin_addr, (rt_uint32_t)end_addr - (rt_uint32_t)begin_addr);
}
void *rt_malloc(rt_size_t size)
{
void* ptr;
/* try to allocate in system heap */
ptr = rt_memheap_alloc(&_heap, size);
if (ptr == RT_NULL)
{
struct rt_object *object;
struct rt_list_node *node;
struct rt_memheap *heap;
struct rt_object_information *information;
extern struct rt_object_information rt_object_container[];
/* try to allocate on other memory heap */
information = &rt_object_container[RT_Object_Class_MemHeap];
for (node = information->object_list.next; node != &(information->object_list); node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
heap = (struct rt_memheap*) object;
/* not allocate in the default system heap */
if (heap == &_heap) continue;
ptr = rt_memheap_alloc(heap, size);
if (ptr != RT_NULL) break;
}
}
return ptr;
}
RTM_EXPORT(rt_malloc);
void rt_free(void *rmem)
{
rt_memheap_free(rmem);
}
RTM_EXPORT(rt_free);
void *rt_realloc(void *rmem, rt_size_t newsize)
{
rt_size_t size;
void *nmem = RT_NULL;
struct rt_memheap_item *header_ptr;
RT_DEBUG_NOT_IN_INTERRUPT;
/* alignment size */
newsize = RT_ALIGN(newsize, RT_ALIGN_SIZE);
/* allocate a memory */
if (rmem == RT_NULL)
{
return rt_malloc(newsize);
}
/* release memory */
if (newsize == 0)
{
rt_free(rmem);
return RT_NULL;
}
/* get old memory item */
header_ptr = (struct rt_memheap_item *)((rt_uint8_t *)rmem - RT_MEMHEAP_SIZE);
size = MEMITEM_SIZE(header_ptr);
if (newsize > size || newsize < size - RT_MEMHEAP_SIZE) /* re-allocate memory */
{
/* re-allocate a memory block */
nmem = (void*)rt_malloc(newsize);
if (nmem != RT_NULL)
{
rt_memcpy(nmem, rmem, size < newsize ? size : newsize);
rt_free(rmem);
}
return nmem;
}
/* use the old memory block */
return rmem;
}
RTM_EXPORT(rt_realloc);
void *rt_calloc(rt_size_t count, rt_size_t size)
{
void *ptr;
rt_size_t total_size;
total_size = count * size;
ptr = rt_malloc(total_size);
if (ptr != RT_NULL)
{
/* clean memory */
rt_memset(ptr, 0, total_size);
}
return ptr;
}
RTM_EXPORT(rt_calloc);
#endif
#endif #endif
src/scheduler.c
浏览文件 @ 97561047
...@@ -268,7 +268,7 @@ void rt_schedule(void) ...@@ -268,7 +268,7 @@ void rt_schedule(void)
/* if the destination thread is not the same as current thread */ /* if the destination thread is not the same as current thread */
if (to_thread != rt_current_thread) if (to_thread != rt_current_thread)
{ {
rt_current_priority = highest_ready_priority; rt_current_priority = (rt_uint8_t)highest_ready_priority;
from_thread = rt_current_thread; from_thread = rt_current_thread;
rt_current_thread = to_thread; rt_current_thread = to_thread;
......
src/thread.c
浏览文件 @ 97561047
...@@ -24,6 +24,7 @@ ...@@ -24,6 +24,7 @@
* 2011-09-01 Bernard fixed rt_thread_exit issue when the current * 2011-09-01 Bernard fixed rt_thread_exit issue when the current
* thread preempted, which reported by Jiaxing Lee. * thread preempted, which reported by Jiaxing Lee.
* 2011-09-08 Bernard fixed the scheduling issue in rt_thread_startup. * 2011-09-08 Bernard fixed the scheduling issue in rt_thread_startup.
* 2012-12-29 Bernard fixed compiling warning.
*/ */
#include <rtthread.h> #include <rtthread.h>
...@@ -88,7 +89,7 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread, ...@@ -88,7 +89,7 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
/* stack init */ /* stack init */
thread->stack_addr = stack_start; thread->stack_addr = stack_start;
thread->stack_size = stack_size; thread->stack_size = (rt_uint16_t)stack_size;
/* init thread stack */ /* init thread stack */
rt_memset(thread->stack_addr, '#', thread->stack_size); rt_memset(thread->stack_addr, '#', thread->stack_size);
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或