From b08ff9eee2461cb6654d52df1d29d6360f05ff97 Mon Sep 17 00:00:00 2001 From: sundm75 Date: Mon, 15 Jan 2018 14:56:48 +0800 Subject: [PATCH] [bsp] Add SmartloongV3 display,touch,msd, hw_i2c driver --- bsp/ls1cdev/drivers/SConscript | 4 + bsp/ls1cdev/drivers/board.c | 118 +- bsp/ls1cdev/drivers/display_controller.c | 233 +++ bsp/ls1cdev/drivers/display_controller.h | 59 + bsp/ls1cdev/drivers/hw_i2c.c | 147 ++ bsp/ls1cdev/drivers/hw_i2c.h | 32 + bsp/ls1cdev/drivers/msd.c | 1693 ++++++++++++++++++++++ bsp/ls1cdev/drivers/msd.h | 132 ++ bsp/ls1cdev/drivers/touch.c | 607 ++++++++ bsp/ls1cdev/drivers/touch.h | 43 + bsp/ls1cdev/rtconfig.h | 10 +- 11 files changed, 3075 insertions(+), 3 deletions(-) create mode 100644 bsp/ls1cdev/drivers/display_controller.c create mode 100644 bsp/ls1cdev/drivers/display_controller.h create mode 100644 bsp/ls1cdev/drivers/hw_i2c.c create mode 100644 bsp/ls1cdev/drivers/hw_i2c.h create mode 100644 bsp/ls1cdev/drivers/msd.c create mode 100644 bsp/ls1cdev/drivers/msd.h create mode 100644 bsp/ls1cdev/drivers/touch.c create mode 100644 bsp/ls1cdev/drivers/touch.h diff --git a/bsp/ls1cdev/drivers/SConscript b/bsp/ls1cdev/drivers/SConscript index 3e76809efb..1dd9875087 100644 --- a/bsp/ls1cdev/drivers/SConscript +++ b/bsp/ls1cdev/drivers/SConscript @@ -5,6 +5,10 @@ src = Glob('*.c') CPPPATH = [cwd] + +if GetDepend('RT_USING_RTGUI')== False: + SrcRemove(src, 'touch.c') + group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH) objs = [] diff --git a/bsp/ls1cdev/drivers/board.c b/bsp/ls1cdev/drivers/board.c index cb5fbdae09..9a54823fb4 100644 --- a/bsp/ls1cdev/drivers/board.c +++ b/bsp/ls1cdev/drivers/board.c @@ -15,11 +15,16 @@ */ #include +#include #include #include "board.h" #include "uart.h" #include "ls1c.h" +#include "ls1c_pin.h" +#include "ls1c_spi.h" +#include "ls1c_spi.h" +#include "drv_spi.h" /** * @addtogroup Loongson LS1B @@ -88,9 +93,92 @@ void rt_hw_board_init(void) #ifdef RT_USING_CONSOLE /* set console device */ - rt_console_set_device("uart2"); + rt_console_set_device(RT_CONSOLE_DEVICE_NAME); #endif + +#ifdef RT_USING_I2C +#ifdef RT_USING_I2C0 +/* + pin_set_purpose(2, PIN_PURPOSE_OTHER); + pin_set_purpose(3, PIN_PURPOSE_OTHER); + pin_set_remap(2, PIN_REMAP_SECOND); + pin_set_remap(3, PIN_REMAP_SECOND); + */ +#endif +#ifdef RT_USING_I2C1 + pin_set_purpose(2, PIN_PURPOSE_OTHER); + pin_set_purpose(3, PIN_PURPOSE_OTHER); + pin_set_remap(2, PIN_REMAP_SECOND); + pin_set_remap(3, PIN_REMAP_SECOND); +#endif +#ifdef RT_USING_I2C2 + pin_set_purpose(51, PIN_PURPOSE_OTHER); + pin_set_purpose(50, PIN_PURPOSE_OTHER); + pin_set_remap(51, PIN_REMAP_FOURTH); + pin_set_remap(50, PIN_REMAP_FOURTH); +#endif + rt_i2c_init(); +#endif + +#ifdef RT_USING_SPI + +#ifdef RT_USING_SPI0 + pin_set_purpose(78, PIN_PURPOSE_OTHER); + pin_set_purpose(79, PIN_PURPOSE_OTHER); + pin_set_purpose(80, PIN_PURPOSE_OTHER); + pin_set_purpose(83, PIN_PURPOSE_OTHER);//cs2 - SD card + pin_set_purpose(82, PIN_PURPOSE_OTHER);//cs1 + pin_set_remap(78, PIN_REMAP_FOURTH); + pin_set_remap(79, PIN_REMAP_FOURTH); + pin_set_remap(80, PIN_REMAP_FOURTH); + pin_set_remap(83, PIN_REMAP_FOURTH);//cs2 - SD card + pin_set_remap(82, PIN_REMAP_FOURTH);//cs1 + ls1c_spi_bus_register(LS1C_SPI_0,"spi0"); +#endif + +#ifdef RT_USING_SPI1 + pin_set_purpose(46, PIN_PURPOSE_OTHER); + pin_set_purpose(47, PIN_PURPOSE_OTHER); + pin_set_purpose(48, PIN_PURPOSE_OTHER); + pin_set_purpose(49, PIN_PURPOSE_OTHER);//CS0 - touch screen + pin_set_remap(46, PIN_REMAP_THIRD); + pin_set_remap(47, PIN_REMAP_THIRD); + pin_set_remap(48, PIN_REMAP_THIRD); + pin_set_remap(49, PIN_REMAP_THIRD);//CS0 - touch screen + ls1c_spi_bus_register(LS1C_SPI_1,"spi1"); + +#endif +#ifdef RT_USING_SPI0 + /* attach cs */ + { + static struct rt_spi_device spi_device1; + static struct rt_spi_device spi_device2; + static struct ls1c_spi_cs spi_cs1; + static struct ls1c_spi_cs spi_cs2; + + /* spi02: CS2 SD Card*/ + spi_cs2.cs = LS1C_SPI_CS_2; + rt_spi_bus_attach_device(&spi_device2, "spi02", "spi0", (void*)&spi_cs2); + spi_cs1.cs = LS1C_SPI_CS_1; + rt_spi_bus_attach_device(&spi_device1, "spi01", "spi0", (void*)&spi_cs1); + msd_init("sd0", "spi02"); + } +#endif +#ifdef RT_USING_SPI1 + { + static struct rt_spi_device spi_device; + static struct ls1c_spi_cs spi_cs; + + /* spi10: CS0 Touch*/ + spi_cs.cs = LS1C_SPI_CS_0; + rt_spi_bus_attach_device(&spi_device, "spi10", "spi1", (void*)&spi_cs); + } +#endif + +#endif + + /* init operating system timer */ rt_hw_timer_init(); @@ -102,6 +190,34 @@ void rt_hw_board_init(void) rt_kprintf("current sr: 0x%08x\n", read_c0_status()); } + +#ifdef RT_USING_RTGUI +#include +#include "display_controller.h" +/* initialize for gui driver */ +int rtgui_lcd_init(void) +{ + rt_device_t dc; + rt_kprintf("DC initied\n"); + + pin_set_purpose(76, PIN_PURPOSE_OTHER); + pin_set_remap(76, PIN_REMAP_DEFAULT); + + /* init Display Controller */ + rt_hw_dc_init(); + + /* find Display Controller device */ + dc = rt_device_find("dc"); + + /* set Display Controller device as rtgui graphic driver */ + rtgui_graphic_set_device(dc); + + + return 0; +} +INIT_DEVICE_EXPORT(rtgui_lcd_init); +#endif + #define __raw_out_put(unr) \ while (*ptr) \ { \ diff --git a/bsp/ls1cdev/drivers/display_controller.c b/bsp/ls1cdev/drivers/display_controller.c new file mode 100644 index 0000000000..84bf99cd5c --- /dev/null +++ b/bsp/ls1cdev/drivers/display_controller.c @@ -0,0 +1,233 @@ +/* + * 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 +#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; itype = 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); +} + diff --git a/bsp/ls1cdev/drivers/display_controller.h b/bsp/ls1cdev/drivers/display_controller.h new file mode 100644 index 0000000000..ad252a9c2f --- /dev/null +++ b/bsp/ls1cdev/drivers/display_controller.h @@ -0,0 +1,59 @@ +/* + * 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 +#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 diff --git a/bsp/ls1cdev/drivers/hw_i2c.c b/bsp/ls1cdev/drivers/hw_i2c.c new file mode 100644 index 0000000000..15d84997c6 --- /dev/null +++ b/bsp/ls1cdev/drivers/hw_i2c.c @@ -0,0 +1,147 @@ +/* + * 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 +#include +#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; +} diff --git a/bsp/ls1cdev/drivers/hw_i2c.h b/bsp/ls1cdev/drivers/hw_i2c.h new file mode 100644 index 0000000000..1bd4e991ed --- /dev/null +++ b/bsp/ls1cdev/drivers/hw_i2c.h @@ -0,0 +1,32 @@ +/* + * 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 + +int rt_i2c_init(void); + +#endif diff --git a/bsp/ls1cdev/drivers/msd.c b/bsp/ls1cdev/drivers/msd.c new file mode 100644 index 0000000000..844302cb3f --- /dev/null +++ b/bsp/ls1cdev/drivers/msd.c @@ -0,0 +1,1693 @@ +/* + * File : msd.c + * 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. + * 2010-07-15 aozima Modify read/write according new block driver interface. + * 2012-02-01 aozima use new RT-Thread SPI drivers. + * 2012-04-11 aozima get max. data transfer rate from CSD[TRAN_SPEED]. + * 2012-05-21 aozima update MMC card support. + */ + +#include +#include "msd.h" + +//#define MSD_TRACE + +#ifdef MSD_TRACE +#define MSD_DEBUG(...) rt_kprintf("[MSD] %d ", rt_tick_get()); rt_kprintf(__VA_ARGS__); +#else +#define MSD_DEBUG(...) +#endif /* #ifdef MSD_TRACE */ + +#define DUMMY 0xFF + +#define CARD_NCR_MAX 8 + +#define CARD_NRC 1 +#define CARD_NCR 1 + +static struct msd_device _msd_device; + +/* function define */ +static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long); + +static rt_err_t MSD_take_owner(struct rt_spi_device* spi_device); +static void MSD_take_cs(struct rt_spi_device* device); +static void MSD_release_cs(struct rt_spi_device* device); + +static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token); +static rt_err_t _wait_ready(struct rt_spi_device* device); +static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size); +static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size); +static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size); +static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size); + +static rt_err_t MSD_take_owner(struct rt_spi_device* spi_device) +{ + rt_err_t result; + + result = rt_mutex_take(&(spi_device->bus->lock), RT_WAITING_FOREVER); + if(result == RT_EOK) + { + if (spi_device->bus->owner != spi_device) + { + /* not the same owner as current, re-configure SPI bus */ + result = spi_device->bus->ops->configure(spi_device, &spi_device->config); + if (result == RT_EOK) + { + /* set SPI bus owner */ + spi_device->bus->owner = spi_device; + } + } + } + + return result; +} + +static void MSD_take_cs(struct rt_spi_device* device) +{ + struct rt_spi_message message; + + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = RT_NULL; + message.length = 0; + message.cs_take = 1; + message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); +} + +static void MSD_release_cs(struct rt_spi_device* device) +{ + struct rt_spi_message message; + + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = RT_NULL; + message.length = 0; + message.cs_take = 0; + message.cs_release = 1; + + /* transfer message */ + device->bus->ops->xfer(device, &message); +} + +static rt_bool_t rt_tick_timeout(rt_tick_t tick_start, rt_tick_t tick_long) +{ + rt_tick_t tick_end = tick_start + tick_long; + rt_tick_t tick_now = rt_tick_get(); + rt_bool_t result = RT_FALSE; + + if(tick_end >= tick_start) + { + if (tick_now >= tick_end) + { + result = RT_TRUE; + } + else + { + result = RT_FALSE; + } + } + else + { + if ((tick_now < tick_start ) && (tick_now >= tick_end) ) + { + result = RT_TRUE; + } + else + { + result = RT_FALSE; + } + } + + return result; +} + +static uint8_t crc7(const uint8_t *buf, int len) +{ + unsigned char i, j, crc, ch, ch2, ch3; + + crc = 0; + + for (i = 0; i < len; i ++) + { + ch = buf[i]; + + for (j = 0; j < 8; j ++, ch <<= 1) + { + ch2 = (crc & 0x40) ? 1 : 0; + ch3 = (ch & 0x80) ? 1 : 0; + + if (ch2 ^ ch3) + { + crc ^= 0x04; + crc <<= 1; + crc |= 0x01; + } + else + { + crc <<= 1; + } + } + } + + return crc; +} + +static rt_err_t _send_cmd( + struct rt_spi_device* device, + uint8_t cmd, + uint32_t arg, + uint8_t crc, + response_type type, + uint8_t * response +) +{ + struct rt_spi_message message; + uint8_t cmd_buffer[8]; + uint8_t recv_buffer[sizeof(cmd_buffer)]; + uint32_t i; + + cmd_buffer[0] = DUMMY; + cmd_buffer[1] = (cmd | 0x40); + cmd_buffer[2] = (uint8_t)(arg >> 24); + cmd_buffer[3] = (uint8_t)(arg >> 16); + cmd_buffer[4] = (uint8_t)(arg >> 8); + cmd_buffer[5] = (uint8_t)(arg); + + if(crc == 0x00) + { + crc = crc7(&cmd_buffer[1], 5); + crc = (crc<<1) | 0x01; + } + cmd_buffer[6] = (crc); + + cmd_buffer[7] = DUMMY; + + /* initial message */ + message.send_buf = cmd_buffer; + message.recv_buf = recv_buffer; + message.length = sizeof(cmd_buffer); + message.cs_take = message.cs_release = 0; + + _wait_ready(device); + + /* transfer message */ + device->bus->ops->xfer(device, &message); + + for(i=CARD_NCR; i<(CARD_NCR_MAX+1); i++) + { + uint8_t send = DUMMY; + + /* initial message */ + message.send_buf = &send; + message.recv_buf = response; + message.length = 1; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + + if(0 == (response[0] & 0x80)) + { + break; + } + } /* wait response */ + + if((CARD_NCR_MAX+1) == i) + { + return RT_ERROR;//fail + } + + //recieve other byte + if(type == response_r1) + { + return RT_EOK; + } + else if(type == response_r1b) + { + rt_tick_t tick_start = rt_tick_get(); + uint8_t recv; + + while(1) + { + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = &recv; + message.length = 1; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + + if(recv == DUMMY) + { + return RT_EOK; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(2000))) + { + return RT_ETIMEOUT; + } + } + } + else if(type == response_r2) + { + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = response+1; + message.length = 1; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } + else if((type == response_r3) || (type == response_r7)) + { + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = response+1; + message.length = 4; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } + else + { + return RT_ERROR; // unknow type? + } + + return RT_EOK; +} + +static rt_err_t _wait_token(struct rt_spi_device* device, uint8_t token) +{ + struct rt_spi_message message; + rt_tick_t tick_start; + uint8_t send, recv; + + tick_start = rt_tick_get(); + + /* wati token */ + /* initial message */ + send = DUMMY; + message.send_buf = &send; + message.recv_buf = &recv; + message.length = 1; + message.cs_take = message.cs_release = 0; + + while(1) + { + /* transfer message */ + device->bus->ops->xfer(device, &message); + + if(recv == token) + { + return RT_EOK; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_WAIT_TOKEN_TIMES))) + { + MSD_DEBUG("[err] wait data start token timeout!\r\n"); + return RT_ETIMEOUT; + } + } /* wati token */ +} + +static rt_err_t _wait_ready(struct rt_spi_device* device) +{ + struct rt_spi_message message; + rt_tick_t tick_start; + uint8_t send, recv; + + tick_start = rt_tick_get(); + + send = DUMMY; + /* initial message */ + message.send_buf = &send; + message.recv_buf = &recv; + message.length = 1; + message.cs_take = message.cs_release = 0; + + while(1) + { + /* transfer message */ + device->bus->ops->xfer(device, &message); + + if(recv == DUMMY) + { + return RT_EOK; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(1000))) + { + MSD_DEBUG("[err] wait ready timeout!\r\n"); + return RT_ETIMEOUT; + } + } +} + +static rt_err_t _read_block(struct rt_spi_device* device, void * buffer, uint32_t block_size) +{ + struct rt_spi_message message; + rt_err_t result; + + /* wati token */ + result = _wait_token(device, MSD_TOKEN_READ_START); + if(result != RT_EOK) + { + return result; + } + + /* read data */ + { + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = buffer; + message.length = block_size; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } /* read data */ + + /* get crc */ + { + uint8_t recv_buffer[2]; + + /* initial message */ + message.send_buf = RT_NULL; + message.recv_buf = recv_buffer; + message.length = 2; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } /* get crc */ + + return RT_EOK; +} + +static rt_err_t _write_block(struct rt_spi_device* device, const void * buffer, uint32_t block_size, uint8_t token) +{ + struct rt_spi_message message; + uint8_t send_buffer[16]; + + rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); + send_buffer[sizeof(send_buffer) - 1] = token; + + /* send start block token */ + { + /* initial message */ + message.send_buf = send_buffer; + message.recv_buf = RT_NULL; + message.length = sizeof(send_buffer); + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } + + /* send data */ + { + /* initial message */ + message.send_buf = buffer; + message.recv_buf = RT_NULL; + message.length = block_size; + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + } + + /* put crc and get data response */ + { + uint8_t recv_buffer[3]; + uint8_t response; + + /* initial message */ + message.send_buf = send_buffer; + message.recv_buf = recv_buffer; + message.length = sizeof(recv_buffer); + message.cs_take = message.cs_release = 0; + + /* transfer message */ + device->bus->ops->xfer(device, &message); + +// response = 0x0E & recv_buffer[2]; + response = MSD_GET_DATA_RESPONSE(recv_buffer[2]); + if(response != MSD_DATA_OK) + { + MSD_DEBUG("[err] write block fail! data response : 0x%02X\r\n", response); + return RT_ERROR; + } + } + + /* wati ready */ + return _wait_ready(device); +} + +/* RT-Thread Device Driver Interface */ +static rt_err_t rt_msd_init(rt_device_t dev) +{ + struct msd_device * msd = (struct msd_device *)dev; + uint8_t response[MSD_RESPONSE_MAX_LEN]; + rt_err_t result = RT_EOK; + rt_tick_t tick_start; + uint32_t OCR; + + if(msd->spi_device == RT_NULL) + { + MSD_DEBUG("[err] the SPI SD device has no SPI!\r\n"); + return RT_EIO; + } + + /* config spi */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = 1000*400; /* 400kbit/s */ + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + + /* init SD card */ + { + struct rt_spi_message message; + + result = MSD_take_owner(msd->spi_device); + + if (result != RT_EOK) + { + goto _exit; + } + + MSD_release_cs(msd->spi_device); + + /* The host shall supply power to the card so that the voltage is reached to Vdd_min within 250ms and + start to supply at least 74 SD clocks to the SD card with keeping CMD line to high. + In case of SPI mode, CS shall be held to high during 74 clock cycles. */ + { + uint8_t send_buffer[100]; /* 100byte > 74 clock */ + + /* initial message */ + rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); + message.send_buf = send_buffer; + message.recv_buf = RT_NULL; + message.length = sizeof(send_buffer); + message.cs_take = message.cs_release = 0; + + /* transfer message */ + msd->spi_device->bus->ops->xfer(msd->spi_device, &message); + } /* send 74 clock */ + + /* Send CMD0 (GO_IDLE_STATE) to put MSD in SPI mode */ + { + tick_start = rt_tick_get(); + + while(1) + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response); + MSD_release_cs(msd->spi_device); + + if((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE)) + { + break; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) + { + MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); + result = RT_ETIMEOUT; + goto _exit; + } + } + + MSD_DEBUG("[info] SD card goto IDLE mode OK!\r\n"); + } /* Send CMD0 (GO_IDLE_STATE) to put MSD in SPI mode */ + + /* CMD8 */ + { + tick_start = rt_tick_get(); + + do + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, SEND_IF_COND, 0x01AA, 0x87, response_r7, response); + MSD_release_cs(msd->spi_device); + + if(result == RT_EOK) + { + MSD_DEBUG("[info] CMD8 response : 0x%02X 0x%02X 0x%02X 0x%02X 0x%02X\r\n", + response[0], response[1], response[2], response[3], response[4]); + + if(response[0] & (1<<2)) + { + /* illegal command, SD V1.x or MMC card */ + MSD_DEBUG("[info] CMD8 is illegal command.\r\n"); + MSD_DEBUG("[info] maybe Ver1.X SD Memory Card or MMC card!\r\n"); + msd->card_type = MSD_CARD_TYPE_SD_V1_X; + break; + } + else + { + /* SD V2.0 or later or SDHC or SDXC memory card! */ + MSD_DEBUG("[info] Ver2.00 or later or SDHC or SDXC memory card!\r\n"); + msd->card_type = MSD_CARD_TYPE_SD_V2_X; + } + + if((0xAA == response[4]) && (0x00 == response[3])) + { + /* SD2.0 not support current voltage */ + MSD_DEBUG("[err] VCA = 0, SD2.0 not surpport current operation voltage range\r\n"); + result = RT_ERROR; + goto _exit; + } + } + else + { + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(200))) + { + MSD_DEBUG("[err] CMD8 SEND_IF_COND timeout!\r\n"); + result = RT_ETIMEOUT; + goto _exit; + } + } + } + while(0xAA != response[4]); + } /* CMD8 */ + + /* Ver1.X SD Memory Card or MMC card */ + if(msd->card_type == MSD_CARD_TYPE_SD_V1_X) + { + rt_bool_t is_sd_v1_x = RT_FALSE; + rt_tick_t tick_start; + + /* try SD Ver1.x */ + while(1) + { + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] It maybe SD1.x or MMC But it is Not response to CMD58!\r\n"); + goto _exit; + } + + if(0 != (response[0]&0xFE)) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] It look CMD58 as illegal command so it is not SD card!\r\n"); + break; + } + MSD_release_cs(msd->spi_device); + + OCR = response[1]; + OCR = (OCR<<8) + response[2]; + OCR = (OCR<<8) + response[3]; + OCR = (OCR<<8) + response[4]; + MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR); + + if( 0 == (OCR & (0x1 << 15))) + { + MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n")); + result = RT_ERROR; + goto _exit; + } + + /* --Send ACMD41 to make card ready */ + tick_start = rt_tick_get(); + + /* try CMD55 + ACMD41 */ + while(1) + { + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41))) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] try CMD55 + ACMD41 timeout! mabey MMC card!\r\n"); + break; + } + + MSD_take_cs(msd->spi_device); + + /* CMD55 APP_CMD */ + result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + continue; + } + + if(0 != (response[0]&0xFE)) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] Not SD card2 , may be MMC\r\n"); + break; + } + + /* ACMD41 SD_SEND_OP_COND */ + result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x00, 0x00, response_r1, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + continue; + } + + if(0 != (response[0]&0xFE)) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] Not SD card4 , may be MMC\r\n"); + break; + } + + if(0 == (response[0]&0xFF)) + { + MSD_release_cs(msd->spi_device); + is_sd_v1_x = RT_TRUE; + MSD_DEBUG("[info] It is Ver1.X SD Memory Card!!!\r\n"); + break; + } + } /* try CMD55 + ACMD41 */ + + break; + } /* try SD Ver1.x */ + + /* try MMC */ + if(is_sd_v1_x != RT_TRUE) + { + uint32_t i; + + MSD_DEBUG("[info] try MMC card!\r\n"); + MSD_release_cs(msd->spi_device); + + /* send dummy clock */ + { + uint8_t send_buffer[100]; + + /* initial message */ + memset(send_buffer, DUMMY, sizeof(send_buffer)); + message.send_buf = send_buffer; + message.recv_buf = RT_NULL; + message.length = sizeof(send_buffer); + message.cs_take = message.cs_release = 0; + + for(i=0; i<10; i++) + { + /* transfer message */ + msd->spi_device->bus->ops->xfer(msd->spi_device, &message); + } + } /* send dummy clock */ + + /* send CMD0 goto IDLE state */ + tick_start = rt_tick_get(); + while(1) + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, GO_IDLE_STATE, 0x00, 0x95, response_r1, response); + MSD_release_cs(msd->spi_device); + + if((result == RT_EOK) && (response[0] == MSD_IN_IDLE_STATE)) + { + break; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) + { + MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); + result = RT_ETIMEOUT; + goto _exit; + } + } /* send CMD0 goto IDLE stat */ + + /* send CMD1 */ + tick_start = rt_tick_get(); + while(1) + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, SEND_OP_COND, 0x00, 0x00, response_r1, response); + MSD_release_cs(msd->spi_device); + + if((result == RT_EOK) && (response[0] == MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[info] It is MMC card!!!\r\n"); + msd->card_type = MSD_CARD_TYPE_MMC; + break; + } + + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES))) + { + MSD_DEBUG("[err] SD card goto IDLE mode timeout!\r\n"); + result = RT_ETIMEOUT; + goto _exit; + } + } /* send CMD1 */ + } /* try MMC */ + } + else if(msd->card_type == MSD_CARD_TYPE_SD_V2_X) + { + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to CMD58!\r\n"); + goto _exit; + } + + if((response[0] & 0xFE) != 0) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] It look CMD58 as illegal command so it is not SD card!\r\n"); + result = RT_ERROR; + goto _exit; + } + + MSD_release_cs(msd->spi_device); + + OCR = response[1]; + OCR = (OCR<<8) + response[2]; + OCR = (OCR<<8) + response[3]; + OCR = (OCR<<8) + response[4]; + MSD_DEBUG("[info] OCR is 0x%08X\r\n", OCR); + + if( 0 == (OCR & (0x1 << 15))) + { + MSD_DEBUG(("[err] SD 1.x But not surpport current voltage\r\n")); + result = RT_ERROR; + goto _exit; + } + + /* --Send ACMD41 to make card ready */ + tick_start = rt_tick_get(); + + /* try CMD55 + ACMD41 */ + do + { + MSD_take_cs(msd->spi_device); + if(rt_tick_timeout(tick_start, rt_tick_from_millisecond(CARD_TRY_TIMES_ACMD41))) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] SD Ver2.x or later try CMD55 + ACMD41 timeout!\r\n"); + result = RT_ERROR; + goto _exit; + } + + /* CMD55 APP_CMD */ + result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x65, response_r1, response); +// if((result != RT_EOK) || (response[0] == 0x01)) + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + continue; + } + + if((response[0] & 0xFE) != 0) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] Not SD ready!\r\n"); + result = RT_ERROR; + goto _exit; + } + + /* ACMD41 SD_SEND_OP_COND */ + result = _send_cmd(msd->spi_device, SD_SEND_OP_COND, 0x40000000, 0x77, response_r1, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] ACMD41 fail!\r\n"); + result = RT_ERROR; + goto _exit; + } + + if((response[0] & 0xFE) != 0) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[info] Not SD card4 , response : 0x%02X\r\n", response[0]); +// break; + } + } + while(response[0] != MSD_RESPONSE_NO_ERROR); + MSD_release_cs(msd->spi_device); + /* try CMD55 + ACMD41 */ + + /* --Read OCR again */ + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, READ_OCR, 0x00, 0x00, response_r3, response); + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] It maybe SD2.0 But it is Not response to 2nd CMD58!\r\n"); + goto _exit; + } + + if((response[0] & 0xFE) != 0) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] It look 2nd CMD58 as illegal command so it is not SD card!\r\n"); + result = RT_ERROR; + goto _exit; + } + MSD_release_cs(msd->spi_device); + + OCR = response[1]; + OCR = (OCR<<8) + response[2]; + OCR = (OCR<<8) + response[3]; + OCR = (OCR<<8) + response[4]; + MSD_DEBUG("[info] OCR 2nd read is 0x%08X\r\n", OCR); + + if((OCR & 0x40000000) != 0) + { + MSD_DEBUG("[info] It is SD2.0 SDHC Card!!!\r\n"); + msd->card_type = MSD_CARD_TYPE_SD_SDHC; + } + else + { + MSD_DEBUG("[info] It is SD2.0 standard capacity Card!!!\r\n"); + } + } /* MSD_CARD_TYPE_SD_V2_X */ + else + { + MSD_DEBUG("[err] SD card type unkonw!\r\n"); + result = RT_ERROR; + goto _exit; + } + } /* init SD card */ + + if(msd->card_type == MSD_CARD_TYPE_SD_SDHC) + { + dev->read = rt_msd_sdhc_read; + dev->write = rt_msd_sdhc_write; + } + else + { + dev->read = rt_msd_read; + dev->write = rt_msd_write; + } + + /* set CRC */ + { + MSD_release_cs(msd->spi_device); + MSD_take_cs(msd->spi_device); +#ifdef MSD_USE_CRC + result = _send_cmd(msd->spi_device, CRC_ON_OFF, 0x01, 0x83, response_r1, response); +#else + result = _send_cmd(msd->spi_device, CRC_ON_OFF, 0x00, 0x91, response_r1, response); +#endif + MSD_release_cs(msd->spi_device); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD59 CRC_ON_OFF fail! response : 0x%02X\r\n", response[0]); + result = RT_ERROR; + goto _exit; + } + } /* set CRC */ + + /* CMD16 SET_BLOCKLEN */ + { + MSD_release_cs(msd->spi_device); + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, SET_BLOCKLEN, SECTOR_SIZE, 0x00, response_r1, response); + MSD_release_cs(msd->spi_device); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD16 SET_BLOCKLEN fail! response : 0x%02X\r\n", response[0]); + result = RT_ERROR; + goto _exit; + } + msd->geometry.block_size = SECTOR_SIZE; + msd->geometry.bytes_per_sector = SECTOR_SIZE; + } + + /* read CSD */ + { + uint8_t CSD_buffer[MSD_CSD_LEN]; + + MSD_take_cs(msd->spi_device); +// result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0xAF, response_r1, response); + result = _send_cmd(msd->spi_device, SEND_CSD, 0x00, 0x00, response_r1, response); + + if(result != RT_EOK) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] CMD9 SEND_CSD timeout!\r\n"); + goto _exit; + } + + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_release_cs(msd->spi_device); + MSD_DEBUG("[err] CMD9 SEND_CSD fail! response : 0x%02X\r\n", response[0]); + result = RT_ERROR; + goto _exit; + } + + result = _read_block(msd->spi_device, CSD_buffer, MSD_CSD_LEN); + MSD_release_cs(msd->spi_device); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read CSD fail!\r\n"); + goto _exit; + } + + /* Analyze CSD */ + { + uint8_t CSD_STRUCTURE; + uint32_t C_SIZE; + uint32_t card_capacity; + + uint8_t tmp8; + uint16_t tmp16; + uint32_t tmp32; + + /* get CSD_STRUCTURE */ + tmp8 = CSD_buffer[0] & 0xC0; /* 0b11000000 */ + CSD_STRUCTURE = tmp8 >> 6; + + /* MMC CSD Analyze. */ + if(msd->card_type == MSD_CARD_TYPE_MMC) + { + uint8_t C_SIZE_MULT; + uint8_t READ_BL_LEN; + + if(CSD_STRUCTURE > 2) + { + MSD_DEBUG("[err] bad CSD Version : %d\r\n", CSD_STRUCTURE); + result = RT_ERROR; + goto _exit; + } + + if(CSD_STRUCTURE == 0) + { + MSD_DEBUG("[info] CSD version No. 1.0\r\n"); + } + else if(CSD_STRUCTURE == 1) + { + MSD_DEBUG("[info] CSD version No. 1.1\r\n"); + } + else if(CSD_STRUCTURE == 2) + { + MSD_DEBUG("[info] CSD version No. 1.2\r\n"); + } + + /* get TRAN_SPEED 8bit [103:96] */ + tmp8 = CSD_buffer[3]; + tmp8 &= 0x03; /* [2:0] transfer rate unit.*/ + if(tmp8 == 0) + { + msd->max_clock = 100 * 1000; /* 0=100kbit/s. */ + } + else if(tmp8 == 1) + { + msd->max_clock = 1 * 1000 * 1000; /* 1=1Mbit/s. */ + } + else if(tmp8 == 2) + { + msd->max_clock = 10 * 1000 * 1000; /* 2=10Mbit/s. */ + } + else if(tmp8 == 3) + { + msd->max_clock = 100 * 1000 * 1000; /* 3=100Mbit/s. */ + } + if(tmp8 == 0) + { + MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dkbit/s.\r\n", tmp8, msd->max_clock/1000); + } + else + { + MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000); + } + + /* get READ_BL_LEN 4bit [83:80] */ + tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */ + READ_BL_LEN = tmp8; /* 4 bit */ + MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN)); + + /* get C_SIZE 12bit [73:62] */ + tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */ + tmp16 = tmp16<<8; + tmp16 += CSD_buffer[7]; /* get [71:64] */ + tmp16 = tmp16<<2; + tmp8 = CSD_buffer[8] & 0xC0; /* get [63:62] 0b11000000 */ + tmp8 = tmp8>>6; + tmp16 = tmp16 + tmp8; + C_SIZE = tmp16; //12 bit + MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); + + /* get C_SIZE_MULT 3bit [49:47] */ + tmp8 = CSD_buffer[9] & 0x03;//0b00000011; + tmp8 = tmp8<<1; + tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/)>>7); + C_SIZE_MULT = tmp8; // 3 bit + MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT); + + /* memory capacity = BLOCKNR * BLOCK_LEN */ + /* BLOCKNR = (C_SIZE+1) * MULT */ + /* MULT = 2^(C_SIZE_MULT+2) */ + /* BLOCK_LEN = 2^READ_BL_LEN */ + card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT+2))); + msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector; + MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity/(1024*1024)); + } + else /* SD CSD Analyze. */ + { + if(CSD_STRUCTURE == 0) + { + uint8_t C_SIZE_MULT; + uint8_t READ_BL_LEN; + + MSD_DEBUG("[info] CSD Version 1.0\r\n"); + + /* get TRAN_SPEED 8bit [103:96] */ + tmp8 = CSD_buffer[3]; + if(tmp8 == 0x32) + { + msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */ + } + else if(tmp8 == 0x5A) + { + msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */ + } + else + { + msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */ + } + MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000); + + /* get READ_BL_LEN 4bit [83:80] */ + tmp8 = CSD_buffer[5] & 0x0F; /* 0b00001111; */ + READ_BL_LEN = tmp8; /* 4 bit */ + MSD_DEBUG("[info] CSD : READ_BL_LEN : %d %dbyte\r\n", READ_BL_LEN, (1 << READ_BL_LEN)); + + /* get C_SIZE 12bit [73:62] */ + tmp16 = CSD_buffer[6] & 0x03; /* get [73:72] 0b00000011 */ + tmp16 = tmp16<<8; + tmp16 += CSD_buffer[7]; /* get [71:64] */ + tmp16 = tmp16<<2; + tmp8 = CSD_buffer[8] & 0xC0; /* get [63:62] 0b11000000 */ + tmp8 = tmp8>>6; + tmp16 = tmp16 + tmp8; + C_SIZE = tmp16; //12 bit + MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); + + /* get C_SIZE_MULT 3bit [49:47] */ + tmp8 = CSD_buffer[9] & 0x03;//0b00000011; + tmp8 = tmp8<<1; + tmp8 = tmp8 + ((CSD_buffer[10] & 0x80/*0b10000000*/)>>7); + C_SIZE_MULT = tmp8; // 3 bit + MSD_DEBUG("[info] CSD : C_SIZE_MULT : %d\r\n", C_SIZE_MULT); + + /* memory capacity = BLOCKNR * BLOCK_LEN */ + /* BLOCKNR = (C_SIZE+1) * MULT */ + /* MULT = 2^(C_SIZE_MULT+2) */ + /* BLOCK_LEN = 2^READ_BL_LEN */ + card_capacity = (1 << READ_BL_LEN) * ((C_SIZE + 1) * (1 << (C_SIZE_MULT+2))); + msd->geometry.sector_count = card_capacity / msd->geometry.bytes_per_sector; + MSD_DEBUG("[info] card capacity : %d Mbyte\r\n", card_capacity/(1024*1024)); + } + else if(CSD_STRUCTURE == 1) + { + MSD_DEBUG("[info] CSD Version 2.0\r\n"); + + /* get TRAN_SPEED 8bit [103:96] */ + tmp8 = CSD_buffer[3]; + if(tmp8 == 0x32) + { + msd->max_clock = 1000 * 1000 * 10; /* 10Mbit/s. */ + } + else if(tmp8 == 0x5A) + { + msd->max_clock = 1000 * 1000 * 50; /* 50Mbit/s. */ + } + else if(tmp8 == 0x0B) + { + msd->max_clock = 1000 * 1000 * 100; /* 100Mbit/s. */ + /* UHS50 Card sets TRAN_SPEED to 0Bh (100Mbit/sec), */ + /* for both SDR50 and DDR50 modes. */ + } + else if(tmp8 == 0x2B) + { + msd->max_clock = 1000 * 1000 * 200; /* 200Mbit/s. */ + /* UHS104 Card sets TRAN_SPEED to 2Bh (200Mbit/sec). */ + } + else + { + msd->max_clock = 1000 * 1000 * 1; /* 1Mbit/s default. */ + } + MSD_DEBUG("[info] TRAN_SPEED: 0x%02X, %dMbit/s.\r\n", tmp8, msd->max_clock/1000/1000); + + /* get C_SIZE 22bit [69:48] */ + tmp32 = CSD_buffer[7] & 0x3F; /* 0b00111111 */ + tmp32 = tmp32<<8; + tmp32 += CSD_buffer[8]; + tmp32 = tmp32<<8; + tmp32 += CSD_buffer[9]; + C_SIZE = tmp32; + MSD_DEBUG("[info] CSD : C_SIZE : %d\r\n", C_SIZE); + + /* memory capacity = (C_SIZE+1) * 512K byte */ + card_capacity = (C_SIZE + 1) / 2; /* unit : Mbyte */ + msd->geometry.sector_count = card_capacity * 1024; /* 1 Mbyte = 512 byte X 2048 */ + MSD_DEBUG("[info] card capacity : %d.%d Gbyte\r\n", card_capacity/1024, (card_capacity%1024)*100/1024); + } + else + { + MSD_DEBUG("[err] bad CSD Version : %d\r\n", CSD_STRUCTURE); + result = RT_ERROR; + goto _exit; + } + } /* SD CSD Analyze. */ + } /* Analyze CSD */ + + } /* read CSD */ + + /* config spi to high speed */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = msd->max_clock; + + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + +_exit: + MSD_release_cs(msd->spi_device); + rt_mutex_release(&(msd->spi_device->bus->lock)); + return result; +} + +static rt_err_t rt_msd_open(rt_device_t dev, rt_uint16_t oflag) +{ +// struct msd_device * msd = (struct msd_device *)dev; + return RT_EOK; +} + +static rt_err_t rt_msd_close(rt_device_t dev) +{ +// struct msd_device * msd = (struct msd_device *)dev; + return RT_EOK; +} + +static rt_size_t rt_msd_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) +{ + struct msd_device * msd = (struct msd_device *)dev; + uint8_t response[MSD_RESPONSE_MAX_LEN]; + rt_err_t result = RT_EOK; + + result = MSD_take_owner(msd->spi_device); + + if (result != RT_EOK) + { + goto _exit; + } + + /* config spi to high speed */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = msd->max_clock; + + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + + /* SINGLE_BLOCK? */ + if(size == 1) + { + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + goto _exit; + } + + result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + } + } + else if(size > 1) + { + uint32_t i; + + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); + size = 0; + goto _exit; + } + + for(i=0; ispi_device, + (uint8_t *)buffer + msd->geometry.bytes_per_sector * i, + msd->geometry.bytes_per_sector); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); + size = i; + break; + } + } + + /* send CMD12 stop transfer */ + result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n"); + } + } /* READ_MULTIPLE_BLOCK */ + +_exit: + /* release and exit */ + MSD_release_cs(msd->spi_device); + rt_mutex_release(&(msd->spi_device->bus->lock)); + + return size; +} + +static rt_size_t rt_msd_sdhc_read(rt_device_t dev, rt_off_t pos, void* buffer, rt_size_t size) +{ + struct msd_device * msd = (struct msd_device *)dev; + uint8_t response[MSD_RESPONSE_MAX_LEN]; + rt_err_t result = RT_EOK; + + result = MSD_take_owner(msd->spi_device); + + if (result != RT_EOK) + { + goto _exit; + } + + /* config spi to high speed */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = msd->max_clock; + + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + + /* SINGLE_BLOCK? */ + if(size == 1) + { + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_SINGLE_BLOCK, pos, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + goto _exit; + } + + result = _read_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + } + } + else if(size > 1) + { + uint32_t i; + + MSD_take_cs(msd->spi_device); + + result = _send_cmd(msd->spi_device, READ_MULTIPLE_BLOCK, pos, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); + size = 0; + goto _exit; + } + + for(i=0; ispi_device, + (uint8_t *)buffer + msd->geometry.bytes_per_sector * i, + msd->geometry.bytes_per_sector); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK #%d fail!\r\n", pos); + size = i; + break; + } + } + + /* send CMD12 stop transfer */ + result = _send_cmd(msd->spi_device, STOP_TRANSMISSION, 0x00, 0x00, response_r1b, response); + if(result != RT_EOK) + { + MSD_DEBUG("[err] read READ_MULTIPLE_BLOCK, send stop token fail!\r\n"); + } + } /* READ_MULTIPLE_BLOCK */ + +_exit: + /* release and exit */ + MSD_release_cs(msd->spi_device); + rt_mutex_release(&(msd->spi_device->bus->lock)); + + return size; +} + +static rt_size_t rt_msd_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size) +{ + struct msd_device * msd = (struct msd_device *)dev; + uint8_t response[MSD_RESPONSE_MAX_LEN]; + rt_err_t result; + + result = MSD_take_owner(msd->spi_device); + + if (result != RT_EOK) + { + MSD_DEBUG("[err] get SPI owner fail!\r\n"); + goto _exit; + } + + /* config spi to high speed */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = msd->max_clock; + + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + + /* SINGLE_BLOCK? */ + if(size == 1) + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n"); + size = 0; + goto _exit; + } + + result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START); + if(result != RT_EOK) + { + MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + } + } + else if(size > 1) + { + struct rt_spi_message message; + uint32_t i; + + MSD_take_cs(msd->spi_device); + +#ifdef MSD_USE_PRE_ERASED + if(msd->card_type != MSD_CARD_TYPE_MMC) + { + /* CMD55 APP_CMD */ + result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n"); + size = 0; + goto _exit; + } + + /* ACMD23 Pre-erased */ + result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n"); + size = 0; + goto _exit; + } + } +#endif + + result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos * msd->geometry.bytes_per_sector, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n"); + size = 0; + goto _exit; + } + + /* write all block */ + for(i=0; ispi_device, + (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i, + msd->geometry.bytes_per_sector, + MSD_TOKEN_WRITE_MULTIPLE_START); + if(result != RT_EOK) + { + MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); + size = i; + break; + } + } /* write all block */ + + /* send stop token */ + { + uint8_t send_buffer[18]; + + rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); + send_buffer[sizeof(send_buffer) - 1] = MSD_TOKEN_WRITE_MULTIPLE_STOP; + + /* initial message */ + message.send_buf = send_buffer; + message.recv_buf = RT_NULL; + message.length = sizeof(send_buffer); + message.cs_take = message.cs_release = 0; + + /* transfer message */ + msd->spi_device->bus->ops->xfer(msd->spi_device, &message); + } + + /* wait ready */ + result = _wait_ready(msd->spi_device); + if(result != RT_EOK) + { + MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n"); + } + } /* size > 1 */ + +_exit: + /* release and exit */ + MSD_release_cs(msd->spi_device); + rt_mutex_release(&(msd->spi_device->bus->lock)); + + return size; +} + +static rt_size_t rt_msd_sdhc_write (rt_device_t dev, rt_off_t pos, const void* buffer, rt_size_t size) +{ + struct msd_device * msd = (struct msd_device *)dev; + uint8_t response[MSD_RESPONSE_MAX_LEN]; + rt_err_t result; + + result = MSD_take_owner(msd->spi_device); + + if (result != RT_EOK) + { + goto _exit; + } + + /* config spi to high speed */ + { + struct rt_spi_configuration cfg; + cfg.data_width = 8; + cfg.mode = RT_SPI_MODE_0 | RT_SPI_MSB; /* SPI Compatible Modes 0 */ + cfg.max_hz = msd->max_clock; + + rt_spi_configure(msd->spi_device, &cfg); + } /* config spi */ + + /* SINGLE_BLOCK? */ + if(size == 1) + { + MSD_take_cs(msd->spi_device); + result = _send_cmd(msd->spi_device, WRITE_BLOCK, pos, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD WRITE_BLOCK fail!\r\n"); + size = 0; + goto _exit; + } + + result = _write_block(msd->spi_device, buffer, msd->geometry.bytes_per_sector, MSD_TOKEN_WRITE_SINGLE_START); + if(result != RT_EOK) + { + MSD_DEBUG("[err] write SINGLE_BLOCK #%d fail!\r\n", pos); + size = 0; + } + } + else if(size > 1) + { + struct rt_spi_message message; + uint32_t i; + + MSD_take_cs(msd->spi_device); + +#ifdef MSD_USE_PRE_ERASED + /* CMD55 APP_CMD */ + result = _send_cmd(msd->spi_device, APP_CMD, 0x00, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD55 APP_CMD fail!\r\n"); + size = 0; + goto _exit; + } + + /* ACMD23 Pre-erased */ + result = _send_cmd(msd->spi_device, SET_WR_BLK_ERASE_COUNT, size, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] ACMD23 SET_BLOCK_COUNT fail!\r\n"); + size = 0; + goto _exit; + } +#endif + + result = _send_cmd(msd->spi_device, WRITE_MULTIPLE_BLOCK, pos, 0x00, response_r1, response); + if((result != RT_EOK) || (response[0] != MSD_RESPONSE_NO_ERROR)) + { + MSD_DEBUG("[err] CMD WRITE_MULTIPLE_BLOCK fail!\r\n"); + size = 0; + goto _exit; + } + + /* write all block */ + for(i=0; ispi_device, + (const uint8_t *)buffer + msd->geometry.bytes_per_sector * i, + msd->geometry.bytes_per_sector, + MSD_TOKEN_WRITE_MULTIPLE_START); + if(result != RT_EOK) + { + MSD_DEBUG("[err] write MULTIPLE_BLOCK #%d fail!\r\n", pos); + size = i; + break; + } + } /* write all block */ + + /* send stop token */ + { + uint8_t send_buffer[18]; + + rt_memset(send_buffer, DUMMY, sizeof(send_buffer)); + send_buffer[sizeof(send_buffer) - 1] = MSD_TOKEN_WRITE_MULTIPLE_STOP; + + /* initial message */ + message.send_buf = send_buffer; + message.recv_buf = RT_NULL; + message.length = sizeof(send_buffer); + message.cs_take = message.cs_release = 0; + + /* transfer message */ + msd->spi_device->bus->ops->xfer(msd->spi_device, &message); + } + + result = _wait_ready(msd->spi_device); + if(result != RT_EOK) + { + MSD_DEBUG("[warning] wait WRITE_MULTIPLE_BLOCK stop token ready timeout!\r\n"); + } + } /* size > 1 */ + +_exit: + /* release and exit */ + MSD_release_cs(msd->spi_device); + rt_mutex_release(&(msd->spi_device->bus->lock)); + + return size; +} + +static rt_err_t rt_msd_control(rt_device_t dev, int cmd, void *args) +{ + struct msd_device * msd = (struct msd_device *)dev; + + RT_ASSERT(dev != RT_NULL); + + if (cmd == RT_DEVICE_CTRL_BLK_GETGEOME) + { + struct rt_device_blk_geometry *geometry; + + geometry = (struct rt_device_blk_geometry *)args; + if (geometry == RT_NULL) return -RT_ERROR; + + geometry->bytes_per_sector = msd->geometry.bytes_per_sector; + geometry->block_size = msd->geometry.block_size; + geometry->sector_count = msd->geometry.sector_count; + } + + return RT_EOK; +} + +rt_err_t msd_init(const char * sd_device_name, const char * spi_device_name) +{ + rt_err_t result = RT_EOK; + struct rt_spi_device * spi_device; + + spi_device = (struct rt_spi_device *)rt_device_find(spi_device_name); + if(spi_device == RT_NULL) + { + MSD_DEBUG("spi device %s not found!\r\n", spi_device_name); + return -RT_ENOSYS; + } + + rt_memset(&_msd_device, 0, sizeof(_msd_device)); + _msd_device.spi_device = spi_device; + + /* register sdcard device */ + _msd_device.parent.type = RT_Device_Class_Block; + + _msd_device.geometry.bytes_per_sector = 0; + _msd_device.geometry.sector_count = 0; + _msd_device.geometry.block_size = 0; + + _msd_device.parent.init = rt_msd_init; + _msd_device.parent.open = rt_msd_open; + _msd_device.parent.close = rt_msd_close; + _msd_device.parent.read = RT_NULL; + _msd_device.parent.write = RT_NULL; + _msd_device.parent.control = rt_msd_control; + + /* no private, no callback */ + _msd_device.parent.user_data = RT_NULL; + _msd_device.parent.rx_indicate = RT_NULL; + _msd_device.parent.tx_complete = RT_NULL; + + result = rt_device_register(&_msd_device.parent, sd_device_name, + RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_REMOVABLE | RT_DEVICE_FLAG_STANDALONE); + + + return result; +} diff --git a/bsp/ls1cdev/drivers/msd.h b/bsp/ls1cdev/drivers/msd.h new file mode 100644 index 0000000000..e004944332 --- /dev/null +++ b/bsp/ls1cdev/drivers/msd.h @@ -0,0 +1,132 @@ +/* + * 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 +#include + +/* 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 diff --git a/bsp/ls1cdev/drivers/touch.c b/bsp/ls1cdev/drivers/touch.c new file mode 100644 index 0000000000..5172b7a359 --- /dev/null +++ b/bsp/ls1cdev/drivers/touch.c @@ -0,0 +1,607 @@ +/* + * 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 +#include +#include "ls1c.h" +#include "ls1c_gpio.h" +#include "ls1c_spi.h" +#include "drv_spi.h" +#include "touch.h" + +#include +#include +#include +#include +#include +#include +#include + +//Ļ Ҫ _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; ispi_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 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; +} diff --git a/bsp/ls1cdev/drivers/touch.h b/bsp/ls1cdev/drivers/touch.h new file mode 100644 index 0000000000..0892d2858f --- /dev/null +++ b/bsp/ls1cdev/drivers/touch.h @@ -0,0 +1,43 @@ +/* + * 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 + + diff --git a/bsp/ls1cdev/rtconfig.h b/bsp/ls1cdev/rtconfig.h index 117282ded0..15b07fea06 100644 --- a/bsp/ls1cdev/rtconfig.h +++ b/bsp/ls1cdev/rtconfig.h @@ -108,7 +108,10 @@ // //
-// #define RT_USING_DFS +#define RT_USING_DFS +#define RT_DFS_ELM_REENTRANT +#define RT_DFS_ELM_DRIVES 2 +#define RT_DFS_ELM_MAX_SECTOR_SIZE 512 // // #define DFS_USING_WORKDIR // @@ -121,9 +124,10 @@ // 1 // 2 // -#define RT_DFS_ELM_USE_LFN 1 +//#define RT_DFS_ELM_USE_LFN 1 // #define RT_DFS_ELM_MAX_LFN 64 +#define RT_DFS_ELM_CODE_PAGE 936 // // #define RT_USING_DFS_YAFFS2 // @@ -232,6 +236,8 @@ #define RT_USING_SPI1 #define RT_USING_I2C +#define RT_USING_I2C1 +#define RT_USING_I2C2 #define RT_USING_I2C_BITOPS