sergiotarxz/nuttx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

esp32_rt_timer.c: Group static variables into a struct and fix naming

Browse Source 
standard

Signed-off-by: Abdelatif Guettouche <abdelatif.guettouche@espressif.com>
This commit is contained in:
Abdelatif Guettouche 2021-09-10 10:51:54 +02:00 committed by Xiang Xiao
parent 0dff3f2762
commit 9e1d2ca95e
1 changed files with 93 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

170
arch/xtensa/src/esp32/esp32_rt_timer.c
View File

@ -60,19 +60,28 @@
#define ESP32_TIMER_PRESCALER (APB_CLK_FREQ / (1000 * 1000))
#define ESP32_RT_TIMER 0 /* Timer 0 */
/****************************************************************************
* Private Types
****************************************************************************/
struct esp32_rt_priv_s
{
int pid;
sem_t toutsem;
struct list_node runlist;
struct list_node toutlist;
spinlock_t lock;
struct esp32_tim_dev_s *timer;
};
/****************************************************************************
* Private Data
****************************************************************************/
static int s_pid;
static sem_t s_toutsem;
static struct list_node s_runlist;
static struct list_node s_toutlist;
static spinlock_t g_lock;
static struct esp32_tim_dev_s *s_esp32_tim_dev;
static struct esp32_rt_priv_s g_rt_priv;
/****************************************************************************
* Private Function Prototypes
@ -102,7 +111,7 @@ static void start_rt_timer(struct rt_timer_s *timer,
struct rt_timer_s *p;
bool inserted = false;
uint64_t counter;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
/* Only idle timer can be started */
@ -110,7 +119,7 @@ static void start_rt_timer(struct rt_timer_s *timer,
{
/* Calculate the timer's alarm value */
ESP32_TIM_GETCTR(tim, &counter);
ESP32_TIM_GETCTR(priv->timer, &counter);
timer->timeout = timeout;
timer->alarm = timer->timeout + counter;
@ -127,7 +136,7 @@ static void start_rt_timer(struct rt_timer_s *timer,
* node of timer whose alarm value is larger than new one
*/
list_for_every_entry(&s_runlist, p, struct rt_timer_s, list)
list_for_every_entry(&priv->runlist, p, struct rt_timer_s, list)
{
if (p->alarm > timer->alarm)
{
@ -143,19 +152,19 @@ static void start_rt_timer(struct rt_timer_s *timer,
if (!inserted)
{
list_add_tail(&s_runlist, &timer->list);
list_add_tail(&priv->runlist, &timer->list);
}
timer->state = RT_TIMER_READY;
/* If this timer is at the head of the list */
if (timer == container_of(s_runlist.next, struct rt_timer_s, list))
if (timer == container_of(priv->runlist.next, struct rt_timer_s, list))
{
/* Reset the hardware timer alarm */
ESP32_TIM_SETALRVL(tim, timer->alarm);
ESP32_TIM_SETALRM(tim, true);
ESP32_TIM_SETALRVL(priv->timer, timer->alarm);
ESP32_TIM_SETALRM(priv->timer, true);
}
}
}
@ -180,7 +189,7 @@ static void stop_rt_timer(struct rt_timer_s *timer)
bool ishead;
struct rt_timer_s *next_timer;
uint64_t alarm;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
/* "start" function can set the timer's repeat flag, and function "stop"
* should remove this flag.
@ -194,7 +203,7 @@ static void stop_rt_timer(struct rt_timer_s *timer)
{
/* Check if the timer is at the head of the list */
if (timer == container_of(s_runlist.next, struct rt_timer_s, list))
if (timer == container_of(priv->runlist.next, struct rt_timer_s, list))
{
ishead = true;
}
@ -210,19 +219,19 @@ static void stop_rt_timer(struct rt_timer_s *timer)
if (ishead)
{
if (!list_is_empty(&s_runlist))
if (!list_is_empty(&priv->runlist))
{
/* Set the value from the next timer as the new hardware timer
* alarm value
*/
next_timer = container_of(s_runlist.next,
next_timer = container_of(priv->runlist.next,
struct rt_timer_s,
list);
alarm = next_timer->alarm;
ESP32_TIM_SETALRVL(tim, alarm);
ESP32_TIM_SETALRM(tim, true);
ESP32_TIM_SETALRVL(priv->timer, alarm);
ESP32_TIM_SETALRM(priv->timer, true);
}
}
}
@ -247,8 +256,9 @@ static void stop_rt_timer(struct rt_timer_s *timer)
static void delete_rt_timer(struct rt_timer_s *timer)
{
irqstate_t flags;
struct esp32_rt_priv_s *priv = &g_rt_priv;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
if (timer->state == RT_TIMER_READY)
{
@ -263,11 +273,11 @@ static void delete_rt_timer(struct rt_timer_s *timer)
goto exit;
}
list_add_after(&s_toutlist, &timer->list);
list_add_after(&priv->toutlist, &timer->list);
timer->state = RT_TIMER_DELETE;
exit:
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
/****************************************************************************
@ -292,27 +302,28 @@ static int rt_timer_thread(int argc, char *argv[])
irqstate_t flags;
struct rt_timer_s *timer;
enum rt_timer_state_e raw_state;
struct esp32_rt_priv_s *priv = &g_rt_priv;
while (1)
{
/* Waiting for all the timers to time out */
ret = nxsem_wait(&s_toutsem);
ret = nxsem_wait(&priv->toutsem);
if (ret)
{
tmrerr("ERROR: Wait s_toutsem error=%d\n", ret);
tmrerr("ERROR: Wait priv->toutsem error=%d\n", ret);
assert(0);
}
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
/* Process all the timers in the list */
while (!list_is_empty(&s_toutlist))
while (!list_is_empty(&priv->toutlist))
{
/* Get the first timer in the list */
timer = container_of(s_toutlist.next, struct rt_timer_s, list);
timer = container_of(priv->toutlist.next, struct rt_timer_s, list);
/* Cache the raw state to decide how to deal with this timer */
@ -326,7 +337,7 @@ static int rt_timer_thread(int argc, char *argv[])
timer->state = RT_TIMER_IDLE;
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
if (raw_state == RT_TIMER_TIMEOUT)
{
@ -339,7 +350,7 @@ static int rt_timer_thread(int argc, char *argv[])
/* Enter critical section for next scanning list */
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
if (raw_state == RT_TIMER_TIMEOUT)
{
@ -352,7 +363,7 @@ static int rt_timer_thread(int argc, char *argv[])
}
}
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
return 0;
@ -380,21 +391,21 @@ static int rt_timer_isr(int irq, void *context, void *arg)
struct rt_timer_s *timer;
uint64_t alarm;
uint64_t counter;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
/* Clear interrupt register status */
ESP32_TIM_ACKINT(tim);
ESP32_TIM_ACKINT(priv->timer);
/* Wake up the thread to process timed-out timers */
nxsem_post(&s_toutsem);
nxsem_post(&priv->toutsem);
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
/* Check if there is a timer running */
if (!list_is_empty(&s_runlist))
if (!list_is_empty(&priv->runlist))
{
/**
* When stop/delete timer, in the same time the hardware timer
@ -402,8 +413,8 @@ static int rt_timer_isr(int irq, void *context, void *arg)
* from running list, so the 1st timer is not which triggers.
*/
timer = container_of(s_runlist.next, struct rt_timer_s, list);
ESP32_TIM_GETCTR(tim, &counter);
timer = container_of(priv->runlist.next, struct rt_timer_s, list);
ESP32_TIM_GETCTR(priv->timer, &counter);
if (timer->alarm <= counter)
{
/* Remove the first timer in the running list and add it to
@ -415,24 +426,25 @@ static int rt_timer_isr(int irq, void *context, void *arg)
list_delete(&timer->list);
timer->state = RT_TIMER_TIMEOUT;
list_add_after(&s_toutlist, &timer->list);
list_add_after(&priv->toutlist, &timer->list);
/* Check if there is a timer running */
if (!list_is_empty(&s_runlist))
if (!list_is_empty(&priv->runlist))
{
/* Reset hardware timer alarm with next timer's alarm value */
timer = container_of(s_runlist.next, struct rt_timer_s, list);
timer = container_of(priv->runlist.next,
struct rt_timer_s, list);
alarm = timer->alarm;
ESP32_TIM_SETALRVL(tim, alarm);
ESP32_TIM_SETALRM(tim, true);
ESP32_TIM_SETALRVL(priv->timer, alarm);
ESP32_TIM_SETALRM(priv->timer, true);
}
}
}
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
return 0;
}
@ -500,13 +512,14 @@ void rt_timer_start(struct rt_timer_s *timer,
bool repeat)
{
irqstate_t flags;
struct esp32_rt_priv_s *priv = &g_rt_priv;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
stop_rt_timer(timer);
start_rt_timer(timer, timeout, repeat);
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
/****************************************************************************
@ -526,10 +539,11 @@ void rt_timer_start(struct rt_timer_s *timer,
void rt_timer_stop(struct rt_timer_s *timer)
{
irqstate_t flags;
struct esp32_rt_priv_s *priv = &g_rt_priv;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
stop_rt_timer(timer);
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
/****************************************************************************
@ -568,9 +582,9 @@ void rt_timer_delete(struct rt_timer_s *timer)
uint64_t IRAM_ATTR rt_timer_time_us(void)
{
uint64_t counter;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
ESP32_TIM_GETCTR(tim, &counter);
ESP32_TIM_GETCTR(priv->timer, &counter);
return counter;
}
@ -593,13 +607,13 @@ uint64_t IRAM_ATTR rt_timer_get_alarm(void)
{
irqstate_t flags;
uint64_t counter;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
uint64_t alarm_value = 0;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
ESP32_TIM_GETCTR(tim, &counter);
ESP32_TIM_GETALRVL(tim, &alarm_value);
ESP32_TIM_GETCTR(priv->timer, &counter);
ESP32_TIM_GETALRVL(priv->timer, &alarm_value);
if (alarm_value <= counter)
{
@ -610,7 +624,7 @@ uint64_t IRAM_ATTR rt_timer_get_alarm(void)
alarm_value -= counter;
}
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
return alarm_value;
}
@ -632,17 +646,17 @@ uint64_t IRAM_ATTR rt_timer_get_alarm(void)
void IRAM_ATTR rt_timer_calibration(uint64_t time_us)
{
uint64_t counter;
struct esp32_tim_dev_s *tim = s_esp32_tim_dev;
struct esp32_rt_priv_s *priv = &g_rt_priv;
irqstate_t flags;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
ESP32_TIM_GETCTR(tim, &counter);
ESP32_TIM_GETCTR(priv->timer, &counter);
counter += time_us;
ESP32_TIM_SETCTR(tim, counter);
ESP32_TIM_RLD_NOW(tim);
ESP32_TIM_SETCTR(priv->timer, counter);
ESP32_TIM_RLD_NOW(priv->timer);
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
}
/****************************************************************************
@ -664,6 +678,7 @@ int esp32_rt_timer_init(void)
int pid;
irqstate_t flags;
struct esp32_tim_dev_s *tim;
struct esp32_rt_priv_s *priv = &g_rt_priv;
tim = esp32_tim_init(ESP32_RT_TIMER);
if (!tim)
@ -672,7 +687,7 @@ int esp32_rt_timer_init(void)
return -EINVAL;
}
nxsem_init(&s_toutsem, 0, 0);
nxsem_init(&priv->toutsem, 0, 0);
pid = kthread_create(RT_TIMER_TASK_NAME,
RT_TIMER_TASK_PRIORITY,
@ -686,13 +701,13 @@ int esp32_rt_timer_init(void)
return pid;
}
list_initialize(&s_runlist);
list_initialize(&s_toutlist);
list_initialize(&priv->runlist);
list_initialize(&priv->toutlist);
s_esp32_tim_dev = tim;
s_pid = pid;
priv->timer = tim;
priv->pid = pid;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
/* ESP32 hardware timer configuration:
* - 1 counter = 1us
@ -710,7 +725,7 @@ int esp32_rt_timer_init(void)
ESP32_TIM_START(tim);
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
return 0;
}
@ -732,16 +747,17 @@ int esp32_rt_timer_init(void)
void esp32_rt_timer_deinit(void)
{
irqstate_t flags;
struct esp32_rt_priv_s *priv = &g_rt_priv;
flags = spin_lock_irqsave(&g_lock);
flags = spin_lock_irqsave(&priv->lock);
ESP32_TIM_STOP(s_esp32_tim_dev);
esp32_tim_deinit(s_esp32_tim_dev);
s_esp32_tim_dev = NULL;
ESP32_TIM_STOP(priv->timer);
esp32_tim_deinit(priv->timer);
priv->timer = NULL;
spin_unlock_irqrestore(&g_lock, flags);
spin_unlock_irqrestore(&priv->lock, flags);
kthread_delete(s_pid);
nxsem_destroy(&s_toutsem);
kthread_delete(priv->pid);
nxsem_destroy(&priv->toutsem);
}