timer.c.svn-base

RT-Thread是发展中的下一代微内核嵌入式实时操作系统

/*
 * File      : timer.c
 * This file is part of RT-Thread RTOS
 * COPYRIGHT (C) 2006, RT-Thread Development Team
 *
 * The license and distribution terms for this file may be
 * found in the file LICENSE in this distribution or at
 * http://www.fayfayspace.org/license/LICENSE.
 *
 * Change Logs:
 * Date           Author       Notes
 * 2006-03-12     Bernard      first version
 * 2006-04-29     Bernard      implement thread timer
 * 2006-06-04     Bernard      implement rt_timer_control
 */

#include <rtthread.h>
#include <rthw.h>

#include "kservice.h"

// #define TIMER_DEBUG
static rt_list_t rt_timer_list;

/**
 * @addtogroup Kernel
 */
/*@{*/
void rt_system_timer_init()
{
	rt_list_init(&rt_timer_list);
}

void _rt_timer_init(rt_timer_t timer, 
	void (*timeout)(void* parameter), void* parameter, 
	rt_tick_t time, rt_uint8 flag)
{
	timer->parent.flag 	= flag;

	/* set deactivated */
	timer->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;

	timer->timeout_func = timeout;
	timer->parameter   	= parameter;

	timer->timeout_tick	= 0;
	timer->init_tick 	= time;

	/* init timer list */
	rt_list_init(&(timer->list));
}

void rt_timer_init(rt_timer_t timer, 
	const char* name, 
	void (*timeout)(void* parameter), void* parameter, 
	rt_tick_t time, rt_uint8 flag)
{
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

	/* timer object init */
	rt_object_init((rt_object_t)timer, RT_Object_Class_Timer, name);

	_rt_timer_init(timer, timeout, parameter, time, flag);
}

rt_timer_t rt_timer_create(const char* name, void (*timeout)(void* parameter), void* parameter, rt_tick_t time, rt_uint8 flag)
{
	struct rt_timer* timer;

	timer = (struct rt_timer*)rt_object_allocate(RT_Object_Class_Timer, name);
	if (timer == RT_NULL)
	{
		return RT_NULL;
	}

	_rt_timer_init(timer, timeout, parameter, time, flag);

	return timer;
}

rt_err_t rt_timer_delete(rt_timer_t timer)
{
	register rt_base_t level;
	
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

	/* disable interrupt */
	level = rt_hw_interrupt_disable();

	/* remove it from timer list */
	rt_list_remove(&(timer->list));

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

	if (rt_object_is_systemobject((rt_object_t)timer))
	{
		rt_object_detach((rt_object_t)timer);
	}
	else
	{
		rt_object_delete((rt_object_t)timer);
	}

	return -RT_EOK;
}

rt_err_t rt_timer_start(rt_timer_t timer)
{
	rt_list_t *n;
	struct rt_timer* t;
	register rt_base_t level;

	/* timer check */
	RT_ASSERT(timer != RT_NULL);

	timer->timeout_tick = rt_tick_get() + timer->init_tick;

	/* disable interrupt */
	level = rt_hw_interrupt_disable();

	/* insert timer to system timer list */	
	for (n = rt_timer_list.next; n != &rt_timer_list; n = n->next)
	{
		t = rt_list_entry(n, struct rt_timer, list);
		if (t->timeout_tick > timer->timeout_tick)
		{
			rt_list_insert_before(n, &(timer->list));
			break;
		}
	}

	/* no found suitable position in timer list */
	if (n == &rt_timer_list)
	{
		rt_list_insert_before(n, &(timer->list));
	}

	timer->parent.flag |= RT_TIMER_FLAG_ACTIVATED;

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

	return RT_EOK;
}

rt_err_t rt_timer_stop(rt_timer_t timer)
{
	register rt_base_t level;

	/* timer check */
	RT_ASSERT(timer != RT_NULL);
	RT_ASSERT(timer->parent.flag & RT_TIMER_FLAG_ACTIVATED);

	/* disable interrupt */
	level = rt_hw_interrupt_disable();

	/* remove it from timer list */
	rt_list_remove(&(timer->list));

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

	return RT_EOK;
}

rt_err_t rt_timer_control(rt_timer_t timer, rt_uint8 cmd, void* arg)
{
	/* timer check */
	RT_ASSERT(timer != RT_NULL);

	switch (cmd)
	{
	case RT_TIMER_CTRL_GET_TIME:
		*(rt_tick_t*)arg = timer->init_tick;
		break;

	case RT_TIMER_CTRL_SET_TIME:
		timer->init_tick = *(rt_tick_t*)arg;
		break;

	case RT_TIMER_CTRL_SET_ONESHOT:
		timer->parent.flag &= ~(1 << RT_TIMER_FLAG_PERIODIC);
		break;

	case RT_TIMER_CTRL_SET_PERIODIC:
		timer->parent.flag |= (1 << RT_TIMER_FLAG_PERIODIC);
		break;
	}

	return RT_EOK;
}

void rt_timer_check()
{
	rt_tick_t current_tick;
	rt_list_t *n;
	struct rt_timer *t;
	register rt_base_t level;

#ifdef TIMER_DEBUG
	rt_kprintf("timer check enter\n");
#endif

	current_tick = rt_tick_get();

	/* disable interrupt */
	level = rt_hw_interrupt_disable();

	for (n = rt_timer_list.next; n != &(rt_timer_list); )
	{
		t = rt_list_entry(n, struct rt_timer, list);
		if (current_tick >= t->timeout_tick)
		{
			t->timeout_func(t->parameter);

			/* reget tick */
			current_tick = rt_tick_get();

#ifdef TIMER_DEBUG
			rt_kprintf("current tick: %d\n", current_tick);
#endif

			if (t->parent.flag & RT_TIMER_FLAG_PERIODIC)
			{
				/* it's a periodic timer, re-start it */
				rt_timer_start(t);

				/* move node to next timer */
				n = n->next;
			}
			else
			{
				/* move node to next before remove */
				n = n->next;

				/* remove it from timer list */
				t->parent.flag &= ~RT_TIMER_FLAG_ACTIVATED;
				rt_list_remove(&(t->list));
			}
		}
		else break;
	}

	/* enable interrupt */
	rt_hw_interrupt_enable(level);

#ifdef TIMER_DEBUG
	rt_kprintf("timer check leave\n");
#endif

}

/*@}*/