libs/rt-thread-official
libs
/
rt-thread-official
mirror of https://github.com/RT-Thread/rt-thread.git
4
0
Fork 0
Code Issues Releases Wiki Activity
rt-thread-official/bsp/mini2440/drivers/key.c

343 lines
8.3 KiB
C
Raw Blame History

/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2010-10-01 Yi.Qiu first version
*/
/*
* Warning, this keypad driver can only work on QEMU emulator
*/
#include <rtthread.h>
#include <s3c24x0.h>
#include <rthw.h>
#define KEY_RX_BUFFER_SIZE 32
struct rt_key_device
{
struct rt_device parent;
rt_uint32_t rx_buffer[KEY_RX_BUFFER_SIZE];
rt_uint32_t read_index, save_index;
};
static struct rt_key_device *key_device = RT_NULL;
/* save a char to serial buffer */
static void rt_key_savechar(char ch)
{
rt_base_t level;
/* disable interrupt */
level = rt_hw_interrupt_disable();
key_device->rx_buffer[key_device->save_index] = ch;
key_device->save_index ++;
if (key_device->save_index >= KEY_RX_BUFFER_SIZE)
key_device->save_index = 0;
/* if the next position is read index, discard this 'read char' */
if (key_device->save_index == key_device->read_index)
{
key_device->read_index ++;
if (key_device->read_index >= KEY_RX_BUFFER_SIZE)
key_device->read_index = 0;
}
/* enable interrupt */
rt_hw_interrupt_enable(level);
}
/* ISR for serial interrupt */
static void rt_hw_key_isr(void)
{
/* save on rx buffer */
rt_key_savechar(URXH1 & 0xff);
/* invoke callback */
if (key_device->parent.rx_indicate != RT_NULL)
{
rt_size_t rx_length;
/* get rx length */
rx_length = key_device->read_index > key_device->save_index ?
KEY_RX_BUFFER_SIZE - key_device->read_index + key_device->save_index :
key_device->save_index - key_device->read_index;
key_device->parent.rx_indicate(&key_device->parent, rx_length);
}
}
/**
* This function is only for QEMU emulation
*/
static void rt_key_handler(int vector, void *param)
{
INTSUBMSK |= (BIT_SUB_RXD1);
rt_hw_key_isr();
SUBSRCPND |= BIT_SUB_RXD1;
/*Unmask sub interrupt (RXD0)*/
INTSUBMSK &=~(BIT_SUB_RXD1);
}
/**
* This function is only for QEMU emulation
*/
static void key_init(void)
{
int i = 0;
GPHCON |= 0xa0;
/*PULLUP is enable */
GPHUP |= 0x0c;
/* FIFO enable, Tx/Rx FIFO clear */
UFCON1 = 0x0;
/* disable the flow control */
UMCON1= 0x0;
/* Normal,No parity,1 stop,8 bit */
ULCON1 = 0x3;
/*
* tx=level,rx=edge,disable timeout int.,enable rx error int.,
* normal,interrupt or polling
*/
UCON1 = 0x245;
//UBRD0 = div;
// UBRD0 = 0x500; /* baudrate = 19200bps */
UBRD1 = 0x1a;
UTXH1 = 0x2;
URXH1 = 0x1;
/* output PCLK to UART0/1, PWMTIMER */
CLKCON |= 0x0D00;
for (i = 0; i < 100; i++);
/* install key isr */
INTSUBMSK &= ~(BIT_SUB_RXD1);
rt_hw_interrupt_install(INTUART1, rt_key_handler, RT_NULL , "INTUART1");
rt_hw_interrupt_umask(INTUART1);
}
static rt_err_t rt_key_init(rt_device_t dev)
{
if (!(dev->flag & RT_DEVICE_FLAG_ACTIVATED))
{
if (dev->flag & RT_DEVICE_FLAG_INT_RX)
{
rt_memset(key_device->rx_buffer, 0,
sizeof(key_device->rx_buffer));
key_device->read_index = key_device->save_index = 0;
}
dev->flag |= RT_DEVICE_FLAG_ACTIVATED;
}
return RT_EOK;
}
static rt_err_t rt_key_open(rt_device_t dev, rt_uint16_t oflag)
{
return RT_EOK;
}
static rt_err_t rt_key_close(rt_device_t dev)
{
return RT_EOK;
}
static rt_ssize_t rt_key_read (rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
{
rt_uint8_t* ptr;
rt_err_t err_code;
rt_base_t level;
ptr = buffer;
err_code = RT_EOK;
/* interrupt mode Rx */
while (size)
{
if (key_device->read_index != key_device->save_index)
{
*ptr++ = key_device->rx_buffer[key_device->read_index];
size --;
/* disable interrupt */
level = rt_hw_interrupt_disable();
key_device->read_index ++;
if (key_device->read_index >= KEY_RX_BUFFER_SIZE)
key_device->read_index = 0;
/* enable interrupt */
rt_hw_interrupt_enable(level);
}
else
{
/* set error code */
err_code = -RT_EEMPTY;
break;
}
}
/* set error code */
rt_set_errno(err_code);
return (rt_uint32_t)ptr - (rt_uint32_t)buffer;
}
static rt_err_t rt_key_control(rt_device_t dev, int cmd, void *args)
{
return RT_EOK;
}
#ifdef RT_USING_RTGUI
#include <rtgui/event.h>
#include <rtgui/rtgui_server.h>
#include <rtgui/kbddef.h>
static int s_key_map[0xff] = {0};
static void rt_keymap_init(void)
{
s_key_map[0x1] = RTGUIK_ESCAPE;
s_key_map[0xc] = RTGUIK_MINUS;
s_key_map[0x39] = RTGUIK_SPACE;
s_key_map[0xd] = RTGUIK_KP_EQUALS;
s_key_map[0xe] = RTGUIK_BACKSPACE;
s_key_map[0xf] = RTGUIK_TAB;
s_key_map[0x1c] = RTGUIK_KP_ENTER;
s_key_map[0xb] = RTGUIK_0;
s_key_map[0x2] = RTGUIK_1;
s_key_map[0x3] = RTGUIK_2;
s_key_map[0x4] = RTGUIK_3;
s_key_map[0x5] = RTGUIK_4;
s_key_map[0x6] = RTGUIK_5;
s_key_map[0x7] = RTGUIK_6;
s_key_map[0x8] = RTGUIK_7;
s_key_map[0x9] = RTGUIK_8;
s_key_map[0xa] = RTGUIK_9;
s_key_map[0x3b] = RTGUIK_F1;
s_key_map[0x3c] = RTGUIK_F2;
s_key_map[0x3d] = RTGUIK_F3;
s_key_map[0x3e] = RTGUIK_F4;
s_key_map[0xef] = RTGUIK_F5;
s_key_map[0x40] = RTGUIK_F6;
s_key_map[0x41] = RTGUIK_F7;
s_key_map[0x42] = RTGUIK_F8;
s_key_map[0x43] = RTGUIK_F9;
s_key_map[0x1e] = RTGUIK_a;
s_key_map[0x30] = RTGUIK_b;
s_key_map[0x2c] = RTGUIK_c;
s_key_map[0x20] = RTGUIK_d;
s_key_map[0x12] = RTGUIK_e;
s_key_map[0x21] = RTGUIK_f;
s_key_map[0x22] = RTGUIK_g;
s_key_map[0x23] = RTGUIK_h;
s_key_map[0x17] = RTGUIK_i;
s_key_map[0x24] = RTGUIK_j;
s_key_map[0x25] = RTGUIK_k;
s_key_map[0x26] = RTGUIK_l;
s_key_map[0x32] = RTGUIK_m;
s_key_map[0x31] = RTGUIK_n;
s_key_map[0x18] = RTGUIK_o;
s_key_map[0x19] = RTGUIK_p;
s_key_map[0x10] = RTGUIK_q;
s_key_map[0x13] = RTGUIK_r;
s_key_map[0x1f] = RTGUIK_s;
s_key_map[0x14] = RTGUIK_t;
s_key_map[0x16] = RTGUIK_u;
s_key_map[0x2f] = RTGUIK_v;
s_key_map[0x11] = RTGUIK_w;
s_key_map[0x2d] = RTGUIK_x;
s_key_map[0x15] = RTGUIK_y;
s_key_map[0x2c] = RTGUIK_z;
s_key_map[0x4b] = RTGUIK_LEFT;
s_key_map[0x4d] = RTGUIK_RIGHT;
s_key_map[0x50] = RTGUIK_DOWN;
s_key_map[0x2e] = RTGUIK_DELETE;
s_key_map[0x48] = RTGUIK_UP;
}
static rt_err_t rtgui_key_rx(rt_device_t dev, rt_size_t size)
{
struct rtgui_event_kbd kbd_event;
char key_value;
while(rt_device_read(dev, 0, &key_value, 1) == 1)
{
/* init keyboard event */
RTGUI_EVENT_KBD_INIT(&kbd_event);
kbd_event.mod = RTGUI_KMOD_NONE;
kbd_event.unicode = 0;
kbd_event.key = RTGUIK_UNKNOWN;
if(key_value & 0x80)
{
kbd_event.type = RTGUI_KEYUP;
}
else
{
kbd_event.type = RTGUI_KEYDOWN;
}
kbd_event.key = s_key_map[key_value & 0x7F];
}
if (kbd_event.key != RTGUIK_UNKNOWN)
{
/* post down event */
rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event));
}
return RT_EOK;
}
#endif
/*
* key driver register
*/
void rt_hw_key_init(void)
{
/* hardware init */
key_init();
key_device = (struct rt_key_device*)rt_malloc (sizeof(struct rt_key_device));
if (key_device == RT_NULL) return; /* no memory yet */
/* clear device structure */
rt_memset(&(key_device->parent), 0, sizeof(struct rt_device));
key_device->parent.type = RT_Device_Class_Char;
key_device->parent.tx_complete = RT_NULL;
key_device->parent.init = rt_key_init;
key_device->parent.open = rt_key_open;
key_device->parent.close = rt_key_close;
key_device->parent.read = rt_key_read;
key_device->parent.write = RT_NULL;
key_device->parent.control = rt_key_control;
key_device->parent.user_data = RT_NULL;
#ifdef RT_USING_RTGUI
key_device->parent.rx_indicate = rtgui_key_rx;
/* init keymap */
rt_keymap_init();
#endif
/* register key device to RT-Thread */
rt_device_register(&(key_device->parent), "key", RT_DEVICE_FLAG_RDONLY | RT_DEVICE_FLAG_INT_RX);
}
View Git Blame Copy Permalink