[bsp] Add display,sd,touch,hw_i2c driver

bsp/ls1cdev/drivers/display_controller.c

+/*
+ * File      :display_controller.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       	Notes
+ * 2011-08-09     lgnq         first version for LS1B DC
+ * 2015-07-06    chinesebear   modified for loongson 1c
+ * 2018-01-06    sundm75       modified for smartloong 
+ */
+
+#include <rtthread.h>
+#include "display_controller.h"
+#include "../../libraries/ls1c_pwm.h"
+#include "../../libraries/ls1c_public.h"
+#include "../../libraries/ls1c_gpio.h"
+
+struct vga_struct vga_mode[] =
+{
+	{/*"480x272_60.00"*/    111000,   480,    482,    523,    525,    272,    274,    284,    286,    },
+	{/*"640x480_70.00"*/    28560,  640,    664,    728,    816,    480,    481,    484,    500,    },
+	{/*"640x640_60.00"*/	33100,	640,	672,	736,	832,	640,	641,	644,	663,	},
+	{/*"640x768_60.00"*/	39690,	640,	672,	736,	832,	768,	769,	772,	795,	},
+	{/*"640x800_60.00"*/	42130,	640,	680,	744,	848,	800,	801,	804,	828,	},
+	{/*"800x480_70.00"*/    35840,  800,    832,    912,    1024,   480,    481,    484,    500,    },
+	{/*"800x600_60.00"*/	38220,	800,	832,	912,	1024,	600,	601,	604,	622,	},
+	{/*"800x640_60.00"*/	40730,	800,	832,	912,	1024,	640,	641,	644,	663,	},
+	{/*"832x600_60.00"*/	40010,	832,	864,	952,	1072,	600,	601,	604,	622,	},
+	{/*"832x608_60.00"*/	40520,	832,	864,	952,	1072,	608,	609,	612,	630,	},
+	{/*"1024x480_60.00"*/	38170,	1024,	1048,	1152,	1280,	480,	481,	484,	497,	},
+	{/*"1024x600_60.00"*/	48960,	1024,	1064,	1168,	1312,	600,	601,	604,	622,	},
+	{/*"1024x640_60.00"*/	52830,	1024,	1072,	1176,	1328,	640,	641,	644,	663,	},
+	{/*"1024x768_60.00"*/	64110,	1024,	1080,	1184,	1344,	768,	769,	772,	795,	},
+	{/*"1152x764_60.00"*/   71380,  1152,   1208,   1328,   1504,   764,    765,    768,    791,    },
+	{/*"1280x800_60.00"*/   83460,  1280,   1344,   1480,   1680,   800,    801,    804,    828,    },
+	{/*"1280x1024_55.00"*/  98600,  1280,   1352,   1488,   1696,   1024,   1025,   1028,   1057,   },
+	{/*"1440x800_60.00"*/   93800,  1440,   1512,   1664,   1888,   800,    801,    804,    828,    },
+	{/*"1440x900_67.00"*/   120280, 1440,   1528,   1680,   1920,   900,    901,    904,    935,    },
+};
+
+ALIGN(16)
+volatile rt_uint16_t _rt_framebuffer[FB_YSIZE][FB_XSIZE];
+static struct rt_device_graphic_info _dc_info;
+
+static void pwminit(void)
+{
+    pwm_info_t pwm_info;
+    pwm_info.gpio = LS1C_PWM0_GPIO06;           // pwm引脚位gpio06
+    pwm_info.mode = PWM_MODE_NORMAL;         // 正常模式--连续输出pwm波形
+    pwm_info.duty = 0.85;                                   // pwm占空比 85%
+    pwm_info.period_ns = 5*1000*1000;              // pwm周期5ms
+
+	/*pwm初始化，初始化后立即产生pwm波形*/
+	pwm_init(&pwm_info);
+
+	/* 使能pwm */
+	pwm_enable(&pwm_info);
+}
+int caclulate_freq(rt_uint32_t  XIN, rt_uint32_t PCLK)
+{
+	rt_uint32_t divider_int;
+	rt_uint32_t needed_pixclk;
+	rt_uint32_t  pll_clk, pix_div;
+	rt_uint32_t  regval;
+
+
+	pll_clk = PLL_FREQ; // 读CPU的 PLL及SDRAM 分频系数
+	pll_clk =( pll_clk>>8 )& 0xff;
+	pll_clk = XIN *  pll_clk / 4 ;
+	pix_div = PLL_DIV_PARAM;//读CPU的 CPU/CAMERA/DC 分频系数
+	pix_div = (pix_div>>24)&0xff;
+	rt_kprintf("old pll_clk=%d, pix_div=%d\n", pll_clk, pix_div);
+
+	divider_int = pll_clk/(1000000) *PCLK/1000; 
+	if(divider_int%1000>=500)
+		divider_int = divider_int/1000+1;
+	else
+		divider_int = divider_int/1000;
+	rt_kprintf("divider_int = %d\n", divider_int);
+	
+	/* check whether divisor is too small. */
+	if (divider_int < 1) {
+		rt_kprintf("Warning: clock source is too slow.Try smaller resolution\n");
+		divider_int = 1;
+	}
+	else if(divider_int > 100) {
+		rt_kprintf("Warning: clock source is too fast.Try smaller resolution\n");
+		divider_int = 100;
+	}
+	/* 配置分频寄存器 */
+	{
+		rt_uint32_t regval = 0;
+		regval = PLL_DIV_PARAM;
+		/*首先需要把分频使能位清零 */
+		regval &= ~0x80000030;	//PIX_DIV_VALID  PIX_SEL  置0
+		regval &= ~(0x3f<<24);	//PIX_DIV 清零
+		regval |= divider_int << 24;
+		PLL_DIV_PARAM = regval; 
+		regval |= 0x80000030;	//PIX_DIV_VALID  PIX_SEL  置1
+		PLL_DIV_PARAM = regval; 
+	}
+	rt_kprintf("new PLL_FREQ=0x%x, PLL_DIV_PARAM=0x%x\n", PLL_FREQ, PLL_DIV_PARAM);
+	rt_thread_delay(10);
+	return 0;
+}
+
+static rt_err_t rt_dc_init(rt_device_t dev)
+{
+	int i, out, mode=-1;
+	int val;
+	
+	rt_kprintf("PWM initied\n");
+	/* Set the back light PWM. */
+	pwminit();
+	
+	for (i=0; i<sizeof(vga_mode)/sizeof(struct vga_struct); i++)
+	{
+		if (vga_mode[i].hr == FB_XSIZE && vga_mode[i].vr == FB_YSIZE)
+		{
+			mode=i;
+			/* 计算时钟 配置频率*/
+			caclulate_freq(OSC, vga_mode[i].pclk);
+			break;
+		}
+	}
+
+	if (mode<0)
+	{
+		rt_kprintf("\n\n\nunsupported framebuffer resolution\n\n\n");
+		return;
+	}
+
+	DC_FB_CONFIG = 0x0;
+	DC_FB_CONFIG = 0x3; //	// framebuffer configuration RGB565
+ 	DC_FB_BUFFER_ADDR0 = (rt_uint32_t)_rt_framebuffer - 0x80000000;
+	DC_FB_BUFFER_ADDR1 = (rt_uint32_t)_rt_framebuffer - 0x80000000;
+	DC_DITHER_CONFIG = 0x0;  //颜色抖动配置寄存器
+	DC_DITHER_TABLE_LOW = 0x0; //颜色抖动查找表低位寄存器 
+	DC_DITHER_TABLE_HIGH = 0x0; //颜色抖动查找表高位寄存器
+	DC_PANEL_CONFIG = 0x80001311; //液晶面板配置寄存器
+	DC_PANEL_TIMING = 0x0;
+
+	DC_HDISPLAY = (vga_mode[mode].hfl<<16) | vga_mode[mode].hr;
+	DC_HSYNC = 0x40000000 | (vga_mode[mode].hse<<16) | vga_mode[mode].hss;
+	DC_VDISPLAY = (vga_mode[mode].vfl<<16) | vga_mode[mode].vr;
+	DC_VSYNC = 0x40000000 | (vga_mode[mode].vse<<16) | vga_mode[mode].vss;
+
+#if defined(CONFIG_VIDEO_32BPP)
+	DC_FB_CONFIG = 0x00100105;
+	DC_FB_BUFFER_STRIDE = FB_XSIZE*4;
+#elif defined(CONFIG_VIDEO_24BPP)
+	DC_FB_CONFIG = 0x00100104;
+	DC_FB_BUFFER_STRIDE = (FB_XSIZE*4+255)&(~255);
+#elif defined(CONFIG_VIDEO_16BPP)// 使用这个选项
+	DC_FB_CONFIG = 0x00100103;
+	DC_FB_BUFFER_STRIDE = (FB_XSIZE*2+255)&(~255);
+#elif defined(CONFIG_VIDEO_15BPP)
+	DC_FB_CONFIG = 0x00100102;
+	DC_FB_BUFFER_STRIDE =  (FB_XSIZE*2+255)&(~255);
+#elif defined(CONFIG_VIDEO_12BPP)
+	DC_FB_CONFIG = 0x00100101;
+	DC_FB_BUFFER_STRIDE =  (FB_XSIZE*2+255)&(~255);
+#else  
+	DC_FB_CONFIG = 0x00100104;
+	DC_FB_BUFFER_STRIDE = (FB_XSIZE*4+255)&(~255);
+#endif 
+	return RT_EOK;
+}
+
+static rt_err_t rt_dc_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, &_dc_info, sizeof(_dc_info));
+		break;
+	case RTGRAPHIC_CTRL_SET_MODE:
+		break;
+	}
+
+	return RT_EOK;
+}
+
+void rt_hw_dc_init(void)
+{
+	rt_device_t dc = rt_malloc(sizeof(struct rt_device));
+	if (dc == RT_NULL) 
+	{
+		rt_kprintf("dc == RT_NULL\n");
+		return; /* no memory yet */
+	}
+
+	_dc_info.bits_per_pixel = 16;
+	_dc_info.pixel_format = RTGRAPHIC_PIXEL_FORMAT_RGB565P;
+	_dc_info.framebuffer = (rt_uint8_t*)HW_FB_ADDR;
+	_dc_info.width = FB_XSIZE;
+	_dc_info.height = FB_YSIZE;
+
+	/* init device structure */
+	dc->type = RT_Device_Class_Graphic;
+	dc->init = rt_dc_init;
+	dc->open = RT_NULL;
+	dc->close = RT_NULL;
+	dc->control = rt_dc_control;
+	dc->user_data = (void*)&_dc_info;
+	
+	/* register Display Controller device to RT-Thread */
+	rt_device_register(dc, "dc", RT_DEVICE_FLAG_RDWR);
+	
+	rt_device_init(dc);
+}
+

bsp/ls1cdev/drivers/display_controller.h

+/*
+ * File      : display_controller.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006-2012, 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
+ * 2011-08-08     lgnq            first version for LS1B
+ * 2015-07-06    chinesebear   modified for loongson 1c
+  * 2018-01-06    sundm75   modified for smartloong 
+*/
+ 
+#ifndef __DISPLAY_CONTROLLER_H__
+#define __DISPLAY_CONTROLLER_H__
+
+#include <rtthread.h>
+#include "ls1c.h"
+
+#define DC_BASE					0xBC301240  //Display Controller
+
+/* Frame Buffer registers */
+#define DC_FB_CONFIG			__REG32(DC_BASE + 0x000)
+#define DC_FB_BUFFER_ADDR0		__REG32(DC_BASE + 0x020)
+#define DC_FB_BUFFER_STRIDE		__REG32(DC_BASE + 0x040)
+#define DC_FB_BUFFER_ORIGIN		__REG32(DC_BASE + 0x060)
+#define DC_DITHER_CONFIG		__REG32(DC_BASE + 0x120)
+#define DC_DITHER_TABLE_LOW		__REG32(DC_BASE + 0x140)
+#define DC_DITHER_TABLE_HIGH	__REG32(DC_BASE + 0x160)
+#define DC_PANEL_CONFIG			__REG32(DC_BASE + 0x180)
+#define DC_PANEL_TIMING			__REG32(DC_BASE + 0x1A0)
+#define DC_HDISPLAY				__REG32(DC_BASE + 0x1C0)
+#define DC_HSYNC				__REG32(DC_BASE + 0x1E0)
+#define DC_VDISPLAY				__REG32(DC_BASE + 0x240)
+#define DC_VSYNC				__REG32(DC_BASE + 0x260)
+#define DC_FB_BUFFER_ADDR1		__REG32(DC_BASE + 0x340)
+
+/* Display Controller driver for 1024x768 16bit */
+#define FB_XSIZE		480
+#define FB_YSIZE		272
+#define CONFIG_VIDEO_16BPP
+
+#define OSC 24000000 		/* Hz */
+
+#define K1BASE				0xA0000000
+#define KSEG1(addr)			((void *)(K1BASE | (rt_uint32_t)(addr)))
+#define HW_FB_ADDR			KSEG1(_rt_framebuffer)
+
+struct vga_struct
+{
+	long pclk;
+	int hr,hss,hse,hfl;
+	int vr,vss,vse,vfl;
+};
+
+#endif

bsp/ls1cdev/drivers/hw_i2c.c

+/*
+ * File      :hw_i2c.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       	Notes
+ * 2018-01-04     Sundm75        the first version
+ */
+
+#include <rtthread.h>
+#include <rtdevice.h>
+#include "ls1c_i2c.h"  
+
+struct ls1c_i2c_bus
+{
+    struct rt_i2c_bus_device parent;
+    rt_uint32_t u32Module;
+};
+
+rt_size_t rt_i2c_master_xfer(struct rt_i2c_bus_device *bus,
+                          struct rt_i2c_msg         *msgs,
+                          rt_uint32_t               num)
+{
+    struct ls1c_i2c_bus * i2c_bus = (struct ls1c_i2c_bus *)bus;
+	ls1c_i2c_info_t i2c_info;  
+    struct rt_i2c_msg *msg;
+    int i;
+    rt_int32_t ret = RT_EOK;
+    i2c_info.clock = 50000;       // 50kb/s  
+	i2c_info.I2Cx  = i2c_bus->u32Module;
+	i2c_init(&i2c_info);
+	
+    for (i = 0; i < num; i++)
+    {
+        msg = &msgs[i];
+        if (msg->flags == RT_I2C_RD)
+        {
+			i2c_send_start_and_addr(&i2c_info, msg->addr, LS1C_I2C_DIRECTION_READ);  
+			i2c_receive_ack(&i2c_info); 
+			i2c_receive_data(&i2c_info, (rt_uint8_t *)msg->buf, msg->len);  
+			i2c_send_stop(&i2c_info);   
+		 }
+        else if(msg->flags == RT_I2C_WR)
+        {
+			i2c_send_start_and_addr(&i2c_info, msg->addr, LS1C_I2C_DIRECTION_WRITE);  
+			i2c_receive_ack(&i2c_info);  
+			i2c_send_data(&i2c_info, (rt_uint8_t *)msg->buf, msg->len);  
+			i2c_send_stop(&i2c_info);  
+		}
+        ret++;
+    }
+    return ret;
+}
+
+rt_err_t rt_i2c_bus_control(struct rt_i2c_bus_device *bus,
+                          rt_uint32_t               cmd,
+                          rt_uint32_t               arg)
+{
+    struct ls1c_i2c_bus * i2c_bus = (struct ls1c_i2c_bus *)bus;
+
+    RT_ASSERT(bus != RT_NULL);
+    i2c_bus = (struct ls1c_i2c_bus *)bus->parent.user_data;
+
+    RT_ASSERT(i2c_bus != RT_NULL);
+
+    switch (cmd)
+    {
+        case RT_DEVICE_CTRL_CONFIG :
+            break;
+    }
+
+    return RT_EOK;
+}
+
+static const struct rt_i2c_bus_device_ops ls1c_i2c_ops =
+{
+    rt_i2c_master_xfer,
+    RT_NULL,
+    rt_i2c_bus_control
+};
+
+
+#ifdef RT_USING_I2C0
+static struct ls1c_i2c_bus ls1c_i2c_bus_0 = 
+{
+    {1},
+    LS1C_I2C_0,
+};
+#endif
+
+#ifdef RT_USING_I2C1
+static struct ls1c_i2c_bus ls1c_i2c_bus_1 = 
+{
+    {1},
+    LS1C_I2C_1,
+};
+#endif
+
+#ifdef RT_USING_I2C2
+static struct ls1c_i2c_bus ls1c_i2c_bus_2 = 
+{
+    {1},
+    LS1C_I2C_2,
+};
+#endif
+
+int rt_i2c_init(void)
+{
+    struct ls1c_i2c_bus* ls1c_i2c;
+
+#ifdef RT_USING_I2C0
+    ls1c_i2c = &ls1c_i2c_bus_0;
+    ls1c_i2c->parent.ops = &ls1c_i2c_ops;
+    rt_i2c_bus_device_register(&ls1c_i2c->parent, "i2c0");
+    rt_kprintf("i2c0_init!\n");
+#endif
+#ifdef RT_USING_I2C1
+    ls1c_i2c = &ls1c_i2c_bus_1;
+    ls1c_i2c->parent.ops = &ls1c_i2c_ops;
+    rt_i2c_bus_device_register(&ls1c_i2c->parent, "i2c1");
+    rt_kprintf("i2c1_init!\n");
+#endif
+
+#ifdef RT_USING_I2C2
+    ls1c_i2c = &ls1c_i2c_bus_2;
+    ls1c_i2c->parent.ops = &ls1c_i2c_ops;
+    rt_i2c_bus_device_register(&ls1c_i2c->parent, "i2c2");
+    rt_kprintf("i2c2_init!\n");
+#endif
+
+    return RT_EOK;
+}

bsp/ls1cdev/drivers/hw_i2c.h

+/*
+ * File      : hw_i2c.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2017, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2018-01-04     Sundm75        the first version
+ */
+
+#ifndef LS1C_I2C_H
+#define LS1C_I2C_H
+
+#include <rtthread.h>
+
+int rt_i2c_init(void);
+
+#endif 

bsp/ls1cdev/drivers/msd.h

+/*
+ * File      : msd.h
+ * SPI mode SD Card Driver
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development 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
+ * 2009-04-17     Bernard      first version.
+ */
+
+#ifndef MSD_H_INCLUDED
+#define MSD_H_INCLUDED
+
+#include <stdint.h>
+#include <drivers/spi.h>
+
+/* SD command (SPI mode) */
+#define GO_IDLE_STATE                       0   /* CMD0  R1  */
+#define SEND_OP_COND                        1   /* CMD1  R1  */
+#define SWITCH_FUNC                         6   /* CMD6  R1  */
+#define SEND_IF_COND                        8   /* CMD8  R7  */
+#define SEND_CSD                            9   /* CMD9  R1  */
+#define SEND_CID                            10  /* CMD10 R1  */
+#define STOP_TRANSMISSION                   12  /* CMD12 R1B */
+#define SEND_STATUS                         13  /* CMD13 R2  */
+#define SET_BLOCKLEN                        16  /* CMD16 R1  */
+#define READ_SINGLE_BLOCK                   17  /* CMD17 R1  */
+#define READ_MULTIPLE_BLOCK                 18  /* CMD18 R1  */
+#define WRITE_BLOCK                         24  /* CMD24 R1  */
+#define WRITE_MULTIPLE_BLOCK                25  /* CMD25 R1  */
+#define PROGRAM_CSD                         27  /* CMD27 R1  */
+#define SET_WRITE_PROT                      28  /* CMD28 R1B */
+#define CLR_WRITE_PROT                      29  /* CMD29 R1B */
+#define SEND_WRITE_PROT                     30  /* CMD30 R1  */
+#define ERASE_WR_BLK_START_ADDR             32  /* CMD32 R1  */
+#define ERASE_WR_BLK_END_ADDR               33  /* CMD33 R1  */
+#define ERASE                               38  /* CMD38 R1B */
+#define LOCK_UNLOCK                         42  /* CMD42 R1  */
+#define APP_CMD                             55  /* CMD55 R1  */
+#define GEN_CMD                             56  /* CMD56 R1  */
+#define READ_OCR                            58  /* CMD58 R3  */
+#define CRC_ON_OFF                          59  /* CMD59 R1  */
+
+/* Application-Specific Command */
+#define SD_STATUS                           13  /* ACMD13 R2 */
+#define SEND_NUM_WR_BLOCKS                  22  /* ACMD22 R1 */
+#define SET_WR_BLK_ERASE_COUNT              23  /* ACMD23 R1 */
+#define SD_SEND_OP_COND                     41  /* ACMD41 R1 */
+#define SET_CLR_CARD_DETECT                 42  /* ACMD42 R1 */
+#define SEND_SCR                            51  /* ACMD51 R1 */
+
+/* Start Data tokens  */
+/* Tokens (necessary because at nop/idle (and CS active) only 0xff is on the data/command line) */
+#define MSD_TOKEN_READ_START                0xFE  /* Data token start byte, Start Single Block Read */
+#define MSD_TOKEN_WRITE_SINGLE_START        0xFE  /* Data token start byte, Start Single Block Write */
+
+#define MSD_TOKEN_WRITE_MULTIPLE_START      0xFC  /* Data token start byte, Start Multiple Block Write */
+#define MSD_TOKEN_WRITE_MULTIPLE_STOP       0xFD  /* Data toke stop byte, Stop Multiple Block Write */
+
+/* MSD reponses and error flags */
+#define MSD_RESPONSE_NO_ERROR               0x00
+#define MSD_IN_IDLE_STATE                   0x01
+#define MSD_ERASE_RESET                     0x02
+#define MSD_ILLEGAL_COMMAND                 0x04
+#define MSD_COM_CRC_ERROR                   0x08
+#define MSD_ERASE_SEQUENCE_ERROR            0x10
+#define MSD_ADDRESS_ERROR                   0x20
+#define MSD_PARAMETER_ERROR                 0x40
+#define MSD_RESPONSE_FAILURE                0xFF
+
+/* Data response error */
+#define MSD_DATA_OK                         0x05
+#define MSD_DATA_CRC_ERROR                  0x0B
+#define MSD_DATA_WRITE_ERROR                0x0D
+#define MSD_DATA_OTHER_ERROR                0xFF
+#define MSD_DATA_RESPONSE_MASK              0x1F
+#define MSD_GET_DATA_RESPONSE(res)          (res & MSD_DATA_RESPONSE_MASK)
+
+#define MSD_CMD_LEN                         6           /**< command, arg and crc. */
+#define MSD_RESPONSE_MAX_LEN                5           /**< response max len  */
+#define MSD_CSD_LEN                         16          /**< SD crad CSD register len */
+#define SECTOR_SIZE                         512         /**< sector size, default 512byte */
+
+/* card try timeout, unit: ms */
+#define CARD_TRY_TIMES                      3000
+#define CARD_TRY_TIMES_ACMD41               800
+#define CARD_WAIT_TOKEN_TIMES               800
+
+#define MSD_USE_PRE_ERASED                              /**< id define MSD_USE_PRE_ERASED, before CMD25, send ACMD23 */
+
+/**
+ * SD/MMC card type
+ */
+typedef enum
+{
+	MSD_CARD_TYPE_UNKNOWN = 0,                      /**< unknown */
+	MSD_CARD_TYPE_MMC,                              /**< MultiMedia Card */
+	MSD_CARD_TYPE_SD_V1_X,                          /**< Ver 1.X  Standard Capacity SD Memory Card */
+	MSD_CARD_TYPE_SD_V2_X,                          /**< Ver 2.00 or later Standard Capacity SD Memory Card */
+	MSD_CARD_TYPE_SD_SDHC,                          /**< High Capacity SD Memory Card */
+	MSD_CARD_TYPE_SD_SDXC,                          /**< later Extended Capacity SD Memory Card */
+}msd_card_type;
+
+typedef enum
+{
+    response_type_unknown = 0,
+    response_r1,
+    response_r1b,
+    response_r2,
+    response_r3,
+    response_r4,
+    response_r5,
+    response_r7,
+}response_type;
+
+struct msd_device
+{
+    struct rt_device                parent;      /**< RT-Thread device struct */
+    struct rt_device_blk_geometry   geometry;    /**< sector size, sector count */
+    struct rt_spi_device *          spi_device;  /**< SPI interface */
+    msd_card_type                   card_type;   /**< card type: MMC SD1.x SD2.0 SDHC SDXC */
+    uint32_t                        max_clock;   /**< MAX SPI clock */
+};
+
+extern rt_err_t msd_init(const char * sd_device_name, const char * spi_device_name);
+
+#endif // MSD_H_INCLUDED

bsp/ls1cdev/drivers/touch.c

+/*
+ * File      : touch.c
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-12-30    Sundm75       first version
+ */
+ 
+#include <stdbool.h>
+#include <drivers/spi.h>
+#include "ls1c.h"
+#include "ls1c_gpio.h"  
+#include "ls1c_spi.h"
+#include "drv_spi.h"
+#include "touch.h"
+
+#include <rtgui/calibration.h>
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <rtgui/event.h>
+#include <rtgui/kbddef.h>
+#include <rtgui/rtgui_server.h>
+#include <rtgui/rtgui_system.h>
+
+//竖屏幕 不需要  _ILI_HORIZONTAL_DIRECTION_
+//横屏幕 需要  _ILI_HORIZONTAL_DIRECTION_
+
+//#define _ILI_HORIZONTAL_DIRECTION_
+
+#if defined(_ILI_HORIZONTAL_DIRECTION_)
+#define X_WIDTH 272
+#define Y_WIDTH 480
+#else
+#define X_WIDTH 480
+#define Y_WIDTH 272
+#endif
+/*
+TOUCH INT: 84
+*/
+#define IS_TOUCH_UP()     gpio_get(TOUCH_INT_PIN)
+
+#define led_gpio 52    // led1指示 
+
+#define DUMMY                 0x00
+
+/*
+7  6 - 4  3      2     1-0
+s  A2-A0 MODE SER/DFR PD1-PD0
+*/
+/* bit[1:0] power-down */
+#define POWER_MODE0     (0) /* Power-Down Between Conversions. When */
+                            /* each conversion is finished, the converter */
+                            /* enters a low-power mode. At the start of the */
+                            /* next conversion, the device instantly powers up */
+                            /* to full power. There is no need for additional */
+                            /* delays to ensure full operation, and the very first */
+                            /* conversion is valid. The Y? switch is on when in */
+                            /* power-down.*/
+#define POWER_MODE1     (1) /* Reference is off and ADC is on. */
+#define POWER_MODE2     (2) /* Reference is on and ADC is off. */
+#define POWER_MODE3     (3) /* Device is always powered. Reference is on and */
+                            /* ADC is on. */
+/* bit[2] SER/DFR */
+#define DIFFERENTIAL    (0<<2)
+#define SINGLE_ENDED    (1<<2)
+/* bit[3] mode */
+#define MODE_12BIT      (0<<3)
+#define MODE_8BIT       (1<<3)
+/* bit[6:4] differential mode */
+#define MEASURE_X       (((1<<2) | (0<<1) | (1<<0))<<4)
+#define MEASURE_Y       (((0<<2) | (0<<1) | (1<<0))<<4)
+#define MEASURE_Z1      (((0<<2) | (1<<1) | (1<<0))<<4)
+#define MEASURE_Z2      (((1<<2) | (0<<1) | (0<<0))<<4)
+/* bit[7] start */
+#define START           (1<<7)
+
+/* X Y change. */
+#define TOUCH_MSR_X     (START | MEASURE_X | MODE_12BIT | DIFFERENTIAL | POWER_MODE0)
+#define TOUCH_MSR_Y     (START | MEASURE_Y | MODE_12BIT | DIFFERENTIAL | POWER_MODE0)
+
+
+/* 以下定义XPT2046 的触摸屏位置*/
+#if defined(_ILI_HORIZONTAL_DIRECTION_)
+#define MIN_X_DEFAULT   2047
+#define MAX_X_DEFAULT   47
+#define MIN_Y_DEFAULT   102 
+#define MAX_Y_DEFAULT   1939 
+#else
+#define MIN_X_DEFAULT   47
+#define MAX_X_DEFAULT   2047
+#define MIN_Y_DEFAULT   1939 
+#define MAX_Y_DEFAULT   102
+#endif
+
+
+
+#define SAMP_CNT 8                              //the adc array size
+#define SAMP_CNT_DIV2 4                         //the middle of the adc array
+#define SH   10                                 // Valve value
+
+
+/*宏定义 */
+#define TOUCH_SPI_X                 SPI1 
+#define TOUCH_INT_PIN               84 
+#define TOUCH_CS_PIN                49 
+#define TOUCH_SCK_PIN               46
+#define TOUCH_MISO_PIN              47
+#define TOUCH_MOSI_PIN              48     
+
+
+/*创建结构体将需要用到的东西进行打包*/
+struct rtgui_touch_device 
+{
+    struct rt_device parent;                    /* 用于注册设备*/
+
+    rt_uint16_t x, y;                           /* 记录读取到的位置值  */ 
+
+    rt_bool_t calibrating;                      /* 触摸校准标志 */ 
+    rt_touch_calibration_func_t calibration_func;/* 触摸函数 函数指针 */       
+
+    rt_uint16_t min_x, max_x;                   /* 校准后 X 方向最小 最大值 */ 
+    rt_uint16_t min_y, max_y;                   /* 校准后 Y 方向最小 最大值 */
+
+    struct rt_spi_device * spi_device;          /* SPI 设备 用于通信 */ 
+    struct rt_event event;                       /* 事件同步，用于“笔中断” */ 
+};
+static struct rtgui_touch_device *touch = RT_NULL;
+
+static rt_err_t  touch_send_then_recv(struct rt_spi_device *device,
+                               const void           *send_buf,
+                               rt_size_t             send_length,
+                               void                 *recv_buf,
+                               rt_size_t             recv_length)
+{
+    rt_err_t result;
+    struct rt_spi_message message;
+    rt_uint8_t dummy[128] ;
+
+    rt_memset(dummy, DUMMY, sizeof(dummy));
+
+    RT_ASSERT(device != RT_NULL);
+    RT_ASSERT(device->bus != RT_NULL);
+
+    result = rt_mutex_take(&(device->bus->lock), RT_WAITING_FOREVER);
+    if (result == RT_EOK)
+    {
+        if (device->bus->owner != device)
+        {
+            /* not the same owner as current, re-configure SPI bus */
+            result = device->bus->ops->configure(device, &device->config);
+            if (result == RT_EOK)
+            {
+                /* set SPI bus owner */
+                device->bus->owner = device;
+            }
+            else
+            {
+                /* configure SPI bus failed */
+                result = -RT_EIO;
+                goto __exit;
+            }
+        }
+
+        /* send data */
+        message.send_buf   = send_buf;
+        message.recv_buf   = RT_NULL;
+        message.length     = send_length;
+        message.cs_take    = 1;
+        message.cs_release = 0;
+        message.next       = RT_NULL;
+
+        result = device->bus->ops->xfer(device, &message);
+        if (result == 0)
+        {
+            result = -RT_EIO;
+            goto __exit;
+        }
+
+        /* recv data */
+        message.send_buf   = dummy;
+        message.recv_buf   = recv_buf;
+        message.length     = recv_length;
+        message.cs_take    = 0;
+        message.cs_release = 1;
+        message.next       = RT_NULL;
+
+        result = device->bus->ops->xfer(device, &message);
+        if (result == 0)
+        {
+            result = -RT_EIO;
+            goto __exit;
+        }
+
+        result = RT_EOK;
+    }
+    else
+    {
+        return -RT_EIO;
+    }
+
+__exit:
+    rt_mutex_release(&(device->bus->lock));
+
+    return result;
+}
+
+
+static void rtgui_touch_calculate(void)
+{
+    if (touch != RT_NULL)
+    {
+        /* read touch */
+        {
+            rt_uint8_t i, j, k, min;
+	        rt_uint16_t temp;
+            rt_uint16_t tmpxy[2][SAMP_CNT];
+            rt_uint8_t send_buffer[1];
+            rt_uint8_t recv_buffer[2];
+            for(i=0; i<SAMP_CNT; i++)
+            {
+                send_buffer[0] = TOUCH_MSR_X;
+		  touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
+                rt_kprintf("touch x: %d ",(recv_buffer[0]*256|recv_buffer[1])>>4);
+#if defined(_ILI_HORIZONTAL_DIRECTION_)
+                tmpxy[1][i]  = (recv_buffer[0]<<8)|recv_buffer[1] ;
+                tmpxy[1][i] >>= 4;
+#else
+                tmpxy[0][i]  = (recv_buffer[0]<<8)|recv_buffer[1] ;
+                tmpxy[0][i] >>=4;
+
+#endif
+                send_buffer[0] = TOUCH_MSR_Y;
+                touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
+		  rt_kprintf("touch y: %d \n",(recv_buffer[0]*256|recv_buffer[1])>>4);
+
+#if defined(_ILI_HORIZONTAL_DIRECTION_)
+                tmpxy[0][i]  = (recv_buffer[0]<<8)|recv_buffer[1] ;
+                tmpxy[0][i] >>= 4;
+#else
+                tmpxy[1][i]  = (recv_buffer[0]<<8)|recv_buffer[1] ;
+                tmpxy[1][i] >>= 4;
+#endif
+            }
+            /*再次打开触摸中断*/
+            send_buffer[0] = 1 << 7;
+		  touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
+                touch_send_then_recv(touch->spi_device, send_buffer, 1, recv_buffer, 2);
+            /* calculate average */
+			{
+				rt_uint32_t total_x = 0;
+				rt_uint32_t total_y = 0;
+				for(k=0; k<2; k++)
+				{ 
+					// sorting the ADC value
+					for(i=0; i<SAMP_CNT-1; i++)
+					{
+						min=i;
+						for (j=i+1; j<SAMP_CNT; j++)
+						{
+							if (tmpxy[k][min] > tmpxy[k][j]) 
+								min=j;
+						}
+						temp = tmpxy[k][i];
+						tmpxy[k][i] = tmpxy[k][min];
+						tmpxy[k][min] = temp;
+				    }
+				    //check value for Valve value
+					if((tmpxy[k][SAMP_CNT_DIV2+1]-tmpxy[k][SAMP_CNT_DIV2-2]) > SH)
+					{
+						return;
+					}
+				}
+				total_x=tmpxy[0][SAMP_CNT_DIV2-2]+tmpxy[0][SAMP_CNT_DIV2-1]+tmpxy[0][SAMP_CNT_DIV2]+tmpxy[0][SAMP_CNT_DIV2+1];
+				total_y=tmpxy[1][SAMP_CNT_DIV2-2]+tmpxy[1][SAMP_CNT_DIV2-1]+tmpxy[1][SAMP_CNT_DIV2]+tmpxy[1][SAMP_CNT_DIV2+1];
+				//calculate average value
+				touch->x=total_x>>2;
+				touch->y=total_y>>2;
+                rt_kprintf("touch->x:%d touch->y:%d\r\n", touch->x, touch->y);
+           } /* calculate average */
+        } /* read touch */
+
+        /* if it's not in calibration status  */
+        /*触摸值缩放*/
+        if (touch->calibrating != RT_TRUE)
+        {
+            if (touch->max_x > touch->min_x)
+            {
+                touch->x = (touch->x - touch->min_x) * X_WIDTH/(touch->max_x - touch->min_x);
+            }
+            else
+            {
+                touch->x = (touch->min_x - touch->x) * X_WIDTH/(touch->min_x - touch->max_x);
+            }
+
+            if (touch->max_y > touch->min_y)
+            {
+                touch->y = (touch->y - touch->min_y) * Y_WIDTH /(touch->max_y - touch->min_y);
+            }
+            else
+            {
+                touch->y = (touch->min_y - touch->y) * Y_WIDTH /(touch->min_y - touch->max_y);
+            }
+        }
+    }
+}
+#include "ls1c_regs.h"
+#define TOUCH_INT_EN				__REG32(LS1C_INT4_EN)
+rt_inline void touch_int_cmd(rt_bool_t NewState)
+{
+	if(NewState == RT_TRUE)
+		{
+			//TOUCH_INT_EN |= (1<<(TOUCH_INT_PIN-64));
+			reg_set_one_bit(LS1C_INT4_EN, 1<<(TOUCH_INT_PIN-64));
+		}
+	else
+		{
+			//TOUCH_INT_EN &=(~ (1<<(TOUCH_INT_PIN-64)));
+			reg_clr_one_bit(LS1C_INT4_EN, 1<<(TOUCH_INT_PIN-64));
+		}
+
+}
+
+void ls1c_touch_irqhandler(void) /* TouchScreen */
+{
+  if(gpio_get(TOUCH_INT_PIN)==0)
+  {
+    /* 触摸屏按下后操作 */  
+	if (gpio_level_low == gpio_get(led_gpio))
+		gpio_set(led_gpio, gpio_level_high); 
+	else
+		gpio_set(led_gpio, gpio_level_low); 
+	touch_int_cmd(RT_FALSE);
+	rt_event_send(&touch->event, 1);
+  }
+}
+
+/*管脚初始化，配置中断打开SPI1 CS0 设备*/
+rt_inline void touch_init(void)
+{	 
+    unsigned int touch_int_gpio = TOUCH_INT_PIN;     // 触摸屏中断
+    int touch_irq = LS1C_GPIO_TO_IRQ(touch_int_gpio);  
+  
+    // 初始化按键中断  
+    gpio_set_irq_type(touch_int_gpio, IRQ_TYPE_EDGE_FALLING);  
+    rt_hw_interrupt_install(touch_irq, ls1c_touch_irqhandler, RT_NULL, "touch");  
+    rt_hw_interrupt_umask(touch_irq);  
+    gpio_init(touch_int_gpio, gpio_mode_input);  
+  
+    // 初始化led  
+    gpio_init(led_gpio, gpio_mode_output); 
+    gpio_set(led_gpio, gpio_level_high);   
+}
+
+
+/* RT-Thread Device Interface */
+static rt_err_t rtgui_touch_init (rt_device_t dev)
+{
+    rt_uint8_t send;
+	rt_uint8_t recv_buffer[2];
+    struct rtgui_touch_device * touch_device = (struct rtgui_touch_device *)dev;
+	
+    touch_init();
+    rt_kprintf("touch_init ...\n");
+    send = START | DIFFERENTIAL | POWER_MODE0;
+    touch_send_then_recv(touch->spi_device, &send, 1, recv_buffer, 2);
+
+    return RT_EOK;
+}
+
+static rt_err_t rtgui_touch_control (rt_device_t dev, int cmd, void *args)
+{
+    switch (cmd)
+    {
+    case RT_TOUCH_CALIBRATION:
+        touch->calibrating = RT_TRUE;
+        touch->calibration_func = (rt_touch_calibration_func_t)args;
+        break;
+
+    case RT_TOUCH_NORMAL:
+        touch->calibrating = RT_FALSE;
+        break;
+
+    case RT_TOUCH_CALIBRATION_DATA:
+    {
+        struct calibration_data* data;
+        data = (struct calibration_data*) args;
+
+        //update
+        touch->min_x = data->min_x;
+        touch->max_x = data->max_x;
+        touch->min_y = data->min_y;
+        touch->max_y = data->max_y;
+    }
+    break;
+    }
+
+    return RT_EOK;
+}
+
+void _set_mouse_position(rt_uint32_t X, rt_uint32_t Y)
+{}
+static void touch_thread_entry(void *parameter)
+{
+    rt_bool_t touch_down = RT_FALSE;
+    rt_uint32_t event_value;
+    struct rtgui_event_mouse emouse;
+    static struct _touch_previous
+    {
+        rt_uint32_t x;
+        rt_uint32_t y;
+    } touch_previous;
+
+    RTGUI_EVENT_MOUSE_BUTTON_INIT(&emouse);
+    emouse.wid = RT_NULL;
+
+    while(1)
+    {
+        /* 接收到触摸中断事件 */
+        if(rt_event_recv(&touch->event,
+                         1,
+                         RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+                         100,
+                         &event_value)
+                == RT_EOK)
+        {
+            while(1)
+            {
+                if (IS_TOUCH_UP())
+                {
+                    /* 触摸笔抬起 */
+                    /* touch up */
+                    emouse.button = (RTGUI_MOUSE_BUTTON_LEFT |RTGUI_MOUSE_BUTTON_UP);
+
+                    /* use old value */
+                    emouse.x = touch->x;
+                    emouse.y = touch->y;
+
+                    if(touch_down != RT_TRUE) 
+                    {                    
+                        touch_int_cmd(RT_TRUE);
+                        break;
+                    }    
+
+                    if ((touch->calibrating == RT_TRUE) && (touch->calibration_func != RT_NULL))
+                    {
+                        /* 触摸校准处理 */
+                        /* callback function */
+                        touch->calibration_func(emouse.x, emouse.y);
+											
+                    }
+                    else
+                    {
+                        /* 向ui发送触摸坐标 */
+                        rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
+                    }
+                    rt_kprintf("touch up: (%d, %d)\n", emouse.x, emouse.y);
+
+                    /* clean */
+                    touch_previous.x = touch_previous.y = 0;
+                    touch_down = RT_FALSE;
+
+                    touch_int_cmd(RT_TRUE);
+                    break;
+                } /* touch up */
+                else /* touch down or move */
+                {
+                    if(touch_down == RT_FALSE)
+                    {
+                        rt_thread_delay(RT_TICK_PER_SECOND / 10);
+                    }
+                    else
+                    {
+                        rt_thread_delay(5);
+                    }
+
+                    if(IS_TOUCH_UP()) continue;
+
+                    /* calculation */
+                    rtgui_touch_calculate();
+                    
+                    /* send mouse event */
+                    emouse.parent.type = RTGUI_EVENT_MOUSE_BUTTON;
+                    emouse.parent.sender = RT_NULL;
+
+                    emouse.x = touch->x;
+                    emouse.y = touch->y;
+                    _set_mouse_position(emouse.x, emouse.y);
+                    /* 光标跟随 */
+                    /* init mouse button */
+                    emouse.button = (RTGUI_MOUSE_BUTTON_LEFT |RTGUI_MOUSE_BUTTON_DOWN);
+
+                    /* send event to server */
+                    if (touch->calibrating != RT_TRUE)
+                    {
+#define previous_keep      8
+                        /* filter. */
+                        if((touch_previous.x > touch->x + previous_keep)
+                            || (touch_previous.x < touch->x - previous_keep)
+                            || (touch_previous.y > touch->y + previous_keep)
+                            || (touch_previous.y < touch->y - previous_keep))
+                        {
+                            touch_previous.x = touch->x;
+                            touch_previous.y = touch->y;
+                            /* 向ui发送触摸坐标 */
+                            rtgui_server_post_event(&emouse.parent, sizeof(struct rtgui_event_mouse));
+                            if(touch_down == RT_FALSE)
+                            {
+                                touch_down = RT_TRUE;
+                                rt_kprintf("touch down: (%d, %d)\n", emouse.x, emouse.y);
+                            }
+                            else
+                            {
+                                rt_kprintf("touch motion: (%d, %d)\n", emouse.x, emouse.y);
+                            }
+                        }
+                    }
+                    else
+                    {
+                        touch_down = RT_TRUE;
+                    }
+                } /* touch down or move */
+            } /* read touch */
+        } /* event recv */
+    } /* thread while(1) */
+}
+
+
+rt_err_t rtgui_touch_hw_init(const char * spi_device_name)
+{
+    	 rt_uint32_t arg[2]; 
+	struct rt_device * spi_device;
+    	struct rt_thread * touch_thread;
+	rt_err_t err;
+
+	rt_kprintf("spi1 cs0 start...\n");
+	spi_device = rt_device_find("spi10");
+	if(spi_device ==  RT_NULL)
+	{
+		rt_kprintf("Did not find spi1, exit thread....\n");
+		return;
+	}
+	err = rt_device_open(spi_device, RT_DEVICE_OFLAG_RDWR);
+	if(err != RT_EOK)
+	{
+		rt_kprintf("Open spi1 failed %08X, exit thread....\n", err);
+		return;
+	}
+      
+      /* config spi */
+      {
+          struct rt_spi_configuration cfg;
+          cfg.data_width = 8;
+          cfg.mode = RT_SPI_MODE_0; 
+       cfg.max_hz  = 200 * 1000; /* 200K */
+        rt_spi_configure((struct rt_spi_device *)spi_device, &cfg);
+      }
+
+	touch = (struct rtgui_touch_device*)rt_malloc (sizeof(struct rtgui_touch_device));
+    if (touch == RT_NULL) return RT_ENOMEM; /* no memory yet */
+
+    /* clear device structure */
+    rt_memset(&(touch->parent), 0, sizeof(struct rt_device));
+
+    rt_event_init(&touch->event, "touch", RT_IPC_FLAG_FIFO);
+
+    touch->spi_device = (struct rt_spi_device *)spi_device;
+    touch->calibrating = false;
+
+    touch->min_x = MIN_X_DEFAULT;
+    touch->max_x = MAX_X_DEFAULT;
+    touch->min_y = MIN_Y_DEFAULT; 
+    touch->max_y = MAX_Y_DEFAULT;
+
+    /* init device structure */
+    touch->parent.type = RT_Device_Class_Miscellaneous;
+    touch->parent.init = rtgui_touch_init;
+    touch->parent.control = rtgui_touch_control;
+    touch->parent.user_data = RT_NULL;
+
+    /* register touch device to RT-Thread */
+    rt_device_register(&(touch->parent), "touch", RT_DEVICE_FLAG_RDWR);
+	
+
+    touch_thread = rt_thread_create("touch_thread",
+                                    touch_thread_entry, RT_NULL,
+                                    4096, RTGUI_SVR_THREAD_PRIORITY-1, 1);
+    if (touch_thread != RT_NULL) rt_thread_startup(touch_thread);
+
+     rt_device_init((rt_device_t)touch);
+   return RT_EOK;
+}

bsp/ls1cdev/drivers/touch.h

+/*
+ * File      : touch.h
+ * This file is part of RT-Thread RTOS
+ * COPYRIGHT (C) 2006 - 2012, RT-Thread Development Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Change Logs:
+ * Date           Author       Notes
+ * 2017-12-30    Sundm75       first version
+ */
+ #ifndef __TOUCH_H__
+#define __TOUCH_H__
+
+#define RT_TOUCH_NORMAL		        0
+#define RT_TOUCH_CALIBRATION_DATA	1
+#define RT_TOUCH_CALIBRATION 		2
+
+//#define SAVE_CALIBRATION
+
+     
+rt_uint16_t touch_read_x(void);
+rt_uint16_t touch_read_y(void);
+void touch_config(void);
+																 
+
+rt_err_t rtgui_touch_hw_init(const char * spi_device_name);
+		  
+#endif
+
+