key_buffer.c

sparc硬件平台上的键盘驱动

/************************************************************
  Copyright (C), 2007,DTK Computer.
  FileName: key_buffer.c
  Author:   rome              Version : 1.0.0         Date:2007.03.21
  Description:     键盘缓冲操作，在内部处理了竞争条件的情况。      
  Version:         DTK-EMMI-1.0.0
  Function List:   
    1.key_buffer_new:键盘缓冲对象的创建。
    2.key_buffer_clear:清除键盘缓冲内容。
    3.key_buffer_is_empty:缓冲对象内部没有加锁的情况下判断缓冲是否为空。
    4.key_buffer_is_empty_unlock:缓冲对象内部加锁的情况下判断缓冲是否为空。 
    5.key_buffer_put:把扫描码放进缓冲。
    6.key_buffer_get:从缓冲获取扫描码，超时返回超时码。
  Macro List:
    1.key_buffer_cycle_add:在 0到(KEY_BUFFER_LEN-1)的取值范围内循环加。
    2.TRACE(x...):用于测试打印调试信息。
  History:         
      <author>   <time>    <version >    <desc>
      rome      2007/03/21  1.0.0     build this moudle  
***********************************************************/

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <time.h>
#include <sys/time.h>
#include <assert.h>

#include "key_buffer.h"
#include "mmi_lock.h"

//#define KEY_BUFFER_LEN 16
#define KEY_BUFFER_LEN 8 /* for test the simulate */

/* 通过 ＆ 操作符使KeyBuffer中的index值的取值范围为: 0---KEY_BUFFER_LEN - 1 
   注意KEY_BUFFER_LEN必需是 2 的 n 次方 */
#define key_buffer_cycle_add(index)                   \
         do                                           \
         {                                            \
          (index) = ((index) + 1) & (KEY_BUFFER_LEN - 1); \
         } while(0)

/* 下面的宏是测试用的 */
#define KEY_BUFFER_TEST 1
#ifdef KEY_BUFFER_TEST
    #define TRACE(x...)    printf("KeyBuffer: " x)
#else
    #define TRACE(x...)   do {} while(0)
#endif

struct _KeyBuffer
{
    mmi_mutex_t lock;
    mmi_thread_cond_t cond;
    D_INT8 waiter;
    D_INT8 head;
    D_INT8 tail;
    char buf[KEY_BUFFER_LEN];
};

KeyBuffer *key_buffer_new(void)
{
    KeyBuffer *key_buffer;

    key_buffer = (KeyBuffer *)calloc(1, sizeof(struct _KeyBuffer));
    key_buffer->head = key_buffer->tail = 0;
    key_buffer->waiter = 0;
    mmi_mutext_init(&key_buffer->lock, NULL);
    mmi_thread_cond_init(&key_buffer->cond, NULL);

    return key_buffer;
}

void key_buffer_destroy(KeyBuffer *key_buffer)
{
    mmi_mutext_destroy(&key_buffer->lock);
    mmi_thread_cond_destroy(&key_buffer->cond);
    
    //memset(key_buffer, 0, sizeof(KeyBuffer));
    free(key_buffer);
}

void key_buffer_clear(KeyBuffer *key_buffer)
{
    mmi_mutex_lock(&key_buffer->lock);

    key_buffer->head = key_buffer->tail = 0;

    mmi_mutex_unlock(&key_buffer->lock);
}

D_BOOL key_buffer_is_empty(KeyBuffer *key_buffer)
{
    D_BOOL is_empty;

    mmi_mutex_lock(&key_buffer->lock);

    is_empty = key_buffer_is_empty_unlock(key_buffer);

    mmi_mutex_unlock(&key_buffer->lock);

    return is_empty;
}

D_BOOL key_buffer_is_empty_unlock(KeyBuffer *key_buffer)
{
    return key_buffer->head == key_buffer->tail;
}

void key_buffer_put(KeyBuffer *key_buffer, char ch)
{
    mmi_mutex_lock(&key_buffer->lock);

    key_buffer->buf[key_buffer->head] = ch;
    key_buffer_cycle_add(key_buffer->head);
    if (key_buffer->head == key_buffer->tail)
    {
        key_buffer_cycle_add(key_buffer->tail);
    }

    if (key_buffer->waiter > 0)
    {
        mmi_thread_cond_signal(&key_buffer->cond);
    }

#ifdef KEY_BUFFER_TEST
    int head = (key_buffer->head >= key_buffer->tail) 
               ? key_buffer->head
               : key_buffer->head + KEY_BUFFER_LEN;
    int tail = key_buffer->tail;
    TRACE("there is number %d char in the key buffer\n", head - tail);
#endif

    mmi_mutex_unlock(&key_buffer->lock);
}

D_INT16 key_buffer_get(KeyBuffer *key_buffer, D_INT8 timeout)
{
    D_INT32 ret_waite = 0;
    D_INT16 ret_ch;

    mmi_mutex_lock(&key_buffer->lock);

    if (timeout > 0)
    {
        struct timespec waite_time = {0};
        struct timeval current_time;

        gettimeofday(&current_time, NULL);

        /* FIXME: 这里的时间处理看具体的硬件封装接口 */
        //clock_gettime(CLOCK_REALTIME, &waite_time);
        waite_time.tv_sec = current_time.tv_sec;
        waite_time.tv_sec += timeout;

        while (key_buffer_is_empty_unlock(key_buffer) && 0 == ret_waite)
        {
            key_buffer->waiter++; 
            TRACE("there is %d waiting for key_buffer\n",key_buffer->waiter); 

            ret_waite = mmi_thread_cond_timedwait(&key_buffer->cond, 
                                                  &key_buffer->lock, 
                                                  &waite_time);

            key_buffer->waiter--; 
            TRACE("there is %d waiting for key_buffer\n",key_buffer->waiter); 
        }
    }
    else
    {
        while (key_buffer_is_empty_unlock(key_buffer) && 0 == ret_waite)
        {
            key_buffer->waiter++; 
            TRACE("there is %d waiting for key_buffer\n",key_buffer->waiter); 

            ret_waite = mmi_thread_cond_wait(&key_buffer->cond, &key_buffer->lock);

            key_buffer->waiter--; 
            TRACE("there is %d waiting for key_buffer\n",key_buffer->waiter); 
        }
    }

    if (0 == ret_waite) /* 正常返回 */
    {
        ret_ch = key_buffer->buf[key_buffer->tail];
        key_buffer_cycle_add(key_buffer->tail);

        mmi_mutex_unlock(&key_buffer->lock);

        return ret_ch;
    }
    else
    {
        mmi_mutex_unlock(&key_buffer->lock);

        if (timeout)
        {
            return GET_OVER_TIME; 
        }

        printf("key_buffer_get error !!!\n");
        assert(0); /* 在调试时，出错停止 */

        return GET_OVER_TIME;
    }
}