uniform code writing-disable interrupt

1 files changed, 83 insertions, 83 deletions

diff --git a/src/ipc.c b/src/ipc.c
index e7e92976e5..6fd9ce596b 100644
--- a/src/ipc.c
+++ b/src/ipc.c
@@ -220,13 +220,13 @@ rt_inline rt_err_t _ipc_list_resume(rt_list_t *list)
 rt_inline rt_err_t _ipc_list_resume_all(rt_list_t *list)
 {
     struct rt_thread *thread;
-    register rt_ubase_t temp;
+    rt_base_t level;
 
     /* wakeup all suspended threads */
     while (!rt_list_isempty(list))
     {
         /* disable interrupt */
-        temp = rt_hw_interrupt_disable();
+        level = rt_hw_interrupt_disable();
 
         /* get next suspended thread */
         thread = rt_list_entry(list->next, struct rt_thread, tlist);
@@ -241,7 +241,7 @@ rt_inline rt_err_t _ipc_list_resume_all(rt_list_t *list)
         rt_thread_resume(thread);
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
     }
 
     return RT_EOK;
@@ -483,7 +483,7 @@ RTM_EXPORT(rt_sem_delete);
  */
 rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout)
 {
-    register rt_base_t temp;
+    rt_base_t level;
     struct rt_thread *thread;
 
     /* parameter check */
@@ -493,7 +493,7 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout)
     RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(sem->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s take sem:%s, which value is: %d\n",
                                 rt_thread_self()->name,
@@ -506,14 +506,14 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout)
         sem->value --;
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
     }
     else
     {
         /* no waiting, return with timeout */
         if (timeout == 0)
         {
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             return -RT_ETIMEOUT;
         }
@@ -551,7 +551,7 @@ rt_err_t rt_sem_take(rt_sem_t sem, rt_int32_t timeout)
             }
 
             /* enable interrupt */
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             /* do schedule */
             rt_schedule();
@@ -605,7 +605,7 @@ RTM_EXPORT(rt_sem_trytake);
  */
 rt_err_t rt_sem_release(rt_sem_t sem)
 {
-    register rt_base_t temp;
+    rt_base_t level;
     register rt_bool_t need_schedule;
 
     /* parameter check */
@@ -617,7 +617,7 @@ rt_err_t rt_sem_release(rt_sem_t sem)
     need_schedule = RT_FALSE;
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     RT_DEBUG_LOG(RT_DEBUG_IPC, ("thread %s releases sem:%s, which value is: %d\n",
                                 rt_thread_self()->name,
@@ -638,13 +638,13 @@ rt_err_t rt_sem_release(rt_sem_t sem)
         }
         else
         {
-            rt_hw_interrupt_enable(temp); /* enable interrupt */
+            rt_hw_interrupt_enable(level); /* enable interrupt */
             return -RT_EFULL; /* value overflowed */
         }
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     /* resume a thread, re-schedule */
     if (need_schedule == RT_TRUE)
@@ -671,7 +671,7 @@ RTM_EXPORT(rt_sem_release);
  */
 rt_err_t rt_sem_control(rt_sem_t sem, int cmd, void *arg)
 {
-    rt_ubase_t level;
+    rt_base_t level;
 
     /* parameter check */
     RT_ASSERT(sem != RT_NULL);
@@ -913,7 +913,7 @@ RTM_EXPORT(rt_mutex_delete);
  */
 rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
 {
-    register rt_base_t temp;
+    rt_base_t level;
     struct rt_thread *thread;
 
     /* this function must not be used in interrupt even if time = 0 */
@@ -928,7 +928,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
     thread = rt_thread_self();
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mutex->parent.parent)));
 
@@ -948,7 +948,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
         }
         else
         {
-            rt_hw_interrupt_enable(temp); /* enable interrupt */
+            rt_hw_interrupt_enable(level); /* enable interrupt */
             return -RT_EFULL; /* value overflowed */
         }
     }
@@ -971,7 +971,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
             }
             else
             {
-                rt_hw_interrupt_enable(temp); /* enable interrupt */
+                rt_hw_interrupt_enable(level); /* enable interrupt */
                 return -RT_EFULL; /* value overflowed */
             }
         }
@@ -984,7 +984,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
                 thread->error = -RT_ETIMEOUT;
 
                 /* enable interrupt */
-                rt_hw_interrupt_enable(temp);
+                rt_hw_interrupt_enable(level);
 
                 return -RT_ETIMEOUT;
             }
@@ -1023,7 +1023,7 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
                 }
 
                 /* enable interrupt */
-                rt_hw_interrupt_enable(temp);
+                rt_hw_interrupt_enable(level);
 
                 /* do schedule */
                 rt_schedule();
@@ -1037,14 +1037,14 @@ rt_err_t rt_mutex_take(rt_mutex_t mutex, rt_int32_t timeout)
                 {
                     /* the mutex is taken successfully. */
                     /* disable interrupt */
-                    temp = rt_hw_interrupt_disable();
+                    level = rt_hw_interrupt_disable();
                 }
             }
         }
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mutex->parent.parent)));
 
@@ -1089,7 +1089,7 @@ RTM_EXPORT(rt_mutex_trytake);
  */
 rt_err_t rt_mutex_release(rt_mutex_t mutex)
 {
-    register rt_base_t temp;
+    rt_base_t level;
     struct rt_thread *thread;
     rt_bool_t need_schedule;
 
@@ -1106,7 +1106,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
     thread = rt_thread_self();
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     RT_DEBUG_LOG(RT_DEBUG_IPC,
                  ("mutex_release:current thread %s, mutex value: %d, hold: %d\n",
@@ -1120,7 +1120,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
         thread->error = -RT_ERROR;
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         return -RT_ERROR;
     }
@@ -1159,7 +1159,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
             }
             else
             {
-                rt_hw_interrupt_enable(temp); /* enable interrupt */
+                rt_hw_interrupt_enable(level); /* enable interrupt */
                 return -RT_EFULL; /* value overflowed */
             }
 
@@ -1177,7 +1177,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
             }
             else
             {
-                rt_hw_interrupt_enable(temp); /* enable interrupt */
+                rt_hw_interrupt_enable(level); /* enable interrupt */
                 return -RT_EFULL; /* value overflowed */
             }
 
@@ -1188,7 +1188,7 @@ rt_err_t rt_mutex_release(rt_mutex_t mutex)
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     /* perform a schedule */
     if (need_schedule == RT_TRUE)
@@ -1441,7 +1441,7 @@ 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;
+    rt_base_t level;
     register rt_base_t status;
     rt_bool_t need_schedule;
 
@@ -1569,7 +1569,7 @@ rt_err_t rt_event_recv(rt_event_t   event,
                        rt_uint32_t *recved)
 {
     struct rt_thread *thread;
-    register rt_ubase_t level;
+    rt_base_t level;
     register rt_base_t status;
 
     /* parameter check */
@@ -1702,7 +1702,7 @@ RTM_EXPORT(rt_event_recv);
  */
 rt_err_t rt_event_control(rt_event_t event, int cmd, void *arg)
 {
-    rt_ubase_t level;
+    rt_base_t level;
 
     /* parameter check */
     RT_ASSERT(event != RT_NULL);
@@ -1993,7 +1993,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
                          rt_int32_t   timeout)
 {
     struct rt_thread *thread;
-    register rt_ubase_t temp;
+    rt_base_t level;
     rt_uint32_t tick_delta;
 
     /* parameter check */
@@ -2011,12 +2011,12 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
     RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mb->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* for non-blocking call */
     if (mb->entry == mb->size && timeout == 0)
     {
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
         return -RT_EFULL;
     }
 
@@ -2030,7 +2030,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
         if (timeout == 0)
         {
             /* enable interrupt */
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             return -RT_EFULL;
         }
@@ -2057,7 +2057,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
         }
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         /* re-schedule */
         rt_schedule();
@@ -2070,7 +2070,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
         }
 
         /* disable interrupt */
-        temp = rt_hw_interrupt_disable();
+        level = rt_hw_interrupt_disable();
 
         /* if it's not waiting forever and then re-calculate timeout tick */
         if (timeout > 0)
@@ -2096,7 +2096,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
     }
     else
     {
-        rt_hw_interrupt_enable(temp); /* enable interrupt */
+        rt_hw_interrupt_enable(level); /* enable interrupt */
         return -RT_EFULL; /* value overflowed */
     }
 
@@ -2106,7 +2106,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
         _ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         rt_schedule();
 
@@ -2114,7 +2114,7 @@ rt_err_t rt_mb_send_wait(rt_mailbox_t mb,
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     return RT_EOK;
 }
@@ -2163,7 +2163,7 @@ RTM_EXPORT(rt_mb_send);
  */
 rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
 {
-    register rt_ubase_t temp;
+    rt_base_t level;
 
     /* parameter check */
     RT_ASSERT(mb != RT_NULL);
@@ -2172,11 +2172,11 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
     RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mb->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     if (mb->entry == mb->size)
     {
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
         return -RT_EFULL;
     }
 
@@ -2202,7 +2202,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
         _ipc_list_resume(&(mb->parent.suspend_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         rt_schedule();
 
@@ -2210,7 +2210,7 @@ rt_err_t rt_mb_urgent(rt_mailbox_t mb, rt_ubase_t value)
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     return RT_EOK;
 }
@@ -2238,7 +2238,7 @@ RTM_EXPORT(rt_mb_urgent);
 rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
 {
     struct rt_thread *thread;
-    register rt_ubase_t temp;
+    rt_base_t level;
     rt_uint32_t tick_delta;
 
     /* parameter check */
@@ -2256,12 +2256,12 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
     RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mb->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* for non-blocking call */
     if (mb->entry == 0 && timeout == 0)
     {
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         return -RT_ETIMEOUT;
     }
@@ -2276,7 +2276,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
         if (timeout == 0)
         {
             /* enable interrupt */
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             thread->error = -RT_ETIMEOUT;
 
@@ -2305,7 +2305,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
         }
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         /* re-schedule */
         rt_schedule();
@@ -2318,7 +2318,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
         }
 
         /* disable interrupt */
-        temp = rt_hw_interrupt_disable();
+        level = rt_hw_interrupt_disable();
 
         /* if it's not waiting forever and then re-calculate timeout tick */
         if (timeout > 0)
@@ -2350,7 +2350,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
         _ipc_list_resume(&(mb->suspend_sender_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent)));
 
@@ -2360,7 +2360,7 @@ rt_err_t rt_mb_recv(rt_mailbox_t mb, rt_ubase_t *value, rt_int32_t timeout)
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mb->parent.parent)));
 
@@ -2385,7 +2385,7 @@ RTM_EXPORT(rt_mb_recv);
  */
 rt_err_t rt_mb_control(rt_mailbox_t mb, int cmd, void *arg)
 {
-    rt_ubase_t level;
+    rt_base_t level;
 
     /* parameter check */
     RT_ASSERT(mb != RT_NULL);
@@ -2744,7 +2744,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
                          rt_size_t   size,
                          rt_int32_t  timeout)
 {
-    register rt_ubase_t temp;
+    rt_base_t level;
     struct rt_mq_message *msg;
     rt_uint32_t tick_delta;
     struct rt_thread *thread;
@@ -2770,7 +2770,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* get a free list, there must be an empty item */
     msg = (struct rt_mq_message *)mq->msg_queue_free;
@@ -2778,7 +2778,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     if (msg == RT_NULL && timeout == 0)
     {
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         return -RT_EFULL;
     }
@@ -2793,7 +2793,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
         if (timeout == 0)
         {
             /* enable interrupt */
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             return -RT_EFULL;
         }
@@ -2820,7 +2820,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
         }
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         /* re-schedule */
         rt_schedule();
@@ -2833,7 +2833,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
         }
 
         /* disable interrupt */
-        temp = rt_hw_interrupt_disable();
+        level = rt_hw_interrupt_disable();
 
         /* if it's not waiting forever and then re-calculate timeout tick */
         if (timeout > 0)
@@ -2849,7 +2849,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     mq->msg_queue_free = msg->next;
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     /* the msg is the new tailer of list, the next shall be NULL */
     msg->next = RT_NULL;
@@ -2857,7 +2857,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     rt_memcpy(msg + 1, buffer, size);
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
     /* link msg to message queue */
     if (mq->msg_queue_tail != RT_NULL)
     {
@@ -2878,7 +2878,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     }
     else
     {
-        rt_hw_interrupt_enable(temp); /* enable interrupt */
+        rt_hw_interrupt_enable(level); /* enable interrupt */
         return -RT_EFULL; /* value overflowed */
     }
 
@@ -2888,7 +2888,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
         _ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         rt_schedule();
 
@@ -2896,7 +2896,7 @@ rt_err_t rt_mq_send_wait(rt_mq_t     mq,
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     return RT_EOK;
 }
@@ -2952,7 +2952,7 @@ RTM_EXPORT(rt_mq_send);
  */
 rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
 {
-    register rt_ubase_t temp;
+    rt_base_t level;
     struct rt_mq_message *msg;
 
     /* parameter check */
@@ -2968,7 +2968,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     RT_OBJECT_HOOK_CALL(rt_object_put_hook, (&(mq->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* get a free list, there must be an empty item */
     msg = (struct rt_mq_message *)mq->msg_queue_free;
@@ -2976,7 +2976,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     if (msg == RT_NULL)
     {
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         return -RT_EFULL;
     }
@@ -2984,13 +2984,13 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     mq->msg_queue_free = msg->next;
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     /* copy buffer */
     rt_memcpy(msg + 1, buffer, size);
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* link msg to the beginning of message queue */
     msg->next = (struct rt_mq_message *)mq->msg_queue_head;
@@ -3007,7 +3007,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     }
     else
     {
-        rt_hw_interrupt_enable(temp); /* enable interrupt */
+        rt_hw_interrupt_enable(level); /* enable interrupt */
         return -RT_EFULL; /* value overflowed */
     }
 
@@ -3017,7 +3017,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
         _ipc_list_resume(&(mq->parent.suspend_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         rt_schedule();
 
@@ -3025,7 +3025,7 @@ rt_err_t rt_mq_urgent(rt_mq_t mq, const void *buffer, rt_size_t size)
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     return RT_EOK;
 }
@@ -3064,7 +3064,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
                     rt_int32_t timeout)
 {
     struct rt_thread *thread;
-    register rt_ubase_t temp;
+    rt_base_t level;
     struct rt_mq_message *msg;
     rt_uint32_t tick_delta;
 
@@ -3084,12 +3084,12 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
     RT_OBJECT_HOOK_CALL(rt_object_trytake_hook, (&(mq->parent.parent)));
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
 
     /* for non-blocking call */
     if (mq->entry == 0 && timeout == 0)
     {
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         return -RT_ETIMEOUT;
     }
@@ -3104,7 +3104,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         if (timeout == 0)
         {
             /* enable interrupt */
-            rt_hw_interrupt_enable(temp);
+            rt_hw_interrupt_enable(level);
 
             thread->error = -RT_ETIMEOUT;
 
@@ -3133,7 +3133,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         }
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         /* re-schedule */
         rt_schedule();
@@ -3146,7 +3146,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         }
 
         /* disable interrupt */
-        temp = rt_hw_interrupt_disable();
+        level = rt_hw_interrupt_disable();
 
         /* if it's not waiting forever and then re-calculate timeout tick */
         if (timeout > 0)
@@ -3174,13 +3174,13 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     /* copy message */
     rt_memcpy(buffer, msg + 1, size > mq->msg_size ? mq->msg_size : size);
 
     /* disable interrupt */
-    temp = rt_hw_interrupt_disable();
+    level = rt_hw_interrupt_disable();
     /* put message to free list */
     msg->next = (struct rt_mq_message *)mq->msg_queue_free;
     mq->msg_queue_free = msg;
@@ -3191,7 +3191,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
         _ipc_list_resume(&(mq->suspend_sender_thread));
 
         /* enable interrupt */
-        rt_hw_interrupt_enable(temp);
+        rt_hw_interrupt_enable(level);
 
         RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mq->parent.parent)));
 
@@ -3201,7 +3201,7 @@ rt_err_t rt_mq_recv(rt_mq_t    mq,
     }
 
     /* enable interrupt */
-    rt_hw_interrupt_enable(temp);
+    rt_hw_interrupt_enable(level);
 
     RT_OBJECT_HOOK_CALL(rt_object_take_hook, (&(mq->parent.parent)));
 
@@ -3226,7 +3226,7 @@ RTM_EXPORT(rt_mq_recv);
  */
 rt_err_t rt_mq_control(rt_mq_t mq, int cmd, void *arg)
 {
-    rt_ubase_t level;
+    rt_base_t level;
     struct rt_mq_message *msg;
 
     /* parameter check */