From 1cffb60ce03ad8e2d19394fae507a06bdb824188 Mon Sep 17 00:00:00 2001 From: "dzzxzz@gmail.com" Date: Tue, 25 Dec 2012 06:45:34 +0000 Subject: [PATCH] fixed the coding style in ipc.c git-svn-id: https://rt-thread.googlecode.com/svn/trunk@2520 bbd45198-f89e-11dd-88c7-29a3b14d5316 --- src/ipc.c | 2716 +++++++++++++++++++++++++++-------------------------- 1 file changed, 1387 insertions(+), 1329 deletions(-) diff --git a/src/ipc.c b/src/ipc.c index 38b2c609a..4ae821a91 100644 --- a/src/ipc.c +++ b/src/ipc.c @@ -61,60 +61,66 @@ extern void (*rt_object_put_hook)(struct rt_object *object); */ rt_inline rt_err_t rt_ipc_object_init(struct rt_ipc_object *ipc) { - /* init ipc object */ - rt_list_init(&(ipc->suspend_thread)); + /* init ipc object */ + rt_list_init(&(ipc->suspend_thread)); - return RT_EOK; + return RT_EOK; } /** - * This function will suspend a thread to a specified list. IPC object or some double-queue - * object (mailbox etc.) contains this kind of list. + * This function will suspend a thread to a specified list. IPC object or some + * double-queue object (mailbox etc.) contains this kind of list. * * @param list the IPC suspended thread list * @param thread the thread object to be suspended - * @param flag the IPC object flag, which shall be RT_IPC_FLAG_FIFO/RT_IPC_FLAG_PRIO. + * @param flag the IPC object flag, + * which shall be RT_IPC_FLAG_FIFO/RT_IPC_FLAG_PRIO. * * @return the operation status, RT_EOK on successful */ -rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list, struct rt_thread *thread, rt_uint8_t flag) +rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list, + struct rt_thread *thread, + rt_uint8_t flag) { - /* suspend thread */ - rt_thread_suspend(thread); - - switch (flag) - { - case RT_IPC_FLAG_FIFO: - rt_list_insert_before(list, &(thread->tlist)); - break; - - case RT_IPC_FLAG_PRIO: - { - struct rt_list_node *n; - struct rt_thread *sthread; - - /* find a suitable position */ - for (n = list->next; n != list; n = n->next) - { - sthread = rt_list_entry(n, struct rt_thread, tlist); - - /* find out */ - if (thread->current_priority < sthread->current_priority) - { - /* insert this thread before the sthread */ - rt_list_insert_before(&(sthread->tlist), &(thread->tlist)); - break; - } - } - - /* not found a suitable position, append to the end of suspend_thread list */ - if (n == list) - rt_list_insert_before(list, &(thread->tlist)); - } - break; - } - - return RT_EOK; + /* suspend thread */ + rt_thread_suspend(thread); + + switch (flag) + { + case RT_IPC_FLAG_FIFO: + rt_list_insert_before(list, &(thread->tlist)); + break; + + case RT_IPC_FLAG_PRIO: + { + struct rt_list_node *n; + struct rt_thread *sthread; + + /* find a suitable position */ + for (n = list->next; n != list; n = n->next) + { + sthread = rt_list_entry(n, struct rt_thread, tlist); + + /* find out */ + if (thread->current_priority < sthread->current_priority) + { + /* insert this thread before the sthread */ + rt_list_insert_before(&(sthread->tlist), &(thread->tlist)); + break; + } + } + + /* + * not found a suitable position, + * append to the end of suspend_thread list + */ + if (n == list) + rt_list_insert_before(list, &(thread->tlist)); + } + break; + } + + return RT_EOK; } /** @@ -128,17 +134,17 @@ rt_inline rt_err_t rt_ipc_list_suspend(rt_list_t *list, struct rt_thread *thread */ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list) { - struct rt_thread *thread; + struct rt_thread *thread; - /* get thread entry */ - thread = rt_list_entry(list->next, struct rt_thread, tlist); + /* get thread entry */ + thread = rt_list_entry(list->next, struct rt_thread, tlist); - RT_DEBUG_LOG(RT_DEBUG_IPC, ("resume thread:%s\n", thread->name)); + RT_DEBUG_LOG(RT_DEBUG_IPC, ("resume thread:%s\n", thread->name)); - /* resume it */ - rt_thread_resume(thread); + /* resume it */ + rt_thread_resume(thread); - return RT_EOK; + return RT_EOK; } /** @@ -151,38 +157,38 @@ rt_inline rt_err_t rt_ipc_list_resume(rt_list_t *list) */ rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list) { - struct rt_thread *thread; - register rt_ubase_t temp; - - /* wakeup all suspend threads */ - while (!rt_list_isempty(list)) - { - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* get next suspend thread */ - thread = rt_list_entry(list->next, struct rt_thread, tlist); - /* set error code to RT_ERROR */ - thread->error = -RT_ERROR; - - /* - * resume thread - * In rt_thread_resume function, it will remove current thread from - * suspend list - */ - rt_thread_resume(thread); - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - } - - return RT_EOK; + struct rt_thread *thread; + register rt_ubase_t temp; + + /* wakeup all suspend threads */ + while (!rt_list_isempty(list)) + { + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* get next suspend thread */ + thread = rt_list_entry(list->next, struct rt_thread, tlist); + /* set error code to RT_ERROR */ + thread->error = -RT_ERROR; + + /* + * resume thread + * In rt_thread_resume function, it will remove current thread from + * suspend list + */ + rt_thread_resume(thread); + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + } + + return RT_EOK; } #ifdef RT_USING_SEMAPHORE /** - * This function will initialize a semaphore and put it under control of resource - * management. + * This function will initialize a semaphore and put it under control of + * resource management. * * @param sem the semaphore object * @param name the name of semaphore @@ -191,23 +197,26 @@ rt_inline rt_err_t rt_ipc_list_resume_all(rt_list_t *list) * * @return the operation status, RT_EOK on successful */ -rt_err_t rt_sem_init(rt_sem_t sem, const char *name, rt_uint32_t value, rt_uint8_t flag) +rt_err_t rt_sem_init(rt_sem_t sem, + const char *name, + rt_uint32_t value, + rt_uint8_t flag) { - RT_ASSERT(sem != RT_NULL); + RT_ASSERT(sem != RT_NULL); - /* init object */ - rt_object_init(&(sem->parent.parent), RT_Object_Class_Semaphore, name); + /* init object */ + rt_object_init(&(sem->parent.parent), RT_Object_Class_Semaphore, name); - /* init ipc object */ - rt_ipc_object_init(&(sem->parent)); + /* init ipc object */ + rt_ipc_object_init(&(sem->parent)); - /* set init value */ - sem->value = value; + /* set init value */ + sem->value = value; - /* set parent */ - sem->parent.parent.flag = flag; + /* set parent */ + sem->parent.parent.flag = flag; - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_sem_init); @@ -222,15 +231,15 @@ RTM_EXPORT(rt_sem_init); */ rt_err_t rt_sem_detach(rt_sem_t sem) { - RT_ASSERT(sem != RT_NULL); + RT_ASSERT(sem != RT_NULL); - /* wakeup all suspend threads */ - rt_ipc_list_resume_all(&(sem->parent.suspend_thread)); + /* wakeup all suspend threads */ + rt_ipc_list_resume_all(&(sem->parent.suspend_thread)); - /* detach semaphore object */ - rt_object_detach(&(sem->parent.parent)); + /* detach semaphore object */ + rt_object_detach(&(sem->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_sem_detach); @@ -248,25 +257,25 @@ RTM_EXPORT(rt_sem_detach); */ rt_sem_t rt_sem_create(const char *name, rt_uint32_t value, rt_uint8_t flag) { - rt_sem_t sem; + rt_sem_t sem; - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* allocate object */ - sem = (rt_sem_t)rt_object_allocate(RT_Object_Class_Semaphore, name); - if (sem == RT_NULL) - return sem; + /* allocate object */ + sem = (rt_sem_t)rt_object_allocate(RT_Object_Class_Semaphore, name); + if (sem == RT_NULL) + return sem; - /* init ipc object */ - rt_ipc_object_init(&(sem->parent)); + /* init ipc object */ + rt_ipc_object_init(&(sem->parent)); - /* set init value */ - sem->value = value; + /* set init value */ + sem->value = value; - /* set parent */ - sem->parent.parent.flag = flag; + /* set parent */ + sem->parent.parent.flag = flag; - return sem; + return sem; } RTM_EXPORT(rt_sem_create); @@ -281,17 +290,17 @@ RTM_EXPORT(rt_sem_create); */ rt_err_t rt_sem_delete(rt_sem_t sem) { - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - RT_ASSERT(sem != RT_NULL); + RT_ASSERT(sem != RT_NULL); - /* wakeup all suspend threads */ - rt_ipc_list_resume_all(&(sem->parent.suspend_thread)); + /* wakeup all suspend threads */ + rt_ipc_list_resume_all(&(sem->parent.suspend_thread)); - /* delete semaphore object */ - rt_object_delete(&(sem->parent.parent)); + /* delete semaphore object */ + rt_object_delete(&(sem->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_sem_delete); #endif @@ -307,84 +316,87 @@ RTM_EXPORT(rt_sem_delete); */ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t time) { - register rt_base_t temp; - struct rt_thread *thread; + register rt_base_t temp; + struct rt_thread *thread; - RT_ASSERT(sem != RT_NULL); + RT_ASSERT(sem != RT_NULL); - RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent))); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n", + RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n", rt_thread_self()->name, ((struct rt_object *)sem)->name, sem->value)); - if (sem->value > 0) - { - /* semaphore is available */ - sem->value --; - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - } - else - { - /* no waiting, return with timeout */ - if (time == 0) - { - rt_hw_interrupt_enable(temp); - - return -RT_ETIMEOUT; - } - else - { - /* current context checking */ - RT_DEBUG_NOT_IN_INTERRUPT; - - /* semaphore is unavailable, push to suspend list */ - /* get current thread */ - thread = rt_thread_self(); - - /* reset thread error number */ - thread->error = RT_EOK; - - RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n", + if (sem->value > 0) + { + /* semaphore is available */ + sem->value --; + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + } + else + { + /* no waiting, return with timeout */ + if (time == 0) + { + rt_hw_interrupt_enable(temp); + + return -RT_ETIMEOUT; + } + else + { + /* current context checking */ + RT_DEBUG_NOT_IN_INTERRUPT; + + /* semaphore is unavailable, push to suspend list */ + /* get current thread */ + thread = rt_thread_self(); + + /* reset thread error number */ + thread->error = RT_EOK; + + RT_DEBUG_LOG(RT_DEBUG_IPC, ("sem take: suspend thread - %s\n", thread->name)); - /* suspend thread */ - rt_ipc_list_suspend(&(sem->parent.suspend_thread), - thread, sem->parent.parent.flag); + /* suspend thread */ + rt_ipc_list_suspend(&(sem->parent.suspend_thread), + thread, + sem->parent.parent.flag); - /* has waiting time, start thread timer */ - if (time > 0) - { - RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n", + /* has waiting time, start thread timer */ + if (time > 0) + { + RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n", thread->name)); - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &time); - rt_timer_start(&(thread->thread_timer)); - } + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &time); + rt_timer_start(&(thread->thread_timer)); + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - /* do schedule */ - rt_schedule(); + /* do schedule */ + rt_schedule(); - if (thread->error != RT_EOK) - { - return thread->error; - } - } - } + if (thread->error != RT_EOK) + { + return thread->error; + } + } + } - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(sem->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(sem->parent.parent))); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_sem_take); @@ -397,7 +409,7 @@ RTM_EXPORT(rt_sem_take); */ rt_err_t rt_sem_trytake(rt_sem_t sem) { - return rt_sem_take(sem, 0); + return rt_sem_take(sem, 0); } RTM_EXPORT(rt_sem_trytake); @@ -411,38 +423,38 @@ RTM_EXPORT(rt_sem_trytake); */ rt_err_t rt_sem_release(rt_sem_t sem) { - register rt_base_t temp; - register rt_bool_t need_schedule; + register rt_base_t temp; + register rt_bool_t need_schedule; - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(sem->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(sem->parent.parent))); - need_schedule = RT_FALSE; + need_schedule = RT_FALSE; - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n", + RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n", rt_thread_self()->name, ((struct rt_object *)sem)->name, sem->value)); - if (!rt_list_isempty(&sem->parent.suspend_thread)) - { - /* resume the suspended thread */ - rt_ipc_list_resume(&(sem->parent.suspend_thread)); - need_schedule = RT_TRUE; - } - else - sem->value ++; /* increase value */ + if (!rt_list_isempty(&sem->parent.suspend_thread)) + { + /* resume the suspended thread */ + rt_ipc_list_resume(&(sem->parent.suspend_thread)); + need_schedule = RT_TRUE; + } + else + sem->value ++; /* increase value */ - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - /* resume a thread, re-schedule */ - if (need_schedule == RT_TRUE) - rt_schedule(); + /* resume a thread, re-schedule */ + if (need_schedule == RT_TRUE) + rt_schedule(); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_sem_release); @@ -457,33 +469,33 @@ RTM_EXPORT(rt_sem_release); */ rt_err_t rt_sem_control(rt_sem_t sem, rt_uint8_t cmd, void *arg) { - rt_ubase_t level; - RT_ASSERT(sem != RT_NULL); + rt_ubase_t level; + RT_ASSERT(sem != RT_NULL); - if (cmd == RT_IPC_CMD_RESET) - { - rt_uint32_t value; + if (cmd == RT_IPC_CMD_RESET) + { + rt_uint32_t value; - /* get value */ - value = (rt_uint32_t)arg; - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + /* get value */ + value = (rt_uint32_t)arg; + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* resume all waiting thread */ - rt_ipc_list_resume_all(&sem->parent.suspend_thread); + /* resume all waiting thread */ + rt_ipc_list_resume_all(&sem->parent.suspend_thread); - /* set new value */ - sem->value = (rt_uint16_t)value; + /* set new value */ + sem->value = (rt_uint16_t)value; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - return -RT_ERROR; + return -RT_ERROR; } RTM_EXPORT(rt_sem_control); #endif /* end of RT_USING_SEMAPHORE */ @@ -501,23 +513,23 @@ RTM_EXPORT(rt_sem_control); */ rt_err_t rt_mutex_init(rt_mutex_t mutex, const char *name, rt_uint8_t flag) { - RT_ASSERT(mutex != RT_NULL); + RT_ASSERT(mutex != RT_NULL); - /* init object */ - rt_object_init(&(mutex->parent.parent), RT_Object_Class_Mutex, name); + /* init object */ + rt_object_init(&(mutex->parent.parent), RT_Object_Class_Mutex, name); - /* init ipc object */ - rt_ipc_object_init(&(mutex->parent)); + /* init ipc object */ + rt_ipc_object_init(&(mutex->parent)); - mutex->value = 1; - mutex->owner = RT_NULL; - mutex->original_priority = 0xFF; - mutex->hold = 0; + mutex->value = 1; + mutex->owner = RT_NULL; + mutex->original_priority = 0xFF; + mutex->hold = 0; - /* set flag */ - mutex->parent.parent.flag = flag; + /* set flag */ + mutex->parent.parent.flag = flag; - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mutex_init); @@ -532,15 +544,15 @@ RTM_EXPORT(rt_mutex_init); */ rt_err_t rt_mutex_detach(rt_mutex_t mutex) { - RT_ASSERT(mutex != RT_NULL); + RT_ASSERT(mutex != RT_NULL); - /* wakeup all suspend threads */ - rt_ipc_list_resume_all(&(mutex->parent.suspend_thread)); + /* wakeup all suspend threads */ + rt_ipc_list_resume_all(&(mutex->parent.suspend_thread)); - /* detach semaphore object */ - rt_object_detach(&(mutex->parent.parent)); + /* detach semaphore object */ + rt_object_detach(&(mutex->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mutex_detach); @@ -557,27 +569,27 @@ RTM_EXPORT(rt_mutex_detach); */ rt_mutex_t rt_mutex_create(const char *name, rt_uint8_t flag) { - struct rt_mutex *mutex; + struct rt_mutex *mutex; - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* allocate object */ - mutex = (rt_mutex_t)rt_object_allocate(RT_Object_Class_Mutex, name); - if (mutex == RT_NULL) - return mutex; + /* allocate object */ + mutex = (rt_mutex_t)rt_object_allocate(RT_Object_Class_Mutex, name); + if (mutex == RT_NULL) + return mutex; - /* init ipc object */ - rt_ipc_object_init(&(mutex->parent)); + /* init ipc object */ + rt_ipc_object_init(&(mutex->parent)); - mutex->value = 1; - mutex->owner = RT_NULL; - mutex->original_priority = 0xFF; - mutex->hold = 0; + mutex->value = 1; + mutex->owner = RT_NULL; + mutex->original_priority = 0xFF; + mutex->hold = 0; - /* set flag */ - mutex->parent.parent.flag = flag; + /* set flag */ + mutex->parent.parent.flag = flag; - return mutex; + return mutex; } RTM_EXPORT(rt_mutex_create); @@ -592,17 +604,17 @@ RTM_EXPORT(rt_mutex_create); */ rt_err_t rt_mutex_delete(rt_mutex_t mutex) { - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - RT_ASSERT(mutex != RT_NULL); + RT_ASSERT(mutex != RT_NULL); - /* wakeup all suspend threads */ - rt_ipc_list_resume_all(&(mutex->parent.suspend_thread)); + /* wakeup all suspend threads */ + rt_ipc_list_resume_all(&(mutex->parent.suspend_thread)); - /* delete semaphore object */ - rt_object_delete(&(mutex->parent.parent)); + /* delete semaphore object */ + rt_object_delete(&(mutex->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mutex_delete); #endif @@ -618,119 +630,123 @@ RTM_EXPORT(rt_mutex_delete); */ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t time) { - register rt_base_t temp; - struct rt_thread *thread; + register rt_base_t temp; + struct rt_thread *thread; - /* this function must not be used in interrupt even if time = 0 */ - RT_DEBUG_NOT_IN_INTERRUPT; + /* this function must not be used in interrupt even if time = 0 */ + RT_DEBUG_NOT_IN_INTERRUPT; - RT_ASSERT(mutex != RT_NULL); + RT_ASSERT(mutex != RT_NULL); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - /* get current thread */ - thread = rt_thread_self(); + /* get current thread */ + thread = rt_thread_self(); - RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mutex->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mutex->parent.parent))); - RT_DEBUG_LOG(RT_DEBUG_IPC, + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_take: current thread %s, mutex value: %d, hold: %d\n", thread->name, mutex->value, mutex->hold)); - /* reset thread error */ - thread->error = RT_EOK; - - if (mutex->owner == thread) - { - /* it's the same thread */ - mutex->hold ++; - } - else - { - /* The value of mutex is 1 in initial status. Therefore, if the - * value is great than 0, it indicates the mutex is avaible. - */ - if (mutex->value > 0) - { - /* mutex is available */ - mutex->value --; - - /* set mutex owner and original priority */ - mutex->owner = thread; - mutex->original_priority = thread->current_priority; - mutex->hold ++; - } - else - { - /* no waiting, return with timeout */ - if (time == 0) - { - /* set error as timeout */ - thread->error = -RT_ETIMEOUT; - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return -RT_ETIMEOUT; - } - else - { - /* mutex is unavailable, push to suspend list */ - RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_take: suspend thread: %s\n", + /* reset thread error */ + thread->error = RT_EOK; + + if (mutex->owner == thread) + { + /* it's the same thread */ + mutex->hold ++; + } + else + { + /* The value of mutex is 1 in initial status. Therefore, if the + * value is great than 0, it indicates the mutex is avaible. + */ + if (mutex->value > 0) + { + /* mutex is available */ + mutex->value --; + + /* set mutex owner and original priority */ + mutex->owner = thread; + mutex->original_priority = thread->current_priority; + mutex->hold ++; + } + else + { + /* no waiting, return with timeout */ + if (time == 0) + { + /* set error as timeout */ + thread->error = -RT_ETIMEOUT; + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return -RT_ETIMEOUT; + } + else + { + /* mutex is unavailable, push to suspend list */ + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_take: suspend thread: %s\n", thread->name)); - /* change the owner thread priority of mutex */ - if (thread->current_priority < mutex->owner->current_priority) - { - /* change the owner thread priority */ - rt_thread_control(mutex->owner, RT_THREAD_CTRL_CHANGE_PRIORITY, - &thread->current_priority); - } - - /* suspend current thread */ - rt_ipc_list_suspend(&(mutex->parent.suspend_thread), - thread, mutex->parent.parent.flag); - - /* has waiting time, start thread timer */ - if (time > 0) - { - RT_DEBUG_LOG(RT_DEBUG_IPC, + /* change the owner thread priority of mutex */ + if (thread->current_priority < mutex->owner->current_priority) + { + /* change the owner thread priority */ + rt_thread_control(mutex->owner, + RT_THREAD_CTRL_CHANGE_PRIORITY, + &thread->current_priority); + } + + /* suspend current thread */ + rt_ipc_list_suspend(&(mutex->parent.suspend_thread), + thread, + mutex->parent.parent.flag); + + /* has waiting time, start thread timer */ + if (time > 0) + { + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_take: start the timer of thread:%s\n", thread->name)); - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &time); - rt_timer_start(&(thread->thread_timer)); - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - /* do schedule */ - rt_schedule(); - - if (thread->error != RT_EOK) - { - /* return error */ - return thread->error; - } - else - { - /* the mutex is taken successfully. */ - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - } - } - } - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mutex->parent.parent))); - - return RT_EOK; + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &time); + rt_timer_start(&(thread->thread_timer)); + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + /* do schedule */ + rt_schedule(); + + if (thread->error != RT_EOK) + { + /* return error */ + return thread->error; + } + else + { + /* the mutex is taken successfully. */ + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + } + } + } + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mutex->parent.parent))); + + return RT_EOK; } RTM_EXPORT(rt_mutex_take); @@ -744,85 +760,88 @@ RTM_EXPORT(rt_mutex_take); */ rt_err_t rt_mutex_release(rt_mutex_t mutex) { - register rt_base_t temp; - struct rt_thread *thread; - rt_bool_t need_schedule; + register rt_base_t temp; + struct rt_thread *thread; + rt_bool_t need_schedule; - need_schedule = RT_FALSE; + need_schedule = RT_FALSE; - /* get current thread */ - thread = rt_thread_self(); + /* get current thread */ + thread = rt_thread_self(); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - RT_DEBUG_LOG(RT_DEBUG_IPC, + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_release:current thread %s, mutex value: %d, hold: %d\n", thread->name, mutex->value, mutex->hold)); - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mutex->parent.parent))); - - /* mutex only can be released by owner */ - if (thread != mutex->owner) - { - thread->error = -RT_ERROR; - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return -RT_ERROR; - } - - /* decrease hold */ - mutex->hold --; - /* if no hold */ - if (mutex->hold == 0) - { - /* change the owner thread to original priority */ - if (mutex->original_priority != mutex->owner->current_priority) - { - rt_thread_control(mutex->owner, RT_THREAD_CTRL_CHANGE_PRIORITY, - &(mutex->original_priority)); - } - - /* wakeup suspended thread */ - if (!rt_list_isempty(&mutex->parent.suspend_thread)) - { - /* get suspended thread */ - thread = rt_list_entry(mutex->parent.suspend_thread.next, struct rt_thread, tlist); - - RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_release: resume thread: %s\n", + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mutex->parent.parent))); + + /* mutex only can be released by owner */ + if (thread != mutex->owner) + { + thread->error = -RT_ERROR; + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return -RT_ERROR; + } + + /* decrease hold */ + mutex->hold --; + /* if no hold */ + if (mutex->hold == 0) + { + /* change the owner thread to original priority */ + if (mutex->original_priority != mutex->owner->current_priority) + { + rt_thread_control(mutex->owner, + RT_THREAD_CTRL_CHANGE_PRIORITY, + &(mutex->original_priority)); + } + + /* wakeup suspended thread */ + if (!rt_list_isempty(&mutex->parent.suspend_thread)) + { + /* get suspended thread */ + thread = rt_list_entry(mutex->parent.suspend_thread.next, + struct rt_thread, + tlist); + + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mutex_release: resume thread: %s\n", thread->name)); - /* set new owner and priority */ - mutex->owner = thread; - mutex->original_priority = thread->current_priority; - mutex->hold ++; + /* set new owner and priority */ + mutex->owner = thread; + mutex->original_priority = thread->current_priority; + mutex->hold ++; - /* resume thread */ - rt_ipc_list_resume(&(mutex->parent.suspend_thread)); + /* resume thread */ + rt_ipc_list_resume(&(mutex->parent.suspend_thread)); - need_schedule = RT_TRUE; - } - else - { - /* increase value */ - mutex->value ++; + need_schedule = RT_TRUE; + } + else + { + /* increase value */ + mutex->value ++; - /* clear owner */ - mutex->owner = RT_NULL; - mutex->original_priority = 0xff; - } - } + /* clear owner */ + mutex->owner = RT_NULL; + mutex->original_priority = 0xff; + } + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - /* perform a schedule */ - if (need_schedule == RT_TRUE) - rt_schedule(); + /* perform a schedule */ + if (need_schedule == RT_TRUE) + rt_schedule(); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mutex_release); @@ -837,7 +856,7 @@ RTM_EXPORT(rt_mutex_release); */ rt_err_t rt_mutex_control(rt_mutex_t mutex, rt_uint8_t cmd, void *arg) { - return -RT_ERROR; + return -RT_ERROR; } RTM_EXPORT(rt_mutex_control); #endif /* end of RT_USING_MUTEX */ @@ -855,21 +874,21 @@ RTM_EXPORT(rt_mutex_control); */ rt_err_t rt_event_init(rt_event_t event, const char *name, rt_uint8_t flag) { - RT_ASSERT(event != RT_NULL); + RT_ASSERT(event != RT_NULL); - /* init object */ - rt_object_init(&(event->parent.parent), RT_Object_Class_Event, name); + /* init object */ + rt_object_init(&(event->parent.parent), RT_Object_Class_Event, name); - /* set parent flag */ - event->parent.parent.flag = flag; + /* set parent flag */ + event->parent.parent.flag = flag; - /* init ipc object */ - rt_ipc_object_init(&(event->parent)); + /* init ipc object */ + rt_ipc_object_init(&(event->parent)); - /* init event */ - event->set = 0; + /* init event */ + event->set = 0; - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_event_init); @@ -882,16 +901,16 @@ RTM_EXPORT(rt_event_init); */ rt_err_t rt_event_detach(rt_event_t event) { - /* parameter check */ - RT_ASSERT(event != RT_NULL); + /* parameter check */ + RT_ASSERT(event != RT_NULL); - /* resume all suspended thread */ - rt_ipc_list_resume_all(&(event->parent.suspend_thread)); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&(event->parent.suspend_thread)); - /* detach event object */ - rt_object_detach(&(event->parent.parent)); + /* detach event object */ + rt_object_detach(&(event->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_event_detach); @@ -906,25 +925,25 @@ RTM_EXPORT(rt_event_detach); */ rt_event_t rt_event_create(const char *name, rt_uint8_t flag) { - rt_event_t event; + rt_event_t event; - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* allocate object */ - event = (rt_event_t)rt_object_allocate(RT_Object_Class_Event, name); - if (event == RT_NULL) - return event; + /* allocate object */ + event = (rt_event_t)rt_object_allocate(RT_Object_Class_Event, name); + if (event == RT_NULL) + return event; - /* set parent */ - event->parent.parent.flag = flag; + /* set parent */ + event->parent.parent.flag = flag; - /* init ipc object */ - rt_ipc_object_init(&(event->parent)); + /* init ipc object */ + rt_ipc_object_init(&(event->parent)); - /* init event */ - event->set = 0; + /* init event */ + event->set = 0; - return event; + return event; } RTM_EXPORT(rt_event_create); @@ -937,18 +956,18 @@ RTM_EXPORT(rt_event_create); */ rt_err_t rt_event_delete(rt_event_t event) { - /* parameter check */ - RT_ASSERT(event != RT_NULL); + /* parameter check */ + RT_ASSERT(event != RT_NULL); - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* resume all suspended thread */ - rt_ipc_list_resume_all(&(event->parent.suspend_thread)); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&(event->parent.suspend_thread)); - /* delete event object */ - rt_object_delete(&(event->parent.parent)); + /* delete event object */ + rt_object_delete(&(event->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_event_delete); #endif @@ -964,89 +983,89 @@ RTM_EXPORT(rt_event_delete); */ rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set) { - struct rt_list_node *n; - struct rt_thread *thread; - register rt_ubase_t level; - register rt_base_t status; - rt_bool_t need_schedule; - - /* parameter check */ - RT_ASSERT(event != RT_NULL); - if (set == 0) - return -RT_ERROR; - - need_schedule = RT_FALSE; - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(event->parent.parent))); - - /* disable interrupt */ - level = rt_hw_interrupt_disable(); - - /* set event */ - event->set |= set; - - if (!rt_list_isempty(&event->parent.suspend_thread)) - { - /* search thread list to resume thread */ - n = event->parent.suspend_thread.next; - while (n != &(event->parent.suspend_thread)) - { - /* get thread */ - thread = rt_list_entry(n, struct rt_thread, tlist); - - status = -RT_ERROR; - if (thread->event_info & RT_EVENT_FLAG_AND) - { - if ((thread->event_set & event->set) == thread->event_set) - { - /* received an AND event */ - status = RT_EOK; - } - } - else if (thread->event_info & RT_EVENT_FLAG_OR) - { - if (thread->event_set & event->set) - { - /* save recieved event set */ - thread->event_set = thread->event_set & event->set; - - /* received an OR event */ - status = RT_EOK; - } - } - - /* move node to the next */ - n = n->next; - - /* condition is satisfied, resume thread */ - if (status == RT_EOK) - { - /* clear event */ - if (thread->event_info & RT_EVENT_FLAG_CLEAR) - event->set &= ~thread->event_set; - - /* resume thread, and thread list breaks out */ - rt_thread_resume(thread); - - /* need do a scheduling */ - need_schedule = RT_TRUE; - } - } - } - - /* enable interrupt */ - rt_hw_interrupt_enable(level); - - /* do a schedule */ - if (need_schedule == RT_TRUE) - rt_schedule(); - - return RT_EOK; + struct rt_list_node *n; + struct rt_thread *thread; + register rt_ubase_t level; + register rt_base_t status; + rt_bool_t need_schedule; + + /* parameter check */ + RT_ASSERT(event != RT_NULL); + if (set == 0) + return -RT_ERROR; + + need_schedule = RT_FALSE; + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(event->parent.parent))); + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + + /* set event */ + event->set |= set; + + if (!rt_list_isempty(&event->parent.suspend_thread)) + { + /* search thread list to resume thread */ + n = event->parent.suspend_thread.next; + while (n != &(event->parent.suspend_thread)) + { + /* get thread */ + thread = rt_list_entry(n, struct rt_thread, tlist); + + status = -RT_ERROR; + if (thread->event_info & RT_EVENT_FLAG_AND) + { + if ((thread->event_set & event->set) == thread->event_set) + { + /* received an AND event */ + status = RT_EOK; + } + } + else if (thread->event_info & RT_EVENT_FLAG_OR) + { + if (thread->event_set & event->set) + { + /* save recieved event set */ + thread->event_set = thread->event_set & event->set; + + /* received an OR event */ + status = RT_EOK; + } + } + + /* move node to the next */ + n = n->next; + + /* condition is satisfied, resume thread */ + if (status == RT_EOK) + { + /* clear event */ + if (thread->event_info & RT_EVENT_FLAG_CLEAR) + event->set &= ~thread->event_set; + + /* resume thread, and thread list breaks out */ + rt_thread_resume(thread); + + /* need do a scheduling */ + need_schedule = RT_TRUE; + } + } + } + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + + /* do a schedule */ + if (need_schedule == RT_TRUE) + rt_schedule(); + + return RT_EOK; } RTM_EXPORT(rt_event_send); /** - * This function will receive an event from event object, if the event is unavailable, - * the thread shall wait for a specified time. + * This function will receive an event from event object, if the event is + * unavailable, the thread shall wait for a specified time. * * @param event the fast event object * @param set the interested event set @@ -1056,99 +1075,107 @@ RTM_EXPORT(rt_event_send); * * @return the error code */ -rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option, rt_int32_t timeout, rt_uint32_t *recved) +rt_err_t rt_event_recv(rt_event_t event, + rt_uint32_t set, + rt_uint8_t option, + rt_int32_t timeout, + rt_uint32_t *recved) { - struct rt_thread *thread; - register rt_ubase_t level; - register rt_base_t status; - - RT_DEBUG_NOT_IN_INTERRUPT; - - /* parameter check */ - RT_ASSERT(event != RT_NULL); - if (set == 0) - return -RT_ERROR; - - /* init status */ - status = -RT_ERROR; - /* get current thread */ - thread = rt_thread_self(); - /* reset thread error */ - thread->error = RT_EOK; - - RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(event->parent.parent))); - - /* disable interrupt */ - level = rt_hw_interrupt_disable(); - - /* check event set */ - if (option & RT_EVENT_FLAG_AND) - { - if ((event->set & set) == set) - status = RT_EOK; - } - else if (option & RT_EVENT_FLAG_OR) - { - if (event->set & set) - status = RT_EOK; - } - - if (status == RT_EOK) - { - /* set received event */ - *recved = (event->set & set); - - /* received event */ - if (option & RT_EVENT_FLAG_CLEAR) - event->set &= ~set; - } - else if (timeout == 0) - { - /* no waiting */ - thread->error = -RT_ETIMEOUT; - } - else - { - /* fill thread event info */ - thread->event_set = set; - thread->event_info = option; - - /* put thread to suspended thread list */ - rt_ipc_list_suspend(&(event->parent.suspend_thread), thread, event->parent.parent.flag); - - /* if there is a waiting timeout, active thread timer */ - if (timeout > 0) - { - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout); - rt_timer_start(&(thread->thread_timer)); - } - - /* enable interrupt */ - rt_hw_interrupt_enable(level); - - /* do a schedule */ - rt_schedule(); - - if (thread->error != RT_EOK) - { - /* return error */ - return thread->error; - } - - /* received an event, disable interrupt to protect */ - level = rt_hw_interrupt_disable(); - - /* set received event */ - *recved = thread->event_set; - } - - /* enable interrupt */ - rt_hw_interrupt_enable(level); - - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(event->parent.parent))); - - return thread->error; + struct rt_thread *thread; + register rt_ubase_t level; + register rt_base_t status; + + RT_DEBUG_NOT_IN_INTERRUPT; + + /* parameter check */ + RT_ASSERT(event != RT_NULL); + if (set == 0) + return -RT_ERROR; + + /* init status */ + status = -RT_ERROR; + /* get current thread */ + thread = rt_thread_self(); + /* reset thread error */ + thread->error = RT_EOK; + + RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(event->parent.parent))); + + /* disable interrupt */ + level = rt_hw_interrupt_disable(); + + /* check event set */ + if (option & RT_EVENT_FLAG_AND) + { + if ((event->set & set) == set) + status = RT_EOK; + } + else if (option & RT_EVENT_FLAG_OR) + { + if (event->set & set) + status = RT_EOK; + } + + if (status == RT_EOK) + { + /* set received event */ + *recved = (event->set & set); + + /* received event */ + if (option & RT_EVENT_FLAG_CLEAR) + event->set &= ~set; + } + else if (timeout == 0) + { + /* no waiting */ + thread->error = -RT_ETIMEOUT; + } + else + { + /* fill thread event info */ + thread->event_set = set; + thread->event_info = option; + + /* put thread to suspended thread list */ + rt_ipc_list_suspend(&(event->parent.suspend_thread), + thread, + event->parent.parent.flag); + + /* if there is a waiting timeout, active thread timer */ + if (timeout > 0) + { + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &timeout); + rt_timer_start(&(thread->thread_timer)); + } + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + + /* do a schedule */ + rt_schedule(); + + if (thread->error != RT_EOK) + { + /* return error */ + return thread->error; + } + + /* received an event, disable interrupt to protect */ + level = rt_hw_interrupt_disable(); + + /* set received event */ + *recved = thread->event_set; + } + + /* enable interrupt */ + rt_hw_interrupt_enable(level); + + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(event->parent.parent))); + + return thread->error; } RTM_EXPORT(rt_event_recv); @@ -1163,29 +1190,29 @@ RTM_EXPORT(rt_event_recv); */ rt_err_t rt_event_control(rt_event_t event, rt_uint8_t cmd, void *arg) { - rt_ubase_t level; - RT_ASSERT(event != RT_NULL); + rt_ubase_t level; + RT_ASSERT(event != RT_NULL); - if (cmd == RT_IPC_CMD_RESET) - { - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + if (cmd == RT_IPC_CMD_RESET) + { + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* resume all waiting thread */ - rt_ipc_list_resume_all(&event->parent.suspend_thread); + /* resume all waiting thread */ + rt_ipc_list_resume_all(&event->parent.suspend_thread); - /* init event set */ - event->set = 0; + /* init event set */ + event->set = 0; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - return -RT_ERROR; + return -RT_ERROR; } RTM_EXPORT(rt_event_control); #endif /* end of RT_USING_EVENT */ @@ -1203,30 +1230,34 @@ RTM_EXPORT(rt_event_control); * * @return the operation status, RT_EOK on successful */ -rt_err_t rt_mb_init(rt_mailbox_t mb, const char *name, void *msgpool, rt_size_t size, rt_uint8_t flag) +rt_err_t rt_mb_init(rt_mailbox_t mb, + const char *name, + void *msgpool, + rt_size_t size, + rt_uint8_t flag) { - RT_ASSERT(mb != RT_NULL); + RT_ASSERT(mb != RT_NULL); - /* init object */ - rt_object_init(&(mb->parent.parent), RT_Object_Class_MailBox, name); + /* init object */ + rt_object_init(&(mb->parent.parent), RT_Object_Class_MailBox, name); - /* set parent flag */ - mb->parent.parent.flag = flag; + /* set parent flag */ + mb->parent.parent.flag = flag; - /* init ipc object */ - rt_ipc_object_init(&(mb->parent)); + /* init ipc object */ + rt_ipc_object_init(&(mb->parent)); - /* init mailbox */ - mb->msg_pool = msgpool; - mb->size = size; - mb->entry = 0; - mb->in_offset = 0; - mb->out_offset = 0; + /* init mailbox */ + mb->msg_pool = msgpool; + mb->size = size; + mb->entry = 0; + mb->in_offset = 0; + mb->out_offset = 0; - /* init an additional list of sender suspend thread */ - rt_list_init(&(mb->suspend_sender_thread)); + /* init an additional list of sender suspend thread */ + rt_list_init(&(mb->suspend_sender_thread)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mb_init); @@ -1239,18 +1270,18 @@ RTM_EXPORT(rt_mb_init); */ rt_err_t rt_mb_detach(rt_mailbox_t mb) { - /* parameter check */ - RT_ASSERT(mb != RT_NULL); + /* parameter check */ + RT_ASSERT(mb != RT_NULL); - /* resume all suspended thread */ - rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); - /* also resume all mailbox private suspended thread */ - rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); + /* also resume all mailbox private suspended thread */ + rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); - /* detach mailbox object */ - rt_object_detach(&(mb->parent.parent)); + /* detach mailbox object */ + rt_object_detach(&(mb->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mb_detach); @@ -1266,39 +1297,39 @@ RTM_EXPORT(rt_mb_detach); */ rt_mailbox_t rt_mb_create(const char *name, rt_size_t size, rt_uint8_t flag) { - rt_mailbox_t mb; + rt_mailbox_t mb; - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* allocate object */ - mb = (rt_mailbox_t)rt_object_allocate(RT_Object_Class_MailBox, name); - if (mb == RT_NULL) - return mb; + /* allocate object */ + mb = (rt_mailbox_t)rt_object_allocate(RT_Object_Class_MailBox, name); + if (mb == RT_NULL) + return mb; - /* set parent */ - mb->parent.parent.flag = flag; + /* set parent */ + mb->parent.parent.flag = flag; - /* init ipc object */ - rt_ipc_object_init(&(mb->parent)); + /* init ipc object */ + rt_ipc_object_init(&(mb->parent)); - /* init mailbox */ - mb->size = size; - mb->msg_pool = rt_malloc(mb->size * sizeof(rt_uint32_t)); - if (mb->msg_pool == RT_NULL) - { - /* delete mailbox object */ - rt_object_delete(&(mb->parent.parent)); + /* init mailbox */ + mb->size = size; + mb->msg_pool = rt_malloc(mb->size * sizeof(rt_uint32_t)); + if (mb->msg_pool == RT_NULL) + { + /* delete mailbox object */ + rt_object_delete(&(mb->parent.parent)); - return RT_NULL; - } - mb->entry = 0; - mb->in_offset = 0; - mb->out_offset = 0; + return RT_NULL; + } + mb->entry = 0; + mb->in_offset = 0; + mb->out_offset = 0; - /* init an additional list of sender suspend thread */ - rt_list_init(&(mb->suspend_sender_thread)); + /* init an additional list of sender suspend thread */ + rt_list_init(&(mb->suspend_sender_thread)); - return mb; + return mb; } RTM_EXPORT(rt_mb_create); @@ -1311,31 +1342,31 @@ RTM_EXPORT(rt_mb_create); */ rt_err_t rt_mb_delete(rt_mailbox_t mb) { - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* parameter check */ - RT_ASSERT(mb != RT_NULL); + /* parameter check */ + RT_ASSERT(mb != RT_NULL); - /* resume all suspended thread */ - rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); - /* also resume all mailbox private suspended thread */ - rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); + /* also resume all mailbox private suspended thread */ + rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); #if defined(RT_USING_MODULE) && defined(RT_USING_SLAB) - /* the mb object belongs to an application module */ - if (mb->parent.parent.flag & RT_OBJECT_FLAG_MODULE) - rt_module_free(mb->parent.parent.module_id, mb->msg_pool); - else + /* the mb object belongs to an application module */ + if (mb->parent.parent.flag & RT_OBJECT_FLAG_MODULE) + rt_module_free(mb->parent.parent.module_id, mb->msg_pool); + else #endif - /* free mailbox pool */ - rt_free(mb->msg_pool); + /* free mailbox pool */ + rt_free(mb->msg_pool); - /* delete mailbox object */ - rt_object_delete(&(mb->parent.parent)); + /* delete mailbox object */ + rt_object_delete(&(mb->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mb_delete); #endif @@ -1350,125 +1381,131 @@ RTM_EXPORT(rt_mb_delete); * * @return the error code */ -rt_err_t rt_mb_send_wait(rt_mailbox_t mb, rt_uint32_t value, rt_int32_t timeout) +rt_err_t rt_mb_send_wait(rt_mailbox_t mb, + rt_uint32_t value, + rt_int32_t timeout) { - struct rt_thread *thread; - register rt_ubase_t temp; - rt_uint32_t tick_delta; - - /* parameter check */ - RT_ASSERT(mb != RT_NULL); - - /* initialize delta tick */ - tick_delta = 0; - /* get current thread */ - thread = rt_thread_self(); - - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mb->parent.parent))); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* for non-blocking call */ - if (mb->entry == mb->size && timeout == 0) - { - rt_hw_interrupt_enable(temp); - - return -RT_EFULL; - } - - /* mailbox is full */ - while (mb->entry == mb->size) - { - /* reset error number in thread */ - thread->error = RT_EOK; - - /* no waiting, return timeout */ - if (timeout == 0) - { - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return -RT_EFULL; - } - - RT_DEBUG_NOT_IN_INTERRUPT; - /* suspend current thread */ - rt_ipc_list_suspend(&(mb->suspend_sender_thread), thread, mb->parent.parent.flag); - - /* has waiting time, start thread timer */ - if (timeout > 0) - { - /* get the start tick of timer */ - tick_delta = rt_tick_get(); - - RT_DEBUG_LOG(RT_DEBUG_IPC, ("mb_send_wait: start timer of thread:%s\n", + struct rt_thread *thread; + register rt_ubase_t temp; + rt_uint32_t tick_delta; + + /* parameter check */ + RT_ASSERT(mb != RT_NULL); + + /* initialize delta tick */ + tick_delta = 0; + /* get current thread */ + thread = rt_thread_self(); + + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mb->parent.parent))); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* for non-blocking call */ + if (mb->entry == mb->size && timeout == 0) + { + rt_hw_interrupt_enable(temp); + + return -RT_EFULL; + } + + /* mailbox is full */ + while (mb->entry == mb->size) + { + /* reset error number in thread */ + thread->error = RT_EOK; + + /* no waiting, return timeout */ + if (timeout == 0) + { + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return -RT_EFULL; + } + + RT_DEBUG_NOT_IN_INTERRUPT; + /* suspend current thread */ + rt_ipc_list_suspend(&(mb->suspend_sender_thread), + thread, + mb->parent.parent.flag); + + /* has waiting time, start thread timer */ + if (timeout > 0) + { + /* get the start tick of timer */ + tick_delta = rt_tick_get(); + + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mb_send_wait: start timer of thread:%s\n", thread->name)); - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout); - rt_timer_start(&(thread->thread_timer)); - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - /* re-schedule */ - rt_schedule(); - - /* resume from suspend state */ - if (thread->error != RT_EOK) - { - /* return error */ - return thread->error; - } - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* if it's not waiting forever and then re-calculate timeout tick */ - if (timeout > 0) - { - tick_delta = rt_tick_get() - tick_delta; - timeout -= tick_delta; - if (timeout < 0) - timeout = 0; - } - } - - /* set ptr */ - mb->msg_pool[mb->in_offset] = value; - /* increase input offset */ - ++ mb->in_offset; - if (mb->in_offset >= mb->size) - mb->in_offset = 0; - /* increase message entry */ - mb->entry ++; - - /* resume suspended thread */ - if (!rt_list_isempty(&mb->parent.suspend_thread)) - { - rt_ipc_list_resume(&(mb->parent.suspend_thread)); - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - rt_schedule(); - - return RT_EOK; - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return RT_EOK; + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &timeout); + rt_timer_start(&(thread->thread_timer)); + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + /* re-schedule */ + rt_schedule(); + + /* resume from suspend state */ + if (thread->error != RT_EOK) + { + /* return error */ + return thread->error; + } + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* if it's not waiting forever and then re-calculate timeout tick */ + if (timeout > 0) + { + tick_delta = rt_tick_get() - tick_delta; + timeout -= tick_delta; + if (timeout < 0) + timeout = 0; + } + } + + /* set ptr */ + mb->msg_pool[mb->in_offset] = value; + /* increase input offset */ + ++ mb->in_offset; + if (mb->in_offset >= mb->size) + mb->in_offset = 0; + /* increase message entry */ + mb->entry ++; + + /* resume suspended thread */ + if (!rt_list_isempty(&mb->parent.suspend_thread)) + { + rt_ipc_list_resume(&(mb->parent.suspend_thread)); + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + rt_schedule(); + + return RT_EOK; + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return RT_EOK; } RTM_EXPORT(rt_mb_send_wait); /** - * This function will send a mail to mailbox object, if there are threads suspended - * on mailbox object, it will be waked up. This function will return immediately, if - * you want blocking send, use rt_mb_send_wait instead. + * This function will send a mail to mailbox object, if there are threads + * suspended on mailbox object, it will be waked up. This function will return + * immediately, if you want blocking send, use rt_mb_send_wait instead. * * @param mb the mailbox object * @param value the mail @@ -1477,13 +1514,13 @@ RTM_EXPORT(rt_mb_send_wait); */ rt_err_t rt_mb_send(rt_mailbox_t mb, rt_uint32_t value) { - return rt_mb_send_wait(mb, value, 0); + return rt_mb_send_wait(mb, value, 0); } RTM_EXPORT(rt_mb_send); /** - * This function will receive a mail from mailbox object, if there is no mail in - * mailbox object, the thread shall wait for a specified time. + * This function will receive a mail from mailbox object, if there is no mail + * in mailbox object, the thread shall wait for a specified time. * * @param mb the mailbox object * @param value the received mail will be saved in @@ -1493,123 +1530,127 @@ RTM_EXPORT(rt_mb_send); */ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_uint32_t *value, rt_int32_t timeout) { - struct rt_thread *thread; - register rt_ubase_t temp; - rt_uint32_t tick_delta; - - /* parameter check */ - RT_ASSERT(mb != RT_NULL); - - /* initialize delta tick */ - tick_delta = 0; - /* get current thread */ - thread = rt_thread_self(); - - RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mb->parent.parent))); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* for non-blocking call */ - if (mb->entry == 0 && timeout == 0) - { - rt_hw_interrupt_enable(temp); - - return -RT_ETIMEOUT; - } - - /* mailbox is empty */ - while (mb->entry == 0) - { - /* reset error number in thread */ - thread->error = RT_EOK; - - /* no waiting, return timeout */ - if (timeout == 0) - { - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - thread->error = -RT_ETIMEOUT; - - return -RT_ETIMEOUT; - } - - RT_DEBUG_NOT_IN_INTERRUPT; - /* suspend current thread */ - rt_ipc_list_suspend(&(mb->parent.suspend_thread), thread, mb->parent.parent.flag); - - /* has waiting time, start thread timer */ - if (timeout > 0) - { - /* get the start tick of timer */ - tick_delta = rt_tick_get(); - - RT_DEBUG_LOG(RT_DEBUG_IPC, ("mb_recv: start timer of thread:%s\n", + struct rt_thread *thread; + register rt_ubase_t temp; + rt_uint32_t tick_delta; + + /* parameter check */ + RT_ASSERT(mb != RT_NULL); + + /* initialize delta tick */ + tick_delta = 0; + /* get current thread */ + thread = rt_thread_self(); + + RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mb->parent.parent))); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* for non-blocking call */ + if (mb->entry == 0 && timeout == 0) + { + rt_hw_interrupt_enable(temp); + + return -RT_ETIMEOUT; + } + + /* mailbox is empty */ + while (mb->entry == 0) + { + /* reset error number in thread */ + thread->error = RT_EOK; + + /* no waiting, return timeout */ + if (timeout == 0) + { + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + thread->error = -RT_ETIMEOUT; + + return -RT_ETIMEOUT; + } + + RT_DEBUG_NOT_IN_INTERRUPT; + /* suspend current thread */ + rt_ipc_list_suspend(&(mb->parent.suspend_thread), + thread, + mb->parent.parent.flag); + + /* has waiting time, start thread timer */ + if (timeout > 0) + { + /* get the start tick of timer */ + tick_delta = rt_tick_get(); + + RT_DEBUG_LOG(RT_DEBUG_IPC, ("mb_recv: start timer of thread:%s\n", thread->name)); - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout); - rt_timer_start(&(thread->thread_timer)); - } + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &timeout); + rt_timer_start(&(thread->thread_timer)); + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - /* re-schedule */ - rt_schedule(); + /* re-schedule */ + rt_schedule(); - /* resume from suspend state */ - if (thread->error != RT_EOK) - { - /* return error */ - return thread->error; - } + /* resume from suspend state */ + if (thread->error != RT_EOK) + { + /* return error */ + return thread->error; + } - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - /* if it's not waiting forever and then re-calculate timeout tick */ - if (timeout > 0) - { - tick_delta = rt_tick_get() - tick_delta; - timeout -= tick_delta; - if (timeout < 0) - timeout = 0; - } - } + /* if it's not waiting forever and then re-calculate timeout tick */ + if (timeout > 0) + { + tick_delta = rt_tick_get() - tick_delta; + timeout -= tick_delta; + if (timeout < 0) + timeout = 0; + } + } - /* fill ptr */ - *value = mb->msg_pool[mb->out_offset]; + /* fill ptr */ + *value = mb->msg_pool[mb->out_offset]; - /* increase output offset */ - ++ mb->out_offset; - if (mb->out_offset >= mb->size) - mb->out_offset = 0; - /* decrease message entry */ - mb->entry --; + /* increase output offset */ + ++ mb->out_offset; + if (mb->out_offset >= mb->size) + mb->out_offset = 0; + /* decrease message entry */ + mb->entry --; - /* resume suspended thread */ - if (!rt_list_isempty(&(mb->suspend_sender_thread))) - { - rt_ipc_list_resume(&(mb->suspend_sender_thread)); + /* resume suspended thread */ + if (!rt_list_isempty(&(mb->suspend_sender_thread))) + { + rt_ipc_list_resume(&(mb->suspend_sender_thread)); - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent))); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent))); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mb_recv); @@ -1624,33 +1665,33 @@ RTM_EXPORT(rt_mb_recv); */ rt_err_t rt_mb_control(rt_mailbox_t mb, rt_uint8_t cmd, void *arg) { - rt_ubase_t level; - RT_ASSERT(mb != RT_NULL); + rt_ubase_t level; + RT_ASSERT(mb != RT_NULL); - if (cmd == RT_IPC_CMD_RESET) - { - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + if (cmd == RT_IPC_CMD_RESET) + { + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* resume all waiting thread */ - rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); - /* also resume all mailbox private suspended thread */ - rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); + /* resume all waiting thread */ + rt_ipc_list_resume_all(&(mb->parent.suspend_thread)); + /* also resume all mailbox private suspended thread */ + rt_ipc_list_resume_all(&(mb->suspend_sender_thread)); - /* re-init mailbox */ - mb->entry = 0; - mb->in_offset = 0; - mb->out_offset = 0; + /* re-init mailbox */ + mb->entry = 0; + mb->in_offset = 0; + mb->out_offset = 0; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - return -RT_ERROR; + return -RT_ERROR; } RTM_EXPORT(rt_mb_control); #endif /* end of RT_USING_MAILBOX */ @@ -1658,12 +1699,12 @@ RTM_EXPORT(rt_mb_control); #ifdef RT_USING_MESSAGEQUEUE struct rt_mq_message { - struct rt_mq_message *next; + struct rt_mq_message *next; }; /** - * This function will initialize a message queue and put it under control of resource - * management. + * This function will initialize a message queue and put it under control of + * resource management. * * @param mq the message object * @param name the name of message queue @@ -1674,48 +1715,53 @@ struct rt_mq_message * * @return the operation status, RT_EOK on successful */ -rt_err_t rt_mq_init(rt_mq_t mq, const char *name, void *msgpool, rt_size_t msg_size, rt_size_t pool_size, rt_uint8_t flag) +rt_err_t rt_mq_init(rt_mq_t mq, + const char *name, + void *msgpool, + rt_size_t msg_size, + rt_size_t pool_size, + rt_uint8_t flag) { - struct rt_mq_message *head; - register rt_base_t temp; + struct rt_mq_message *head; + register rt_base_t temp; - /* parameter check */ - RT_ASSERT(mq != RT_NULL); + /* parameter check */ + RT_ASSERT(mq != RT_NULL); - /* init object */ - rt_object_init(&(mq->parent.parent), RT_Object_Class_MessageQueue, name); + /* init object */ + rt_object_init(&(mq->parent.parent), RT_Object_Class_MessageQueue, name); - /* set parent flag */ - mq->parent.parent.flag = flag; + /* set parent flag */ + mq->parent.parent.flag = flag; - /* init ipc object */ - rt_ipc_object_init(&(mq->parent)); + /* init ipc object */ + rt_ipc_object_init(&(mq->parent)); - /* set messasge pool */ - mq->msg_pool = msgpool; + /* set messasge pool */ + mq->msg_pool = msgpool; - /* get correct message size */ - mq->msg_size = RT_ALIGN(msg_size, RT_ALIGN_SIZE); - mq->max_msgs = pool_size / (mq->msg_size + sizeof(struct rt_mq_message)); + /* get correct message size */ + mq->msg_size = RT_ALIGN(msg_size, RT_ALIGN_SIZE); + mq->max_msgs = pool_size / (mq->msg_size + sizeof(struct rt_mq_message)); - /* init message list */ - mq->msg_queue_head = RT_NULL; - mq->msg_queue_tail = RT_NULL; + /* init message list */ + mq->msg_queue_head = RT_NULL; + mq->msg_queue_tail = RT_NULL; - /* init message empty list */ - mq->msg_queue_free = RT_NULL; - 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))); - head->next = mq->msg_queue_free; - mq->msg_queue_free = head; - } + /* init message empty list */ + mq->msg_queue_free = RT_NULL; + 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))); + head->next = mq->msg_queue_free; + mq->msg_queue_free = head; + } - /* the initial entry is zero */ - mq->entry = 0; + /* the initial entry is zero */ + mq->entry = 0; - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mq_init); @@ -1728,16 +1774,16 @@ RTM_EXPORT(rt_mq_init); */ rt_err_t rt_mq_detach(rt_mq_t mq) { - /* parameter check */ - RT_ASSERT(mq != RT_NULL); + /* parameter check */ + RT_ASSERT(mq != RT_NULL); - /* resume all suspended thread */ - rt_ipc_list_resume_all(&mq->parent.suspend_thread); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&mq->parent.suspend_thread); - /* detach message queue object */ - rt_object_detach(&(mq->parent.parent)); + /* detach message queue object */ + rt_object_detach(&(mq->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mq_detach); @@ -1752,58 +1798,61 @@ RTM_EXPORT(rt_mq_detach); * * @return the created message queue, RT_NULL on error happen */ -rt_mq_t rt_mq_create(const char *name, rt_size_t msg_size, rt_size_t max_msgs, rt_uint8_t flag) +rt_mq_t rt_mq_create(const char *name, + rt_size_t msg_size, + rt_size_t max_msgs, + rt_uint8_t flag) { - struct rt_messagequeue *mq; - struct rt_mq_message *head; - register rt_base_t temp; - - RT_DEBUG_NOT_IN_INTERRUPT; - - /* allocate object */ - mq = (rt_mq_t)rt_object_allocate(RT_Object_Class_MessageQueue, name); - if (mq == RT_NULL) - return mq; - - /* set parent */ - mq->parent.parent.flag = flag; - - /* init ipc object */ - rt_ipc_object_init(&(mq->parent)); - - /* init message queue */ - - /* get correct message size */ - mq->msg_size = RT_ALIGN(msg_size, RT_ALIGN_SIZE); - mq->max_msgs = max_msgs; - - /* allocate message pool */ - mq->msg_pool = rt_malloc((mq->msg_size + sizeof(struct rt_mq_message))* mq->max_msgs); - if (mq->msg_pool == RT_NULL) - { - rt_mq_delete(mq); - - return RT_NULL; - } - - /* init message list */ - mq->msg_queue_head = RT_NULL; - mq->msg_queue_tail = RT_NULL; - - /* init message empty list */ - mq->msg_queue_free = RT_NULL; - 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))); - head->next = mq->msg_queue_free; - mq->msg_queue_free = head; - } - - /* the initial entry is zero */ - mq->entry = 0; - - return mq; + struct rt_messagequeue *mq; + struct rt_mq_message *head; + register rt_base_t temp; + + RT_DEBUG_NOT_IN_INTERRUPT; + + /* allocate object */ + mq = (rt_mq_t)rt_object_allocate(RT_Object_Class_MessageQueue, name); + if (mq == RT_NULL) + return mq; + + /* set parent */ + mq->parent.parent.flag = flag; + + /* init ipc object */ + rt_ipc_object_init(&(mq->parent)); + + /* init message queue */ + + /* get correct message size */ + mq->msg_size = RT_ALIGN(msg_size, RT_ALIGN_SIZE); + mq->max_msgs = max_msgs; + + /* allocate message pool */ + mq->msg_pool = rt_malloc((mq->msg_size + sizeof(struct rt_mq_message))* mq->max_msgs); + if (mq->msg_pool == RT_NULL) + { + rt_mq_delete(mq); + + return RT_NULL; + } + + /* init message list */ + mq->msg_queue_head = RT_NULL; + mq->msg_queue_tail = RT_NULL; + + /* init message empty list */ + mq->msg_queue_free = RT_NULL; + 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))); + head->next = mq->msg_queue_free; + mq->msg_queue_free = head; + } + + /* the initial entry is zero */ + mq->entry = 0; + + return mq; } RTM_EXPORT(rt_mq_create); @@ -1816,35 +1865,35 @@ RTM_EXPORT(rt_mq_create); */ rt_err_t rt_mq_delete(rt_mq_t mq) { - RT_DEBUG_NOT_IN_INTERRUPT; + RT_DEBUG_NOT_IN_INTERRUPT; - /* parameter check */ - RT_ASSERT(mq != RT_NULL); + /* parameter check */ + RT_ASSERT(mq != RT_NULL); - /* resume all suspended thread */ - rt_ipc_list_resume_all(&(mq->parent.suspend_thread)); + /* resume all suspended thread */ + rt_ipc_list_resume_all(&(mq->parent.suspend_thread)); #if defined(RT_USING_MODULE) && defined(RT_USING_SLAB) - /* the mq object belongs to an application module */ - if (mq->parent.parent.flag & RT_OBJECT_FLAG_MODULE) - rt_module_free(mq->parent.parent.module_id, mq->msg_pool); - else + /* the mq object belongs to an application module */ + if (mq->parent.parent.flag & RT_OBJECT_FLAG_MODULE) + rt_module_free(mq->parent.parent.module_id, mq->msg_pool); + else #endif - /* free message queue pool */ - rt_free(mq->msg_pool); + /* free message queue pool */ + rt_free(mq->msg_pool); - /* delete message queue object */ - rt_object_delete(&(mq->parent.parent)); + /* delete message queue object */ + rt_object_delete(&(mq->parent.parent)); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mq_delete); #endif /** - * This function will send a message to message queue object, if there are threads - * suspended on message queue object, it will be waked up. + * This function will send a message to message queue object, if there are + * threads suspended on message queue object, it will be waked up. * * @param mq the message queue object * @param buffer the message @@ -1854,85 +1903,85 @@ RTM_EXPORT(rt_mq_delete); */ rt_err_t rt_mq_send(rt_mq_t mq, void *buffer, rt_size_t size) { - register rt_ubase_t temp; - struct rt_mq_message *msg; - - RT_ASSERT(mq != RT_NULL); - RT_ASSERT(buffer != RT_NULL); - RT_ASSERT(size != 0); - - /* greater than one message size */ - if (size > mq->msg_size) - return -RT_ERROR; - - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent))); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* get a free list, there must be an empty item */ - msg = (struct rt_mq_message*)mq->msg_queue_free; - /* message queue is full */ - if (msg == RT_NULL) - { - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return -RT_EFULL; - } - /* move free list pointer */ - mq->msg_queue_free = msg->next; - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - /* the msg is the new tailer of list, the next shall be NULL */ - msg->next = RT_NULL; - /* copy buffer */ - rt_memcpy(msg + 1, buffer, size); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - /* link msg to message queue */ - if (mq->msg_queue_tail != RT_NULL) - { - /* if the tail exists, */ - ((struct rt_mq_message *)mq->msg_queue_tail)->next = msg; - } - - /* set new tail */ - mq->msg_queue_tail = msg; - /* if the head is empty, set head */ - if (mq->msg_queue_head == RT_NULL) - mq->msg_queue_head = msg; - - /* increase message entry */ - mq->entry ++; - - /* resume suspended thread */ - if (!rt_list_isempty(&mq->parent.suspend_thread)) - { - rt_ipc_list_resume(&(mq->parent.suspend_thread)); - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - rt_schedule(); - - return RT_EOK; - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - return RT_EOK; + register rt_ubase_t temp; + struct rt_mq_message *msg; + + RT_ASSERT(mq != RT_NULL); + RT_ASSERT(buffer != RT_NULL); + RT_ASSERT(size != 0); + + /* greater than one message size */ + if (size > mq->msg_size) + return -RT_ERROR; + + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent))); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* get a free list, there must be an empty item */ + msg = (struct rt_mq_message*)mq->msg_queue_free; + /* message queue is full */ + if (msg == RT_NULL) + { + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return -RT_EFULL; + } + /* move free list pointer */ + mq->msg_queue_free = msg->next; + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + /* the msg is the new tailer of list, the next shall be NULL */ + msg->next = RT_NULL; + /* copy buffer */ + rt_memcpy(msg + 1, buffer, size); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + /* link msg to message queue */ + if (mq->msg_queue_tail != RT_NULL) + { + /* if the tail exists, */ + ((struct rt_mq_message *)mq->msg_queue_tail)->next = msg; + } + + /* set new tail */ + mq->msg_queue_tail = msg; + /* if the head is empty, set head */ + if (mq->msg_queue_head == RT_NULL) + mq->msg_queue_head = msg; + + /* increase message entry */ + mq->entry ++; + + /* resume suspended thread */ + if (!rt_list_isempty(&mq->parent.suspend_thread)) + { + rt_ipc_list_resume(&(mq->parent.suspend_thread)); + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + rt_schedule(); + + return RT_EOK; + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + return RT_EOK; } RTM_EXPORT(rt_mq_send); /** - * This function will send urgently a message to message queue object, which means - * the message will be inserted to the head of message queue. If there are threads - * suspended on message queue object, it will be waked up. + * This function will send an urgent message to message queue object, which + * means the message will be inserted to the head of message queue. If there + * are threads suspended on message queue object, it will be waked up. * * @param mq the message queue object * @param buffer the message @@ -1942,78 +1991,79 @@ RTM_EXPORT(rt_mq_send); */ rt_err_t rt_mq_urgent(rt_mq_t mq, void *buffer, rt_size_t size) { - register rt_ubase_t temp; - struct rt_mq_message *msg; + register rt_ubase_t temp; + struct rt_mq_message *msg; - RT_ASSERT(mq != RT_NULL); - RT_ASSERT(buffer != RT_NULL); - RT_ASSERT(size != 0); + RT_ASSERT(mq != RT_NULL); + RT_ASSERT(buffer != RT_NULL); + RT_ASSERT(size != 0); - /* greater than one message size */ - if (size > mq->msg_size) - return -RT_ERROR; + /* greater than one message size */ + if (size > mq->msg_size) + return -RT_ERROR; - RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent))); + RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent))); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - /* get a free list, there must be an empty item */ - msg = (struct rt_mq_message *)mq->msg_queue_free; - /* message queue is full */ - if (msg == RT_NULL) - { - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* get a free list, there must be an empty item */ + msg = (struct rt_mq_message *)mq->msg_queue_free; + /* message queue is full */ + if (msg == RT_NULL) + { + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - return -RT_EFULL; - } - /* move free list pointer */ - mq->msg_queue_free = msg->next; + return -RT_EFULL; + } + /* move free list pointer */ + mq->msg_queue_free = msg->next; - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - /* copy buffer */ - rt_memcpy(msg + 1, buffer, size); + /* copy buffer */ + rt_memcpy(msg + 1, buffer, size); - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); - /* link msg to the beginning of message queue */ - msg->next = mq->msg_queue_head; - mq->msg_queue_head = msg; + /* link msg to the beginning of message queue */ + msg->next = mq->msg_queue_head; + mq->msg_queue_head = msg; - /* if there is no tail */ - if (mq->msg_queue_tail == RT_NULL) - mq->msg_queue_tail = msg; + /* if there is no tail */ + if (mq->msg_queue_tail == RT_NULL) + mq->msg_queue_tail = msg; - /* increase message entry */ - mq->entry ++; + /* increase message entry */ + mq->entry ++; - /* resume suspended thread */ - if (!rt_list_isempty(&mq->parent.suspend_thread)) - { - rt_ipc_list_resume(&(mq->parent.suspend_thread)); + /* resume suspended thread */ + if (!rt_list_isempty(&mq->parent.suspend_thread)) + { + rt_ipc_list_resume(&(mq->parent.suspend_thread)); - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - /* enable interrupt */ - rt_hw_interrupt_enable(temp); + /* enable interrupt */ + rt_hw_interrupt_enable(temp); - return RT_EOK; + return RT_EOK; } RTM_EXPORT(rt_mq_urgent); /** - * This function will receive a message from message queue object, if there is no - * message in message queue object, the thread shall wait for a specified time. + * This function will receive a message from message queue object, if there is + * no message in message queue object, the thread shall wait for a specified + * time. * * @param mq the message queue object * @param buffer the received message will be saved in @@ -2022,130 +2072,138 @@ RTM_EXPORT(rt_mq_urgent); * * @return the error code */ -rt_err_t rt_mq_recv(rt_mq_t mq, void *buffer, rt_size_t size, rt_int32_t timeout) +rt_err_t rt_mq_recv(rt_mq_t mq, + void *buffer, + rt_size_t size, + rt_int32_t timeout) { - struct rt_thread *thread; - register rt_ubase_t temp; - struct rt_mq_message *msg; - rt_uint32_t tick_delta; - - RT_ASSERT(mq != RT_NULL); - RT_ASSERT(buffer != RT_NULL); - RT_ASSERT(size != 0); - - /* initialize delta tick */ - tick_delta = 0; - /* get current thread */ - thread = rt_thread_self(); - RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mq->parent.parent))); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* for non-blocking call */ - if (mq->entry == 0 && timeout == 0) - { - rt_hw_interrupt_enable(temp); - - return -RT_ETIMEOUT; - } - - /* message queue is empty */ - while (mq->entry == 0) - { - RT_DEBUG_NOT_IN_INTERRUPT; - - /* reset error number in thread */ - thread->error = RT_EOK; - - /* no waiting, return timeout */ - if (timeout == 0) - { - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - thread->error = -RT_ETIMEOUT; - - return -RT_ETIMEOUT; - } - - /* suspend current thread */ - rt_ipc_list_suspend(&(mq->parent.suspend_thread), thread, mq->parent.parent.flag); - - /* has waiting time, start thread timer */ - if (timeout > 0) - { - /* get the start tick of timer */ - tick_delta = rt_tick_get(); - - RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n", + struct rt_thread *thread; + register rt_ubase_t temp; + struct rt_mq_message *msg; + rt_uint32_t tick_delta; + + RT_ASSERT(mq != RT_NULL); + RT_ASSERT(buffer != RT_NULL); + RT_ASSERT(size != 0); + + /* initialize delta tick */ + tick_delta = 0; + /* get current thread */ + thread = rt_thread_self(); + RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mq->parent.parent))); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* for non-blocking call */ + if (mq->entry == 0 && timeout == 0) + { + rt_hw_interrupt_enable(temp); + + return -RT_ETIMEOUT; + } + + /* message queue is empty */ + while (mq->entry == 0) + { + RT_DEBUG_NOT_IN_INTERRUPT; + + /* reset error number in thread */ + thread->error = RT_EOK; + + /* no waiting, return timeout */ + if (timeout == 0) + { + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + thread->error = -RT_ETIMEOUT; + + return -RT_ETIMEOUT; + } + + /* suspend current thread */ + rt_ipc_list_suspend(&(mq->parent.suspend_thread), + thread, + mq->parent.parent.flag); + + /* has waiting time, start thread timer */ + if (timeout > 0) + { + /* get the start tick of timer */ + tick_delta = rt_tick_get(); + + RT_DEBUG_LOG(RT_DEBUG_IPC, ("set thread:%s to timer list\n", thread->name)); - /* reset the timeout of thread timer and start it */ - rt_timer_control(&(thread->thread_timer), RT_TIMER_CTRL_SET_TIME, &timeout); - rt_timer_start(&(thread->thread_timer)); - } - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - /* re-schedule */ - rt_schedule(); - - /* recv message */ - if (thread->error != RT_EOK) - { - /* return error */ - return thread->error; - } - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - - /* if it's not waiting forever and then re-calculate timeout tick */ - if (timeout > 0) - { - tick_delta = rt_tick_get() - tick_delta; - timeout -= tick_delta; - if (timeout < 0) - timeout = 0; - } - } - - /* get message from queue */ - msg = (struct rt_mq_message *)mq->msg_queue_head; - - /* move message queue head */ - mq->msg_queue_head = msg->next; - /* reach queue tail, set to NULL */ - if (mq->msg_queue_tail == msg) - mq->msg_queue_tail = RT_NULL; - - /* decrease message entry */ - mq->entry --; - - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - /* copy message */ - rt_memcpy(buffer, msg + 1, size > mq->msg_size ? mq->msg_size : size); - - /* disable interrupt */ - temp = rt_hw_interrupt_disable(); - /* put message to free list */ - msg->next = (struct rt_mq_message *)mq->msg_queue_free; - mq->msg_queue_free = msg; - /* enable interrupt */ - rt_hw_interrupt_enable(temp); - - RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mq->parent.parent))); - - return RT_EOK; + /* reset the timeout of thread timer and start it */ + rt_timer_control(&(thread->thread_timer), + RT_TIMER_CTRL_SET_TIME, + &timeout); + rt_timer_start(&(thread->thread_timer)); + } + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + /* re-schedule */ + rt_schedule(); + + /* recv message */ + if (thread->error != RT_EOK) + { + /* return error */ + return thread->error; + } + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + + /* if it's not waiting forever and then re-calculate timeout tick */ + if (timeout > 0) + { + tick_delta = rt_tick_get() - tick_delta; + timeout -= tick_delta; + if (timeout < 0) + timeout = 0; + } + } + + /* get message from queue */ + msg = (struct rt_mq_message *)mq->msg_queue_head; + + /* move message queue head */ + mq->msg_queue_head = msg->next; + /* reach queue tail, set to NULL */ + if (mq->msg_queue_tail == msg) + mq->msg_queue_tail = RT_NULL; + + /* decrease message entry */ + mq->entry --; + + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + /* copy message */ + rt_memcpy(buffer, msg + 1, size > mq->msg_size ? mq->msg_size : size); + + /* disable interrupt */ + temp = rt_hw_interrupt_disable(); + /* put message to free list */ + msg->next = (struct rt_mq_message *)mq->msg_queue_free; + mq->msg_queue_free = msg; + /* enable interrupt */ + rt_hw_interrupt_enable(temp); + + RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mq->parent.parent))); + + return RT_EOK; } RTM_EXPORT(rt_mq_recv); /** - * This function can get or set some extra attributions of a message queue object. + * This function can get or set some extra attributions of a message queue + * object. * * @param mq the message queue object * @param cmd the execution command @@ -2155,50 +2213,50 @@ RTM_EXPORT(rt_mq_recv); */ rt_err_t rt_mq_control(rt_mq_t mq, rt_uint8_t cmd, void *arg) { - rt_ubase_t level; - struct rt_mq_message *msg; + rt_ubase_t level; + struct rt_mq_message *msg; - RT_ASSERT(mq != RT_NULL); + RT_ASSERT(mq != RT_NULL); - if (cmd == RT_IPC_CMD_RESET) - { - /* disable interrupt */ - level = rt_hw_interrupt_disable(); + if (cmd == RT_IPC_CMD_RESET) + { + /* disable interrupt */ + level = rt_hw_interrupt_disable(); - /* resume all waiting thread */ - rt_ipc_list_resume_all(&mq->parent.suspend_thread); + /* resume all waiting thread */ + rt_ipc_list_resume_all(&mq->parent.suspend_thread); - /* release all message in the queue */ - while (mq->msg_queue_head != RT_NULL) - { - /* get message from queue */ - msg = (struct rt_mq_message *)mq->msg_queue_head; + /* release all message in the queue */ + while (mq->msg_queue_head != RT_NULL) + { + /* get message from queue */ + msg = (struct rt_mq_message *)mq->msg_queue_head; - /* move message queue head */ - mq->msg_queue_head = msg->next; - /* reach queue tail, set to NULL */ - if (mq->msg_queue_tail == msg) - mq->msg_queue_tail = RT_NULL; + /* move message queue head */ + mq->msg_queue_head = msg->next; + /* reach queue tail, set to NULL */ + if (mq->msg_queue_tail == msg) + mq->msg_queue_tail = RT_NULL; - /* put message to free list */ - msg->next = (struct rt_mq_message *)mq->msg_queue_free; - mq->msg_queue_free = msg; - } + /* put message to free list */ + msg->next = (struct rt_mq_message *)mq->msg_queue_free; + mq->msg_queue_free = msg; + } - /* clean entry */ - mq->entry = 0; + /* clean entry */ + mq->entry = 0; - /* enable interrupt */ - rt_hw_interrupt_enable(level); + /* enable interrupt */ + rt_hw_interrupt_enable(level); - rt_schedule(); + rt_schedule(); - return RT_EOK; - } + return RT_EOK; + } - return -RT_ERROR; + return -RT_ERROR; } -RTM_EXPORT(rt_mq_control); +RTM_EXPORT(rt_mq_control); #endif /* end of RT_USING_MESSAGEQUEUE */ /*@}*/ -- GitLab