chinky/rtt-f030
chinky/rtt-f030
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update mini2440 bsp

Browse Source 
git-svn-id: https://rt-thread.googlecode.com/svn/trunk@1239 bbd45198-f89e-11dd-88c7-29a3b14d5316
This commit is contained in:
qiuyiuestc 2011-01-12 14:54:05 +00:00
parent 50bd74d3cb
commit 7c83c7da56
7 changed files with 738 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bsp/mini2440/application.c
View File

@ -105,6 +105,9 @@ void rt_init_thread_entry(void* parameter)
/* init touch panel */ /* init touch panel */
rtgui_touch_hw_init(); rtgui_touch_hw_init();
/* init keypad */
rt_hw_key_init();
/* re-init device driver */ /* re-init device driver */
rt_device_init_all(); rt_device_init_all();
@ -143,6 +146,9 @@ void rt_init_thread_entry(void* parameter)
/* init touch panel */ /* init touch panel */
rtgui_touch_hw_init(); rtgui_touch_hw_init();
/* init keypad */
rt_hw_key_init();
/* re-init device driver */ /* re-init device driver */
rt_device_init_all(); rt_device_init_all();

66
bsp/mini2440/board.c
View File

@ -29,16 +29,12 @@
extern rt_uint32_t PCLK, FCLK, HCLK, UCLK; extern rt_uint32_t PCLK, FCLK, HCLK, UCLK;
extern void rt_hw_clock_init(void); 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_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_get_clock(void);
extern void rt_hw_set_dividor(rt_uint8_t hdivn, rt_uint8_t pdivn); 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); extern void rt_hw_set_clock(rt_uint8_t sdiv, rt_uint8_t pdiv, rt_uint8_t mdiv);
#define UART0 ((struct uartport *)&U0BASE) #define UART0 ((struct uartport *)&U0BASE)
struct serial_int_rx uart0_int_rx; struct serial_int_rx uart0_int_rx;
struct serial_device uart0 = struct serial_device uart0 =
@ -49,10 +45,20 @@ struct serial_device uart0 =
}; };
struct rt_device uart0_device; 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 * This function will handle rtos timer
*/ */
void rt_timer_handler(int vector) static void rt_timer_handler(int vector)
{ {
rt_tick_increase(); rt_tick_increase();
} }
@ -60,7 +66,7 @@ void rt_timer_handler(int vector)
/** /**
* This function will handle serial * This function will handle serial
*/ */
void rt_serial_handler(int vector) static void rt_serial0_handler(int vector)
{ {
INTSUBMSK |= (BIT_SUB_RXD0); INTSUBMSK |= (BIT_SUB_RXD0);
@ -72,10 +78,25 @@ void rt_serial_handler(int vector)
INTSUBMSK &=~(BIT_SUB_RXD0); 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 * This function will handle init uart
*/ */
void rt_hw_uart_init(void) static void rt_hw_uart_init(void)
{ {
int i; int i;
/* UART0 port configure */ /* UART0 port configure */
@ -99,19 +120,39 @@ void rt_hw_uart_init(void)
/* output PCLK to UART0/1, PWMTIMER */ /* output PCLK to UART0/1, PWMTIMER */
CLKCON |= 0x0D00; 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++); for (i = 0; i < 100; i++);
/* install uart isr */ /* install uart0 isr */
INTSUBMSK &= ~(BIT_SUB_RXD0); 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_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 * This function will init timer4 for system ticks
*/ */
void rt_hw_timer_init() static void rt_hw_timer_init()
{ {
/* timer4, pre = 15+1 */ /* timer4, pre = 15+1 */
TCFG0 &= 0xffff00ff; TCFG0 &= 0xffff00ff;
@ -148,11 +189,6 @@ void rt_hw_board_init()
/* initialize uart */ /* initialize uart */
rt_hw_uart_init(); rt_hw_uart_init();
#ifdef RT_USING_RTGUI
/* init virtual keypad */
rt_hw_key_init();
#endif
/* initialize mmu */ /* initialize mmu */
rt_hw_mmu_init(); rt_hw_mmu_init();

354
bsp/mini2440/key.c
View File

@ -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 <rtthread.h>
#include <s3c24x0.h> #include <s3c24x0.h>
#include <rthw.h>
#ifdef RT_USING_RTGUI #define KEY_RX_BUFFER_SIZE 32
#include <rtgui/event.h>
#include <rtgui/rtgui_server.h>
#endif
static void key_handle(int key_value) struct rt_key_device
{ {
#ifdef RT_USING_RTGUI struct rt_device parent;
struct rtgui_event_kbd kbd_event;
/* init keyboard event */ rt_uint32_t rx_buffer[KEY_RX_BUFFER_SIZE];
RTGUI_EVENT_KBD_INIT(&kbd_event); rt_uint32_t read_index, save_index;
kbd_event.mod = RTGUI_KMOD_NONE; };
kbd_event.unicode = 0; static struct rt_key_device *key_device = RT_NULL;
kbd_event.key = RTGUIK_UNKNOWN;
if(key_value & 0x80) /* save a char to serial buffer */
static void rt_key_savechar(char ch)
{ {
kbd_event.type = RTGUI_KEYUP; rt_base_t level;
}
else /* 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; /* enable interrupt */
switch(key_value) rt_hw_interrupt_enable(level);
{
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;
} }
if (kbd_event.key != RTGUIK_UNKNOWN) /* ISR for serial interrupt */
static void rt_hw_key_isr(void)
{ {
/* post down event */ /* save on rx buffer */
rtgui_server_post_event(&(kbd_event.parent), sizeof(kbd_event)); 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 * 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); INTSUBMSK |= (BIT_SUB_RXD1);
key_handle(URXH1); rt_hw_key_isr();
SUBSRCPND |= BIT_SUB_RXD1; SUBSRCPND |= BIT_SUB_RXD1;
@ -105,9 +94,9 @@ void rt_virtual_key_isr(int vector)
/** /**
* This function is only for QEMU emulation * 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; GPHCON |= 0xa0;
/*PULLUP is enable */ /*PULLUP is enable */
@ -137,10 +126,219 @@ void rt_hw_key_init(void)
for (i = 0; i < 100; i++); for (i = 0; i < 100; i++);
/* install keypad isr */ /* install key isr */
INTSUBMSK &= ~(BIT_SUB_RXD1); 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); 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);
}

24
bsp/mini2440/lcd_t35.c
View File

@ -113,8 +113,8 @@
#define S3C2410_LCDINT_FRSYNC (1<<1) #define S3C2410_LCDINT_FRSYNC (1<<1)
static volatile rt_uint16_t _rt_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH]; 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_hw_framebuffer[RT_HW_LCD_HEIGHT][RT_HW_LCD_WIDTH];
struct rtgui_lcd_device struct rtgui_lcd_device
{ {
@ -307,7 +307,7 @@ static rt_err_t rt_lcd_init (rt_device_t dev)
GPDCON = 0xaaaaaaaa; GPDCON = 0xaaaaaaaa;
#define M5D(n) ((n)&0x1fffff) #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); 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); 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); 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; 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) void rt_hw_lcd_init(void)
{ {
lcd = (struct rtgui_lcd_device*)rt_malloc(sizeof(struct rtgui_lcd_device)); 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 */ /* init device structure */
lcd->parent.type = RT_Device_Class_Unknown; lcd->parent.type = RT_Device_Class_Unknown;
lcd->parent.init = rt_lcd_init; 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.control = rt_lcd_control;
lcd->parent.user_data = RT_NULL; lcd->parent.user_data = RT_NULL;
lcd->byte_per_pixel = 2; lcd->byte_per_pixel = 2;
lcd->width = LCD_WIDTH; lcd->width = LCD_WIDTH;
lcd->height = LCD_HEIGHT; lcd->height = LCD_HEIGHT;
lcd->hw_framebuffer = (void*)_rt_hw_framebuffer; lcd->hw_framebuffer = (void*)_rt_framebuffer;
/* register touch device to RT-Thread */ /* register touch device to RT-Thread */
rt_device_register(&(lcd->parent), "lcd", RT_DEVICE_FLAG_RDWR); rt_device_register(&(lcd->parent), "lcd", RT_DEVICE_FLAG_RDWR);

10
bsp/mini2440/sdcard.c
View File

@ -340,22 +340,22 @@ struct dfs_partition part[4];
static rt_err_t rt_sdcard_init(rt_device_t dev) 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) 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) 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) 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) 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; return size;
} }
void rt_hw_sdcard_init() void rt_hw_sdcard_init(void)
{ {
rt_uint8_t i, status; rt_uint8_t i, status;
rt_uint8_t *sector; rt_uint8_t *sector;

9
bsp/mini2440/startup.c
View File

@ -38,6 +38,8 @@ extern void rt_application_init(void);
extern struct serial_device uart0; extern struct serial_device uart0;
extern struct rt_device uart0_device; extern struct rt_device uart0_device;
extern struct serial_device uart2;
extern struct rt_device uart2_device;
/** /**
* @addtogroup mini2440 * @addtogroup mini2440
@ -105,11 +107,16 @@ void rtthread_startup(void)
rt_system_scheduler_init(); rt_system_scheduler_init();
#ifdef RT_USING_DEVICE #ifdef RT_USING_DEVICE
/* register uart1 */ /* register uart0 */
rt_hw_serial_register(&uart0_device, "uart0", rt_hw_serial_register(&uart0_device, "uart0",
RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM, RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_STREAM,
&uart0); &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 #ifdef RT_USING_DFS
rt_hw_sdcard_init(); rt_hw_sdcard_init();
#endif #endif