/* find the correspond timer node, if not find insert one*/
TimerNodePtr findTimerNode(int tick_num) {
int sum = 0;
int num = tick_num;
TimerNodePtr cur = g_timer_chain;
TimerNodePtr pre = g_timer_chain;
timer_debug("findTimerNode: tick_num %d", tick_num);
while (sum < num && cur != NULL) {
sum += cur->tick_number;
if (sum == num) {
return cur;
}
pre = cur;
cur = cur->next;
}
timer_debug("findTimerNode: sum %d, num %d", sum, num);
if (cur == NULL && sum < num) {
timer_debug("findTimerNode: insert node");
return insertTimerNode(pre, num - sum);
} else {
timer_debug("findTimerNode: splitTimerNode");
return splitTimerNode(pre, sum - num);
}
}
void removeTimerItem(TimerItemPtr ptr) {
timer_debug("removeTimerItem: ptr %d", ptr);
if (ptr != NULL) {
ptr->pre->next = ptr->next;
if (ptr->next != NULL) {
ptr->next->pre = ptr->pre;
}
my_free(ptr);
}
timer_debug("removeTimerItem: success remove");
}
TimerNodePtr splitTimerNode(TimerNodePtr cur, int tick_num) {
TimerNodePtr new_timer_node = (TimerNodePtr)my_malloc(sizeof(TimerNode));
timer_debug("splitTimerNode: tick_num %d, before %d", tick_num, cur->tick_number);
new_timer_node->tick_number = tick_num;
new_timer_node->item_head = cur->item_head;
new_timer_node->next = cur->next;
cur->tick_number -= tick_num;
cur->item_head = (TimerItemPtr)my_malloc(sizeof(TimerItem));
cur->item_head->next = NULL;
cur->item_head->pre = NULL;
cur->item_head->type = TIMER_NONE;
cur->next = new_timer_node;
timer_debug("splitTimerNode: first_part %d, second_part %d", cur->tick_number, \
new_timer_node->tick_number);
return cur;
}
TimerNodePtr insertTimerNode(TimerNodePtr end, int tick_num) {
TimerNodePtr new_timer_node = (TimerNodePtr)my_malloc(sizeof(TimerNode));
new_timer_node->item_head = (TimerItemPtr)my_malloc(sizeof(TimerItem));
new_timer_node->item_head->next = NULL;
new_timer_node->item_head->pre = NULL;
new_timer_node->item_head->type = TIMER_NONE;
new_timer_node->next = NULL;
new_timer_node->tick_number = tick_num;
if (end == NULL) {
/* the time node chain is empty*/
g_timer_chain = new_timer_node;
timer_debug("insertTimerNode: empty chain");
} else {
end->next = new_timer_node;
}
timer_debug("insertTimerNode: end %d, tick_num %d", end, tick_num);
return new_timer_node;
}
void removeTimerNode(TimerNodePtr ptr) {
TimerItemPtr tmp_item = ptr->item_head;
while (ptr->item_head != NULL) {
tmp_item = ptr->item_head;
ptr->item_head = tmp_item->next;
my_free(tmp_item);
}
timer_debug("removeTimerNode: ptr %d", ptr);
my_free(ptr);
}
void initTimer() {
/* @TODO start the timer task and forward timer*/
initCallbackInfo();
g_timer_switcher = 1;
g_timer_tick_sem = initSemaphore();
g_timer_end_sem = initSemaphore();
createTask(decreaseTimerNode, 0);
sysClkConnect(increaseTick, 0);
sysClkRateSet(1000 / TICK);
sysClkEnable();
timer_debug("initTimer: getrate %d", sysClkRateGet());
}
TimerID insertTimerItem(int tick_num, TimerItemType type, MySemaphorePtr sem, \
TaskCallback callback, void* args, TimerID tid) {
TimerNodePtr timer_node = findTimerNode(tick_num);
TimerItemPtr new_timer_item;
timer_debug("insertTimerItem: tick_num %d, type %d, sem %d, tid %d", \
tick_num, type, sem, tid);
new_timer_item = (TimerItemPtr)my_malloc(sizeof(TimerItem));
timer_debug("insertTimerNode: after alloc memory");
new_timer_item->type = type;
new_timer_item->sem = sem;
new_timer_item->interval = tick_num;
new_timer_item->callback = callback;
new_timer_item->args = args;
if (type != TIMER_SEM) {
timer_debug("inserttimernode: not sem");
tid = addCallbackItem(new_timer_item, tid);
if (tid == -1) {
my_free(new_timer_item);
return -1;
}
}
new_timer_item->pre = timer_node->item_head;
new_timer_item->next = timer_node->item_head->next;
timer_debug("insertTimerNode: after asign");
if (timer_node->item_head->next != NULL) {
timer_node->item_head->next->pre = new_timer_item;
}
timer_node->item_head->next = new_timer_item;
timer_debug("insertTimerNode: after asign item_head");
timer_debug("insertTimerItem: end of the function, tid %d", tid);
new_timer_item->tid = tid;
return tid;
}
void decreaseTimerNode(long arg0, long arg1, long arg2, long arg3, long arg4, \
long arg5, long arg6, long arg7, long arg8, long arg9) {
TimerNodePtr tmp_node;
TimerItemPtr tmp_item;
while (g_timer_switcher == 1) {
waitSemaphore(g_timer_tick_sem);
lockTimerGlobalInfo();
if (g_timer_chain == NULL) {
timer_debug("decreaseTimerNode: g_timer_chain is empty");
unlockTimerGlobalInfo();
continue;
}
tmp_node = g_timer_chain;
timer_debug("decreaseTimerNode: before tick_num %d", tmp_node->tick_number);
tmp_node->tick_number --;
if (tmp_node->tick_number == 0) {
timer_debug("decreaseTimerNode: activate timers");
while (tmp_node->item_head != NULL) {
tmp_item = tmp_node->item_head;
tmp_node->item_head = tmp_item->next;
activateTimerItem(tmp_item);
my_free(tmp_item);
}
timer_debug("decreaseTimerNode: after activate");
g_timer_chain = tmp_node->next;
my_free(tmp_node);
}
timer_debug("decreaseTimerNode: end of");
unlockTimerGlobalInfo();
}
timer_debug("decreaseTimerNode: $$$$$$$$$$$$$$$$$$$$$$$$$$$$$$");
postSemaphore(g_timer_end_sem);
}
void activateTimerItem(TimerItemPtr ptr) {
TaskID task_id;
timer_debug("activateTimerItem: ptr %d, tid %d", ptr, ptr->tid);
if (ptr->type == TIMER_SEM) {
/* @TODO sem*/
postSemaphore(ptr->sem);
} else if (ptr->type != TIMER_NONE) {
timer_debug("activateTimerItem: callback %d, args %d", ptr->callback, \
ptr->args);
/* @TODO call the function */
createTask(ptr->callback, ptr->args);
if (ptr->type == TIMER_INTERVAL) {
timer_debug("activateTimerItem: the TIMER_INTERVAL");
insertTimerItem(ptr->interval, ptr->type, NULL, ptr->callback, \
ptr->args, ptr->tid);
timer_debug("activateTimerItem: after insert");
} else {
removeCallbackItem(ptr->tid);
}
}
}
void deinitTimer() {
TimerNodePtr tmp_node;
TimerItemPtr tmp_item;
timer_debug("deinitTimer: ");
g_timer_switcher = 0;
waitSemaphore(g_timer_end_sem);
destroySemaphore(g_timer_end_sem);
sysClkDisable();
destroySemaphore(g_timer_tick_sem);
while (g_timer_chain != NULL) {
tmp_node = g_timer_chain;
g_timer_chain = tmp_node->next;
removeTimerNode(tmp_node);
}
g_timer_chain = NULL;
deinitCallbackInfo();
timer_loginfo("deinit g_timer_chain success");
}
void init_timer(uint32_t frequency)
{
uint32_t divisor;
timer_debug("\n");
/* Register our timer callback. */
register_interrupt_handler(IRQ0, (isr_t)&_timer_callback);
/* Get the 16-bit divisor. */
divisor = PIT_CLOCK_FREQUENCY / frequency;
/* Send the command byte. */
PIT_COMMAND_OUT(0x36);
/* The divisor must be sent byte-wise. */
PIT_0_DATA_OUT((uint8_t)(divisor & 0xFF));
PIT_0_DATA_OUT((uint8_t)((divisor>>8) & 0xFF));
}
/***************************************************************************//**
* @brief
* Initialize the specified TIMER unit
*
* @details
*
* @note
*
* @param[in] device
* Pointer to device descriptor
*
* @param[in] unitNumber
* Unit number
*
* @return
* Pointer to TIMER device
******************************************************************************/
static struct efm32_timer_device_t *rt_hw_timer_unit_init(
rt_device_t device,
rt_uint8_t unitNumber,
rt_uint8_t mode)
{
struct efm32_timer_device_t *timer;
TIMER_Init_TypeDef init;
efm32_irq_hook_init_t hook;
CMU_Clock_TypeDef timerClock;
IRQn_Type timerIrq;
do
{
/* Allocate device */
timer = rt_malloc(sizeof(struct efm32_timer_device_t));
if (timer == RT_NULL)
{
timer_debug("no memory for TIMER%d driver\n", unitNumber);
break;
}
/* Initialization */
if (unitNumber >= TIMER_COUNT)
{
break;
}
switch (unitNumber)
{
case 0:
timer->timer_device = TIMER0;
timerClock = (CMU_Clock_TypeDef)cmuClock_TIMER0;
timerIrq = TIMER0_IRQn;
break;
case 1:
timer->timer_device = TIMER1;
timerClock = (CMU_Clock_TypeDef)cmuClock_TIMER1;
timerIrq = TIMER1_IRQn;
break;
case 2:
timer->timer_device = TIMER2;
timerClock = (CMU_Clock_TypeDef)cmuClock_TIMER2;
timerIrq = TIMER2_IRQn;
break;
default:
break;
}
/* Enable TIMER clock */
CMU_ClockEnable(timerClock, true);
/* Reset */
TIMER_Reset(timer->timer_device);
/* Init specified TIMER unit */
init.enable = false;
init.debugRun = true;
init.prescale = TMR_CFG_PRESCALER;
init.clkSel = timerClkSelHFPerClk;
init.fallAction = timerInputActionNone;
init.riseAction = timerInputActionNone;
init.mode = timerModeUp;
init.dmaClrAct = false;
init.quadModeX4 = false;
init.oneShot = (mode > 0) ? true : false;
init.sync = false;
TIMER_Init(timer->timer_device, &init);
/* Config interrupt and NVIC */
hook.type = efm32_irq_type_timer;
hook.unit = unitNumber;
hook.cbFunc = rt_hw_timer_isr;
hook.userPtr = device;
efm32_irq_hook_register(&hook);
/* Enable overflow interrupt */
TIMER_IntEnable(timer->timer_device, TIMER_IF_OF);
TIMER_IntClear(timer->timer_device, TIMER_IF_OF);
/* Enable TIMERn interrupt vector in NVIC */
NVIC_ClearPendingIRQ(timerIrq);
NVIC_SetPriority(timerIrq, EFM32_IRQ_PRI_DEFAULT);
NVIC_EnableIRQ(timerIrq);
return timer;
} while(0);
if (timer)
{
rt_free(timer);
}
rt_kprintf("TIMER: Init failed!\n");
return RT_NULL;
}