1. Add 4.3 inch lcd(480x272) support for mini2440

2. Add choice menu for lcd configure
3. Remove origin sdcard driver and add new mmc driver that use kernel
mmc stack for s3c2440

bsp/mini2440/.config

@@ -161,7 +161,13 @@ CONFIG_RT_USING_PIN=y
 # CONFIG_RT_USING_MTD_NAND is not set
 # CONFIG_RT_USING_PM is not set
 # CONFIG_RT_USING_RTC is not set
-# CONFIG_RT_USING_SDIO is not set
+CONFIG_RT_USING_SDIO=y
+CONFIG_RT_SDIO_STACK_SIZE=512
+CONFIG_RT_SDIO_THREAD_PRIORITY=15
+CONFIG_RT_MMCSD_STACK_SIZE=1024
+CONFIG_RT_MMCSD_THREAD_PREORITY=22
+CONFIG_RT_MMCSD_MAX_PARTITION=16
+# CONFIG_RT_SDIO_DEBUG is not set
 # CONFIG_RT_USING_SPI is not set
 # CONFIG_RT_USING_WDT is not set
 # CONFIG_RT_USING_AUDIO is not set

bsp/mini2440/Kconfig

@@ -16,12 +16,33 @@ config PKGS_DIR
     default "packages"
 
 config BOARD_MINI2440
-    bool "mini2440"
+    bool
     select ARCH_ARM_ARM9
     select RT_USING_COMPONENTS_INIT
     select RT_USING_USER_MAIN
     default y
 
+choice
+    prompt "Lcd for mini2440"
+    default RT_MINI2440_LCD_T35
+    depends on PKG_USING_GUIENGINE
+
+    config RT_MINI2440_LCD_A70
+        bool "A70"
+
+    config RT_MINI2440_LCD_T43
+        bool "T43"
+    
+    config RT_MINI2440_LCD_N35
+        bool "N35"
+    
+    config RT_MINI2440_LCD_T35
+        bool "T35"
+
+    config RT_MINI2440_LCD_X35
+        bool "X35"
+endchoice
+
 source "$RTT_DIR/Kconfig"
 source "$PKGS_DIR/Kconfig"
 

bsp/mini2440/applications/main.c

@@ -5,9 +5,24 @@
 
 #include "led.h"
 
+#ifdef PKG_USING_GUIENGINE
+#include <rtgui/driver.h>
+#endif
+
 int main(void)
 {
-    printf("hello rt-thread\n");
+	rt_device_t device;
+
+	printf("hello rt-thread\n");
+
+#ifdef PKG_USING_GUIENGINE
+	device = rt_device_find("lcd");
+	if (device)
+	{
+		rtgui_graphic_set_device(device);
+	}
+#endif
+
 
     while (1)
     {

bsp/mini2440/applications/mnt.c

@@ -6,15 +6,28 @@
 
 int mnt_init(void)
 {
-	if (dfs_mount("sd0", "/", "elm", 0, 0) == 0)
+	rt_uint32_t tryCnt = 5;
+	rt_device_t dev;
+
+	while(tryCnt--)
 	{
-		rt_kprintf("File System initialized!\n");
+		dev = rt_device_find("sd0");
+		if(dev != RT_NULL)
+		{
+			break;
+		}
+		rt_thread_mdelay(500);
+	}
+
+	if(dfs_mount("sd0", "/", "elm", 0, 0) == 0)                                                                                                                                                        
+	{
+		rt_kprintf("File System initialized!\n");                                                                                                                                                       
 	}
 	else
 	{
 		rt_kprintf("File System initialzation failed!\n");
 	}
-   
+
 	return RT_EOK;
 }
 INIT_ENV_EXPORT(mnt_init);

bsp/mini2440/drivers/SConscript

@@ -8,30 +8,30 @@ cwd     = os.path.join(str(Dir('#')), 'drivers')
 src = Split("""
 board.c
 led.c
+key.c
 uart.c
 """)
 
-if GetDepend('RT_USING_DFS'):
-	src += ['sdcard.c']
-
 if GetDepend('RT_USING_LWIP'):
 	src += ['dm9000.c']
 
-if GetDepend('PKG_USING_GUIENGINE'):
-    src += ['touch.c', 'key.c']
+if GetDepend('RT_MINI2440_LCD_A70'):
+    src += ['lcd_a70.c']
+if GetDepend('RT_MINI2440_LCD_T43'):
+    src += ['lcd_t43.c']
+if GetDepend('RT_MINI2440_LCD_N35'):
+    src += ['lcd_n35.c']
+if GetDepend('RT_MINI2440_LCD_T35'):
+    src += ['lcd_t35.c']
+if GetDepend('RT_MINI2440_LCD_X35'):
+    src += ['lcd_x35.c']
 
-if GetDepend('RT_USING_RTI'):
-    src += ['rti_stub.c']
-		
 if GetDepend('PKG_USING_GUIENGINE'):
-	if rtconfig.RT_USING_LCD_TYPE == 'PNL_A70':
-		src += ['lcd_a70.c']
-	elif rtconfig.RT_USING_LCD_TYPE == 'PNL_N35':
-		src += ['lcd_n35.c']
-	elif rtconfig.RT_USING_LCD_TYPE == 'PNL_T35':
-		src += ['lcd_t35.c']
-	elif rtconfig.RT_USING_LCD_TYPE == 'PNL_X35':
-                src += ['lcd_x35.c']
+	src += ['touch.c']
+
+if GetDepend('RT_USING_SDIO'):
+    src += ['s3cmci.c']
+
 
 CPPPATH = [cwd]
 

bsp/mini2440/drivers/lcd.h

-/*
- * File      : lcd.h
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, 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
- * 2008-03-29     Yi.Qiu
- */
-#ifndef __LCD_H__
-#define __LCD_H__
-
-#include <rtthread.h>
-
-void rt_hw_lcd_init(void);
-
-#endif

bsp/mini2440/drivers/lcd_a70.c

@@ -15,7 +15,6 @@
 #include <rtthread.h>
 #include <s3c24x0.h>
 
-#include "lcd.h"
 
 /* LCD driver for A7' */
 #define LCD_WIDTH 800
@@ -223,10 +222,11 @@ static rt_err_t rt_lcd_control (rt_device_t dev, int cmd, void *args)
 	return RT_EOK;
 }
 
-void rt_hw_lcd_init(void)
+int rt_hw_lcd_init(void)
 {
 	rt_device_t lcd = rt_malloc(sizeof(struct rt_device));
-	if (lcd == RT_NULL) return; /* no memory yet */
+	if (lcd == RT_NULL) 
+            return -RT_ERROR; /* no memory yet */
 
 	_lcd_info.bits_per_pixel = 16;
 	_lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
@@ -246,3 +246,4 @@ void rt_hw_lcd_init(void)
 	rt_device_register(lcd, "lcd", RT_DEVICE_FLAG_RDWR);
 }
 
+INIT_BOARD_EXPORT(rt_hw_lcd_init);

bsp/mini2440/drivers/lcd_n35.c

@@ -15,7 +15,6 @@
 #include <rtthread.h>
 #include <s3c24x0.h>
 
-#include "lcd.h"
 
 /* LCD driver for N3'5 */
 #define LCD_WIDTH 240
@@ -224,10 +223,11 @@ static rt_err_t rt_lcd_control (rt_device_t dev, int cmd, void *args)
 	return RT_EOK;
 }
 
-void rt_hw_lcd_init(void)
+int rt_hw_lcd_init(void)
 {
 	rt_device_t lcd = rt_malloc(sizeof(struct rt_device));
-	if (lcd == RT_NULL) return; /* no memory yet */
+	if (lcd == RT_NULL) 
+            return -RT_ERROR; /* no memory yet */
 
 	_lcd_info.bits_per_pixel = 16;
 	_lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
@@ -247,3 +247,4 @@ void rt_hw_lcd_init(void)
 	rt_device_register(lcd, "lcd", RT_DEVICE_FLAG_RDWR);
 }
 
+INIT_BOARD_EXPORT(rt_hw_lcd_init);

bsp/mini2440/drivers/lcd_t35.c

@@ -15,7 +15,6 @@
 #include <rtthread.h>
 
 #include <s3c24x0.h>
-#include "lcd.h"
 
 /* LCD driver for T3'5 */
 #define LCD_WIDTH 240
@@ -225,10 +224,11 @@ static rt_err_t rt_lcd_control (rt_device_t dev, int cmd, void *args)
 	return RT_EOK;
 }
 
-void rt_hw_lcd_init(void)
+int rt_hw_lcd_init(void)
 {
 	rt_device_t lcd = rt_malloc(sizeof(struct rt_device));
-	if (lcd == RT_NULL) return; /* no memory yet */
+	if (lcd == RT_NULL) 
+		return -RT_ERROR; /* no memory yet */
 
 	_lcd_info.bits_per_pixel = 16;
 	_lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
@@ -248,3 +248,4 @@ void rt_hw_lcd_init(void)
 	rt_device_register(lcd, "lcd", RT_DEVICE_FLAG_RDWR);
 }
 
+INIT_BOARD_EXPORT(rt_hw_lcd_init);

bsp/mini2440/drivers/lcd_t43.c

+/*
+ * File      : lcd_t43.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
+ * 2020-04-12     Jonne        first version from 4.3 inch lcd(480x272)
+ */
+
+#include <rtthread.h>
+#include <s3c24x0.h>
+
+/* LCD driver for N3'5 */
+#define LCD_WIDTH 480
+#define LCD_HEIGHT 272
+#define LCD_PIXCLOCK 4
+
+#define LCD_RIGHT_MARGIN 2
+#define LCD_LEFT_MARGIN 2
+#define LCD_HSYNC_LEN 41
+
+#define LCD_UPPER_MARGIN 2
+#define LCD_LOWER_MARGIN 2
+#define LCD_VSYNC_LEN 10
+
+#define LCD_XSIZE  LCD_WIDTH
+#define LCD_YSIZE  LCD_HEIGHT
+#define SCR_XSIZE  LCD_WIDTH
+#define SCR_YSIZE  LCD_HEIGHT
+
+#define RT_HW_LCD_WIDTH         LCD_WIDTH
+#define RT_HW_LCD_HEIGHT        LCD_HEIGHT
+
+#define MVAL		(13)
+#define MVAL_USED 	(0)		//0=each frame   1=rate by MVAL
+#define INVVDEN		(1)		//0=normal       1=inverted
+#define BSWP		(0)		//Byte swap control
+#define HWSWP		(1)		//Half word swap control
+
+#define GPB1_TO_OUT()		(GPBUP &= 0xfffd, GPBCON &= 0xfffffff3, GPBCON |= 0x00000004)
+#define GPB1_TO_1()			(GPBDAT |= 0x0002)
+#define GPB1_TO_0()			(GPBDAT &= 0xfffd)
+
+#define S3C2410_LCDCON1_CLKVAL(x)  ((x) << 8)
+#define S3C2410_LCDCON1_MMODE	   (1<<7)
+#define S3C2410_LCDCON1_DSCAN4	   (0<<5)
+#define S3C2410_LCDCON1_STN4	   (1<<5)
+#define S3C2410_LCDCON1_STN8	   (2<<5)
+#define S3C2410_LCDCON1_TFT	       (3<<5)
+
+#define S3C2410_LCDCON1_STN1BPP	   (0<<1)
+#define S3C2410_LCDCON1_STN2GREY   (1<<1)
+#define S3C2410_LCDCON1_STN4GREY   (2<<1)
+#define S3C2410_LCDCON1_STN8BPP	   (3<<1)
+#define S3C2410_LCDCON1_STN12BPP   (4<<1)
+
+#define S3C2410_LCDCON1_TFT1BPP	   (8<<1)
+#define S3C2410_LCDCON1_TFT2BPP	   (9<<1)
+#define S3C2410_LCDCON1_TFT4BPP	   (10<<1)
+#define S3C2410_LCDCON1_TFT8BPP	   (11<<1)
+#define S3C2410_LCDCON1_TFT16BPP   (12<<1)
+#define S3C2410_LCDCON1_TFT24BPP   (13<<1)
+
+#define S3C2410_LCDCON1_ENVID	   (1)
+
+#define S3C2410_LCDCON1_MODEMASK    0x1E
+
+#define S3C2410_LCDCON2_VBPD(x)	    ((x) << 24)
+#define S3C2410_LCDCON2_LINEVAL(x)  ((x) << 14)
+#define S3C2410_LCDCON2_VFPD(x)	    ((x) << 6)
+#define S3C2410_LCDCON2_VSPW(x)	    ((x) << 0)
+
+#define S3C2410_LCDCON2_GET_VBPD(x) ( ((x) >> 24) & 0xFF)
+#define S3C2410_LCDCON2_GET_VFPD(x) ( ((x) >>  6) & 0xFF)
+#define S3C2410_LCDCON2_GET_VSPW(x) ( ((x) >>  0) & 0x3F)
+
+#define S3C2410_LCDCON3_HBPD(x)	    ((x) << 19)
+#define S3C2410_LCDCON3_WDLY(x)	    ((x) << 19)
+#define S3C2410_LCDCON3_HOZVAL(x)   ((x) << 8)
+#define S3C2410_LCDCON3_HFPD(x)	    ((x) << 0)
+#define S3C2410_LCDCON3_LINEBLANK(x)((x) << 0)
+
+#define S3C2410_LCDCON3_GET_HBPD(x) ( ((x) >> 19) & 0x7F)
+#define S3C2410_LCDCON3_GET_HFPD(x) ( ((x) >>  0) & 0xFF)
+
+#define S3C2410_LCDCON4_MVAL(x)	    ((x) << 8)
+#define S3C2410_LCDCON4_HSPW(x)	    ((x) << 0)
+#define S3C2410_LCDCON4_WLH(x)	    ((x) << 0)
+
+#define S3C2410_LCDCON4_GET_HSPW(x) ( ((x) >>  0) & 0xFF)
+
+#define S3C2410_LCDCON5_BPP24BL	    (1<<12)
+#define S3C2410_LCDCON5_FRM565	    (1<<11)
+#define S3C2410_LCDCON5_INVVCLK	    (1<<10)
+#define S3C2410_LCDCON5_INVVLINE    (1<<9)
+#define S3C2410_LCDCON5_INVVFRAME   (1<<8)
+#define S3C2410_LCDCON5_INVVD	    (1<<7)
+#define S3C2410_LCDCON5_INVVDEN	    (1<<6)
+#define S3C2410_LCDCON5_INVPWREN    (1<<5)
+#define S3C2410_LCDCON5_INVLEND	    (1<<4)
+#define S3C2410_LCDCON5_PWREN	    (1<<3)
+#define S3C2410_LCDCON5_ENLEND	    (1<<2)
+#define S3C2410_LCDCON5_BSWP	    (1<<1)
+#define S3C2410_LCDCON5_HWSWP	    (1<<0)
+
+#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];
+static struct rt_device_graphic_info _lcd_info;
+
+static void lcd_power_enable(int invpwren, int pwren)
+{
+    //GPG4 is setted as LCD_PWREN
+    GPGUP  = GPGUP | (1<<4); // Pull-up disable
+    GPGCON = GPGCON | (3<<8); //GPG4=LCD_PWREN
+
+    //Enable LCD POWER ENABLE Function
+    LCDCON5 = LCDCON5&(~(1<<3))|(pwren<<3);   // PWREN
+    LCDCON5 = LCDCON5&(~(1<<5))|(invpwren<<5);   // INVPWREN
+}
+
+static void lcd_envid_on_off(int onoff)
+{
+	if(onoff==1)
+		/*ENVID=ON*/
+		LCDCON1|=1;
+	else
+		/*ENVID Off*/
+		LCDCON1 =LCDCON1 & 0x3fffe;
+}
+
+//********************** BOARD LCD backlight ****************************
+static void LcdBkLtSet(rt_uint32_t HiRatio)
+{
+#define FREQ_PWM1		1000
+	if(!HiRatio)
+	{
+		GPBCON  = GPBCON & (~(3<<2)) | (1<<2) ;	
+		GPBDAT &= ~(1<<1);
+		return;
+	}
+	GPBCON = GPBCON & (~(3<<2)) | (2<<2) ;
+
+	if( HiRatio > 100 ) HiRatio = 100 ;
+
+	TCON = TCON & (~(0xf<<8)) ;			    // clear manual update bit, stop Timer1
+
+	TCFG0 &= 0xffffff00;					// set Timer 0&1 prescaler 0
+	TCFG0 |= 15;							//prescaler = 15+1
+
+	TCFG1 &= 0xffffff0f;					// set Timer 1 MUX 1/16
+	TCFG1 |= 0x00000030;					// set Timer 1 MUX 1/16
+
+	TCNTB1	 = ( 100000000>>8 )/FREQ_PWM1;  //if set inverter off, when TCNT2<=TCMP2, TOUT is high, TCNT2>TCMP2, TOUT is low
+	TCMPB1  = ( TCNTB1*(100-HiRatio))/100 ;	//if set inverter on,  when TCNT2<=TCMP2, TOUT is low,  TCNT2>TCMP2, TOUT is high
+
+	TCON = TCON & (~(0xf<<8)) | (0x0e<<8) ;
+	TCON = TCON & (~(0xf<<8)) | (0x0d<<8) ;
+}
+
+/* RT-Thread Device Interface */
+static rt_err_t rt_lcd_init (rt_device_t dev)
+{	
+	GPB1_TO_OUT();
+	GPB1_TO_1();
+
+	GPCUP  = 0x00000000;
+	GPCCON = 0xaaaa02a9;
+
+	GPDUP  = 0x00000000;
+	GPDCON = 0xaaaaaaaa;
+
+#define	M5D(n)	((n)&0x1fffff)
+#define LCD_ADDR ((rt_uint32_t)_rt_framebuffer)
+	LCDCON1 = (LCD_PIXCLOCK << 8) | (3 <<  5) | (12 << 1);
+   	LCDCON2 = ((LCD_UPPER_MARGIN - 1) << 24) | ((LCD_HEIGHT - 1) << 14) | ((LCD_LOWER_MARGIN - 1) << 6) | ((LCD_VSYNC_LEN - 1) << 0);
+   	LCDCON3 = ((LCD_RIGHT_MARGIN - 1) << 19) | ((LCD_WIDTH  - 1) <<  8) | ((LCD_LEFT_MARGIN - 1) << 0);
+   	LCDCON4 = (13 <<  8) | ((LCD_HSYNC_LEN - 1) << 0);
+#if !defined(LCD_CON5)
+    #define LCD_CON5 ((1<<11) | (0<<10) | (1<<9) | (1<<8) | (1<<0))
+#endif
+    LCDCON5   =  LCD_CON5;
+
+    LCDSADDR1 = ((LCD_ADDR >> 22) << 21) | ((M5D(LCD_ADDR >> 1)) <<  0);
+    LCDSADDR2 = M5D((LCD_ADDR + LCD_WIDTH * LCD_HEIGHT * 2) >> 1);
+    LCDSADDR3 = LCD_WIDTH;
+
+	LCDINTMSK |= (3);
+	LPCSEL &= (~7) ;
+	TPAL=0;
+
+	LcdBkLtSet(70) ;
+	lcd_power_enable(0, 1);
+	lcd_envid_on_off(1);
+
+	return RT_EOK;
+}
+
+static rt_err_t rt_lcd_control (rt_device_t dev, int cmd, void *args)
+{
+	switch (cmd)
+	{
+	case RTGRAPHIC_CTRL_RECT_UPDATE:
+		break;
+	case RTGRAPHIC_CTRL_POWERON:
+		break;
+	case RTGRAPHIC_CTRL_POWEROFF:
+		break;
+	case RTGRAPHIC_CTRL_GET_INFO:		
+		rt_memcpy(args, &_lcd_info, sizeof(_lcd_info));
+		break;
+	case RTGRAPHIC_CTRL_SET_MODE:
+		break;
+	}
+
+	return RT_EOK;
+}
+
+int rt_hw_lcd_init(void)
+{
+	rt_device_t lcd = rt_malloc(sizeof(struct rt_device));
+	if (lcd == RT_NULL) 
+            return -RT_ERROR; /* no memory yet */
+
+	_lcd_info.bits_per_pixel = 16;
+	_lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
+	_lcd_info.framebuffer = (void*)_rt_framebuffer;
+	_lcd_info.width = LCD_WIDTH;
+	_lcd_info.height = LCD_HEIGHT;
+
+	/* init device structure */
+	lcd->type = RT_Device_Class_Unknown;
+	lcd->init = rt_lcd_init;
+	lcd->open = RT_NULL;
+	lcd->close = RT_NULL;
+	lcd->control = rt_lcd_control;
+	lcd->user_data = (void*)&_lcd_info;
+	
+	/* register lcd device to RT-Thread */
+	rt_device_register(lcd, "lcd", RT_DEVICE_FLAG_RDWR);
+}
+
+INIT_BOARD_EXPORT(rt_hw_lcd_init);

bsp/mini2440/drivers/lcd_x35.c

@@ -17,7 +17,6 @@
 #include <rtthread.h>
 #include <s3c24x0.h>
 
-#include "lcd.h"
 
 /* LCD driver for X3'5 */
 #define LCD_WIDTH 240   // xres
@@ -230,10 +229,11 @@ static rt_err_t rt_lcd_control (rt_device_t dev, int cmd, void *args)
 	return RT_EOK;
 }
 
-void rt_hw_lcd_init(void)
+int rt_hw_lcd_init(void)
 {
 	rt_device_t lcd = rt_malloc(sizeof(struct rt_device));
-	if (lcd == RT_NULL) return; /* no memory yet */
+	if (lcd == RT_NULL) 
+            return -RT_ERROR; /* no memory yet */
 
 	_lcd_info.bits_per_pixel = 16;
 	_lcd_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
@@ -253,3 +253,4 @@ void rt_hw_lcd_init(void)
 	rt_device_register(lcd, "lcd", RT_DEVICE_FLAG_RDWR);
 }
 
+INIT_BOARD_EXPORT(rt_hw_lcd_init);

bsp/mini2440/drivers/s3cmci.c

+/*
+ * File      : s3cmci.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
+ * 2020-04-15     Jonne        first version for s3c2440 mmc controller
+ */
+
+#include <rthw.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <drivers/mmcsd_core.h>
+#include <s3c24x0.h>
+
+#define S3C_PCLK	50000000
+
+
+static void s3c_mmc_set_clk(struct rt_mmcsd_host *host, rt_uint32_t clock)
+{
+    rt_uint32_t prescale;
+    rt_uint32_t realClk;
+
+    for(prescale = 0; prescale < 256; ++prescale) 
+    {
+        realClk = S3C_PCLK / (1 + prescale);
+        if(realClk <= clock) 
+        {
+            break;
+        }
+    }
+
+    SDIPRE = prescale;
+    host->io_cfg.clock = realClk;
+}
+
+static rt_uint32_t s3c_mmc_send_cmd(struct rt_mmcsd_host *host, struct rt_mmcsd_cmd *cmd)
+{
+    rt_uint32_t ccon;
+    rt_uint32_t cmdSta;
+
+    SDICARG = cmd->arg;
+
+    ccon = cmd->cmd_code & 0x3f;
+    ccon |= (0 << 7) | (1 << 6); /* two start bits*/
+    ccon |= (1 << 8);/* command start*/
+
+    if(cmd->flags & 0xF)
+    {
+        // Need response
+        ccon |= (1 << 9);
+    }
+
+    if((cmd->flags & 0xF) == RESP_R2)
+    {
+        // R2 need 136bit response
+        ccon |= (1 << 10);
+    }
+
+    SDICCON = ccon; /* start cmd */
+
+    if(cmd->flags & 0xF) 
+    {
+        cmdSta = SDICSTA;
+        while((cmdSta & 0x200) != 0x200 && (cmdSta & 0x400) != 0x400) 
+        {
+            cmdSta = SDICSTA;
+        }
+
+        if((cmdSta & 0x1000) == 0x1000 && (cmd->flags & 0xF) != RESP_R3 && (cmd->flags & 0xF) != RESP_R4) 
+        {
+            // crc error, but R3 R4 ignore it
+            SDICSTA = cmdSta;
+            return -RT_ERROR;
+        }
+
+        if((cmdSta & 0xF00) != 0xa00)
+        {
+            SDICSTA = cmdSta;
+            return -RT_ERROR;
+        }
+
+        cmd->resp[0] = SDIRSP0;
+        if((cmd->flags & 0xF) == RESP_R2) 
+        {
+            cmd->resp[1] = SDIRSP1;
+            cmd->resp[2] = SDIRSP2;
+            cmd->resp[3] = SDIRSP3;
+        }
+    }
+    else
+    {
+        cmdSta = SDICSTA;
+        while((cmdSta & 0x800) != 0x800)
+        {
+            cmdSta = SDICSTA;
+        } 
+    }
+
+    SDICSTA = cmdSta; // clear current status
+
+    return RT_EOK;
+
+}
+
+static rt_uint32_t s3c_mmc_xfer_data(struct rt_mmcsd_data *data)
+{
+    rt_uint32_t status;
+    rt_uint32_t xfer_size;
+    rt_uint32_t handled_size = 0;
+    rt_uint32_t *pBuf = RT_NULL;
+
+
+    if(data == RT_NULL)
+    {
+        return -RT_ERROR;
+    }
+
+    xfer_size = data->blks * data->blksize;
+
+    pBuf = data->buf;
+    if(data->flags & DATA_DIR_READ)
+    {
+        while(handled_size < xfer_size)
+        {
+            if ((SDIDSTA & 0x20) == 0x20)
+            {
+                SDIDSTA = (0x1 << 0x5);
+                break; 
+            }
+
+            status = SDIFSTA;
+            if ((status & 0x1000) == 0x1000)
+            {
+                *pBuf++ = SDIDAT;
+                handled_size += 4;
+            }
+        }
+    }
+    else 
+    {
+        while(handled_size < xfer_size)
+        {
+            status = SDIFSTA;
+            if ((status & 0x2000) == 0x2000)
+            {
+                SDIDAT = *pBuf++;
+                handled_size += 4;
+            }
+        }
+    }
+
+    // wait for end
+    status = SDIDSTA;
+    while((status & 0x30) == 0)
+    {
+        status = SDIDSTA;
+    }
+    SDIDSTA = status;
+
+    if ((status & 0xfc) != 0x10)
+    {
+        return -RT_ERROR;
+    }
+
+    SDIDCON = SDIDCON & ~(7<<12);
+    SDIFSTA = SDIFSTA & 0x200;
+    SDIDSTA = 0x10;
+
+    return RT_EOK;
+}
+static void mmc_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
+{
+    rt_uint32_t ret;
+    struct rt_mmcsd_cmd *cmd;
+    struct rt_mmcsd_data *data;
+    rt_uint32_t val;
+    rt_uint32_t tryCnt = 0;
+
+    if(req->cmd == RT_NULL)
+    {
+        goto out;
+    }
+    cmd = req->cmd;
+
+    /* prepare for data transfer*/
+    if(req->data != RT_NULL) 
+    {
+        SDIFSTA = SDIFSTA | (1<<16); // reset fifo 
+
+        while(SDIDSTA & 0x03)
+        {
+            if(tryCnt++ > 500)
+            {
+                break;
+                SDIDSTA = SDIDSTA;
+            }
+        }
+
+        data = req->data;
+
+        if((data->blksize & 0x3) != 0)
+        {
+            goto out;
+        }
+
+        val = (2 << 22)  //word transfer
+                  | (1 << 20) // transmet after response
+                  | (1 << 19) // reciveve after command sent
+                  | (1 << 17) // block data transfer
+                  | (1 << 14); // data start
+
+        if(host->io_cfg.bus_width == MMCSD_BUS_WIDTH_4)
+        {
+            val |= (1 << 16); // wide bus mode(4bit data)
+        }
+
+        if(data->flags & DATA_DIR_READ) 
+        {
+            // for data read 
+            val |= (2 << 12);
+        }
+        else 
+        {
+            val |= (3 << 12);
+        }
+
+        val |= (data->blks & 0xFFF);
+
+        SDIDCON = val;
+
+        SDIBSIZE = data->blksize;
+        SDIDTIMER = 0x7fffff;
+    }
+
+    ret = s3c_mmc_send_cmd(host,req->cmd);
+    if(ret != RT_EOK) {
+        cmd->err = ret;
+        goto out;
+    }
+
+    if(req->data != RT_NULL)
+    {
+        /*do transfer data*/
+        ret = s3c_mmc_xfer_data(data);
+        if(ret != RT_EOK)
+        {
+            data->err = ret;
+            goto out;
+        }
+    }
+
+out:
+    mmcsd_req_complete(host);
+}
+static void mmc_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *io_cfg)
+{
+    switch (io_cfg->power_mode) {
+    case MMCSD_POWER_ON:
+    case MMCSD_POWER_UP:
+        /* Enable PCLK into SDI Block */
+        CLKCON |= 1 << 9;
+        
+        /* Setup GPIO as SD and SDCMD, SDDAT[3:0] Pull up En */
+        GPEUP  = GPEUP  & (~(0x3f << 5))   | (0x01 << 5);
+        GPECON = GPECON & (~(0xfff << 10)) | (0xaaa << 10);
+        break;
+
+    case MMCSD_POWER_OFF:
+    default:
+        break;                 
+    }
+
+    s3c_mmc_set_clk(host, io_cfg->clock);
+
+    SDICON =  1;
+}
+
+static rt_int32_t mmc_get_card_status(struct rt_mmcsd_host *host)
+{
+    return RT_EOK;
+}
+static void mmc_enable_sdio_irq(struct rt_mmcsd_host *host, rt_int32_t en)
+{
+}
+
+static const struct rt_mmcsd_host_ops ops = 
+{
+    mmc_request,
+    mmc_set_iocfg,
+    mmc_get_card_status,
+    mmc_enable_sdio_irq
+};
+
+int s3c_sdio_init(void)
+{
+    struct rt_mmcsd_host * host = RT_NULL;
+
+
+    host = mmcsd_alloc_host();
+    if (!host)
+    {
+        goto err;
+    }
+
+    host->ops = &ops;
+    host->freq_min = 300000;
+    host->freq_max = 50000000;
+    host->valid_ocr = VDD_32_33 | VDD_33_34;
+    host->flags = MMCSD_MUTBLKWRITE | MMCSD_SUP_HIGHSPEED | MMCSD_SUP_SDIO_IRQ | MMCSD_BUSWIDTH_4;
+    host->max_seg_size = 2048;
+    host->max_dma_segs = 10;
+    host->max_blk_size = 512;
+    host->max_blk_count = 4096;
+
+
+    mmcsd_change(host);
+
+    return RT_EOK;
+
+err:
+    if(host)  rt_free(host);
+
+    return -RT_EIO;
+}
+
+INIT_DEVICE_EXPORT(s3c_sdio_init);

bsp/mini2440/drivers/sdcard.c

-/*
- * File      : sd.c
- * This file is part of RT-Thread RTOS
- * COPYRIGHT (C) 2006, 2007, 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
- * 2007-12-02     Yi.Qiu        the first version
- * 2010-01-01     Bernard       Modify for mini2440
- * 2012-12-15     amr168        support SDHC
- * 2017-11-20     kuangdazzidd  add csd cmd support
- */
-
-#include "sdcard.h"
-#include "rtdef.h"
-
-extern   rt_uint32_t   PCLK;
-volatile rt_uint32_t   rd_cnt;
-volatile rt_uint32_t   wt_cnt;
-volatile rt_int32_t    RCA;
-volatile rt_int32_t    sd_type;
-
-struct sd_csd {
-    rt_uint16_t    bsize;
-    rt_uint32_t    nblks;
-}g_sd_csd;
-
-static void sd_delay(rt_uint32_t ms)
-{
-    ms *= 7326;
-    while(--ms);
-}
-
-static int sd_cmd_end(int cmd, int be_resp)
-{
-    int finish0;
-
-    if (!be_resp)
-    {
-        finish0 = SDICSTA;
-
-        while ((finish0&0x800) != 0x800)
-            finish0 = SDICSTA;
-
-        SDICSTA = finish0;
-
-        return RT_EOK;
-    }
-    else
-    {
-        finish0 = SDICSTA;
-
-        while (!(((finish0&0x200)==0x200) | ((finish0&0x400) == 0x400)))
-            finish0=SDICSTA;
-
-        if (cmd == 1 || cmd == 41)
-        {
-            if ((finish0 & 0xf00) != 0xa00)
-            {
-                SDICSTA = finish0;
-                    if ((finish0&0x400) == 0x400)
-                        return RT_ERROR;
-            }
-            SDICSTA = finish0;
-        }
-        else
-        {
-            if ((finish0 & 0x1f00) != 0xa00)
-            {
-                /* rt_kprintf("CMD%d:SDICSTA=0x%x, SDIRSP0=0x%x\n", cmd, SDICSTA, SDIRSP0); */
-                SDICSTA = finish0;
-                if ((finish0 & 0x400) == 0x400)
-                    return RT_ERROR;
-            }
-            SDICSTA = finish0;
-        }
-        return RT_EOK;
-    }
-}
-
-static int sd_data_end(void)
-{
-    int finish;
-
-    finish = SDIDSTA;
-
-    while (!(((finish & 0x10) == 0x10) | ((finish & 0x20) == 0x20)))
-    {
-        finish = SDIDSTA;
-    }
-
-    if ((finish & 0xfc) != 0x10)
-    {
-        SDIDSTA = 0xec;
-
-        return RT_ERROR;
-    }
-
-    return RT_EOK;
-}
-
-static void sd_cmd0(void)
-{
-    SDICARG = 0x0;
-    SDICCON = (1<<8) | 0x40;
-
-    sd_cmd_end(0, 0);
-    SDICSTA = 0x800;      /* Clear cmd_end(no rsp) */
-}
-
-static int sd_cmd55(void)
-{
-    SDICARG = RCA << 16;
-    SDICCON = (0x1 << 9) | (0x1 << 8) | 0x77;
-
-    if (sd_cmd_end(55, 1) == RT_ERROR)
-    {
-        /* rt_kprintf("CMD55 error\n"); */
-        return RT_ERROR;
-    }
-
-    SDICSTA = 0xa00;
-
-
-    return RT_EOK;
-}
-
-static int sd_cmd9(void *p_rsp)
-{
-SDICARG = RCA << 16;
-SDICCON = (1 << 10) | (1 << 9) | (0x1<<8) | (0x40 | 0x09);
-
-sd_cmd_end(9, 1);
-
-    ((rt_uint32_t *)p_rsp)[0] = SDIRSP3;
-    ((rt_uint32_t *)p_rsp)[1] = SDIRSP2;
-    ((rt_uint32_t *)p_rsp)[2] = SDIRSP1;
-    ((rt_uint32_t *)p_rsp)[3] = SDIRSP0;
-
-return RT_EOK;
-}
-
-static void sd_sel_desel(char sel_desel)
-{
-    if (sel_desel)
-    {
-RECMDS7:
-        SDICARG = RCA << 16;
-        SDICCON = (0x1 << 9) | (0x1 << 8) | 0x47;
-        if (sd_cmd_end(7, 1) == RT_ERROR)
-            goto RECMDS7;
-
-        SDICSTA = 0xa00;
-
-        if (SDIRSP0 & 0x1e00 != 0x800)
-            goto RECMDS7;
-    }
-    else
-    {
-RECMDD7:
-        SDICARG = 0 << 16;
-        SDICCON = (0x1 << 8) | 0x47;
-
-        if (sd_cmd_end(7, 0) == RT_ERROR)
-            goto RECMDD7;
-        SDICSTA = 0x800;
-    }
-}
-
-static void sd_setbus(void)
-{
-    do
-    {
-        sd_cmd55();
-
-        SDICARG = 1 << 1; /* 4bit bus */
-        SDICCON = (0x1<<9) | (0x1<<8) | 0x46; /* sht_resp, wait_resp, start, CMD55 */
-    }while (sd_cmd_end(6, 1) == RT_ERROR);
-
-    SDICSTA=0xa00;      /* Clear cmd_end(with rsp) */
-}
-
-
-static rt_uint32_t bits_str (rt_uint32_t *str, rt_uint32_t start, rt_uint8_t len)
-{
-    rt_uint32_t  mask;
-    rt_uint32_t  index;
-    rt_uint8_t   shift;
-    rt_uint32_t  value;
-
-    mask  = (int)((len < 32) ? (1 << len) : 0) - 1;
-    index = start / 32;
-    shift = start & 31;
-    value = str[index] >> shift;
-
-    if ((len + shift) > 32) {
-        value |= str[index + 1] << (32 - shift);
-    }
-    value &= mask;
-    return value;
-}
-
-
-static int sd_decode_csd (rt_uint32_t  *p_csd)
-{
-    rt_uint32_t e, m, r;
-    rt_uint8_t  structure;
-
-    structure = bits_str(p_csd, 126, 2);
-
-    switch (structure) {
-        case 0:
-            m = bits_str(p_csd, 99, 4);
-            e = bits_str(p_csd, 96, 3);
-            g_sd_csd.bsize  = 512;
-            m = bits_str(p_csd, 62, 12);
-            e = bits_str(p_csd, 47, 3);
-            r = bits_str(p_csd, 80, 4);
-            g_sd_csd.nblks = ((1 + m) << (e + r - 7));
-            break;
-
-        case 1:
-            m = bits_str(p_csd, 99, 4);
-            e = bits_str(p_csd, 96, 3);
-            g_sd_csd.bsize  = 512;
-            m = bits_str(p_csd, 48, 22);
-            g_sd_csd.nblks = (1 + m) << 10;
-            break;
-
-        default:
-            return RT_ERROR;
-    }
-    return RT_EOK;
-}
-
-
-static int sd_send_csd(rt_uint32_t  *p_csd)
-{
-    int         ret;
-    rt_uint32_t rsp[4];
-
-    ret = sd_cmd9((void*)&rsp);
-
-    if (ret != 0) {
-        return ret;
-    }
-
-    rt_memcpy((void*)p_csd, (void*)rsp, 16);
-    return RT_EOK;
-}
-
-static int sd_ocr(void)
-{
-    int i, ver=0;
-
-    /* Negotiate operating condition for SD, it makes card ready state */
-    for (i = 0; i < 50; i ++)
-    {
-        sd_cmd55();
-
-        SDICARG = 0x40ff8000; /* HCS=1, compatible v1.x and v2.0 */
-        SDICCON = (0x1<<9) | (0x1<<8) | 0x69;
-
-        /* if using real board, should replace code here. need to modify qemu in near future*/
-        /* Check end of ACMD41 */
-        if (sd_cmd_end(41, 1) == RT_EOK)
-        {
-            if (SDIRSP0 == 0x80ff8000)
-            {
-                ver = 1; /* SD V1.x, CCS=0 */
-                break;
-            }
-            else if (SDIRSP0 == 0xc0ff8000)
-            {
-                ver = 2; /* SD V2.0, CCS=1 */
-                break;
-            }
-        }
-
-        sd_delay(200);
-    }
-    SDICSTA = 0xa00;
-
-    return ver;
-}
-
-rt_err_t sd_cmd8(void)
-{
-    SDICARG = 0x000001AA; 
-    SDICCON = (0x1<<9) | (0x1<<8) | 0x48; //sht_resp, wait_resp, start
-    if (sd_cmd_end(8, 1) == RT_ERROR)
-        return RT_ERROR;
-    SDICSTA = 0xa00;
-    
-    if ((SDIRSP0&0x1aa) == 0x1aa)
-        return RT_EOK; 
-    else 
-        return RT_ERROR;
-}
-
-static rt_uint8_t sd_init(void)
-{
-    //-- SD controller & card initialize
-    int         i;
-    rt_uint32_t csd[4];
-    /* Important notice for MMC test condition */
-    /* Cmd & Data lines must be enabled by pull up resister */
-    SDIPRE    = PCLK / (INICLK) - 1;
-    SDICON    = (0<<4) | 1;   // Type A, clk enable
-    SDIFSTA   = SDIFSTA | (1<<16);
-    SDIBSIZE  = 0x200;       /* 512byte per one block */
-    SDIDTIMER = 0x7fffff;     /* timeout count */
-
-    /* Wait 74SDCLK for MMC card */
-    for (i = 0; i < 0x1000; i ++);
-
-    sd_cmd0();
-    sd_cmd8(); /* Must be use it, Host shall supports high capacity */
-
-    /* Check SD card OCR */
-    sd_type = sd_ocr();
-    if (sd_type > 0)
-    {
-        rt_kprintf("In SD ready\n");
-    }
-    else
-    {
-        rt_kprintf("Initialize fail\nNo Card assertion\n");
-
-        return RT_ERROR;
-    }
-
-RECMD2:
-    SDICARG = 0x0;
-    SDICCON = (0x1<<10)|(0x1<<9)|(0x1<<8)|0x42; /* lng_resp, wait_resp, start, CMD2 */
-    if (sd_cmd_end(2, 1) == RT_ERROR)
-        goto RECMD2;
-
-    SDICSTA = 0xa00;    /* Clear cmd_end(with rsp) */
-
-RECMD3:
-    SDICARG = 0<<16;    /* CMD3(MMC:Set RCA, SD:Ask RCA-->SBZ) */
-    SDICCON = (0x1<<9)|(0x1<<8)|0x43; /* sht_resp, wait_resp, start, CMD3 */
-    if (sd_cmd_end(3, 1) == RT_ERROR)
-        goto RECMD3;
-    SDICSTA=0xa00;  /* Clear cmd_end(with rsp) */
-
-    sd_send_csd(csd);
-    sd_decode_csd(csd);
-
-    RCA = (SDIRSP0 & 0xffff0000) >> 16;
-    SDIPRE = PCLK / (SDCLK) - 1; /* Normal clock=25MHz */
-    if (SDIRSP0 & 0x1e00 != 0x600)
-        goto RECMD3;
-
-    sd_sel_desel(1);
-    sd_delay(200);
-    sd_setbus();
-
-    return RT_EOK;
-}
-
-static rt_uint8_t sd_readblock(rt_uint32_t address, rt_uint8_t *buf)
-{
-    rt_uint32_t status, tmp;
-
-    rd_cnt = 0;
-    SDIFSTA = SDIFSTA | (1<<16);
-
-    SDIDCON = (2 << 22) | (1 << 19) | (1 << 17) | (1 << 16) | (1 << 14) | (2 << 12) | (1 << 0);
-    SDICARG = address;
-
-RERDCMD:
-    SDICCON = (0x1 << 9 ) | (0x1 << 8) | 0x51;
-    if (sd_cmd_end(17, 1) == RT_ERROR)
-    {
-        rt_kprintf("Read CMD Error\n");
-        goto RERDCMD;
-    }
-
-    SDICSTA = 0xa00;
-
-    while (rd_cnt < 128)
-    {
-        if ((SDIDSTA & 0x20) == 0x20)
-        {
-            SDIDSTA = (0x1 << 0x5);
-            break;
-        }
-        status = SDIFSTA;
-        if ((status & 0x1000) == 0x1000)
-        {
-            tmp = SDIDAT;
-            rt_memcpy(buf, &tmp, sizeof(rt_uint32_t));
-            rd_cnt ++;
-            buf += 4;
-        }
-    }
-    if (sd_data_end() == RT_ERROR)
-    {
-        rt_kprintf("Dat error\n");
-
-        return RT_ERROR;
-    }
-
-    SDIDCON = SDIDCON &~ (7<<12);
-    SDIFSTA = SDIFSTA & 0x200;
-    SDIDSTA = 0x10;
-
-    return RT_EOK;
-}
-
-static rt_uint8_t sd_writeblock(rt_uint32_t address, rt_uint8_t *buf)
-{
-    rt_uint32_t status, tmp;
-
-    wt_cnt = 0;
-    SDIFSTA = SDIFSTA | (1 << 16);
-
-    SDIDCON = (2 << 22) | (1 << 20) | (1 << 17) | (1 << 16) | (1 << 14) | (3 << 12) | (1 << 0);
-    SDICARG = address;
-
-REWTCMD:
-    SDICCON = (0x1 << 9) | (0x1 << 8) |0x58;
-
-    if (sd_cmd_end(24, 1) == RT_ERROR)
-        goto REWTCMD;
-
-    SDICSTA = 0xa00;
-
-    while (wt_cnt < 128)
-    {
-        status = SDIFSTA;
-        if ((status & 0x2000) == 0x2000)
-        {
-            rt_memcpy(&tmp, buf, sizeof(rt_uint32_t));
-            SDIDAT = tmp;
-            wt_cnt ++;
-            buf += 4;
-        }
-    }
-    if (sd_data_end() == RT_ERROR)
-    {
-        rt_kprintf("Data Error\n");
-
-        return RT_ERROR;
-    }
-    SDIDCON = SDIDCON &~ (7<<12);
-    SDIDSTA = 0x10;
-
-    return RT_EOK;
-}
-
-#ifdef RT_USING_DFS
-/* RT-Thread Device Driver Interface */
-#include <rtthread.h>
-
-#include <dfs_fs.h>
-
-struct rt_device sdcard_device[4];
-struct dfs_partition part[4];
-
-static rt_err_t rt_sdcard_init(rt_device_t dev)
-{
-    return RT_EOK;
-}
-
-static rt_err_t rt_sdcard_open(rt_device_t dev, rt_uint16_t oflag)
-{
-    return RT_EOK;
-}
-
-static rt_err_t rt_sdcard_close(rt_device_t dev)
-{
-    return RT_EOK;
-}
-
-static rt_err_t rt_sdcard_control(rt_device_t dev, int cmd, void *args)
-{
-struct rt_device_blk_geometry *p_geometry = (struct rt_device_blk_geometry *)args;
-p_geometry->block_size = g_sd_csd.bsize;
-p_geometry->sector_count = g_sd_csd.nblks;
-p_geometry->bytes_per_sector = 512;
-    return RT_EOK;
-}
-
-static rt_size_t rt_sdcard_read(rt_device_t dev,
-                                rt_off_t    pos,
-                                void       *buffer,
-                                rt_size_t   size)
-{
-    int i, addr;
-    struct dfs_partition *part = (struct dfs_partition *)dev->user_data;
-
-    if (dev == RT_NULL)
-    {
-        rt_set_errno(-EINVAL);
-
-        return 0;
-    }
-
-    /* read all sectors */
-    for (i = 0; i < size; i ++)
-    {
-        rt_sem_take(part->lock, RT_WAITING_FOREVER);
-        if (sd_type == 1)
-            addr = (part->offset + i + pos)*SECTOR_SIZE;
-        else
-            addr = (part->offset + i + pos);
-        sd_readblock(addr, (rt_uint8_t *)((rt_uint8_t *)buffer + i * SECTOR_SIZE));
-        rt_sem_release(part->lock);
-    }
-
-    /* the length of reading must align to SECTOR SIZE */
-    return size;
-}
-
-static rt_size_t rt_sdcard_write(rt_device_t dev,
-                                 rt_off_t    pos,
-                                 const void *buffer,
-                                 rt_size_t   size)
-{
-    int i, addr;
-    struct dfs_partition *part = (struct dfs_partition *)dev->user_data;
-
-    if (dev == RT_NULL)
-    {
-        rt_set_errno(-EINVAL);
-
-        return 0;
-    }
-
-    /* read all sectors */
-    for (i = 0; i < size; i++)
-    {
-        rt_sem_take(part->lock, RT_WAITING_FOREVER);
-        if (sd_type == 1)
-            addr = (part->offset + i + pos)*SECTOR_SIZE;
-        else
-            addr = (part->offset + i + pos);
-        sd_writeblock(addr, (rt_uint8_t*)((rt_uint8_t*)buffer + i * SECTOR_SIZE));
-        rt_sem_release(part->lock);
-    }
-
-    /* the length of reading must align to SECTOR SIZE */
-    return size;
-}
-
-int rt_hw_sdcard_init(void)
-{
-    rt_uint8_t i, status;
-    rt_uint8_t *sector;
-    char dname[4];
-    char sname[8];
-
-    /* Enable PCLK into SDI Block */
-    CLKCON |= 1 << 9;
-
-    /* Setup GPIO as SD and SDCMD, SDDAT[3:0] Pull up En */
-    GPEUP  = GPEUP  & (~(0x3f << 5))   | (0x01 << 5);
-    GPECON = GPECON & (~(0xfff << 10)) | (0xaaa << 10);
-
-    RCA = 0;
-
-    if (sd_init() == RT_EOK)
-    {
-        /* get the first sector to read partition table */
-        sector = (rt_uint8_t*) rt_malloc (512);
-        if (sector == RT_NULL)
-        {
-            rt_kprintf("allocate partition sector buffer failed\n");
-
-            return -RT_ERROR;
-        }
-        status = sd_readblock(0, sector);
-        if (status == RT_EOK)
-        {
-            for (i = 0; i < 4; i ++)
-            {
-                /* get the first partition */
-                status = dfs_filesystem_get_partition(&part[i], sector, i);
-                if (status == RT_EOK)
-                {
-                    rt_snprintf(dname, 4, "sd%d",  i);
-                    rt_snprintf(sname, 8, "sem_sd%d",  i);
-                    part[i].lock = rt_sem_create(sname, 1, RT_IPC_FLAG_FIFO);
-
-                    /* register sdcard device */
-                    sdcard_device[i].type      = RT_Device_Class_Block;
-                    sdcard_device[i].init      = rt_sdcard_init;
-                    sdcard_device[i].open      = rt_sdcard_open;
-                    sdcard_device[i].close     = rt_sdcard_close;
-                    sdcard_device[i].read      = rt_sdcard_read;
-                    sdcard_device[i].write     = rt_sdcard_write;
-                    sdcard_device[i].control   = rt_sdcard_control;
-                    sdcard_device[i].user_data = &part[i];
-
-                    rt_device_register(&sdcard_device[i], dname,
-                        RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
-                }
-                else
-                {
-                    if (i == 0)
-                    {
-                        /* there is no partition table */
-                        part[0].offset = 0;
-                        part[0].size   = 0;
-                        part[0].lock   = rt_sem_create("sem_sd0", 1, RT_IPC_FLAG_FIFO);
-
-                        /* register sdcard device */
-                        sdcard_device[0].type      = RT_Device_Class_Block;
-                        sdcard_device[0].init      = rt_sdcard_init;
-                        sdcard_device[0].open      = rt_sdcard_open;
-                        sdcard_device[0].close     = rt_sdcard_close;
-                        sdcard_device[0].read      = rt_sdcard_read;
-                        sdcard_device[0].write     = rt_sdcard_write;
-                        sdcard_device[0].control   = rt_sdcard_control;
-                        sdcard_device[0].user_data = &part[0];
-
-                        rt_device_register(&sdcard_device[0], "sd0",
-                            RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE);
-
-                        break;
-                    }
-                }
-            }
-        }
-        else
-        {
-            rt_kprintf("read sdcard first sector failed\n");
-        }
-
-        /* release sector buffer */
-        rt_free(sector);
-
-        return -RT_ERROR; 
-    }
-    else
-    {
-        rt_kprintf("sdcard init failed\n");
-    }
-
-    return RT_EOK;
-}
-
-INIT_BOARD_EXPORT(rt_hw_sdcard_init);
-#endif

bsp/mini2440/drivers/sdcard.h

-#ifndef __SDCARD_H
-#define __SDCARD_H
-
-#include  <s3c24x0.h>
-
-#define INICLK	300000
-#define SDCLK	24000000	//PCLK=49.392MHz
-#define MMCCLK	15000000	//PCLK=49.392MHz
-
-#endif
-

bsp/mini2440/drivers/touch.c

@@ -16,13 +16,14 @@
 #include <rtthread.h>
 #include <s3c24x0.h>
 
-#ifdef RT_USING_RTGUI
+#ifdef PKG_USING_GUIENGINE
 #include <rtgui/rtgui_system.h>
 #include <rtgui/rtgui_server.h>
 #include <rtgui/event.h>
 #endif
 
-#include "lcd.h"
+#define TOUCH_SWAP_XY
+
 #include "touch.h"
 
 /* ADCCON Register Bits */
@@ -108,7 +109,7 @@ struct rtgui_touch_device
 };
 static struct rtgui_touch_device *touch = RT_NULL;
 
-#ifdef RT_USING_RTGUI
+#ifdef PKG_USING_GUIENGINE
 static void report_touch_input(int updown)
 {
 	struct rtgui_event_mouse emouse;
@@ -125,6 +126,12 @@ static void report_touch_input(int updown)
 		ts.xp = ts.xp / ts.count;
 		ts.yp = ts.yp / ts.count;;
 
+	#ifdef TOUCH_SWAP_XY
+		ts.xp = ts.xp + ts.yp;
+		ts.yp = ts.xp - ts.yp;
+		ts.xp = ts.xp - ts.yp;
+	#endif
+
 		if ((touch->calibrating == RT_TRUE) && (touch->calibration_func != RT_NULL))
 		{
 			touch->x = ts.xp;
@@ -446,7 +453,7 @@ static rt_err_t rtgui_touch_control(rt_device_t dev, int cmd, void *args)
 	return RT_EOK;
 }
 
-void rtgui_touch_hw_init(void)
+int rtgui_touch_hw_init(void)
 {
 	rt_err_t result = RT_FALSE;
 	rt_device_t device = RT_NULL;
@@ -454,7 +461,7 @@ void rtgui_touch_hw_init(void)
 
 	touch = (struct rtgui_touch_device *)rt_malloc(sizeof(struct rtgui_touch_device));
 	if (touch == RT_NULL)
-		return; /* no memory yet */
+		return -RT_ERROR; /* no memory yet */
 
 	/* clear device structure */
 	rt_memset(&(touch->parent), 0, sizeof(struct rt_device));
@@ -473,17 +480,19 @@ void rtgui_touch_hw_init(void)
 	touch->parent.user_data = RT_NULL;
 
 	device = rt_device_find("lcd");
-	if (device == RT_NULL)
-		return; /* no this device */	
+	if (device == RT_NULL) 
+	{
+		rt_kprintf("No lcd found\n");
+		return -RT_ERROR; /* no this device */	
+	}
 
 	/* get graphic device info */
 	result = rt_device_control(device, RTGRAPHIC_CTRL_GET_INFO, &info);
 	if (result != RT_EOK)
 	{
-
 		/* get device information failed */
-
-		return;
+		rt_kprintf("Get graphic device info failed\n");
+		return -RT_ERROR;
 	}
 
 	touch->width = info.width;
@@ -495,4 +504,8 @@ void rtgui_touch_hw_init(void)
 
 	/* register touch device to RT-Thread */
 	rt_device_register(&(touch->parent), "touch", RT_DEVICE_FLAG_RDWR);
+
+	return RT_EOK;
 }
+
+INIT_PREV_EXPORT(rtgui_touch_hw_init);

bsp/mini2440/drivers/touch.h

@@ -26,7 +26,7 @@ typedef void (*rt_touch_calibration_func_t)(rt_uint16_t x, rt_uint16_t y);
 
 typedef void (*rt_touch_eventpost_func_t)(void *, struct rt_touch_event *);
 
-void rtgui_touch_hw_init(void);
+int rtgui_touch_hw_init(void);
 
 #endif
 

bsp/mini2440/rtconfig.h

@@ -107,6 +107,12 @@
 #define RT_SERIAL_USING_DMA
 #define RT_SERIAL_RB_BUFSZ 64
 #define RT_USING_PIN
+#define RT_USING_SDIO
+#define RT_SDIO_STACK_SIZE 512
+#define RT_SDIO_THREAD_PRIORITY 15
+#define RT_MMCSD_STACK_SIZE 1024
+#define RT_MMCSD_THREAD_PREORITY 22
+#define RT_MMCSD_MAX_PARTITION 16
 
 /* Using USB */
 

bsp/mini2440/rtconfig.py

 import os
 
-# panel options
-# 'PNL_A70','PNL_N35', 'PNL_T35' , 'PNL_X35'
-RT_USING_LCD_TYPE = 'PNL_T35'
-
 # toolchains options
 ARCH     = 'arm'
 CPU      = 's3c24x0'