timer.c

Go to the documentation of this file.

#include "timer.h"
#include "hw/hw_timer.h"

#include "cfg/cfg_timer.h"
#include "cfg/cfg_wdt.h"
#include "cfg/cfg_proc.h"
#include "cfg/cfg_signal.h"
#include <cfg/os.h>
#include <cfg/debug.h>
#include <cfg/module.h>

#include <cpu/attr.h>
#include <cpu/types.h>
#include <cpu/irq.h>
#include <cpu/power.h> // cpu_relax()

#include <kern/proc_p.h> // proc_decQuantun()

/*
 * Include platform-specific binding code if we're hosted.
 * Try the CPU specific one for bare-metal environments.
 */
#if OS_HOSTED
    //#include OS_CSOURCE(timer)
    #include <emul/timer_posix.c>
#else
    #ifndef WIZ_AUTOGEN
        #warning Deprecated: now you should include timer_<cpu> directly in the makefile. Remove this line and the following once done.
        #include CPU_CSOURCE(timer)
    #endif
#endif

/*
 * Sanity check for config parameters required by this module.
 */
#if !defined(CONFIG_KERN) || ((CONFIG_KERN != 0) && CONFIG_KERN != 1)
    #error CONFIG_KERN must be set to either 0 or 1 in config.h
#endif
#if !defined(CONFIG_WATCHDOG) || ((CONFIG_WATCHDOG != 0) && CONFIG_WATCHDOG != 1)
    #error CONFIG_WATCHDOG must be set to either 0 or 1 in config.h
#endif

#if CONFIG_WATCHDOG
    #include <drv/wdt.h>
#endif

#if defined (CONFIG_KERN_SIGNALS) && CONFIG_KERN_SIGNALS
    #include <kern/signal.h> /* sig_wait(), sig_check() */
    #include <kern/proc.h>   /* proc_current() */
    #include <cfg/macros.h>  /* BV() */
#endif


#if !defined(CONFIG_TIMER_STROBE) || !CONFIG_TIMER_STROBE
    #define TIMER_STROBE_ON    do {/*nop*/} while(0)
    #define TIMER_STROBE_OFF   do {/*nop*/} while(0)
    #define TIMER_STROBE_INIT  do {/*nop*/} while(0)
#endif


volatile ticks_t _clock;


#if CONFIG_TIMER_EVENTS

REGISTER static List timers_queue;

INLINE void timer_addToList(Timer *timer, List *queue)
{
    /* Inserting timers twice causes mayhem. */
    ASSERT(timer->magic != TIMER_MAGIC_ACTIVE);
    DB(timer->magic = TIMER_MAGIC_ACTIVE;)


    /* Calculate expiration time for this timer */
    timer->tick = _clock + timer->_delay;

    /*
     * Search for the first node whose expiration time is
     * greater than the timer we want to add.
     */
    Timer *node = (Timer *)LIST_HEAD(queue);
    while (node->link.succ)
    {
        /*
         * Stop just after the insertion point.
         * (this fancy compare takes care of wrap-arounds).
         */
        if (node->tick - timer->tick > 0)
            break;

        /* Go to next node */
        node = (Timer *)node->link.succ;
    }

    /* Enqueue timer request into the list */
    INSERT_BEFORE(&timer->link, &node->link);
}

void timer_add(Timer *timer)
{
    ATOMIC(timer_addToList(timer, &timers_queue));
}

Timer *timer_abort(Timer *timer)
{
    ATOMIC(REMOVE(&timer->link));
    DB(timer->magic = TIMER_MAGIC_INACTIVE;)

    return timer;
}


INLINE void timer_poll(List *queue)
{
    Timer *timer;

    /*
     * Check the first timer request in the list and process
     * it when it has expired. Repeat this check until the
     * first node has not yet expired. Since the list is sorted
     * by expiry time, all the following requests are guaranteed
     * to expire later.
     */
    while ((timer = (Timer *)LIST_HEAD(queue))->link.succ)
    {
        /* This request in list has not yet expired? */
        if (timer_clock() - timer->tick < 0)
            break;

        /* Retreat the expired timer */
        REMOVE(&timer->link);
        DB(timer->magic = TIMER_MAGIC_INACTIVE;)

        /* Execute the associated event */
        event_do(&timer->expire);
    }
}

void synctimer_add(Timer *timer, List *queue)
{
    timer_addToList(timer, queue);
}

void synctimer_poll(List *queue)
{
    timer_poll(queue);
}

#endif /* CONFIG_TIMER_EVENTS */


void timer_delayTicks(ticks_t delay)
{
    /* We shouldn't sleep with interrupts disabled */
    IRQ_ASSERT_ENABLED();

#if CONFIG_KERN_SIGNALS
    Timer t;

    if (proc_preemptAllowed())
    {
        ASSERT(!sig_check(SIG_SINGLE));
        timer_setSignal(&t, proc_current(), SIG_SINGLE);
        timer_setDelay(&t, delay);
        timer_add(&t);
        sig_wait(SIG_SINGLE);
    }
    else
#endif /* !CONFIG_KERN_SIGNALS */
    {
        ticks_t start = timer_clock();

        /* Busy wait */
        while (timer_clock() - start < delay)
            cpu_relax();
    }
}


#if CONFIG_TIMER_UDELAY

void timer_busyWait(hptime_t delay)
{
    hptime_t now, prev = timer_hw_hpread();
    hptime_t delta;

    for(;;)
    {
        now = timer_hw_hpread();
        /*
         * We rely on hptime_t being unsigned here to
         * reduce the modulo to an AND in the common
         * case of TIMER_HW_CNT.
         */
        delta = (now - prev) % TIMER_HW_CNT;
        if (delta >= delay)
            break;
        delay -= delta;
        prev = now;
    }
}

void timer_delayHp(hptime_t delay)
{
    if (UNLIKELY(delay > us_to_hptime(1000)))
    {
        timer_delayTicks(delay / (TIMER_HW_HPTICKS_PER_SEC / TIMER_TICKS_PER_SEC));
        delay %= (TIMER_HW_HPTICKS_PER_SEC / TIMER_TICKS_PER_SEC);
    }

    timer_busyWait(delay);
}
#endif /* CONFIG_TIMER_UDELAY */

DEFINE_TIMER_ISR
{
    /*
     * With the Metrowerks compiler, the only way to force the compiler generate
     * an interrupt service routine is to put a pragma directive within the function
     * body.
     */
    #ifdef __MWERKS__
    #pragma interrupt saveall
    #endif

    /*
     * On systems sharing IRQ line and vector, this check is needed
     * to ensure that IRQ is generated by timer source.
     */
    if (!timer_hw_triggered())
        return;

    TIMER_STROBE_ON;

    /* Update the master ms counter */
    ++_clock;

    /* Update the current task's quantum (if enabled). */
    proc_decQuantum();

    #if CONFIG_TIMER_EVENTS
        timer_poll(&timers_queue);
    #endif

    /* Perform hw IRQ handling */
    timer_hw_irq();
    
    TIMER_STROBE_OFF;
}

MOD_DEFINE(timer)


void timer_init(void)
{
    #if CONFIG_KERN_IRQ
        MOD_CHECK(irq);
    #endif

    #if CONFIG_TIMER_EVENTS
        LIST_INIT(&timers_queue);
    #endif

    TIMER_STROBE_INIT;

    _clock = 0;

    timer_hw_init();

    MOD_INIT(timer);
}


#if (ARCH & ARCH_EMUL)

void timer_cleanup(void)
{
    MOD_CLEANUP(timer);

    timer_hw_cleanup();

    // Hmmm... apparently, the demo app does not cleanup properly
    //ASSERT(LIST_EMPTY(&timers_queue));
}
#endif /* ARCH_EMUL */