update mini2440 bsp
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1239 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
qiuyiuestc
parent
50bd74d3cb
commit
7c83c7da56
@ -105,6 +105,9 @@ void rt_init_thread_entry(void* parameter)
|
||||
/* init touch panel */
|
||||
rtgui_touch_hw_init();
|
||||
|
||||
/* init keypad */
|
||||
rt_hw_key_init();
|
||||
|
||||
/* re-init device driver */
|
||||
rt_device_init_all();
|
||||
|
||||
@ -143,6 +146,9 @@ void rt_init_thread_entry(void* parameter)
|
||||
/* init touch panel */
|
||||
rtgui_touch_hw_init();
|
||||
|
||||
/* init keypad */
|
||||
rt_hw_key_init();
|
||||
|
||||
/* re-init device driver */
|
||||
rt_device_init_all();
|
||||
|
||||
|
||||
@ -29,16 +29,12 @@
|
||||
extern rt_uint32_t PCLK, FCLK, HCLK, UCLK;
|
||||
|
||||
extern void rt_hw_clock_init(void);
|
||||
extern void rt_hw_lcd_init(void);
|
||||
extern void rt_hw_mmu_init(void);
|
||||
extern void rt_hw_touch_init(void);
|
||||
extern void rt_hw_key_init(void);
|
||||
|
||||
extern void rt_hw_get_clock(void);
|
||||
extern void rt_hw_set_dividor(rt_uint8_t hdivn, rt_uint8_t pdivn);
|
||||
extern void rt_hw_set_clock(rt_uint8_t sdiv, rt_uint8_t pdiv, rt_uint8_t mdiv);
|
||||
|
||||
|
||||
#define UART0 ((struct uartport *)&U0BASE)
|
||||
struct serial_int_rx uart0_int_rx;
|
||||
struct serial_device uart0 =
|
||||
@ -49,10 +45,20 @@ struct serial_device uart0 =
|
||||
};
|
||||
struct rt_device uart0_device;
|
||||
|
||||
#define UART2 ((struct uartport *)&U2BASE)
|
||||
struct serial_int_rx uart2_int_rx;
|
||||
struct serial_device uart2 =
|
||||
{
|
||||
UART2,
|
||||
&uart2_int_rx,
|
||||
RT_NULL
|
||||
};
|
||||
struct rt_device uart2_device;
|
||||
|
||||
/**
|
||||
* This function will handle rtos timer
|
||||
*/
|
||||
void rt_timer_handler(int vector)
|
||||
static void rt_timer_handler(int vector)
|
||||
{
|
||||
rt_tick_increase();
|
||||
}
|
||||
@ -60,7 +66,7 @@ void rt_timer_handler(int vector)
|
||||
/**
|
||||
* This function will handle serial
|
||||
*/
|
||||
void rt_serial_handler(int vector)
|
||||
static void rt_serial0_handler(int vector)
|
||||
{
|
||||
INTSUBMSK |= (BIT_SUB_RXD0);
|
||||
|
||||
@ -72,10 +78,25 @@ void rt_serial_handler(int vector)
|
||||
INTSUBMSK &=~(BIT_SUB_RXD0);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function will handle serial
|
||||
*/
|
||||
static void rt_serial2_handler(int vector)
|
||||
{
|
||||
INTSUBMSK |= (BIT_SUB_RXD2);
|
||||
|
||||
rt_hw_serial_isr(&uart2_device);
|
||||
|
||||
SUBSRCPND |= BIT_SUB_RXD2;
|
||||
|
||||
/* Unmask sub interrupt (RXD0) */
|
||||
INTSUBMSK &=~(BIT_SUB_RXD2);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function will handle init uart
|
||||
*/
|
||||
void rt_hw_uart_init(void)
|
||||
static void rt_hw_uart_init(void)
|
||||
{
|
||||
int i;
|
||||
/* UART0 port configure */
|
||||
@ -99,19 +120,39 @@ void rt_hw_uart_init(void)
|
||||
/* output PCLK to UART0/1, PWMTIMER */
|
||||
CLKCON |= 0x0D00;
|
||||
|
||||
/* FIFO enable, Tx/Rx FIFO clear */
|
||||
uart2.uart_device->ufcon = 0x0;
|
||||
/* disable the flow control */
|
||||
uart2.uart_device->umcon = 0x0;
|
||||
/* Normal,No parity,1 stop,8 bit */
|
||||
uart2.uart_device->ulcon = 0x3;
|
||||
/*
|
||||
* tx=level,rx=edge,disable timeout int.,enable rx error int.,
|
||||
* normal,interrupt or polling
|
||||
*/
|
||||
uart2.uart_device->ucon = 0x245;
|
||||
/* Set uart0 bps */
|
||||
uart2.uart_device->ubrd = (rt_int32_t)(PCLK / (BPS * 16)) - 1;
|
||||
|
||||
for (i = 0; i < 100; i++);
|
||||
|
||||
/* install uart isr */
|
||||
/* install uart0 isr */
|
||||
INTSUBMSK &= ~(BIT_SUB_RXD0);
|
||||
|
||||
rt_hw_interrupt_install(INTUART0, rt_serial_handler, RT_NULL);
|
||||
/* install uart2 isr */
|
||||
INTSUBMSK &= ~(BIT_SUB_RXD2);
|
||||
|
||||
rt_hw_interrupt_install(INTUART0, rt_serial0_handler, RT_NULL);
|
||||
rt_hw_interrupt_umask(INTUART0);
|
||||
|
||||
rt_hw_interrupt_install(INTUART2, rt_serial2_handler, RT_NULL);
|
||||
rt_hw_interrupt_umask(INTUART2);
|
||||
}
|
||||
|
||||
/**
|
||||
* This function will init timer4 for system ticks
|
||||
*/
|
||||
void rt_hw_timer_init()
|
||||
static void rt_hw_timer_init()
|
||||
{
|
||||
/* timer4, pre = 15+1 */
|
||||
TCFG0 &= 0xffff00ff;
|
||||
@ -148,11 +189,6 @@ void rt_hw_board_init()
|
||||
/* initialize uart */
|
||||
rt_hw_uart_init();
|
||||
|
||||
#ifdef RT_USING_RTGUI
|
||||
/* init virtual keypad */
|
||||
rt_hw_key_init();
|
||||
#endif
|
||||
|
||||
/* initialize mmu */
|
||||
rt_hw_mmu_init();
|
||||
|
||||
|
||||
@ -1,100 +1,89 @@
|
||||
/*
|
||||
* File : touch.c
|
||||
* This file is part of RT-Thread RTOS
|
||||
* COPYRIGHT (C) 2010, RT-Thread Develop Team
|
||||
*
|
||||
* The license and distribution terms for this file may be
|
||||
* found in the file LICENSE in this distribution or at
|
||||
* http://www.rt-thread.org/license/LICENSE
|
||||
*
|
||||
* 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>
|
||||
|
||||
#ifdef RT_USING_RTGUI
|
||||
#include <rtgui/event.h>
|
||||
#include <rtgui/rtgui_server.h>
|
||||
#endif
|
||||
#define KEY_RX_BUFFER_SIZE 32
|
||||
|
||||
static void key_handle(int key_value)
|
||||
struct rt_key_device
|
||||
{
|
||||
#ifdef RT_USING_RTGUI
|
||||
struct rtgui_event_kbd kbd_event;
|
||||
struct rt_device parent;
|
||||
|
||||
/* init keyboard event */
|
||||
RTGUI_EVENT_KBD_INIT(&kbd_event);
|
||||
kbd_event.mod = RTGUI_KMOD_NONE;
|
||||
kbd_event.unicode = 0;
|
||||
kbd_event.key = RTGUIK_UNKNOWN;
|
||||
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;
|
||||
|
||||
if(key_value & 0x80)
|
||||
/* save a char to serial buffer */
|
||||
static void rt_key_savechar(char ch)
|
||||
{
|
||||
kbd_event.type = RTGUI_KEYUP;
|
||||
}
|
||||
else
|
||||
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)
|
||||
{
|
||||
kbd_event.type = RTGUI_KEYDOWN;
|
||||
key_device->read_index ++;
|
||||
if (key_device->read_index >= KEY_RX_BUFFER_SIZE)
|
||||
key_device->read_index = 0;
|
||||
}
|
||||
|
||||
key_value &= 0x7F;
|
||||
switch(key_value)
|
||||
{
|
||||
case 80:
|
||||
kbd_event.key = RTGUIK_DOWN;
|
||||
break;
|
||||
case 72:
|
||||
kbd_event.key = RTGUIK_UP;
|
||||
break;
|
||||
case 77:
|
||||
kbd_event.key = RTGUIK_RIGHT;
|
||||
break;
|
||||
case 75:
|
||||
kbd_event.key = RTGUIK_LEFT;
|
||||
break;
|
||||
case 31:
|
||||
kbd_event.key = 's';
|
||||
break;
|
||||
case 30:
|
||||
kbd_event.key = 'a';
|
||||
break;
|
||||
case 44:
|
||||
kbd_event.key = 'z';
|
||||
break;
|
||||
case 45:
|
||||
kbd_event.key = 'x';
|
||||
break;
|
||||
case 46:
|
||||
kbd_event.key = 'c';
|
||||
break;
|
||||
case 16:
|
||||
kbd_event.key = 'q';
|
||||
break;
|
||||
case 33:
|
||||
kbd_event.key = 'r';
|
||||
break;
|
||||
case 23:
|
||||
kbd_event.key = 'i';
|
||||
break;
|
||||
case 50:
|
||||
kbd_event.key = 'm';
|
||||
break;
|
||||
case 38:
|
||||
kbd_event.key = 'l';
|
||||
break;
|
||||
case 47:
|
||||
kbd_event.key = 'v';
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
/* enable interrupt */
|
||||
rt_hw_interrupt_enable(level);
|
||||
}
|
||||
|
||||
if (kbd_event.key != RTGUIK_UNKNOWN)
|
||||
/* ISR for serial interrupt */
|
||||
static void rt_hw_key_isr(void)
|
||||
{
|
||||
/* post down event */
|
||||
rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event));
|
||||
/* 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);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
|
||||
/**
|
||||
* This function is only for QEMU emulation
|
||||
*/
|
||||
void rt_virtual_key_isr(int vector)
|
||||
static void rt_key_handler(int vector)
|
||||
{
|
||||
INTSUBMSK |= (BIT_SUB_RXD1);
|
||||
|
||||
key_handle(URXH1);
|
||||
rt_hw_key_isr();
|
||||
|
||||
SUBSRCPND |= BIT_SUB_RXD1;
|
||||
|
||||
@ -105,9 +94,9 @@ void rt_virtual_key_isr(int vector)
|
||||
/**
|
||||
* This function is only for QEMU emulation
|
||||
*/
|
||||
void rt_hw_key_init(void)
|
||||
static void key_init(void)
|
||||
{
|
||||
unsigned long i;
|
||||
int i = 0;
|
||||
|
||||
GPHCON |= 0xa0;
|
||||
/*PULLUP is enable */
|
||||
@ -137,10 +126,219 @@ void rt_hw_key_init(void)
|
||||
|
||||
for (i = 0; i < 100; i++);
|
||||
|
||||
/* install keypad isr */
|
||||
/* install key isr */
|
||||
INTSUBMSK &= ~(BIT_SUB_RXD1);
|
||||
|
||||
rt_hw_interrupt_install(INTUART1, rt_virtual_key_isr, RT_NULL);
|
||||
rt_hw_interrupt_install(INTUART1, rt_key_handler, RT_NULL);
|
||||
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_size_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, rt_uint8_t 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 void 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));
|
||||
}
|
||||
}
|
||||
|
||||
#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);
|
||||
}
|
||||
|
||||
|
||||
@ -113,8 +113,8 @@
|
||||
|
||||
#define S3C2410_LCDINT_FRSYNC (1<<1)
|
||||
|
||||
static volatile rt_uint16_t _rt_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH];
|
||||
static volatile rt_uint16_t _rt_hw_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH];
|
||||
volatile rt_uint16_t _rt_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH];
|
||||
volatile rt_uint16_t _rt_hw_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH];
|
||||
|
||||
struct rtgui_lcd_device
|
||||
{
|
||||
@ -307,7 +307,7 @@ static rt_err_t rt_lcd_init (rt_device_t dev)
|
||||
GPDCON = 0xaaaaaaaa;
|
||||
|
||||
#define M5D(n) ((n)&0x1fffff)
|
||||
#define LCD_ADDR ((rt_uint32_t)_rt_hw_framebuffer)
|
||||
#define LCD_ADDR ((rt_uint32_t)_rt_framebuffer)
|
||||
LCDCON1 = (LCD_PIXCLOCK << 8) | (3 << 5) | (12 << 1);
|
||||
LCDCON2 = (LCD_UPPER_MARGIN << 24) | ((LCD_HEIGHT - 1) << 14) | (LCD_LOWER_MARGIN << 6) | (LCD_VSYNC_LEN << 0);
|
||||
LCDCON3 = (LCD_RIGHT_MARGIN << 19) | ((LCD_WIDTH - 1) << 8) | (LCD_LEFT_MARGIN << 0);
|
||||
@ -357,6 +357,20 @@ static rt_err_t rt_lcd_control (rt_device_t dev, rt_uint8_t cmd, void *args)
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_lcd_open(rt_device_t dev, rt_uint16_t oflag)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_lcd_close(rt_device_t dev)
|
||||
{
|
||||
RT_ASSERT(dev != RT_NULL);
|
||||
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
void rt_hw_lcd_init(void)
|
||||
{
|
||||
lcd = (struct rtgui_lcd_device*)rt_malloc(sizeof(struct rtgui_lcd_device));
|
||||
@ -365,12 +379,14 @@ void rt_hw_lcd_init(void)
|
||||
/* init device structure */
|
||||
lcd->parent.type = RT_Device_Class_Unknown;
|
||||
lcd->parent.init = rt_lcd_init;
|
||||
lcd->parent.open = rt_lcd_open;
|
||||
lcd->parent.open = rt_lcd_close;
|
||||
lcd->parent.control = rt_lcd_control;
|
||||
lcd->parent.user_data = RT_NULL;
|
||||
lcd->byte_per_pixel = 2;
|
||||
lcd->width = LCD_WIDTH;
|
||||
lcd->height = LCD_HEIGHT;
|
||||
lcd->hw_framebuffer = (void*)_rt_hw_framebuffer;
|
||||
lcd->hw_framebuffer = (void*)_rt_framebuffer;
|
||||
|
||||
/* register touch device to RT-Thread */
|
||||
rt_device_register(&(lcd->parent), "lcd", RT_DEVICE_FLAG_RDWR);
|
||||
|
||||
@ -340,22 +340,22 @@ struct dfs_partition part[4];
|
||||
|
||||
static rt_err_t rt_sdcard_init(rt_device_t dev)
|
||||
{
|
||||
return 0;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
|
||||
{
|
||||
return 0;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_sdcard_close(rt_device_t dev)
|
||||
{
|
||||
return 0;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_err_t rt_sdcard_control(rt_device_t dev, rt_uint8_t cmd, void *args)
|
||||
{
|
||||
return 0;
|
||||
return RT_EOK;
|
||||
}
|
||||
|
||||
static rt_size_t rt_sdcard_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size)
|
||||
@ -406,7 +406,7 @@ static rt_size_t rt_sdcard_write (rt_device_t dev, rt_off_t pos, const void* buf
|
||||
return size;
|
||||
}
|
||||
|
||||
void rt_hw_sdcard_init()
|
||||
void rt_hw_sdcard_init(void)
|
||||
{
|
||||
rt_uint8_t i, status;
|
||||
rt_uint8_t *sector;
|
||||
|
||||
@ -38,6 +38,8 @@ extern void rt_application_init(void);
|
||||
|
||||
extern struct serial_device uart0;
|
||||
extern struct rt_device uart0_device;
|
||||
extern struct serial_device uart2;
|
||||
extern struct rt_device uart2_device;
|
||||
|
||||
/**
|
||||
* @addtogroup mini2440
|
||||
@ -105,11 +107,16 @@ void rtthread_startup(void)
|
||||
rt_system_scheduler_init();
|
||||
|
||||
#ifdef RT_USING_DEVICE
|
||||
/* register uart1 */
|
||||
/* register uart0 */
|
||||
rt_hw_serial_register(&uart0_device, "uart0",
|
||||
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
|
||||
&uart0);
|
||||
|
||||
/* register uart2, used for RTI debug */
|
||||
rt_hw_serial_register(&uart2_device, "uart2",
|
||||
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
|
||||
&uart2);
|
||||
|
||||
#ifdef RT_USING_DFS
|
||||
rt_hw_sdcard_init();
|
||||
#endif
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user