void ticker_irq_handler(const ticker_data_t *const ticker)
{
ticker->interface->clear_interrupt();
/* Go through all the pending TimerEvents */
while (1) {
if (ticker->queue->head == NULL) {
break;
}
// update the current timestamp used by the queue
update_present_time(ticker);
if (ticker->queue->head->timestamp <= ticker->queue->present_time) {
// This event was in the past:
// point to the following one and execute its handler
ticker_event_t *p = ticker->queue->head;
ticker->queue->head = ticker->queue->head->next;
if (ticker->queue->event_handler != NULL) {
(*ticker->queue->event_handler)(p->id); // NOTE: the handler can set new events
}
/* Note: We continue back to examining the head because calling the
* event handler may have altered the chain of pending events. */
} else {
break;
}
}
schedule_interrupt(ticker);
}
/*
* Initialize a ticker instance.
*/
static void initialize(const ticker_data_t *ticker)
{
// return if the queue has already been initialized, in that case the
// interface used by the queue is already initialized.
if (ticker->queue->initialized) {
return;
}
ticker->interface->init();
const ticker_info_t *info = ticker->interface->get_info();
uint32_t frequency = info->frequency;
if (info->frequency == 0) {
MBED_ASSERT(0);
frequency = 1000000;
}
uint8_t frequency_shifts = 0;
for (uint8_t i = 31; i > 0; --i) {
if ((1 << i) == frequency) {
frequency_shifts = i;
break;
}
}
uint32_t bits = info->bits;
if ((info->bits > 32) || (info->bits < 4)) {
MBED_ASSERT(0);
bits = 32;
}
uint32_t max_delta = 0x7 << (bits - 4); // 7/16th
uint64_t max_delta_us =
((uint64_t)max_delta * 1000000 + frequency - 1) / frequency;
ticker->queue->event_handler = NULL;
ticker->queue->head = NULL;
ticker->queue->tick_last_read = ticker->interface->read();
ticker->queue->tick_remainder = 0;
ticker->queue->frequency = frequency;
ticker->queue->frequency_shifts = frequency_shifts;
ticker->queue->bitmask = ((uint64_t)1 << bits) - 1;
ticker->queue->max_delta = max_delta;
ticker->queue->max_delta_us = max_delta_us;
ticker->queue->present_time = 0;
ticker->queue->initialized = true;
update_present_time(ticker);
schedule_interrupt(ticker);
}
/*
* Initialize a ticker instance.
*/
static void initialize(const ticker_data_t *ticker)
{
// return if the queue has already been initialized, in that case the
// interface used by the queue is already initialized.
if (ticker->queue->initialized) {
return;
}
ticker->interface->init();
ticker->queue->event_handler = NULL;
ticker->queue->head = NULL;
ticker->queue->present_time = 0;
ticker->queue->initialized = true;
update_present_time(ticker);
schedule_interrupt(ticker);
}
void ticker_insert_event_us(const ticker_data_t *const ticker, ticker_event_t *obj, us_timestamp_t timestamp, uint32_t id)
{
core_util_critical_section_enter();
// update the current timestamp
update_present_time(ticker);
// initialise our data
obj->timestamp = timestamp;
obj->id = id;
/* Go through the list until we either reach the end, or find
an element this should come before (which is possibly the
head). */
ticker_event_t *prev = NULL, *p = ticker->queue->head;
while (p != NULL) {
/* check if we come before p */
if (timestamp < p->timestamp) {
break;
}
/* go to the next element */
prev = p;
p = p->next;
}
/* if we're at the end p will be NULL, which is correct */
obj->next = p;
/* if prev is NULL we're at the head */
if (prev == NULL) {
ticker->queue->head = obj;
} else {
prev->next = obj;
}
schedule_interrupt(ticker);
core_util_critical_section_exit();
}
void ticker_remove_event(const ticker_data_t *const ticker, ticker_event_t *obj)
{
core_util_critical_section_enter();
// remove this object from the list
if (ticker->queue->head == obj) {
// first in the list, so just drop me
ticker->queue->head = obj->next;
schedule_interrupt(ticker);
} else {
// find the object before me, then drop me
ticker_event_t* p = ticker->queue->head;
while (p != NULL) {
if (p->next == obj) {
p->next = obj->next;
break;
}
p = p->next;
}
}
core_util_critical_section_exit();
}
