timer.c

Go to the documentation of this file.

#include <stdint.h>
#include <rtc.h>
#include <intc.h>
#include "timer.h"


struct timeout_t {
        U32 tick; 
        U32 expire_at_tick;
        Bool expired;
        U8 type;
        void (*cb)(void* ctx);
        void* ctx;
};

struct timer_t {
        volatile U32 tick;
        struct timeout_t timeout[8];
        void (*tick_isr) (void* ctx);
        const U32 MS_PER_TICK;
    void *ctx;
};

#define ARRAY_SIZE(a) sizeof(a) / sizeof(a[0])

static __attribute__((__interrupt__)) void irq_handler(void);

static struct timer_t TIMER = {
        .tick = 0,
        .MS_PER_TICK = TIMER_HZ,
        .timeout = { { 0 } },
};

void timer_init(void (*tick_isr) (void* ctx), void* ctx)
{
        struct timer_t* priv = &TIMER;
        uint8_t id;
        
        INTC_register_interrupt(&irq_handler, AVR32_RTC_IRQ, AVR32_INTC_INT0);
        if (!rtc_init(&AVR32_RTC, RTC_OSC_RC, 0))
                Assert(0);

    priv->tick_isr = tick_isr;
    priv->ctx = ctx;
        rtc_set_top_value(&AVR32_RTC, 115 * priv->MS_PER_TICK / 2);
        rtc_enable_interrupt(&AVR32_RTC);
        rtc_enable(&AVR32_RTC);

        for (id = 0; id < ARRAY_SIZE(priv->timeout); id++)
                priv->timeout[id].expired = TRUE;
}


U32 timer_get_ms(void)
{
        struct timer_t* priv = &TIMER;
        return priv->tick * priv->MS_PER_TICK;
}

void timer_delay(U32 ms)
{
        struct timer_t* priv = &TIMER;
        U32 expire_at_tick = priv->tick + ms / priv->MS_PER_TICK;
        while (priv->tick < expire_at_tick);
}

void timer_poll(void)
{
        struct timer_t* priv = &TIMER;
        U8 i;

        for (i = 0; i < ARRAY_SIZE(priv->timeout); i++) {
                struct timeout_t* tmo = &priv->timeout[i];
                if (tmo->expired)
                        continue;
        
                if (tmo->expire_at_tick > priv->tick)
                        continue;

                if (tmo->cb)
                        tmo->cb(tmo->ctx);
                
                if (tmo->type == TIMEOUT_PERIODIC)
                        tmo->expire_at_tick = priv->tick + tmo->tick;
                else
                        tmo->expired = TRUE;
        }
}

static U32 timer_sched_timeout(U32 ms, U8 type)
{
        struct timer_t* priv = &TIMER;
        struct timeout_t* tmo;
        U8 id;

        Assert(type == TIMEOUT_ONESHOT || type == TIMEOUT_PERIODIC);
        
        for (id = 0; id < ARRAY_SIZE(priv->timeout); id++) {
                tmo = &priv->timeout[id];
                if (tmo->expired)
                        break;
        }

        Assert(id != ARRAY_SIZE(priv->timeout));

        tmo->tick = ms / priv->MS_PER_TICK;
        tmo->expire_at_tick = priv->tick + tmo->tick;
        tmo->type = type;
        tmo->expired = FALSE;
        return id;
}

U32 timer_sched_timeout_cb(U32 ms, U8 type, void (*cb)(void *ctx), void* ctx)
{
        struct timer_t* priv = &TIMER;
        struct timeout_t* tmo;
        U8 id;

        Assert(cb);
        id = timer_sched_timeout(ms, type);
        tmo = &priv->timeout[id];

        tmo->cb = cb;
        tmo->ctx = ctx;
        return id;
}


void timer_cancel_timeout(U32 id)
{
        struct timer_t* priv = &TIMER;
        struct timeout_t* tmo;
    
        tmo = &priv->timeout[id];
        tmo->expired = TRUE;
}

static __attribute__((__interrupt__)) void irq_handler(void)
{
        volatile avr32_rtc_t *rtc = &AVR32_RTC;
        struct timer_t* priv = &TIMER;
        priv->tick++;

        if(priv->tick_isr)
                priv->tick_isr(priv->ctx);
        
        rtc->icr = AVR32_RTC_ICR_TOPI_MASK;
        rtc->isr;
}

---