libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity

Merge branch 'master' into RT_MACRO

This commit is contained in:
geniusgogo 2017-09-18 16:27:20 +08:00 committed by GitHub
parent 6b06cb83e3 ed46356eb4
commit 2aae989f40
15 changed files with 226 additions and 225 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

54
include/rtdef.h
View File

@ -97,7 +97,7 @@ typedef rt_base_t rt_off_t; /**< Type for offset */
#define RT_UNUSED __attribute__((unused))
#define RT_USED __attribute__((used))
#define ALIGN(n) __attribute__((aligned(n)))
#define RT_WEAK __weak
#define RT_WEAK __weak
#define rt_inline static __inline
/* module compiling */
#ifdef RT_USING_MODULE
@ -121,7 +121,7 @@ typedef rt_base_t rt_off_t; /**< Type for offset */
#ifdef RT_USING_NEWLIB
#include <stdarg.h>
#else
/* the version of GNU GCC must be greater than 4.x */
/* the version of GNU GCC must be greater than 4.x */
typedef __builtin_va_list __gnuc_va_list;
typedef __gnuc_va_list va_list;
#define va_start(v,l) __builtin_va_start(v,l)
@ -142,7 +142,7 @@ typedef rt_base_t rt_off_t; /**< Type for offset */
#define RT_UNUSED __attribute__((unused))
#define RT_USED __attribute__((used))
#define ALIGN(n) __attribute__((aligned(n)))
#define RT_WEAK __attribute__((weak))
#define RT_WEAK __attribute__((weak))
#define rt_inline static inline
#define RTT_API
#elif defined (_MSC_VER)
@ -151,7 +151,7 @@ typedef rt_base_t rt_off_t; /**< Type for offset */
#define RT_UNUSED
#define RT_USED
#define ALIGN(n) __declspec(align(n))
#define RT_WEAK
#define RT_WEAK
#define rt_inline static __inline
#define RTT_API
#elif defined (__TI_COMPILER_VERSION__)
@ -177,20 +177,20 @@ typedef int (*init_fn_t)(void);
#ifdef _MSC_VER /* we do not support MS VC++ compiler */
#define INIT_EXPORT(fn, level)
#else
#if RT_DEBUG_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; \
const struct rt_init_desc __rt_init_desc_##fn SECTION(".rti_fn."level) = \
{ __rti_##fn##_name, fn};
#else
#define INIT_EXPORT(fn, level) \
const init_fn_t __rt_init_##fn SECTION(".rti_fn."level) = fn
#endif
#if RT_DEBUG_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; \
const struct rt_init_desc __rt_init_desc_##fn SECTION(".rti_fn."level) = \
{ __rti_##fn##_name, fn};
#else
#define INIT_EXPORT(fn, level) \
const init_fn_t __rt_init_##fn SECTION(".rti_fn."level) = fn
#endif
#endif
#else
#define INIT_EXPORT(fn, level)
@ -206,7 +206,7 @@ typedef int (*init_fn_t)(void);
/* file system initialization (dfs-elm, dfs-rom, ...) */
#define INIT_FS_EXPORT(fn) INIT_EXPORT(fn, "4")
/* environment initialization (mount disk, ...) */
#define INIT_ENV_EXPORT(fn) INIT_EXPORT(fn, "5")
#define INIT_ENV_EXPORT(fn) INIT_EXPORT(fn, "5")
/* appliation initialization (rtgui application etc ...) */
#define INIT_APP_EXPORT(fn) INIT_EXPORT(fn, "6")
@ -759,8 +759,8 @@ enum rt_device_class_type
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_Unknown /**< unknown device */
RT_Device_Class_Miscellaneous, /**< Miscellaneous device */
RT_Device_Class_Unknown /**< unknown device */
};
/**
@ -778,9 +778,9 @@ enum rt_device_class_type
#define RT_DEVICE_FLAG_SUSPENDED 0x020 /**< device is suspended */
#define RT_DEVICE_FLAG_STREAM 0x040 /**< stream mode */
#define RT_DEVICE_CTRL_CONFIG 0x03 /* configure device */
#define RT_DEVICE_CTRL_SET_INT 0x10 /* enable receive irq */
#define RT_DEVICE_CTRL_CLR_INT 0x11 /* disable receive irq */
#define RT_DEVICE_CTRL_CONFIG 0x03 /* configure device */
#define RT_DEVICE_CTRL_SET_INT 0x10 /* enable receive irq */
#define RT_DEVICE_CTRL_CLR_INT 0x11 /* disable receive irq */
#define RT_DEVICE_CTRL_GET_INT 0x12
#define RT_DEVICE_FLAG_INT_RX 0x100 /**< INT mode on Rx */
@ -969,15 +969,15 @@ struct rt_module
{
struct rt_object parent; /**< inherit from object */
rt_uint32_t vstart_addr; /**< VMA base address for the
rt_uint32_t vstart_addr; /**< VMA base address for the
first LOAD segment. */
rt_uint8_t *module_space; /**< module memory space */
void *module_entry; /**< the entry address of module */
rt_thread_t module_thread; /**< the main thread of module */
rt_uint8_t* module_cmd_line; /**< module command line */
rt_uint32_t module_cmd_size; /**< the size of module command line */
rt_uint8_t *module_cmd_line; /**< module command line */
rt_uint32_t module_cmd_size; /**< the size of module command line */
#ifdef RT_USING_SLAB
/* module memory allocator */

18
include/rtthread.h
View File

@ -262,8 +262,8 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap,
void *start_addr,
rt_uint32_t size);
rt_err_t rt_memheap_detach(struct rt_memheap *heap);
void* rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size);
void *rt_memheap_realloc(struct rt_memheap* heap, void* ptr, rt_size_t newsize);
void *rt_memheap_alloc(struct rt_memheap *heap, rt_uint32_t size);
void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize);
void rt_memheap_free(void *ptr);
#endif
@ -429,7 +429,7 @@ rt_module_t rt_module_load(const char *name, void *module_ptr);
rt_err_t rt_module_unload(rt_module_t module);
#ifdef RT_USING_DFS
rt_module_t rt_module_open(const char *filename);
rt_module_t rt_module_exec_cmd(const char *path, const char* cmd_line, int size);
rt_module_t rt_module_exec_cmd(const char *path, const char *cmd_line, int size);
#endif
void *rt_module_malloc(rt_size_t size);
void *rt_module_realloc(void *ptr, rt_size_t size);
@ -496,7 +496,7 @@ void rt_kputs(const char *str);
#endif
rt_int32_t rt_vsprintf(char *dest, const char *format, va_list arg_ptr);
rt_int32_t rt_vsnprintf(char *buf, rt_size_t size, const char *fmt, va_list args);
rt_int32_t rt_sprintf(char *buf ,const char *format, ...);
rt_int32_t rt_sprintf(char *buf, const char *format, ...);
rt_int32_t rt_snprintf(char *buf, rt_size_t size, const char *format, ...);
#if defined(RT_USING_DEVICE) && defined(RT_USING_CONSOLE)
@ -517,8 +517,8 @@ void *rt_memset(void *src, int c, rt_ubase_t n);
void *rt_memcpy(void *dest, const void *src, rt_ubase_t n);
rt_int32_t rt_strncmp(const char *cs, const char *ct, rt_ubase_t count);
rt_int32_t rt_strcmp (const char *cs, const char *ct);
rt_size_t rt_strlen (const char *src);
rt_int32_t rt_strcmp(const char *cs, const char *ct);
rt_size_t rt_strlen(const char *src);
char *rt_strdup(const char *s);
char *rt_strstr(const char *str1, const char *str2);
@ -531,10 +531,10 @@ rt_uint32_t rt_strcasecmp(const char *a, const char *b);
void rt_show_version(void);
#ifdef RT_DEBUG
extern void (*rt_assert_hook)(const char* ex, const char* func, rt_size_t line);
void rt_assert_set_hook(void (*hook)(const char* ex, const char* func, rt_size_t line));
extern void (*rt_assert_hook)(const char *ex, const char *func, rt_size_t line);
void rt_assert_set_hook(void (*hook)(const char *ex, const char *func, rt_size_t line));
void rt_assert_handler(const char* ex, const char* func, rt_size_t line);
void rt_assert_handler(const char *ex, const char *func, rt_size_t line);
#endif /* RT_DEBUG */
/**@}*/

8
src/components.c
View File

@ -155,11 +155,11 @@ int $Sub$$main(void)
#elif defined(__ICCARM__)
extern int main(void);
/* __low_level_init will auto called by IAR cstartup */
extern void __iar_data_init3( void );
extern void __iar_data_init3(void);
int __low_level_init(void)
{
// call IAR table copy function.
__iar_data_init3();
// call IAR table copy function.
__iar_data_init3();
rt_hw_interrupt_disable();
rtthread_startup();
return 0;
@ -221,7 +221,7 @@ void rt_application_init(void)
int rtthread_startup(void)
{
rt_hw_interrupt_disable();
rt_hw_interrupt_disable();
/* board level initalization
* NOTE: please initialize heap inside board initialization.

10
src/idle.c
View File

@ -77,7 +77,7 @@ rt_inline int _has_defunct_thread(void)
* into a "if".
*
* So add the volatile qualifier here. */
const volatile rt_list_t *l = (const volatile rt_list_t*)&rt_thread_defunct;
const volatile rt_list_t *l = (const volatile rt_list_t *)&rt_thread_defunct;
return l->next != l;
}
@ -155,8 +155,8 @@ void rt_thread_idle_excute(void)
rt_module_free((rt_module_t)thread->module_id, thread->stack_addr);
else
#endif
/* release thread's stack */
RT_KERNEL_FREE(thread->stack_addr);
/* release thread's stack */
RT_KERNEL_FREE(thread->stack_addr);
/* delete thread object */
rt_object_delete((rt_object_t)thread);
#endif
@ -185,12 +185,12 @@ static void rt_thread_idle_entry(void *parameter)
{
while (1)
{
#ifdef RT_USING_IDLE_HOOK
#ifdef RT_USING_IDLE_HOOK
if (rt_thread_idle_hook != RT_NULL)
{
rt_thread_idle_hook();
}
#endif
#endif
rt_thread_idle_excute();
}

16
src/ipc.c
View File

@ -1382,8 +1382,8 @@ rt_err_t rt_mb_delete(rt_mailbox_t mb)
else
#endif
/* free mailbox pool */
RT_KERNEL_FREE(mb->msg_pool);
/* free mailbox pool */
RT_KERNEL_FREE(mb->msg_pool);
/* delete mailbox object */
rt_object_delete(&(mb->parent.parent));
@ -1775,7 +1775,7 @@ rt_err_t rt_mq_init(rt_mq_t mq,
for (temp = 0; temp < mq->max_msgs; temp ++)
{
head = (struct rt_mq_message *)((rt_uint8_t *)mq->msg_pool +
temp * (mq->msg_size + sizeof(struct rt_mq_message)));
temp * (mq->msg_size + sizeof(struct rt_mq_message)));
head->next = mq->msg_queue_free;
mq->msg_queue_free = head;
}
@ -1849,7 +1849,7 @@ rt_mq_t rt_mq_create(const char *name,
mq->max_msgs = max_msgs;
/* allocate message pool */
mq->msg_pool = RT_KERNEL_MALLOC((mq->msg_size + sizeof(struct rt_mq_message))* mq->max_msgs);
mq->msg_pool = RT_KERNEL_MALLOC((mq->msg_size + sizeof(struct rt_mq_message)) * mq->max_msgs);
if (mq->msg_pool == RT_NULL)
{
rt_mq_delete(mq);
@ -1866,7 +1866,7 @@ rt_mq_t rt_mq_create(const char *name,
for (temp = 0; temp < mq->max_msgs; temp ++)
{
head = (struct rt_mq_message *)((rt_uint8_t *)mq->msg_pool +
temp * (mq->msg_size + sizeof(struct rt_mq_message)));
temp * (mq->msg_size + sizeof(struct rt_mq_message)));
head->next = mq->msg_queue_free;
mq->msg_queue_free = head;
}
@ -1902,8 +1902,8 @@ rt_err_t rt_mq_delete(rt_mq_t mq)
else
#endif
/* free message queue pool */
RT_KERNEL_FREE(mq->msg_pool);
/* free message queue pool */
RT_KERNEL_FREE(mq->msg_pool);
/* delete message queue object */
rt_object_delete(&(mq->parent.parent));
@ -1942,7 +1942,7 @@ rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size)
temp = rt_hw_interrupt_disable();
/* get a free list, there must be an empty item */
msg = (struct rt_mq_message*)mq->msg_queue_free;
msg = (struct rt_mq_message *)mq->msg_queue_free;
/* message queue is full */
if (msg == RT_NULL)
{

75
src/kservice.c
View File

@ -118,7 +118,7 @@ int *_rt_errno(void)
tid = rt_thread_self();
if (tid != RT_NULL)
return (int *)&(tid->error);
return (int *) & (tid->error);
return (int *)&_errno;
}
@ -547,13 +547,13 @@ rt_inline rt_int32_t divide(rt_int32_t *n, rt_int32_t base)
/* optimized for processor which does not support divide instructions. */
if (base == 10)
{
res = ((rt_uint32_t)*n) % 10U;
*n = ((rt_uint32_t)*n) / 10U;
res = ((rt_uint32_t) * n) % 10U;
*n = ((rt_uint32_t) * n) / 10U;
}
else
{
res = ((rt_uint32_t)*n) % 16U;
*n = ((rt_uint32_t)*n) / 16U;
res = ((rt_uint32_t) * n) % 16U;
*n = ((rt_uint32_t) * n) / 16U;
}
return res;
@ -561,7 +561,7 @@ rt_inline rt_int32_t divide(rt_int32_t *n, rt_int32_t base)
rt_inline int skip_atoi(const char **s)
{
register int i=0;
register int i = 0;
while (isdigit(**s))
i = i * 10 + *((*s)++) - '0';
@ -640,7 +640,7 @@ static char *print_number(char *buf,
i = 0;
if (num == 0)
tmp[i++]='0';
tmp[i++] = '0';
else
{
while (num != 0)
@ -655,12 +655,12 @@ static char *print_number(char *buf,
size -= i;
#endif
if (!(type&(ZEROPAD | LEFT)))
if (!(type & (ZEROPAD | LEFT)))
{
if ((sign)&&(size>0))
if ((sign) && (size > 0))
size--;
while (size-->0)
while (size-- > 0)
{
if (buf <= end)
*buf = ' ';
@ -681,7 +681,7 @@ static char *print_number(char *buf,
#ifdef RT_PRINTF_SPECIAL
if (type & SPECIAL)
{
if (base==8)
if (base == 8)
{
if (buf <= end)
*buf = '0';
@ -694,7 +694,7 @@ static char *print_number(char *buf,
++ buf;
if (buf <= end)
{
*buf = type & LARGE? 'X' : 'x';
*buf = type & LARGE ? 'X' : 'x';
}
++ buf;
}
@ -768,7 +768,7 @@ rt_int32_t rt_vsnprintf(char *buf,
/* Make sure end is always >= buf */
if (end < buf)
{
end = ((char *)-1);
end = ((char *) - 1);
size = end - buf;
}
@ -929,7 +929,7 @@ rt_int32_t rt_vsnprintf(char *buf,
++ str;
continue;
/* integer number formats - set up the flags and "break" */
/* integer number formats - set up the flags and "break" */
case 'o':
base = 8;
break;
@ -1028,7 +1028,7 @@ RTM_EXPORT(rt_snprintf);
*/
rt_int32_t rt_vsprintf(char *buf, const char *format, va_list arg_ptr)
{
return rt_vsnprintf(buf, (rt_size_t) -1, format, arg_ptr);
return rt_vsnprintf(buf, (rt_size_t) - 1, format, arg_ptr);
}
RTM_EXPORT(rt_vsprintf);
@ -1044,7 +1044,7 @@ rt_int32_t rt_sprintf(char *buf, const char *format, ...)
va_list arg_ptr;
va_start(arg_ptr, format);
n = rt_vsprintf(buf ,format, arg_ptr);
n = rt_vsprintf(buf, format, arg_ptr);
va_end(arg_ptr);
return n;
@ -1183,7 +1183,7 @@ RTM_EXPORT(rt_kprintf);
*
* @return the allocated memory block on successful, otherwise returns RT_NULL
*/
void* rt_malloc_align(rt_size_t size, rt_size_t align)
void *rt_malloc_align(rt_size_t size, rt_size_t align)
{
void *align_ptr;
void *ptr;
@ -1198,7 +1198,7 @@ void* rt_malloc_align(rt_size_t size, rt_size_t align)
ptr = rt_malloc(align_size);
if (ptr != RT_NULL)
{
/* the allocated memory block is aligned */
/* the allocated memory block is aligned */
if (((rt_uint32_t)ptr & (align - 1)) == 0)
{
align_ptr = (void *)((rt_uint32_t)ptr + align);
@ -1228,7 +1228,7 @@ void rt_free_align(void *ptr)
{
void *real_ptr;
real_ptr = (void *)*(rt_uint32_t *)((rt_uint32_t)ptr - sizeof(void *));
real_ptr = (void *) * (rt_uint32_t *)((rt_uint32_t)ptr - sizeof(void *));
rt_free(real_ptr);
}
RTM_EXPORT(rt_free_align);
@ -1284,13 +1284,14 @@ rt_ubase_t __rt_ffs(rt_ubase_t value)
#ifdef RT_DEBUG
/* RT_ASSERT(EX)'s hook */
void (*rt_assert_hook)(const char* ex, const char* func, rt_size_t line);
void (*rt_assert_hook)(const char *ex, const char *func, rt_size_t line);
/**
* This function will set a hook function to RT_ASSERT(EX). It will run when the expression is false.
*
* @param hook the hook function
*/
void rt_assert_set_hook(void (*hook)(const char* ex, const char* func, rt_size_t line)) {
void rt_assert_set_hook(void (*hook)(const char *ex, const char *func, rt_size_t line))
{
rt_assert_hook = hook;
}
@ -1301,30 +1302,30 @@ void rt_assert_set_hook(void (*hook)(const char* ex, const char* func, rt_size_t
* @param func the function name when assertion.
* @param line the file line number when assertion.
*/
void rt_assert_handler(const char* ex_string, const char* func, rt_size_t line)
void rt_assert_handler(const char *ex_string, const char *func, rt_size_t line)
{
volatile char dummy = 0;
if (rt_assert_hook == RT_NULL)
{
#ifdef RT_USING_MODULE
if (rt_module_self() != RT_NULL)
{
/* unload assertion module */
rt_module_unload(rt_module_self());
if (rt_module_self() != RT_NULL)
{
/* unload assertion module */
rt_module_unload(rt_module_self());
/* re-schedule */
rt_schedule();
}
else
/* re-schedule */
rt_schedule();
}
else
#endif
{
rt_kprintf("(%s) assertion failed at function:%s, line number:%d \n", ex_string, func, line);
while (dummy == 0);
}
{
rt_kprintf("(%s) assertion failed at function:%s, line number:%d \n", ex_string, func, line);
while (dummy == 0);
}
}
else
{
else
{
rt_assert_hook(ex_string, func, line);
}
}
@ -1339,7 +1340,7 @@ void *memmove(void *dest, const void *src, size_t n) __attribute__((weak, alias(
int memcmp(const void *s1, const void *s2, size_t n) __attribute__((weak, alias("rt_memcmp")));
size_t strlen(const char *s) __attribute__((weak, alias("rt_strlen")));
char *strstr(const char *s1,const char *s2) __attribute__((weak, alias("rt_strstr")));
char *strstr(const char *s1, const char *s2) __attribute__((weak, alias("rt_strstr")));
int strcasecmp(const char *a, const char *b) __attribute__((weak, alias("rt_strcasecmp")));
char *strncpy(char *dest, const char *src, size_t n) __attribute__((weak, alias("rt_strncpy")));
int strncmp(const char *cs, const char *ct, size_t count) __attribute__((weak, alias("rt_strncmp")));

10
src/mem.c
View File

@ -335,7 +335,7 @@ void *rt_malloc(rt_size_t size)
*/
mem->used = 1;
#ifdef RT_MEM_STATS
used_mem += mem->next - ((rt_uint8_t*)mem - heap_ptr);
used_mem += mem->next - ((rt_uint8_t *)mem - heap_ptr);
if (max_mem < used_mem)
max_mem = used_mem;
#endif
@ -355,7 +355,7 @@ void *rt_malloc(rt_size_t size)
rt_sem_release(&heap_sem);
RT_ASSERT((rt_uint32_t)mem + SIZEOF_STRUCT_MEM + size <= (rt_uint32_t)heap_end);
RT_ASSERT((rt_uint32_t)((rt_uint8_t *)mem + SIZEOF_STRUCT_MEM) % RT_ALIGN_SIZE == 0);
RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE-1)) == 0);
RT_ASSERT((((rt_uint32_t)mem) & (RT_ALIGN_SIZE - 1)) == 0);
RT_DEBUG_LOG(RT_DEBUG_MEM,
("allocate memory at 0x%x, size: %d\n",
@ -443,7 +443,7 @@ void *rt_realloc(void *rmem, rt_size_t newsize)
ptr2 = ptr + SIZEOF_STRUCT_MEM + newsize;
mem2 = (struct heap_mem *)&heap_ptr[ptr2];
mem2->magic= HEAP_MAGIC;
mem2->magic = HEAP_MAGIC;
mem2->used = 0;
mem2->next = mem->next;
mem2->prev = ptr;
@ -516,7 +516,7 @@ void rt_free(void *rmem)
if (rmem == RT_NULL)
return;
RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE-1)) == 0);
RT_ASSERT((((rt_uint32_t)rmem) & (RT_ALIGN_SIZE - 1)) == 0);
RT_ASSERT((rt_uint8_t *)rmem >= (rt_uint8_t *)heap_ptr &&
(rt_uint8_t *)rmem < (rt_uint8_t *)heap_end);
@ -556,7 +556,7 @@ void rt_free(void *rmem)
}
#ifdef RT_MEM_STATS
used_mem -= (mem->next - ((rt_uint8_t*)mem - heap_ptr));
used_mem -= (mem->next - ((rt_uint8_t *)mem - heap_ptr));
#endif
/* finally, see if prev or next are free also */

16
src/memheap.c
View File

@ -96,7 +96,7 @@ rt_err_t rt_memheap_init(struct rt_memheap *memheap,
item->prev_free = item;
item->next = (struct rt_memheap_item *)
((rt_uint8_t *)item + memheap->available_size + RT_MEMHEAP_SIZE);
((rt_uint8_t *)item + memheap->available_size + RT_MEMHEAP_SIZE);
item->prev = item->next;
/* block list header */
@ -315,10 +315,10 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize)
header_ptr = (struct rt_memheap_item *)
((rt_uint8_t *)ptr - RT_MEMHEAP_SIZE);
oldsize = MEMITEM_SIZE(header_ptr);
/* re-allocate memory */
/* re-allocate memory */
if (newsize > oldsize)
{
void* new_ptr;
void *new_ptr;
struct rt_memheap_item *next_ptr;
/* lock memheap */
@ -371,7 +371,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize)
next_ptr->prev->next = next_ptr->next;
/* build a new one on the right place */
next_ptr = (struct rt_memheap_item*)((char*)ptr + newsize);
next_ptr = (struct rt_memheap_item *)((char *)ptr + newsize);
RT_DEBUG_LOG(RT_DEBUG_MEMHEAP,
("new free block: block[0x%08x] nextm[0x%08x] prevm[0x%08x]",
@ -410,7 +410,7 @@ void *rt_memheap_realloc(struct rt_memheap *heap, void *ptr, rt_size_t newsize)
rt_sem_release(&(heap->lock));
/* re-allocate a memory block */
new_ptr = (void*)rt_memheap_alloc(heap, newsize);
new_ptr = (void *)rt_memheap_alloc(heap, newsize);
if (new_ptr != RT_NULL)
{
rt_memcpy(new_ptr, ptr, oldsize < newsize ? oldsize : newsize);
@ -503,8 +503,8 @@ void rt_memheap_free(void *ptr)
struct rt_memheap_item *header_ptr, *new_ptr;
rt_uint32_t insert_header;
/* NULL check */
if (ptr == RT_NULL) return;
/* NULL check */
if (ptr == RT_NULL) return;
/* set initial status as OK */
insert_header = 1;
@ -610,7 +610,7 @@ void rt_system_heap_init(void *begin_addr, void *end_addr)
void *rt_malloc(rt_size_t size)
{
void* ptr;
void *ptr;
/* try to allocate in system heap */
ptr = rt_memheap_alloc(&_heap, size);

4
src/mempool.c
View File

@ -299,8 +299,8 @@ rt_err_t rt_mp_delete(rt_mp_t mp)
else
#endif
/* release allocated room */
rt_free(mp->start_address);
/* release allocated room */
rt_free(mp->start_address);
/* detach object */
rt_object_delete(&(mp->parent));

86
src/module.c
View File

@ -138,7 +138,7 @@ void list_symbol(void)
index != _rt_module_symtab_end;
index ++)
{
rt_kprintf("%s\n", index->name);
rt_kprintf("%s\n", index->name);
}
return ;
@ -259,10 +259,10 @@ static int rt_module_arm_relocate(struct rt_module *module,
j1 = (lower >> 13) & 1;
j2 = (lower >> 11) & 1;
offset = (sign << 24) |
((~(j1 ^ sign) & 1) << 23) |
((~(j2 ^ sign) & 1) << 22) |
((upper & 0x03ff) << 12) |
((lower & 0x07ff) << 1);
((~(j1 ^ sign) & 1) << 23) |
((~(j2 ^ sign) & 1) << 22) |
((upper & 0x03ff) << 12) |
((lower & 0x07ff) << 1);
if (offset & 0x01000000)
offset -= 0x02000000;
offset += sym_val - (Elf32_Addr)where;
@ -517,7 +517,7 @@ static struct rt_module *_load_shared_object(const char *name,
/* set module entry */
module->module_entry = module->module_space
+ elf_module->e_entry - vstart_addr;
+ elf_module->e_entry - vstart_addr;
/* handle relocation section */
for (index = 0; index < elf_module->e_shnum; index ++)
@ -538,7 +538,7 @@ static struct rt_module *_load_shared_object(const char *name,
symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
shdr[shdr[index].sh_link].sh_offset);
strtab = (rt_uint8_t *)module_ptr +
shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel));
/* relocate every items */
@ -555,7 +555,7 @@ static struct rt_module *_load_shared_object(const char *name,
#ifdef MODULE_USING_386
|| ( (ELF_ST_BIND(sym->st_info) == STB_GLOBAL) && (ELF_ST_TYPE(sym->st_info) == STT_OBJECT) )
#endif
)
)
{
rt_module_arm_relocate(module, rel,
(Elf32_Addr)(module->module_space
@ -597,7 +597,7 @@ static struct rt_module *_load_shared_object(const char *name,
/* find .dynsym section */
rt_uint8_t *shstrab;
shstrab = (rt_uint8_t *)module_ptr +
shdr[elf_module->e_shstrndx].sh_offset;
shdr[elf_module->e_shstrndx].sh_offset;
if (rt_strcmp((const char *)(shstrab + shdr[index].sh_name), ELF_DYNSYM) == 0)
break;
}
@ -609,10 +609,10 @@ static struct rt_module *_load_shared_object(const char *name,
Elf32_Sym *symtab = RT_NULL;
rt_uint8_t *strtab = RT_NULL;
symtab =(Elf32_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr + shdr[index].sh_offset);
strtab = (rt_uint8_t *)module_ptr + shdr[shdr[index].sh_link].sh_offset;
for (i = 0; i < shdr[index].sh_size/sizeof(Elf32_Sym); i++)
for (i = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++)
{
if ((ELF_ST_BIND(symtab[i].st_info) == STB_GLOBAL) &&
(ELF_ST_TYPE(symtab[i].st_info) == STT_FUNC))
@ -620,9 +620,9 @@ static struct rt_module *_load_shared_object(const char *name,
}
module->symtab = (struct rt_module_symtab *)rt_malloc
(count * sizeof(struct rt_module_symtab));
(count * sizeof(struct rt_module_symtab));
module->nsym = count;
for (i = 0, count = 0; i < shdr[index].sh_size/sizeof(Elf32_Sym); i++)
for (i = 0, count = 0; i < shdr[index].sh_size / sizeof(Elf32_Sym); i++)
{
rt_size_t length;
@ -686,7 +686,7 @@ static struct rt_module* _load_relocated_object(const char *name,
/* allocate module */
module = (struct rt_module *)
rt_object_allocate(RT_Object_Class_Module, (const char *)name);
rt_object_allocate(RT_Object_Class_Module, (const char *)name);
if (module == RT_NULL)
return RT_NULL;
@ -777,9 +777,9 @@ static struct rt_module* _load_relocated_object(const char *name,
symtab = (Elf32_Sym *)((rt_uint8_t *)module_ptr +
shdr[shdr[index].sh_link].sh_offset);
strtab = (rt_uint8_t *)module_ptr +
shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
shdr[shdr[shdr[index].sh_link].sh_link].sh_offset;
shstrab = (rt_uint8_t *)module_ptr +
shdr[elf_module->e_shstrndx].sh_offset;
shdr[elf_module->e_shstrndx].sh_offset;
nr_reloc = (rt_uint32_t)(shdr[index].sh_size / sizeof(Elf32_Rel));
/* relocate every items */
@ -803,7 +803,7 @@ static struct rt_module* _load_relocated_object(const char *name,
rt_module_arm_relocate(module, rel,
(Elf32_Addr)(rodata_addr + sym->st_value));
}
else if (rt_strncmp((const char*)
else if (rt_strncmp((const char *)
(shstrab + shdr[sym->st_shndx].sh_name), ELF_BSS, 5) == 0)
{
/* relocate bss section */
@ -854,7 +854,7 @@ static struct rt_module* _load_relocated_object(const char *name,
else
{
rt_module_arm_relocate(module, rel,
(Elf32_Addr)((rt_uint8_t*)
(Elf32_Addr)((rt_uint8_t *)
module->module_space
- module_addr
+ sym->st_value));
@ -868,7 +868,7 @@ static struct rt_module* _load_relocated_object(const char *name,
}
#define RT_MODULE_ARG_MAX 8
static int _rt_module_split_arg(char* cmd, rt_size_t length, char* argv[])
static int _rt_module_split_arg(char *cmd, rt_size_t length, char *argv[])
{
int argc = 0;
char *ptr = cmd;
@ -876,10 +876,10 @@ static int _rt_module_split_arg(char* cmd, rt_size_t length, char* argv[])
while ((ptr - cmd) < length)
{
/* strip bank and tab */
while ((*ptr == ' ' || *ptr == '\t') && (ptr -cmd)< length)
while ((*ptr == ' ' || *ptr == '\t') && (ptr - cmd) < length)
*ptr++ = '\0';
/* check whether it's the end of line */
if ((ptr - cmd)>= length) break;
if ((ptr - cmd) >= length) break;
/* handle string with quote */
if (*ptr == '"')
@ -887,7 +887,7 @@ static int _rt_module_split_arg(char* cmd, rt_size_t length, char* argv[])
argv[argc++] = ++ptr;
/* skip this string */
while (*ptr != '"' && (ptr-cmd) < length)
while (*ptr != '"' && (ptr - cmd) < length)
if (*ptr ++ == '\\') ptr ++;
if ((ptr - cmd) >= length) break;
@ -908,11 +908,11 @@ static int _rt_module_split_arg(char* cmd, rt_size_t length, char* argv[])
}
/* module main thread entry */
static void module_main_entry(void* parameter)
static void module_main_entry(void *parameter)
{
int argc;
char *argv[RT_MODULE_ARG_MAX];
typedef int (*main_func_t)(int argc, char** argv);
typedef int (*main_func_t)(int argc, char **argv);
rt_module_t module = (rt_module_t) parameter;
if (module == RT_NULL)
@ -934,7 +934,7 @@ static void module_main_entry(void* parameter)
}
rt_memset(argv, 0x00, sizeof(argv));
argc = _rt_module_split_arg((char*)module->module_cmd_line,
argc = _rt_module_split_arg((char *)module->module_cmd_line,
module->module_cmd_size, argv);
if (argc == 0)
return;
@ -960,7 +960,7 @@ static void module_main_entry(void* parameter)
*/
rt_module_t rt_module_do_main(const char *name,
void *module_ptr,
const char* cmd_line,
const char *cmd_line,
int line_size)
{
rt_module_t module;
@ -1010,7 +1010,7 @@ rt_module_t rt_module_do_main(const char *name,
if (line_size && cmd_line)
{
/* set module argument */
module->module_cmd_line = (rt_uint8_t*)rt_malloc(line_size + 1);
module->module_cmd_line = (rt_uint8_t *)rt_malloc(line_size + 1);
if (module->module_cmd_line)
{
rt_memcpy(module->module_cmd_line, cmd_line, line_size);
@ -1088,7 +1088,7 @@ rt_module_t rt_module_load(const char *name, void *module_ptr)
#ifdef RT_USING_DFS
#include <dfs_posix.h>
static char* _module_name(const char *path)
static char *_module_name(const char *path)
{
const char *first, *end, *ptr;
char *name;
@ -1136,7 +1136,7 @@ rt_module_t rt_module_open(const char *path)
/* check parameters */
RT_ASSERT(path != RT_NULL);
if (stat(path, &s) !=0)
if (stat(path, &s) != 0)
{
rt_kprintf("Module: access %s failed\n", path);
@ -1197,7 +1197,7 @@ rt_module_t rt_module_open(const char *path)
*
* @return the module object
*/
rt_module_t rt_module_exec_cmd(const char *path, const char* cmd_line, int size)
rt_module_t rt_module_exec_cmd(const char *path, const char *cmd_line, int size)
{
struct stat s;
int fd, length;
@ -1212,7 +1212,7 @@ rt_module_t rt_module_exec_cmd(const char *path, const char* cmd_line, int size)
RT_ASSERT(path != RT_NULL);
/* get file size */
if (stat(path, &s) !=0)
if (stat(path, &s) != 0)
{
rt_kprintf("Module: access %s failed\n", path);
goto __exit;
@ -1649,7 +1649,7 @@ static void rt_module_free_page(rt_module_t module,
}
else if (page[i].npage == npages)
{
for (index = i; index < module->page_cnt-1; index ++)
for (index = i; index < module->page_cnt - 1; index ++)
{
page[index].page_ptr = page[index + 1].page_ptr;
page[index].npage = page[index + 1].npage;
@ -1688,8 +1688,8 @@ void *rt_module_malloc(rt_size_t size)
RT_DEBUG_NOT_IN_INTERRUPT;
nunits = (size + sizeof(struct rt_mem_head) - 1) /
sizeof(struct rt_mem_head)
+ 1;
sizeof(struct rt_mem_head)
+ 1;
RT_ASSERT(size != 0);
RT_ASSERT(nunits != 0);
@ -1732,7 +1732,7 @@ void *rt_module_malloc(rt_size_t size)
/* allocate pages from system heap */
npage = (size + sizeof(struct rt_mem_head) + RT_MM_PAGE_SIZE - 1) /
RT_MM_PAGE_SIZE;
RT_MM_PAGE_SIZE;
if ((up = (struct rt_mem_head *)rt_module_malloc_page(npage)) == RT_NULL)
return RT_NULL;
@ -1765,7 +1765,7 @@ void rt_module_free(rt_module_t module, void *addr)
RT_DEBUG_NOT_IN_INTERRUPT;
RT_ASSERT(addr);
RT_ASSERT((((rt_uint32_t)addr) & (sizeof(struct rt_mem_head) -1)) == 0);
RT_ASSERT((((rt_uint32_t)addr) & (sizeof(struct rt_mem_head) - 1)) == 0);
RT_DEBUG_LOG(RT_DEBUG_MODULE, ("rt_module_free 0x%x\n", addr));
@ -1798,8 +1798,8 @@ void rt_module_free(rt_module_t module, void *addr)
if ((b->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
{
rt_size_t nunits = npage *
RT_MM_PAGE_SIZE /
sizeof(struct rt_mem_head);
RT_MM_PAGE_SIZE /
sizeof(struct rt_mem_head);
/* split memory */
r = b + nunits;
r->next = b->next;
@ -1835,8 +1835,8 @@ void rt_module_free(rt_module_t module, void *addr)
if ((n->size * sizeof(struct rt_page_info) % RT_MM_PAGE_SIZE) != 0)
{
rt_size_t nunits = npage *
RT_MM_PAGE_SIZE /
sizeof(struct rt_mem_head);
RT_MM_PAGE_SIZE /
sizeof(struct rt_mem_head);
/* split memory */
r = n + nunits;
r->next = n->next;
@ -1921,8 +1921,8 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
}
nunits = (size + sizeof(struct rt_mem_head) - 1) /
sizeof(struct rt_mem_head)
+1;
sizeof(struct rt_mem_head)
+ 1;
b = (struct rt_mem_head *)ptr - 1;
if (nunits <= b->size)
@ -1984,7 +1984,7 @@ void *rt_module_realloc(void *ptr, rt_size_t size)
{
if ((p = rt_module_malloc(size)) == RT_NULL)
return RT_NULL;
rt_memmove(p, (b+1), ((b->size) * sizeof(struct rt_mem_head)));
rt_memmove(p, (b + 1), ((b->size) * sizeof(struct rt_mem_head)));
rt_module_free(self_module, (void *)(b + 1));
return (void *)(p);

14
src/object.c
View File

@ -211,7 +211,7 @@ void rt_object_init(struct rt_object *object,
#ifdef RT_USING_MODULE
/* get module object information */
information = (rt_module_self() != RT_NULL) ?
&rt_module_self()->module_object[type] : &rt_object_container[type];
&rt_module_self()->module_object[type] : &rt_object_container[type];
#else
/* get object information */
information = &rt_object_container[type];
@ -362,8 +362,8 @@ void rt_object_delete(rt_object_t object)
else
#endif
/* free the memory of object */
RT_KERNEL_FREE(object);
/* free the memory of object */
RT_KERNEL_FREE(object);
}
#endif
@ -424,7 +424,7 @@ rt_object_t rt_object_find(const char *name, rt_uint8_t type)
if (*name_ptr == '/')
{
struct rt_module* module = RT_NULL;
struct rt_module *module = RT_NULL;
/* get the name length of module */
module_name_length = name_ptr - name;
@ -435,15 +435,15 @@ rt_object_t rt_object_find(const char *name, rt_uint8_t type)
/* find module */
information = &rt_object_container[RT_Object_Class_Module];
for (node = information->object_list.next;
node != &(information->object_list);
node = node->next)
node != &(information->object_list);
node = node->next)
{
object = rt_list_entry(node, struct rt_object, list);
if ((rt_strncmp(object->name, name, module_name_length) == 0) &&
(module_name_length == RT_NAME_MAX || object->name[module_name_length] == '\0'))
{
/* get module */
module = (struct rt_module*)object;
module = (struct rt_module *)object;
break;
}
}

6
src/scheduler.c
View File

@ -90,19 +90,19 @@ static void _rt_scheduler_stack_check(struct rt_thread *thread)
RT_ASSERT(thread != RT_NULL);
if (*((rt_uint8_t *)thread->stack_addr) != '#' ||
(rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr ||
(rt_uint32_t)thread->sp <= (rt_uint32_t)thread->stack_addr ||
(rt_uint32_t)thread->sp >
(rt_uint32_t)thread->stack_addr + (rt_uint32_t)thread->stack_size)
{
rt_uint32_t level;
rt_kprintf("thread:%s stack overflow\n", thread->name);
#ifdef RT_USING_FINSH
#ifdef RT_USING_FINSH
{
extern long list_thread(void);
list_thread();
}
#endif
#endif
level = rt_hw_interrupt_disable();
while (level);
}

34
src/slab.c
View File

@ -222,8 +222,8 @@ static int zone_page_cnt;
#define PAGE_TYPE_LARGE 0x02
struct memusage
{
rt_uint32_t type:2 ; /* page type */
rt_uint32_t size:30; /* pages allocated or offset from zone */
rt_uint32_t type: 2 ; /* page type */
rt_uint32_t size: 30; /* pages allocated or offset from zone */
};
static struct memusage *memusage = RT_NULL;
#define btokup(addr) \
@ -238,7 +238,7 @@ struct rt_page_head
rt_size_t page; /* number of page */
/* dummy */
char dummy[RT_MM_PAGE_SIZE - (sizeof(struct rt_page_head*) + sizeof (rt_size_t))];
char dummy[RT_MM_PAGE_SIZE - (sizeof(struct rt_page_head *) + sizeof(rt_size_t))];
};
static struct rt_page_head *rt_page_list;
static struct rt_semaphore heap_sem;
@ -248,7 +248,7 @@ void *rt_page_alloc(rt_size_t npages)
struct rt_page_head *b, *n;
struct rt_page_head **prev;
if(npages == 0)
if (npages == 0)
return RT_NULL;
/* lock heap */
@ -383,7 +383,7 @@ void rt_system_heap_init(void *begin_addr, void *end_addr)
/* calculate zone size */
zone_size = ZALLOC_MIN_ZONE_SIZE;
while (zone_size < ZALLOC_MAX_ZONE_SIZE && (zone_size << 1) < (limsize/1024))
while (zone_size < ZALLOC_MAX_ZONE_SIZE && (zone_size << 1) < (limsize / 1024))
zone_size <<= 1;
zone_limit = zone_size / 4;
@ -398,7 +398,7 @@ void rt_system_heap_init(void *begin_addr, void *end_addr)
/* allocate memusage array */
limsize = npages * sizeof(struct memusage);
limsize = RT_ALIGN(limsize, RT_MM_PAGE_SIZE);
memusage = rt_page_alloc(limsize/RT_MM_PAGE_SIZE);
memusage = rt_page_alloc(limsize / RT_MM_PAGE_SIZE);
RT_DEBUG_LOG(RT_DEBUG_SLAB, ("memusage 0x%x, size 0x%x\n",
(rt_uint32_t)memusage, limsize));
@ -411,20 +411,20 @@ void rt_system_heap_init(void *begin_addr, void *end_addr)
rt_inline int zoneindex(rt_uint32_t *bytes)
{
/* unsigned for shift opt */
rt_uint32_t n = (rt_uint32_t)*bytes;
rt_uint32_t n = (rt_uint32_t) * bytes;
if (n < 128)
{
*bytes = n = (n + 7) & ~7;
/* 8 byte chunks, 16 zones */
return(n / 8 - 1);
return (n / 8 - 1);
}
if (n < 256)
{
*bytes = n = (n + 15) & ~15;
return(n / 16 + 7);
return (n / 16 + 7);
}
if (n < 8192)
{
@ -432,35 +432,35 @@ rt_inline int zoneindex(rt_uint32_t *bytes)
{
*bytes = n = (n + 31) & ~31;
return(n / 32 + 15);
return (n / 32 + 15);
}
if (n < 1024)
{
*bytes = n = (n + 63) & ~63;
return(n / 64 + 23);
return (n / 64 + 23);
}
if (n < 2048)
{
*bytes = n = (n + 127) & ~127;
return(n / 128 + 31);
return (n / 128 + 31);
}
if (n < 4096)
{
*bytes = n = (n + 255) & ~255;
return(n / 256 + 39);
return (n / 256 + 39);
}
*bytes = n = (n + 511) & ~511;
return(n / 512 + 47);
return (n / 512 + 47);
}
if (n < 16384)
{
*bytes = n = (n + 1023) & ~1023;
return(n / 1024 + 55);
return (n / 1024 + 55);
}
rt_kprintf("Unexpected byte count %d", n);
@ -737,7 +737,7 @@ void *rt_realloc(void *ptr, rt_size_t size)
zoneindex(&size);
if (z->z_chunksize == size)
return(ptr); /* same chunk */
return (ptr); /* same chunk */
/*
* Allocate memory for the new request size. Note that zoneindex has
@ -803,7 +803,7 @@ void rt_free(void *ptr)
RT_OBJECT_HOOK_CALL(rt_free_hook, (ptr));
#ifdef RT_USING_MODULE
if(rt_module_self() != RT_NULL)
if (rt_module_self() != RT_NULL)
{
rt_module_free(rt_module_self(), ptr);

12
src/thread.c
View File

@ -87,7 +87,7 @@ void rt_thread_resume_sethook(void (*hook)(rt_thread_t thread))
*/
void rt_thread_inited_sethook(void (*hook)(rt_thread_t thread))
{
rt_thread_inited_hook = hook;
rt_thread_inited_hook = hook;
}
#endif
@ -151,8 +151,8 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
/* init thread stack */
rt_memset(thread->stack_addr, '#', thread->stack_size);
thread->sp = (void *)rt_hw_stack_init(thread->entry, thread->parameter,
(void *)((char *)thread->stack_addr + thread->stack_size - 4),
(void *)rt_thread_exit);
(void *)((char *)thread->stack_addr + thread->stack_size - 4),
(void *)rt_thread_exit);
/* priority init */
RT_ASSERT(priority < RT_THREAD_PRIORITY_MAX);
@ -185,7 +185,7 @@ static rt_err_t _rt_thread_init(struct rt_thread *thread,
0,
RT_TIMER_FLAG_ONE_SHOT);
RT_OBJECT_HOOK_CALL(rt_thread_inited_hook,(thread));
RT_OBJECT_HOOK_CALL(rt_thread_inited_hook, (thread));
return RT_EOK;
}
@ -643,7 +643,7 @@ rt_err_t rt_thread_suspend(rt_thread_t thread)
/* enable interrupt */
rt_hw_interrupt_enable(temp);
RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook,(thread));
RT_OBJECT_HOOK_CALL(rt_thread_suspend_hook, (thread));
return RT_EOK;
}
RTM_EXPORT(rt_thread_suspend);
@ -686,7 +686,7 @@ rt_err_t rt_thread_resume(rt_thread_t thread)
/* insert to schedule ready list */
rt_schedule_insert_thread(thread);
RT_OBJECT_HOOK_CALL(rt_thread_resume_hook,(thread));
RT_OBJECT_HOOK_CALL(rt_thread_resume_hook, (thread));
return RT_EOK;
}
RTM_EXPORT(rt_thread_resume);

58
src/timer.c
View File

@ -147,13 +147,13 @@ void rt_timer_dump(rt_list_t timer_heads[])
{
rt_list_t *list;
for (list = timer_heads[RT_TIMER_SKIP_LIST_LEVEL-1].next;
list != &timer_heads[RT_TIMER_SKIP_LIST_LEVEL-1];
for (list = timer_heads[RT_TIMER_SKIP_LIST_LEVEL - 1].next;
list != &timer_heads[RT_TIMER_SKIP_LIST_LEVEL - 1];
list = list->next)
{
struct rt_timer *timer = rt_list_entry(list,
struct rt_timer,
row[RT_TIMER_SKIP_LIST_LEVEL-1]);
row[RT_TIMER_SKIP_LIST_LEVEL - 1]);
rt_kprintf("%d", rt_timer_count_height(timer));
}
rt_kprintf("\n");
@ -303,9 +303,9 @@ rt_err_t rt_timer_start(rt_timer_t timer)
/* timer check */
RT_ASSERT(timer != RT_NULL);
/* stop timer firstly */
level = rt_hw_interrupt_disable();
/* remove timer from list */
/* stop timer firstly */
level = rt_hw_interrupt_disable();
/* remove timer from list */
_rt_timer_remove(timer);
/* change status of timer */
timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
@ -339,7 +339,7 @@ rt_err_t rt_timer_start(rt_timer_t timer)
row_head[0] = &timer_list[0];
for (row_lvl = 0; row_lvl < RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
{
for (;row_head[row_lvl] != timer_list[row_lvl].prev;
for (; row_head[row_lvl] != timer_list[row_lvl].prev;
row_head[row_lvl] = row_head[row_lvl]->next)
{
struct rt_timer *t;
@ -363,7 +363,7 @@ rt_err_t rt_timer_start(rt_timer_t timer)
}
}
if (row_lvl != RT_TIMER_SKIP_LIST_LEVEL - 1)
row_head[row_lvl+1] = row_head[row_lvl]+1;
row_head[row_lvl + 1] = row_head[row_lvl] + 1;
}
/* Interestingly, this super simple timer insert counter works very very
@ -373,8 +373,8 @@ rt_err_t rt_timer_start(rt_timer_t timer)
random_nr++;
tst_nr = random_nr;
rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL-1],
&(timer->row[RT_TIMER_SKIP_LIST_LEVEL-1]));
rt_list_insert_after(row_head[RT_TIMER_SKIP_LIST_LEVEL - 1],
&(timer->row[RT_TIMER_SKIP_LIST_LEVEL - 1]));
for (row_lvl = 2; row_lvl <= RT_TIMER_SKIP_LIST_LEVEL; row_lvl++)
{
if (!(tst_nr & RT_TIMER_SKIP_LIST_MASK))
@ -384,7 +384,7 @@ rt_err_t rt_timer_start(rt_timer_t timer)
break;
/* Shift over the bits we have tested. Works well with 1 bit and 2
* bits. */
tst_nr >>= (RT_TIMER_SKIP_LIST_MASK+1)>>1;
tst_nr >>= (RT_TIMER_SKIP_LIST_MASK + 1) >> 1;
}
timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;
@ -498,7 +498,7 @@ void rt_timer_check(void)
/* disable interrupt */
level = rt_hw_interrupt_disable();
while (!rt_list_isempty(&rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1]))
while (!rt_list_isempty(&rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]))
{
t = rt_list_entry(rt_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next,
struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL - 1]);
@ -507,7 +507,7 @@ void rt_timer_check(void)
* It supposes that the new tick shall less than the half duration of
* tick max.
*/
if ((current_tick - t->timeout_tick) < RT_TICK_MAX/2)
if ((current_tick - t->timeout_tick) < RT_TICK_MAX / 2)
{
RT_OBJECT_HOOK_CALL(rt_timer_timeout_hook, (t));
@ -570,13 +570,13 @@ void rt_soft_timer_check(void)
current_tick = rt_tick_get();
/* lock scheduler */
rt_enter_critical();
/* lock scheduler */
rt_enter_critical();
for (n = rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1].next;
n != &(rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL-1]);)
for (n = rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1].next;
n != &(rt_soft_timer_list[RT_TIMER_SKIP_LIST_LEVEL - 1]);)
{
t = rt_list_entry(n, struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL-1]);
t = rt_list_entry(n, struct rt_timer, row[RT_TIMER_SKIP_LIST_LEVEL - 1]);
/*
* It supposes that the new tick shall less than the half duration of
@ -592,8 +592,8 @@ void rt_soft_timer_check(void)
/* remove timer from timer list firstly */
_rt_timer_remove(t);
/* not lock scheduler when performing timeout function */
rt_exit_critical();
/* not lock scheduler when performing timeout function */
rt_exit_critical();
/* call timeout function */
t->timeout_func(t->parameter);
@ -602,8 +602,8 @@ void rt_soft_timer_check(void)
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("current tick: %d\n", current_tick));
/* lock scheduler */
rt_enter_critical();
/* lock scheduler */
rt_enter_critical();
if ((t->parent.flag & RT_TIMER_FLAG_PERIODIC) &&
(t->parent.flag & RT_TIMER_FLAG_ACTIVATED))
@ -621,8 +621,8 @@ void rt_soft_timer_check(void)
else break; /* not check anymore */
}
/* unlock scheduler */
rt_exit_critical();
/* unlock scheduler */
rt_exit_critical();
RT_DEBUG_LOG(RT_DEBUG_TIMER, ("software timer check leave\n"));
}
@ -649,7 +649,7 @@ static void rt_thread_timer_entry(void *parameter)
/* get current tick */
current_tick = rt_tick_get();
if ((next_timeout - current_tick) < RT_TICK_MAX/2)
if ((next_timeout - current_tick) < RT_TICK_MAX / 2)
{
/* get the delta timeout tick */
next_timeout = next_timeout - current_tick;
@ -672,9 +672,9 @@ void rt_system_timer_init(void)
{
int i;
for (i = 0; i < sizeof(rt_timer_list)/sizeof(rt_timer_list[0]); i++)
for (i = 0; i < sizeof(rt_timer_list) / sizeof(rt_timer_list[0]); i++)
{
rt_list_init(rt_timer_list+i);
rt_list_init(rt_timer_list + i);
}
}
@ -689,10 +689,10 @@ void rt_system_timer_thread_init(void)
int i;
for (i = 0;
i < sizeof(rt_soft_timer_list)/sizeof(rt_soft_timer_list[0]);
i < sizeof(rt_soft_timer_list) / sizeof(rt_soft_timer_list[0]);
i++)
{
rt_list_init(rt_soft_timer_list+i);
rt_list_init(rt_soft_timer_list + i);
}
/* start software timer thread */