1 /*
2 * Copyright (c) 2006-2023, RT-Thread Development Team
3 *
4 * SPDX-License-Identifier: Apache-2.0
5 *
6 * Change Logs:
7 * Date Author Notes
8 * 2021-10-11 zhangsz the first version
9 */
10
11 #include <rtthread.h>
12 #include <rthw.h>
13 #include <drivers/lptimer.h>
14
15 static rt_list_t rt_soft_lptimer_list = RT_LIST_OBJECT_INIT(rt_soft_lptimer_list);
16
17 /* lptimer init */
rt_lptimer_init(rt_lptimer_t timer,const char * name,void (* timeout)(void * parameter),void * parameter,rt_tick_t time,rt_uint8_t flag)18 void rt_lptimer_init(rt_lptimer_t timer,
19 const char *name,
20 void (*timeout)(void *parameter),
21 void *parameter,
22 rt_tick_t time,
23 rt_uint8_t flag)
24 {
25 rt_timer_init(&timer->timer, name, timeout, parameter, time, flag);
26 rt_list_init(&timer->list);
27 }
28
29 /* lptimer detach */
rt_lptimer_detach(rt_lptimer_t timer)30 rt_err_t rt_lptimer_detach(rt_lptimer_t timer)
31 {
32 rt_base_t level;
33 rt_err_t ret = RT_EOK;
34 RT_ASSERT(timer != RT_NULL);
35
36 /* disable interrupt */
37 level = rt_hw_interrupt_disable();
38
39 ret = rt_timer_detach(&timer->timer);
40 rt_list_remove(&timer->list);
41
42 /* enable interrupt */
43 rt_hw_interrupt_enable(level);
44 return ret;
45 }
46
47 /* lptimer start */
rt_lptimer_start(rt_lptimer_t timer)48 rt_err_t rt_lptimer_start(rt_lptimer_t timer)
49 {
50 rt_base_t level;
51
52 RT_ASSERT(timer != RT_NULL);
53
54 /* disable interrupt */
55 level = rt_hw_interrupt_disable();
56 rt_list_remove(&timer->list); /* remove first */
57 if (rt_timer_start(&timer->timer) == RT_EOK)
58 {
59 /* insert to lptimer list */
60 rt_list_insert_after(&rt_soft_lptimer_list, &(timer->list));
61 }
62 else
63 {
64 /* enable interrupt */
65 rt_hw_interrupt_enable(level);
66 return -RT_ERROR;
67 }
68
69 /* enable interrupt */
70 rt_hw_interrupt_enable(level);
71 return RT_EOK;
72 }
73
74 /* lptimer stop */
rt_lptimer_stop(rt_lptimer_t timer)75 rt_err_t rt_lptimer_stop(rt_lptimer_t timer)
76 {
77 rt_base_t level;
78 RT_ASSERT(timer != RT_NULL);
79
80 /* disable interrupt */
81 level = rt_hw_interrupt_disable();
82 rt_list_remove(&timer->list);
83 if (rt_timer_stop(&timer->timer) == RT_EOK)
84 {
85 /* enable interrupt */
86 rt_hw_interrupt_enable(level);
87 return RT_EOK;
88 }
89 else
90 {
91 /* enable interrupt */
92 rt_hw_interrupt_enable(level);
93 return -RT_ERROR;
94 }
95 }
96
rt_lptimer_control(rt_lptimer_t timer,int cmd,void * arg)97 rt_err_t rt_lptimer_control(rt_lptimer_t timer, int cmd, void *arg)
98 {
99 RT_ASSERT(timer != RT_NULL);
100
101 return rt_timer_control(&timer->timer, cmd, arg);
102 }
103
104 /* get the next soft lptimer timeout */
rt_lptimer_next_timeout_tick(void)105 rt_tick_t rt_lptimer_next_timeout_tick(void)
106 {
107 struct rt_lptimer *timer;
108 rt_base_t level;
109 rt_tick_t timeout_tick = RT_TICK_MAX;
110 struct rt_list_node *node = RT_NULL;
111 rt_tick_t temp_tick = 0;
112 rt_tick_t min_tick = RT_TICK_MAX;
113 rt_tick_t cur_tick = rt_tick_get();
114
115 /* disable interrupt */
116 level = rt_hw_interrupt_disable();
117
118 if (!rt_list_isempty(&rt_soft_lptimer_list))
119 {
120 /* find the first active timer's timeout */
121 rt_list_for_each(node, &rt_soft_lptimer_list)
122 {
123 timer = rt_list_entry(node, struct rt_lptimer, list);
124 if (timer->timer.parent.flag & RT_TIMER_FLAG_ACTIVATED)
125 {
126 temp_tick = timer->timer.timeout_tick - cur_tick;
127
128 /* find the least timeout_tick */
129 if (min_tick > temp_tick)
130 {
131 min_tick = temp_tick;
132 timeout_tick = timer->timer.timeout_tick;
133 }
134 }
135 }
136 }
137
138 /* enable interrupt */
139 rt_hw_interrupt_enable(level);
140
141 return timeout_tick;
142 }
143
lptimer_dump(void)144 void lptimer_dump(void)
145 {
146 struct rt_lptimer *timer;
147 rt_base_t level;
148 struct rt_list_node *node = RT_NULL;
149
150 /* disable interrupt */
151 level = rt_hw_interrupt_disable();
152
153 rt_kprintf("| lptimer | periodic | timeout | flag |\n");
154 rt_kprintf("+---------------+------------+------------+-------------+\n");
155
156 if (!rt_list_isempty(&rt_soft_lptimer_list))
157 {
158 rt_list_for_each(node, &rt_soft_lptimer_list)
159 {
160 timer = rt_list_entry(node, struct rt_lptimer, list);
161 rt_kprintf("| %-13s | 0x%08x | 0x%08x |",
162 timer->timer.parent.name, timer->timer.init_tick,
163 timer->timer.timeout_tick);
164 if (timer->timer.parent.flag & RT_TIMER_FLAG_ACTIVATED)
165 rt_kprintf(" activated |\n");
166 else
167 rt_kprintf(" deactivated |\n");
168 }
169 }
170
171 /* enable interrupt */
172 rt_hw_interrupt_enable(level);
173 rt_kprintf("+---------------+------------+------------+-------------+\n");
174 }
175
176 MSH_CMD_EXPORT(lptimer_dump, soft lptimer dump);
177