kbd.c

Go to the documentation of this file.

#include <hw_kbd.h>

#include <drv/timer.h>
#include <drv/kbd.h>

#include <cfg/debug.h>
#include <cfg/module.h>
#include <appconfig.h>

/* Configuration sanity checks */
#if !defined(CONFIG_KBD_POLL) || (CONFIG_KBD_POLL != KBD_POLL_SOFTINT && CONFIG_KBD_POLL != CONFIG_POLL_FREERTOS)
    #error CONFIG_KBD_POLL must be defined to either KBD_POLL_SOFTINT or CONFIG_POLL_FREERTOS
#endif
#if !defined(CONFIG_KBD_BEEP) || (CONFIG_KBD_BEEP != 0 && CONFIG_KBD_BEEP != 1)
    #error CONFIG_KBD_BEEP must be defined to either 0 or 1
#endif
#if !defined(CONFIG_KBD_OBSERVER) || (CONFIG_KBD_OBSERVER != 0 && CONFIG_KBD_OBSERVER != 1)
    #error CONFIG_KBD_OBSERVER must be defined to either 0 or 1
#endif
#if !defined(CONFIG_KBD_LONGPRESS) || (CONFIG_KBD_LONGPRESS != 0 && CONFIG_KBD_LONGPRESS != 1)
    #error CONFIG_KBD_LONGPRESS must be defined to either 0 or 1
#endif

#if CONFIG_KBD_BEEP
    #include <drv/buzzer.h>
#endif

#define KBD_CHECK_INTERVAL  10  
#define KBD_DEBOUNCE_TIME   30  
#define KBD_BEEP_TIME        5  
#define KBD_REPEAT_DELAY   400  
#define KBD_REPEAT_RATE    100  
#define KBD_REPEAT_MAXRATE  20  
#define KBD_REPEAT_ACCEL     5  
#define KBD_LNG_DELAY     1000  
static enum { KS_IDLE, KS_REPDELAY, KS_REPEAT } kbd_rptStatus;


static volatile keymask_t kbd_buf; 
static volatile keymask_t kbd_cnt; 
static keymask_t kbd_rpt_mask;     
#if CONFIG_KBD_POLL == KBD_POLL_SOFTINT
static Timer kbd_timer;            
#endif

static List kbd_rawHandlers;       
static List kbd_handlers;          
static KbdHandler kbd_defHandler;  
static KbdHandler kbd_debHandler;  
static KbdHandler kbd_rptHandler;  
#if CONFIG_KBD_LONGPRESS
static KbdHandler kbd_lngHandler;  
#endif

#if CONFIG_KBD_OBSERVER
    #include <mware/observer.h>
    Subject kbd_subject;
#endif


static void kbd_poll(void)
{
    static keymask_t current_key;

    struct KbdHandler *handler;
    keymask_t key = kbd_readkeys();

    /* Call raw input handlers */
    FOREACH_NODE(handler, &kbd_rawHandlers)
        key = handler->hook(key);

    /* If this key was not previously pressed */
    if (key != current_key)
    {
        /* Remember last key */
        current_key = key;

        /* Call cooked input handlers */
        FOREACH_NODE(handler, &kbd_handlers)
            key = handler->hook(key);
    }
}

#if CONFIG_KBD_POLL == KBD_POLL_SOFTINT

static void kbd_softint(UNUSED_ARG(iptr_t, arg))
{
    kbd_poll();
    timer_add(&kbd_timer);
}

#elif CONFIG_KBD_POLL == CONFIG_POLL_FREERTOS

#include "FreeRTOS.h"
#include "task.h"

static portTASK_FUNCTION(kbd_task, arg)
{
    for (;;)
    {
        kbd_poll();
        timer_delay(KBD_CHECK_INTERVAL);
    }
}

#endif /* CONFIG_KBD_POLL */

keymask_t kbd_peek(void)
{
    keymask_t key = 0;

// FIXME: make it optional
    /* Let other tasks run for a while */
    extern void schedule(void);
    schedule();

    /* Extract an event from the keyboard buffer */
    IRQ_DISABLE;
    if (kbd_cnt)
    {
        --kbd_cnt;
        key = kbd_buf;
    }
    IRQ_ENABLE;

    return key;
}

keymask_t kbd_get(void)
{
    keymask_t key;

    while (!(key = kbd_peek())) {}

    return key;
}


keymask_t kbd_get_timeout(mtime_t timeout)
{
    keymask_t key;

    ticks_t start = timer_clock();
    ticks_t stop  = ms_to_ticks(timeout);
    do
    {
        if ((key = kbd_peek()))
            return key;
    }
    while (timer_clock() - start < stop);

    return K_TIMEOUT;
}


void kbd_addHandler(struct KbdHandler *handler)
{
    KbdHandler *node;
    List *list;

    cpuflags_t flags;
    IRQ_SAVE_DISABLE(flags);

    /* Choose between raw and coocked handlers list */
    list = (handler->flags & KHF_RAWKEYS) ?
        &kbd_rawHandlers : &kbd_handlers;

    /*
     * Search for the first node whose priority
     * is lower than the timer we want to add.
     */
    FOREACH_NODE(node,list)
        if (node->pri < handler->pri)
            break;

    /* Enqueue handler in the handlers chain */
    INSERT_BEFORE(&handler->link, &node->link);

    IRQ_RESTORE(flags);
}


void kbd_remHandler(struct KbdHandler *handler)
{
    /* Remove the handler */
    ATOMIC(REMOVE(&handler->link));
}


static keymask_t kbd_defHandlerFunc(keymask_t key)
{
    if (key)
    {
        /* Force a single event in kbd buffer */
        kbd_buf = key;
        kbd_cnt = 1;

        #if CONFIG_KBD_OBSERVER
            observer_notify(&kbd_subject, KBD_EVENT_KEY, &key);
        #endif

        #if CONFIG_KBD_BEEP
            if (!(key & K_REPEAT))
                buz_beep(KBD_BEEP_TIME);
        #endif
    }

    /* Eat all input */
    return 0;
}

static keymask_t kbd_debHandlerFunc(keymask_t key)
{
    static keymask_t debounce_key;

    static ticks_t debounce_time;

    static keymask_t new_key;


    ticks_t now = timer_clock();

    if (key != debounce_key)
    {
        /* Reset debounce timer */
        debounce_key = key;
        debounce_time = now;
    }
    else if ((new_key != debounce_key)
        && (now - debounce_time > ms_to_ticks(KBD_DEBOUNCE_TIME)))
    {
        new_key = debounce_key;
        debounce_time = now;
    }

    return new_key;
}

#if CONFIG_KBD_LONGPRESS

static keymask_t kbd_lngHandlerFunc(keymask_t key)
{
    static ticks_t start;
    ticks_t now = timer_clock();

    if (key & K_LNG_MASK)
    {
        if (now - start > ms_to_ticks(KBD_LNG_DELAY))
            key |= K_LONG;
    }
    else
        start = now;
    return key;
}
#endif

keymask_t kbd_setRepeatMask(keymask_t mask)
{
    keymask_t oldmask = kbd_rpt_mask;
    ATOMIC(kbd_rpt_mask = mask);
    return oldmask;
}

static keymask_t kbd_rptHandlerFunc(keymask_t key)
{
    /* Timer for keyboard repeat events. */
    static ticks_t repeat_time;

    /* Current repeat rate (for acceleration). */
    static ticks_t repeat_rate; 
    ticks_t now = timer_clock();

    switch (kbd_rptStatus)
    {
        case KS_IDLE:
            if (key & kbd_rpt_mask)
            {
                repeat_time = now;
                kbd_rptStatus = KS_REPDELAY;
            }
            break;

        case KS_REPDELAY:
            if (key & kbd_rpt_mask)
            {
                if (now - repeat_time > ms_to_ticks(KBD_REPEAT_DELAY))
                {
                    key = (key & kbd_rpt_mask) | K_REPEAT;
                    repeat_time = now;
                    repeat_rate = ms_to_ticks(KBD_REPEAT_RATE);
                    kbd_rptStatus = KS_REPEAT;
                }
                else
                    key = 0;
            }
            else
                kbd_rptStatus = KS_IDLE;
            break;

        case KS_REPEAT:
            if (key & kbd_rpt_mask)
            {
                if (now - repeat_time > repeat_rate)
                {
                    /* Enqueue a new event in the buffer */
                    key = (key & kbd_rpt_mask) | K_REPEAT;
                    repeat_time = now;

                    /* Repeat rate acceleration */
                    if (repeat_rate > ms_to_ticks(KBD_REPEAT_MAXRATE))
                        repeat_rate -= ms_to_ticks(KBD_REPEAT_ACCEL);
                }
                else
                    key = 0;
            }
            else
                kbd_rptStatus = KS_IDLE;

            break;
    }

    return key;
}


MOD_DEFINE(kbd)


void kbd_init(void)
{
#if CONFIG_KBD_BEEP
    MOD_CHECK(buzzer);
#endif

    KBD_HW_INIT;

    /* Init handlers lists */
    LIST_INIT(&kbd_handlers);
    LIST_INIT(&kbd_rawHandlers);

    /* Add debounce keyboard handler */
    kbd_debHandler.hook = kbd_debHandlerFunc;
    kbd_debHandler.pri = 100; /* high priority */
    kbd_debHandler.flags = KHF_RAWKEYS;
    kbd_addHandler(&kbd_debHandler);

    #if CONFIG_KBD_LONGPRESS
    /* Add long pression keyboard handler */
    kbd_lngHandler.hook = kbd_lngHandlerFunc;
    kbd_lngHandler.pri = 90; /* high priority */
    kbd_lngHandler.flags = KHF_RAWKEYS;
    kbd_addHandler(&kbd_lngHandler);
    #endif

    /* Add repeat keyboard handler */
    kbd_rptHandler.hook = kbd_rptHandlerFunc;
    kbd_rptHandler.pri = 80; /* high priority */
    kbd_rptHandler.flags = KHF_RAWKEYS;
    kbd_addHandler(&kbd_rptHandler);

    /* Add default keyboard handler */
    kbd_defHandler.hook = kbd_defHandlerFunc;
    kbd_defHandler.pri = -128; /* lowest priority */
    kbd_addHandler(&kbd_defHandler);

#if CONFIG_KBD_OBSERVER
    observer_InitSubject(&kbd_subject);
#endif

#if CONFIG_KBD_POLL == KBD_POLL_SOFTINT

    MOD_CHECK(timer);

    /* Add kbd handler to soft timers list */
    event_initSoftInt(&kbd_timer.expire, kbd_softint, NULL);
    timer_setDelay(&kbd_timer, ms_to_ticks(KBD_CHECK_INTERVAL));
    timer_add(&kbd_timer);

#elif CONFIG_KBD_POLL == CONFIG_POLL_FREERTOS

    /* Create a timer specific thread */
    xTaskCreate(kbd_task, "kbd", CONFIG_STACK_KBD,
            NULL, CONFIG_PRI_KBD, NULL);

#else
    #error "Define keyboard poll method"
#endif

    MOD_INIT(kbd);
}