Merge remote-tracking branch 'origin/master' into ci-format

kurisaW · kurisaW · commit 986f0f40df09 · 2025-09-24T21:26:54.000+08:00
diff --git a/bsp/allwinner/libraries/sunxi-hal/hal/source/sdmmc/osal/os/RT-Thread/os_timer.c b/bsp/allwinner/libraries/sunxi-hal/hal/source/sdmmc/osal/os/RT-Thread/os_timer.c
@@ -128,6 +128,7 @@ OS_Status OS_TimerStart(OS_Timer_t *timer)
 OS_Status OS_TimerChangePeriod(OS_Timer_t *timer, OS_Time_t periodMS)
 {
     rt_err_t ret;
+    rt_tick_t period_tick = rt_tick_from_millisecond(periodMS);
 
     OS_DBG("%s(), handle %p\n", __func__, timer->handle);
     OS_HANDLE_ASSERT(OS_TimerIsValid(timer), timer->handle);
@@ -139,7 +140,7 @@ OS_Status OS_TimerChangePeriod(OS_Timer_t *timer, OS_Time_t periodMS)
             return OS_FAIL;
         }
     }
-    ret = rt_timer_control(timer->handle, RT_TIMER_CTRL_SET_TIME, &periodMS);
+    ret = rt_timer_control(timer->handle, RT_TIMER_CTRL_SET_TIME, &period_tick);
     if (ret != RT_EOK) {
         OS_ERR("err %"OS_BASETYPE_F"\n", ret);
         return OS_FAIL;
diff --git a/bsp/allwinner/libraries/sunxi-hal/hal/source/usb/host/ehci-timer.c b/bsp/allwinner/libraries/sunxi-hal/hal/source/usb/host/ehci-timer.c
@@ -97,8 +97,8 @@ static unsigned long event_delays_ns[] = {
 static void ehci_enable_event(struct ehci_hcd *ehci, unsigned event,
         bool resched)
 {
-    unsigned long *timeout = &ehci->hr_timeouts[event];
-    unsigned long time_interval = 0;
+    rt_tick_t *timeout = &ehci->hr_timeouts[event];
+    rt_tick_t time_interval = 0;
 
     if (resched)
     {
diff --git a/bsp/allwinner/libraries/sunxi-hal/hal/source/usb/host/ehci.h b/bsp/allwinner/libraries/sunxi-hal/hal/source/usb/host/ehci.h
@@ -119,7 +119,7 @@ struct ehci_hcd {           /* one per controller */
     /* timing support */
     enum ehci_hrtimer_event next_hrtimer_event;
     unsigned                enabled_hrtimer_events;
-    unsigned long           hr_timeouts[EHCI_HRTIMER_NUM_EVENTS];
+    rt_tick_t               hr_timeouts[EHCI_HRTIMER_NUM_EVENTS];
     osal_timer_t            hrtimer;
 
     int         PSS_poll_count;
diff --git a/bsp/at91/at91sam9260/drivers/at91_mci.c b/bsp/at91/at91sam9260/drivers/at91_mci.c
@@ -430,7 +430,7 @@ static void at91_mci_process_next(struct at91_mci *mci)
  */
 static void at91_mci_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
 {
-    rt_uint32_t timeout = RT_TICK_PER_SECOND;
+    rt_tick_t timeout = RT_TICK_PER_SECOND;
     struct at91_mci *mci = host->private_data;
     mci->req = req;
     mci->current_status = REQ_ST_INIT;
diff --git a/bsp/at91/at91sam9g45/drivers/at91_mci.c b/bsp/at91/at91sam9g45/drivers/at91_mci.c
@@ -430,7 +430,7 @@ static void at91_mci_process_next(struct at91_mci *mci)
  */
 static void at91_mci_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
 {
-    rt_uint32_t timeout = RT_TICK_PER_SECOND;
+    rt_tick_t timeout = RT_TICK_PER_SECOND;
     struct at91_mci *mci = host->private_data;
     mci->req = req;
     mci->current_status = REQ_ST_INIT;
diff --git a/components/drivers/ipc/completion_mp.c b/components/drivers/ipc/completion_mp.c
@@ -242,10 +242,11 @@ static rt_err_t _comp_susp_thread(struct rt_completion *completion,
         /* start timer */
         if (timeout > 0)
         {
+            rt_tick_t timeout_tick = timeout;
             /* reset the timeout of thread timer and start it */
             rt_timer_control(&(thread->thread_timer),
                              RT_TIMER_CTRL_SET_TIME,
-                             &timeout);
+                             &timeout_tick);
             rt_timer_start(&(thread->thread_timer));
         }
 
diff --git a/components/drivers/ipc/completion_up.c b/components/drivers/ipc/completion_up.c
@@ -108,10 +108,11 @@ rt_err_t rt_completion_wait_flags(struct rt_completion *completion,
                 /* start timer */
                 if (timeout > 0)
                 {
+                    rt_tick_t timeout_tick = timeout;
                     /* reset the timeout of thread timer and start it */
                     rt_timer_control(&(thread->thread_timer),
                                      RT_TIMER_CTRL_SET_TIME,
-                                     &timeout);
+                                     &timeout_tick);
                     rt_timer_start(&(thread->thread_timer));
                 }
                 /* enable interrupt */
diff --git a/components/drivers/ipc/condvar.c b/components/drivers/ipc/condvar.c
@@ -47,7 +47,7 @@ static int _waitq_inqueue(rt_wqueue_t *queue, struct rt_wqueue_node *node,
         if (ret == RT_EOK)
         {
             rt_wqueue_add(queue, node);
-            if (timeout != RT_WAITING_FOREVER)
+            if (timeout != (rt_tick_t)RT_WAITING_FOREVER)
             {
                 rt_timer_control(timer, RT_TIMER_CTRL_SET_TIME, &timeout);
 
diff --git a/components/drivers/ipc/dataqueue.c b/components/drivers/ipc/dataqueue.c
@@ -129,10 +129,11 @@ rt_err_t rt_data_queue_push(struct rt_data_queue *queue,
             /* start timer */
             if (timeout > 0)
             {
+                rt_tick_t timeout_tick = timeout;
                 /* reset the timeout of thread timer and start it */
                 rt_timer_control(&(thread->thread_timer),
                                 RT_TIMER_CTRL_SET_TIME,
-                                &timeout);
+                                &timeout_tick);
                 rt_timer_start(&(thread->thread_timer));
             }
 
@@ -247,10 +248,11 @@ rt_err_t rt_data_queue_pop(struct rt_data_queue *queue,
             /* start timer */
             if (timeout > 0)
             {
+                rt_tick_t timeout_tick = timeout;
                 /* reset the timeout of thread timer and start it */
                 rt_timer_control(&(thread->thread_timer),
                                 RT_TIMER_CTRL_SET_TIME,
-                                &timeout);
+                                &timeout_tick);
                 rt_timer_start(&(thread->thread_timer));
             }
 
diff --git a/components/drivers/ipc/waitqueue.c b/components/drivers/ipc/waitqueue.c
@@ -198,7 +198,7 @@ void rt_wqueue_wakeup_all(rt_wqueue_t *queue, void *key)
  */
 static int _rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec, int suspend_flag)
 {
-    int tick;
+    rt_tick_t tick;
     rt_thread_t tid = rt_thread_self();
     rt_timer_t  tmr = &(tid->thread_timer);
     struct rt_wqueue_node __wait;
@@ -241,7 +241,7 @@ static int _rt_wqueue_wait(rt_wqueue_t *queue, int condition, int msec, int susp
     rt_list_insert_before(&(queue->waiting_list), &(__wait.list));
 
     /* start timer */
-    if (tick != RT_WAITING_FOREVER)
+    if (tick != (rt_tick_t)RT_WAITING_FOREVER)
     {
         rt_timer_control(tmr,
                          RT_TIMER_CTRL_SET_TIME,
diff --git a/components/libc/posix/io/epoll/epoll.c b/components/libc/posix/io/epoll/epoll.c
@@ -700,9 +700,10 @@ static int epoll_wait_timeout(struct rt_eventpoll *ep, int msec)
         {
             if (timeout > 0)
             {
+                rt_tick_t timeout_tick = timeout;
                 rt_timer_control(&(thread->thread_timer),
                         RT_TIMER_CTRL_SET_TIME,
-                        &timeout);
+                        &timeout_tick);
                 rt_timer_start(&(thread->thread_timer));
             }
 
diff --git a/components/libc/posix/io/poll/poll.c b/components/libc/posix/io/poll/poll.c
@@ -23,15 +23,15 @@
 #include "poll.h"
 
 
-enum rt_poll_status 
+enum rt_poll_status
 {
     RT_POLL_STAT_INIT,     /**< Poll operation initialization status. */
     RT_POLL_STAT_TRIG,     /**< Poll operation triggered status. */
     RT_POLL_STAT_WAITING   /**< Poll operation waiting status. */
 };
 
 
-struct rt_poll_table 
+struct rt_poll_table
 {
     rt_pollreq_t req;               /**< Poll request. */
     enum rt_poll_status status;     /**< Status of the poll operation. */
@@ -40,7 +40,7 @@ struct rt_poll_table
 };
 
 
-struct rt_poll_node 
+struct rt_poll_node
 {
     struct rt_wqueue_node wqn;     /**< Wait queue node for the poll node. */
     struct rt_poll_table *pt;       /**< Pointer to the parent poll table. */
@@ -158,9 +158,10 @@ static int poll_wait_timeout(struct rt_poll_table *pt, int msec)
         {
             if (timeout > 0)
             {
+                rt_tick_t timeout_tick = timeout;
                 rt_timer_control(&(thread->thread_timer),
                         RT_TIMER_CTRL_SET_TIME,
-                        &timeout);
+                        &timeout_tick);
                 rt_timer_start(&(thread->thread_timer));
                 rt_set_errno(RT_ETIMEOUT);
             }
diff --git a/components/libc/posix/pthreads/pthread_cond.c b/components/libc/posix/pthreads/pthread_cond.c
@@ -418,10 +418,11 @@ rt_err_t _pthread_cond_timedwait(pthread_cond_t *cond,
                 /* has waiting time, start thread timer */
                 if (time > 0)
                 {
+                    rt_tick_t time_tick = time;
                     /* reset the timeout of thread timer and start it */
                     rt_timer_control(&(thread->thread_timer),
                                      RT_TIMER_CTRL_SET_TIME,
-                                     &time);
+                                     &time_tick);
                     rt_timer_start(&(thread->thread_timer));
                 }
 
diff --git a/components/lwp/lwp_ipc.c b/components/lwp/lwp_ipc.c
@@ -553,6 +553,7 @@ static rt_err_t _do_send_recv_timeout(rt_channel_t ch, rt_channel_msg_t data, in
                 rt_thread_wakeup_set(thread_send, wakeup_sender_wait_recv, (void *)ch);
                 if (time > 0)
                 {
+                    rt_tick_t time_tick = time;
                     rt_timer_control(&(thread_send->thread_timer),
                                      RT_TIMER_CTRL_GET_FUNC,
                                      &old_timeout_func);
@@ -562,7 +563,7 @@ static rt_err_t _do_send_recv_timeout(rt_channel_t ch, rt_channel_msg_t data, in
                     /* reset the timeout of thread timer and start it */
                     rt_timer_control(&(thread_send->thread_timer),
                                      RT_TIMER_CTRL_SET_TIME,
-                                     &time);
+                                     &time_tick);
                     rt_timer_start(&(thread_send->thread_timer));
                 }
             }
@@ -597,6 +598,7 @@ static rt_err_t _do_send_recv_timeout(rt_channel_t ch, rt_channel_msg_t data, in
                 rt_thread_wakeup_set(thread_send, wakeup_sender_wait_reply, (void *)ch);
                 if (time > 0)
                 {
+                    rt_tick_t time_tick = time;
                     rt_timer_control(&(thread_send->thread_timer),
                                      RT_TIMER_CTRL_GET_FUNC,
                                      &old_timeout_func);
@@ -606,7 +608,7 @@ static rt_err_t _do_send_recv_timeout(rt_channel_t ch, rt_channel_msg_t data, in
                     /* reset the timeout of thread timer and start it */
                     rt_timer_control(&(thread_send->thread_timer),
                                      RT_TIMER_CTRL_SET_TIME,
-                                     &time);
+                                     &time_tick);
                     rt_timer_start(&(thread_send->thread_timer));
                 }
             }
@@ -870,6 +872,7 @@ static rt_err_t _rt_raw_channel_recv_timeout(rt_channel_t ch, rt_channel_msg_t d
                 thread->error = RT_EOK;
                 if (time > 0)
                 {
+                    rt_tick_t time_tick = time;
                     rt_timer_control(&(thread->thread_timer),
                                      RT_TIMER_CTRL_GET_FUNC,
                                      &old_timeout_func);
@@ -879,7 +882,7 @@ static rt_err_t _rt_raw_channel_recv_timeout(rt_channel_t ch, rt_channel_msg_t d
                     /* reset the timeout of thread timer and start it */
                     rt_timer_control(&(thread->thread_timer),
                                      RT_TIMER_CTRL_SET_TIME,
-                                     &time);
+                                     &time_tick);
                     rt_timer_start(&(thread->thread_timer));
                 }
                 rt_spin_unlock_irqrestore(&ch->slock, level);
diff --git a/components/lwp/lwp_tid.c b/components/lwp/lwp_tid.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2006-2021, RT-Thread Development Team
+ * Copyright (c) 2006-2025 RT-Thread Development Team
  *
  * SPDX-License-Identifier: Apache-2.0
  *
@@ -38,11 +38,29 @@ static int current_tid = 0;
 
 static struct rt_mutex tid_lock;
 
+/**
+ * @brief Initialize the thread ID manager
+ *
+ * @return int Returns RT_EOK (0) on success, error code on failure
+ *
+ * @note This function initializes a mutex lock used for thread ID management.
+ */
 int lwp_tid_init(void)
 {
     return rt_mutex_init(&tid_lock, "tidmtx", RT_IPC_FLAG_PRIO);
 }
 
+/**
+ * @brief Allocates a thread ID (TID) from available resources
+ *
+ * @return int The allocated thread ID, or 0 if no TID available (with warning log)
+ *
+ * @note This function performs thread-safe allocation of a TID by:
+ *       1. First checking the free list of available TIDs
+ *       2. If none available, allocating from the TID array if space remains
+ *       3. Performing a two-phase search for unused TIDs (current_tid+1 to TID_MAX, then 1 to current_tid)
+ *       4. Inserting the allocated TID into the AVL tree for tracking
+ */
 int lwp_tid_get(void)
 {
     struct lwp_avl_struct *p;
@@ -97,6 +115,16 @@ int lwp_tid_get(void)
     return tid;
 }
 
+/**
+ * @brief Releases a thread ID (TID) and associated resources
+ *
+ * @param[in] tid The thread ID to release
+ *
+ * @note  This function performs thread-safe release of a TID by:
+ *        1. Finding the TID in the AVL tree and removing it
+ *        2. Adding the freed TID structure to the free list for reuse
+ *        3. Handling thread reference counting and potential suspension
+ */
 void lwp_tid_put(int tid)
 {
     struct lwp_avl_struct *p;
@@ -133,6 +161,13 @@ void lwp_tid_put(int tid)
         lwp_mutex_release_safe(&tid_lock);
 }
 
+/**
+ * @brief Retrieves the thread object associated with a thread ID (TID)
+ *
+ * @param[in] tid The thread ID to look up
+ *
+ * @return rt_thread_t The associated thread object, or RT_NULL if not found
+ */
 rt_thread_t lwp_tid_get_thread_raw(int tid)
 {
     struct lwp_avl_struct *p;
@@ -146,6 +181,19 @@ rt_thread_t lwp_tid_get_thread_raw(int tid)
     return thread;
 }
 
+/**
+ * @brief Retrieves a thread object by TID and increments its reference count
+ *
+ * @param[in] tid The thread ID to look up (0 means current thread)
+ *
+ * @return rt_thread_t The associated thread object, or RT_NULL if not found
+ *
+ * @note This function provides thread-safe access to a thread object while:
+ *       1. Acquiring the tid_lock mutex for synchronization
+ *       2. Looking up the thread by TID (or returning current thread if tid=0)
+ *       3. Incrementing the thread's reference count if found
+ *       4. Releasing the mutex before returning
+ */
 rt_thread_t lwp_tid_get_thread_and_inc_ref(int tid)
 {
     rt_thread_t thread = RT_NULL;
@@ -160,6 +208,15 @@ rt_thread_t lwp_tid_get_thread_and_inc_ref(int tid)
     return thread;
 }
 
+/**
+ * @brief Decrement the reference count of a thread and potentially resume its suspender
+ *
+ * @param[in] thread The thread object whose reference count needs to be decremented
+ *
+ * @note This function safely decreases the reference count of a thread object. If the reference
+ *       count reaches zero and there is a suspender thread waiting (susp_recycler), it will
+ *       be resumed.
+ */
 void lwp_tid_dec_ref(rt_thread_t thread)
 {
     rt_thread_t susp_putter;
@@ -179,6 +236,15 @@ void lwp_tid_dec_ref(rt_thread_t thread)
     }
 }
 
+/**
+ * @brief Associate a thread with a given TID in the thread ID management system
+ *
+ * @param[in] tid The thread ID to associate with the thread
+ * @param[in] thread The thread object to be associated with the TID
+ *
+ * @note This function safely associates a thread object with a specified thread ID (TID)
+ *       in the system's AVL tree. The operation is protected by a mutex to ensure thread safety.
+ */
 void lwp_tid_set_thread(int tid, rt_thread_t thread)
 {
     struct lwp_avl_struct *p;
diff --git a/components/utilities/rt-link/src/rtlink.c b/components/utilities/rt-link/src/rtlink.c
@@ -302,7 +302,7 @@ static rt_err_t rt_link_frame_send(rt_slist_t *slist)
     }
     else
     {
-        rt_int32_t timeout = RT_LINK_SENT_FRAME_TIMEOUT;
+        rt_tick_t timeout = RT_LINK_SENT_FRAME_TIMEOUT;
         rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
         rt_timer_start(&rt_link_scb->sendtimer);
     }
@@ -536,7 +536,7 @@ static void _long_handle_second(struct rt_link_frame *receive_frame)
         }
         else if (rt_link_hw_recv_len(rt_link_scb->rx_buffer) < (receive_frame->data_len % RT_LINK_MAX_DATA_LENGTH))
         {
-            rt_int32_t timeout = RT_LINK_LONG_FRAME_TIMEOUT;
+            rt_tick_t timeout = RT_LINK_LONG_FRAME_TIMEOUT;
             rt_timer_control(&rt_link_scb->longframetimer, RT_TIMER_CTRL_SET_TIME, &timeout);
             rt_timer_start(&rt_link_scb->longframetimer);
         }
@@ -879,7 +879,7 @@ static void rt_link_send_ready(void)
         rt_link_command_frame_send(RT_LINK_SERVICE_RTLINK, seq,
                                    RT_LINK_HANDSHAKE_FRAME, rt_link_scb->rx_record.rx_seq);
 
-        rt_int32_t timeout = 50;
+        rt_tick_t timeout = 50;
         rt_timer_control(&rt_link_scb->sendtimer, RT_TIMER_CTRL_SET_TIME, &timeout);
         rt_timer_start(&rt_link_scb->sendtimer);
     }
diff --git a/components/vbus/prio_queue.c b/components/vbus/prio_queue.c
diff --git a/components/vbus/vbus.c b/components/vbus/vbus.c
diff --git a/components/vbus/watermark_queue.h b/components/vbus/watermark_queue.h
diff --git a/examples/utest/testcases/kernel/timer_tc.c b/examples/utest/testcases/kernel/timer_tc.c
diff --git a/src/ipc.c b/src/ipc.c
diff --git a/src/mempool.c b/src/mempool.c
diff --git a/src/signal.c b/src/signal.c

Original file line number	Diff line number	Diff line change
`@@ -128,6 +128,7 @@ OS_Status OS_TimerStart(OS_Timer_t *timer)`
`128`	`128`	`OS_Status OS_TimerChangePeriod(OS_Timer_t *timer, OS_Time_t periodMS)`
`129`	`129`	`{`
`130`	`130`	`rt_err_t ret;`
	`131`	`+ rt_tick_t period_tick = rt_tick_from_millisecond(periodMS);`
`131`	`132`
`132`	`133`	`OS_DBG("%s(), handle %p\n", __func__, timer->handle);`
`133`	`134`	`OS_HANDLE_ASSERT(OS_TimerIsValid(timer), timer->handle);`
`@@ -139,7 +140,7 @@ OS_Status OS_TimerChangePeriod(OS_Timer_t *timer, OS_Time_t periodMS)`
`139`	`140`	`return OS_FAIL;`
`140`	`141`	`}`
`141`	`142`	`}`
`142`		`- ret = rt_timer_control(timer->handle, RT_TIMER_CTRL_SET_TIME, &periodMS);`
	`143`	`+ ret = rt_timer_control(timer->handle, RT_TIMER_CTRL_SET_TIME, &period_tick);`
`143`	`144`	`if (ret != RT_EOK) {`
`144`	`145`	`OS_ERR("err %"OS_BASETYPE_F"\n", ret);`
`145`	`146`	`return OS_FAIL;`
Original file line number	Diff line number	Diff line change
`@@ -97,8 +97,8 @@ static unsigned long event_delays_ns[] = {`
`97`	`97`	`static void ehci_enable_event(struct ehci_hcd *ehci, unsigned event,`
`98`	`98`	`bool resched)`
`99`	`99`	`{`
`100`		`- unsigned long *timeout = &ehci->hr_timeouts[event];`
`101`		`- unsigned long time_interval = 0;`
	`100`	`+ rt_tick_t *timeout = &ehci->hr_timeouts[event];`
	`101`	`+ rt_tick_t time_interval = 0;`
`102`	`102`
`103`	`103`	`if (resched)`
`104`	`104`	`{`
Original file line number	Diff line number	Diff line change
`@@ -430,7 +430,7 @@ static void at91_mci_process_next(struct at91_mci *mci)`
`430`	`430`	`*/`
`431`	`431`	`static void at91_mci_request(struct rt_mmcsd_host host, struct rt_mmcsd_req req)`
`432`	`432`	`{`
`433`		`- rt_uint32_t timeout = RT_TICK_PER_SECOND;`
	`433`	`+ rt_tick_t timeout = RT_TICK_PER_SECOND;`
`434`	`434`	`struct at91_mci *mci = host->private_data;`
`435`	`435`	`mci->req = req;`
`436`	`436`	`mci->current_status = REQ_ST_INIT;`
Original file line number	Diff line number	Diff line change
`@@ -242,10 +242,11 @@ static rt_err_t _comp_susp_thread(struct rt_completion *completion,`
`242`	`242`	`/* start timer */`
`243`	`243`	`if (timeout > 0)`
`244`	`244`	`{`
	`245`	`+ rt_tick_t timeout_tick = timeout;`
`245`	`246`	`/* reset the timeout of thread timer and start it */`
`246`	`247`	`rt_timer_control(&(thread->thread_timer),`
`247`	`248`	`RT_TIMER_CTRL_SET_TIME,`
`248`		`- &timeout);`
	`249`	`+ &timeout_tick);`
`249`	`250`	`rt_timer_start(&(thread->thread_timer));`
`250`	`251`	`}`
`251`	`252`
Original file line number	Diff line number	Diff line change
`@@ -108,10 +108,11 @@ rt_err_t rt_completion_wait_flags(struct rt_completion *completion,`
`108`	`108`	`/* start timer */`
`109`	`109`	`if (timeout > 0)`
`110`	`110`	`{`
	`111`	`+ rt_tick_t timeout_tick = timeout;`
`111`	`112`	`/* reset the timeout of thread timer and start it */`
`112`	`113`	`rt_timer_control(&(thread->thread_timer),`
`113`	`114`	`RT_TIMER_CTRL_SET_TIME,`
`114`		`- &timeout);`
	`115`	`+ &timeout_tick);`
`115`	`116`	`rt_timer_start(&(thread->thread_timer));`
`116`	`117`	`}`
`117`	`118`	`/* enable interrupt */`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,7 @@ static int _waitq_inqueue(rt_wqueue_t queue, struct rt_wqueue_node node,`
`47`	`47`	`if (ret == RT_EOK)`
`48`	`48`	`{`
`49`	`49`	`rt_wqueue_add(queue, node);`
`50`		`- if (timeout != RT_WAITING_FOREVER)`
	`50`	`+ if (timeout != (rt_tick_t)RT_WAITING_FOREVER)`
`51`	`51`	`{`
`52`	`52`	`rt_timer_control(timer, RT_TIMER_CTRL_SET_TIME, &timeout);`
`53`	`53`
Original file line number	Diff line number	Diff line change
`@@ -129,10 +129,11 @@ rt_err_t rt_data_queue_push(struct rt_data_queue *queue,`
`129`	`129`	`/* start timer */`
`130`	`130`	`if (timeout > 0)`
`131`	`131`	`{`
	`132`	`+ rt_tick_t timeout_tick = timeout;`
`132`	`133`	`/* reset the timeout of thread timer and start it */`
`133`	`134`	`rt_timer_control(&(thread->thread_timer),`
`134`	`135`	`RT_TIMER_CTRL_SET_TIME,`
`135`		`- &timeout);`
	`136`	`+ &timeout_tick);`
`136`	`137`	`rt_timer_start(&(thread->thread_timer));`
`137`	`138`	`}`
`138`	`139`
`@@ -247,10 +248,11 @@ rt_err_t rt_data_queue_pop(struct rt_data_queue *queue,`
`247`	`248`	`/* start timer */`
`248`	`249`	`if (timeout > 0)`
`249`	`250`	`{`
	`251`	`+ rt_tick_t timeout_tick = timeout;`
`250`	`252`	`/* reset the timeout of thread timer and start it */`
`251`	`253`	`rt_timer_control(&(thread->thread_timer),`
`252`	`254`	`RT_TIMER_CTRL_SET_TIME,`
`253`		`- &timeout);`
	`255`	`+ &timeout_tick);`
`254`	`256`	`rt_timer_start(&(thread->thread_timer));`
`255`	`257`	`}`
`256`	`258`