[bsp] Add SmartloongV3 display,touch,msd, hw_i2c driver

1 files changed, 607 insertions, 0 deletions

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 <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;
+}