!275 添加wdt驱动，更新lcd驱动

Merge pull request !275 from songchao/rt-smart

bsp/imx6ull-artpi-smart/.config

@@ -190,7 +190,7 @@ CONFIG_RT_USING_SPI=y
 # CONFIG_RT_USING_SFUD is not set
 # CONFIG_RT_USING_ENC28J60 is not set
 # CONFIG_RT_USING_SPI_WIFI is not set
-# CONFIG_RT_USING_WDT is not set
+CONFIG_RT_USING_WDT=y
 # CONFIG_RT_USING_AUDIO is not set
 # CONFIG_RT_USING_SENSOR is not set
 # CONFIG_RT_USING_TOUCH is not set
@@ -444,6 +444,7 @@ CONFIG_LWP_TID_MAX_NR=64
 # CONFIG_PKG_USING_AGILE_MODBUS is not set
 # CONFIG_PKG_USING_AGILE_FTP is not set
 # CONFIG_PKG_USING_EMBEDDEDPROTO is not set
+# CONFIG_PKG_USING_RT_LINK_HW is not set
 
 #
 # security packages
@@ -748,7 +749,7 @@ CONFIG_I2C3_BAUD_RATE=400000
 # Select LCD Driver
 #
 CONFIG_BSP_USING_LCD=y
-CONFIG_BSP_LCD_WIDTH=1024
+CONFIG_BSP_LCD_WIDTH=1000
 CONFIG_BSP_LCD_HEIGHT=600
 
 #
@@ -761,3 +762,10 @@ CONFIG_RT_USING_SDIO1=y
 # Select RTC Driver
 #
 CONFIG_BSP_USING_ONCHIP_RTC=y
+
+#
+# Select WDT Driver
+#
+CONFIG_RT_USING_WDT1=y
+CONFIG_RT_USING_WDT2=y
+# CONFIG_RT_USING_WDT3 is not set

bsp/imx6ull-artpi-smart/drivers/Kconfig

@@ -104,7 +104,7 @@ config BSP_USING_LCD
     if BSP_USING_LCD
         config BSP_LCD_WIDTH
             int "Width of LCD panel"
-            default 1024
+            default 1000
         config BSP_LCD_HEIGHT
             int "Height of LCD panel"
             default 600
@@ -120,7 +120,6 @@ menu "Select SDHC Driver"
             bool "Enable SDHC2"
            	default n
     endif
-    
 endmenu
 
 menu "Select RTC Driver"
@@ -131,4 +130,18 @@ menu "Select RTC Driver"
     endif
 endmenu
 
+menu "Select WDT Driver"
+    if RT_USING_WDT
+        config RT_USING_WDT1
+            bool "Enable WDT1"
+            default n
+        config RT_USING_WDT2
+            bool "Enable WDT2"
+           	default n
+        config RT_USING_WDT3
+            bool "Enable WDT3"
+           	default n               
+    endif
+endmenu
+
 endmenu

bsp/imx6ull-artpi-smart/drivers/drv_lcd.c

@@ -7,10 +7,12 @@
  * Date           Author       Notes
  * 2021-01-11     Lyons        first version
  * 2021-06-24     RiceChen     refactor
+ * 2021-07-28     songchao     add cmd
  */
 
 #include <rthw.h>
 #include <rtdevice.h>
+#include <rtthread.h>
 
 #ifdef BSP_USING_LCD
 
@@ -20,9 +22,10 @@
 #include "fsl_iomuxc.h"
 #include "drv_lcd.h"
 #include <lwp_user_mm.h>
+#include "rt_lcd.h"
 
-struct imx6ull_lcd_config lcd_config = LCD_BUS_CONFIG;
-struct imx6ull_lcd_bus lcd_obj;
+static struct imx6ull_lcd_config _lcd_config = LCD_BUS_CONFIG;
+static struct imx6ull_lcd_bus _lcd_obj;
 
 static rt_err_t imx6ull_elcd_init(rt_device_t device)
 {
@@ -64,19 +67,20 @@ static rt_err_t imx6ull_elcd_init(rt_device_t device)
 
     return RT_EOK;
 }
-
 static rt_err_t imx6ull_elcd_control(rt_device_t device, int cmd, void *args)
 {
     struct imx6ull_lcd_bus *elcd_dev = RT_NULL;
+    int mem_size = 0;
 
     RT_ASSERT(device != RT_NULL);
 
     elcd_dev = (struct imx6ull_lcd_bus *)device;
-
     switch(cmd)
     {
         case RTGRAPHIC_CTRL_RECT_UPDATE:
         {
+            mem_size = elcd_dev->info.width * elcd_dev->info.height * elcd_dev->info.bits_per_pixel / 8;
+            rt_hw_cpu_dcache_ops(RT_HW_CACHE_FLUSH, (void *)(_lcd_obj.info.framebuffer), mem_size);
             break;
         }
         case RTGRAPHIC_CTRL_POWERON:
@@ -93,11 +97,9 @@ static rt_err_t imx6ull_elcd_control(rt_device_t device, int cmd, void *args)
         {
             struct lcd_info *info = (struct lcd_info *)args;
             RT_ASSERT(info != RT_NULL);
-
             rt_memcpy(&info->graphic, &elcd_dev->info, sizeof(struct rt_device_graphic_info));
-            
-            info->screen.shamem_len   = elcd_dev->info.width * elcd_dev->info.width * elcd_dev->info.bits_per_pixel/8;
-            info->screen.shamem_start = (rt_uint32_t)lwp_map_user_phy(lwp_self(), RT_NULL, 
+            info->screen.shamem_len = elcd_dev->info.width * elcd_dev->info.height * elcd_dev->info.bits_per_pixel / 8;
+            info->screen.shamem_start = (rt_uint32_t)lwp_map_user_phy(lwp_self(), RT_NULL,
                                                                         elcd_dev->fb_phy,
                                                                         info->screen.shamem_len, 1);
             break;
@@ -106,6 +108,26 @@ static rt_err_t imx6ull_elcd_control(rt_device_t device, int cmd, void *args)
         {
             break;
         }
+        case FBIOGET_FSCREENINFO:
+        {
+            struct fb_fix_screeninfo *info = (struct fb_fix_screeninfo *)args;
+            rt_memcpy(info->id, elcd_dev->config->name, (strlen(elcd_dev->config->name)+1));
+            info->smem_len = elcd_dev->info.width * elcd_dev->info.height * elcd_dev->info.bits_per_pixel / 8;
+            info->smem_start = (rt_uint32_t)lwp_map_user_phy(lwp_self(), RT_NULL,
+                                                                        elcd_dev->fb_phy,
+                                                                        info->smem_len, 1);
+            info->line_length = elcd_dev->info.width * 2;
+            break;
+        }
+        case FBIOGET_VSCREENINFO:
+        {
+            struct fb_var_screeninfo *info = (struct fb_var_screeninfo *)args;
+            info->bits_per_pixel = elcd_dev->info.bits_per_pixel;
+            info->xres = elcd_dev->info.width;
+            info->yres = elcd_dev->info.height;
+            break;
+        }
+
     }
     return RT_EOK;
 }
@@ -126,59 +148,61 @@ int rt_hw_elcd_init(void)
 {
     rt_err_t ret = 0;
 
-    lcd_config.ELCDIF       = (LCDIF_Type *)imx6ull_get_periph_vaddr((rt_uint32_t)(lcd_config.ELCDIF));
-    lcd_config.lcd_mux_base = (rt_uint32_t)imx6ull_get_periph_vaddr((rt_uint32_t)(lcd_config.lcd_mux_base));
-    lcd_config.lcd_cfg_base = (rt_uint32_t)imx6ull_get_periph_vaddr((rt_uint32_t)(lcd_config.lcd_cfg_base));
+    _lcd_config.ELCDIF       = (LCDIF_Type *)imx6ull_get_periph_vaddr((rt_uint32_t)(_lcd_config.ELCDIF));
+    _lcd_config.lcd_mux_base = (rt_uint32_t)imx6ull_get_periph_vaddr((rt_uint32_t)(_lcd_config.lcd_mux_base));
+    _lcd_config.lcd_cfg_base = (rt_uint32_t)imx6ull_get_periph_vaddr((rt_uint32_t)(_lcd_config.lcd_cfg_base));
 
     for(int i = 0; i < LCD_GPIO_MAX; i++)
     {
-        IOMUXC_SetPinMux((lcd_config.lcd_mux_base + i * 4), 0x0U, 0x00000000U, 0x0U, (lcd_config.lcd_cfg_base + i * 4), 0);
-	    IOMUXC_SetPinConfig((lcd_config.lcd_mux_base + i * 4), 0x0U, 0x00000000U, 0x0U, (lcd_config.lcd_cfg_base + i * 4), 0xB9);
+        IOMUXC_SetPinMux((_lcd_config.lcd_mux_base + i * 4),
+                            0x0U, 0x0U, 0x0U, (_lcd_config.lcd_cfg_base + i * 4), 0);
+        IOMUXC_SetPinConfig((_lcd_config.lcd_mux_base + i * 4),
+                            0x0U, 0x0U, 0x0U, (_lcd_config.lcd_cfg_base + i * 4), 0xB9);
     }
 
-    CLOCK_EnableClock(lcd_config.apd_clk_name);
-    CLOCK_EnableClock(lcd_config.pix_clk_name);
+    CLOCK_EnableClock(_lcd_config.apd_clk_name);
+    CLOCK_EnableClock(_lcd_config.pix_clk_name);
 
-    lcd_obj.config = &lcd_config;
+    _lcd_obj.config = &_lcd_config;
 
-    lcd_obj.fb_virt = rt_pages_alloc(rt_page_bits(LCD_BUF_SIZE));
-    lcd_obj.fb_phy = lcd_obj.fb_virt + PV_OFFSET;
+    _lcd_obj.fb_virt = rt_pages_alloc(rt_page_bits(LCD_BUF_SIZE));
+    _lcd_obj.fb_phy = _lcd_obj.fb_virt + PV_OFFSET;
 
-    rt_kprintf("fb address => 0x%08x\n", lcd_obj.fb_phy);
-    if(lcd_obj.fb_phy == RT_NULL)
+    LOG_D("fb address => 0x%08x\n", _lcd_obj.fb_phy);
+    if(_lcd_obj.fb_phy == RT_NULL)
     {
-        rt_kprintf("initialize frame buffer failed!\n");
+        LOG_E("initialize frame buffer failed!\n");
         return -RT_ERROR;
     }
 
-    lcd_obj.info.width          = LCD_WIDTH;
-    lcd_obj.info.height         = LCD_HEIGHT;
-    lcd_obj.info.pixel_format   = RTGRAPHIC_PIXEL_FORMAT_RGB565;
-    lcd_obj.info.bits_per_pixel = LCD_BITS_PER_PIXEL;
-    lcd_obj.info.framebuffer    = (void *)lcd_obj.fb_virt;
-    
-    lcd_obj.parent.type = RT_Device_Class_Graphic;
+    _lcd_obj.info.width          = LCD_WIDTH;
+    _lcd_obj.info.height         = LCD_HEIGHT;
+    _lcd_obj.info.pixel_format   = RTGRAPHIC_PIXEL_FORMAT_RGB565;
+    _lcd_obj.info.bits_per_pixel = LCD_BITS_PER_PIXEL;
+    _lcd_obj.info.framebuffer    = (void *)_lcd_obj.fb_virt;
+
+    _lcd_obj.parent.type = RT_Device_Class_Graphic;
 
 #ifdef RT_USING_DEVICE_OPS
-    lcd_obj.parent.ops         = &elcd_ops;
+    _lcd_obj.parent.ops         = &elcd_ops;
 #else
-    lcd_obj.parent.init    = imx6ull_elcd_init;
-    lcd_obj.parent.open    = RT_NULL;
-    lcd_obj.parent.close   = RT_NULL;
-    lcd_obj.parent.read    = RT_NULL;
-    lcd_obj.parent.write   = RT_NULL;
-    lcd_obj.parent.control = imx6ull_elcd_control;
+    _lcd_obj.parent.init    = imx6ull_elcd_init;
+    _lcd_obj.parent.open    = RT_NULL;
+    _lcd_obj.parent.close   = RT_NULL;
+    _lcd_obj.parent.read    = RT_NULL;
+    _lcd_obj.parent.write   = RT_NULL;
+    _lcd_obj.parent.control = imx6ull_elcd_control;
 #endif
 
-    lcd_obj.parent.user_data = (void *)&lcd_obj.info;
+    _lcd_obj.parent.user_data = (void *)&_lcd_obj.info;
 
-    ret = rt_device_register(&lcd_obj.parent, lcd_obj.config->name, RT_DEVICE_FLAG_RDWR);
+    ret = rt_device_register(&_lcd_obj.parent, _lcd_obj.config->name, RT_DEVICE_FLAG_RDWR);
 
     /* LCD_BL */
-    rt_pin_mode (IMX6ULL_LCD_BL_PIN, PIN_MODE_OUTPUT);  
+    rt_pin_mode(IMX6ULL_LCD_BL_PIN, PIN_MODE_OUTPUT);
     rt_pin_write(IMX6ULL_LCD_BL_PIN, PIN_HIGH);
 
-    rt_memset((rt_uint8_t *)lcd_obj.fb_virt, 0xff, LCD_BUF_SIZE);
+    rt_memset((rt_uint8_t *)_lcd_obj.fb_virt, 0xff, LCD_BUF_SIZE);
 
     return ret;
 }

bsp/imx6ull-artpi-smart/drivers/drv_wdt.c

@@ -0,0 +1,203 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author         Notes
+ * 2021-07-28     songchao           first version
+ */
+
+#include <rtconfig.h>
+
+#ifdef RT_USING_WDT
+#include <rtthread.h>
+#include <rtdbg.h>
+#include "drv_wdt.h"
+#include "fsl_wdog.h"
+#include "imx6ull.h"
+
+enum
+{
+#ifdef RT_USING_WDT1
+    DEV_WDT1,
+#endif
+
+#ifdef RT_USING_WDT2
+    DEV_WDT2,
+#endif
+
+#ifdef RT_USING_WDT3
+    DEV_WDT3,
+#endif
+
+    DEV_MAX,
+};
+
+#ifdef RT_USING_WDT1
+static wdog_config_t WDOG_1_config =
+{
+    .timeoutValue = 0xffu,
+    .enablePowerDown = false,
+    .softwareResetExtension = false,
+    .softwareAssertion = true,
+    .softwareResetSignal = true,
+    .enableWdog = true,
+    .workMode =
+    {
+        .enableWait = false,
+        .enableStop = false,
+        .enableDebug = false,
+    },
+    .enableInterrupt = false,
+    .interruptTimeValue = 0x04u,
+};
+#endif
+
+#ifdef RT_USING_WDT2
+static wdog_config_t WDOG_2_config =
+{
+    .timeoutValue = 0xffu,
+    .enablePowerDown = false,
+    .softwareResetExtension = false,
+    .softwareAssertion = true,
+    .softwareResetSignal = true,
+    .enableWdog = true,
+    .workMode =
+    {
+        .enableWait = false,
+        .enableStop = false,
+        .enableDebug = false,
+    },
+    .enableInterrupt = false,
+    .interruptTimeValue = 0x04u,
+};
+#endif
+
+#ifdef RT_USING_WDT3
+static wdog_config_t WDOG_3_config =
+{
+    .timeoutValue = 0xffu,
+    .enablePowerDown = false,
+    .softwareResetExtension = false,
+    .softwareAssertion = true,
+    .softwareResetSignal = true,
+    .enableWdog = true,
+    .workMode =
+    {
+        .enableWait = false,
+        .enableStop = false,
+        .enableDebug = false,
+    },
+    .enableInterrupt = false,
+    .interruptTimeValue = 0x04u,
+};
+#endif
+
+static rt_watchdog_t imx6ull_watchdog[DEV_MAX] =
+{
+#ifdef RT_USING_WDT1
+    {
+        .name = "wdt1",
+        .paddr = IMX6ULL_WATCHDOG1_BASE,
+        .config = &WDOG_1_config,
+    },
+#endif
+
+#ifdef RT_USING_WDT2
+    {
+        .name = "wdt2",
+        .paddr = IMX6ULL_WATCHDOG2_BASE,
+        .config = &WDOG_2_config,
+    },
+#endif
+
+#ifdef RT_USING_WDT3
+    {
+        .name = "wdt3",
+        .paddr = IMX6ULL_WATCHDOG3_BASE,
+        .config = &WDOG_3_config,
+    },
+#endif
+
+};
+
+static rt_err_t imx6ull_wdog_init(rt_watchdog_t *wdt)
+{
+    WDOG_Type *base = RT_NULL;
+    base = (WDOG_Type *)wdt->vaddr;
+    WDOG_Init(base, wdt->config);
+    WDOG_Disable(base);
+    return RT_EOK;
+}
+
+static rt_err_t imx6ull_wdog_control(rt_watchdog_t *wdt, int cmd, void *args)
+{
+    RT_ASSERT(wdt != NULL);
+
+    WDOG_Type *base = RT_NULL;
+    base = (WDOG_Type *)wdt->vaddr;
+
+    switch(cmd)
+    {
+        case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
+        {
+            *(uint16_t *)args = (base->WCR >> 8)  / 2;
+        }
+        break;
+        case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
+        {
+            RT_ASSERT(*(uint16_t *)args != 0);
+            WDOG_SetTimeoutValue(base, (*(uint16_t *)args) * 2);
+            WDOG_Disable(base);
+        }
+        break;
+        case RT_DEVICE_CTRL_WDT_KEEPALIVE:
+        {
+            WDOG_Refresh(base);
+        }
+        break;
+        case RT_DEVICE_CTRL_WDT_START:
+        {
+            WDOG_Enable(base);
+        }
+        break;
+        case RT_DEVICE_CTRL_WDT_STOP:
+        {
+            WDOG_Disable(base);
+        }
+        break;
+        default:
+            return RT_EINVAL;
+    }
+
+    return RT_EOK;
+}
+
+static struct rt_watchdog_ops imx6ull_wdog_ops =
+{
+    .init = imx6ull_wdog_init,
+    .control = imx6ull_wdog_control,
+};
+
+int rt_hw_wdt_init(void)
+{
+    rt_err_t ret = RT_EOK;
+    for(int idx = 0; idx < GET_ARRAY_NUM(imx6ull_watchdog); idx++)
+    {
+        imx6ull_watchdog[idx].ops = &imx6ull_wdog_ops;
+        imx6ull_watchdog[idx].vaddr = platform_get_periph_vaddr(imx6ull_watchdog[idx].paddr);
+        ret = rt_hw_watchdog_register(&imx6ull_watchdog[idx], imx6ull_watchdog[idx].name,
+                                         RT_DEVICE_FLAG_DEACTIVATE, RT_NULL);
+        if (ret != RT_EOK)
+        {
+            LOG_E("rt device register failed %d\n", ret);
+        }
+    }
+
+    return ret;
+}
+
+INIT_DEVICE_EXPORT(rt_hw_wdt_init);
+
+#endif

bsp/imx6ull-artpi-smart/drivers/drv_wdt.h

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date           Author         Notes
+ * 2021-07-28     songchao           first version
+ */
+
+#ifndef  __WATCHDOG_H__
+#define  __WATCHDOG_H__
+
+#include <rtthread.h>
+#include "fsl_wdog.h"
+
+#define RT_DEVICE_CTRL_WDT_GET_TIMEOUT    (1) /* get timeout(in seconds) */
+#define RT_DEVICE_CTRL_WDT_SET_TIMEOUT    (2) /* set timeout(in seconds) */
+#define RT_DEVICE_CTRL_WDT_GET_TIMELEFT   (3) /* get the left time before reboot(in seconds) */
+#define RT_DEVICE_CTRL_WDT_KEEPALIVE      (4) /* refresh watchdog */
+#define RT_DEVICE_CTRL_WDT_START          (5) /* start watchdog */
+#define RT_DEVICE_CTRL_WDT_STOP           (6) /* stop watchdog */
+
+struct rt_watchdog_ops;
+struct rt_watchdog_device
+{
+    struct rt_device parent;
+    const struct rt_watchdog_ops *ops;
+    const char                  *name;
+    rt_uint32_t                 paddr;
+    rt_uint32_t                 vaddr;
+    rt_uint32_t                 irqno;
+    wdog_config_t *config;
+};
+typedef struct rt_watchdog_device rt_watchdog_t;
+
+struct rt_watchdog_ops
+{
+    rt_err_t (*init)(rt_watchdog_t *wdt);
+    rt_err_t (*control)(rt_watchdog_t *wdt, int cmd, void *arg);
+};
+
+rt_err_t rt_hw_watchdog_register(rt_watchdog_t *wdt,
+                                 const char    *name,
+                                 rt_uint32_t    flag,
+                                 void          *data);
+
+#endif /* __WATCHDOG_H__ */

bsp/imx6ull-artpi-smart/rtconfig.h

@@ -124,6 +124,7 @@
 #define RT_MMCSD_THREAD_PREORITY 22
 #define RT_MMCSD_MAX_PARTITION 16
 #define RT_USING_SPI
+#define RT_USING_WDT
 
 /* Using USB */
 
@@ -267,9 +268,6 @@
 
 /* Micrium: Micrium software products porting for RT-Thread */
 
-#define PKG_USING_LWEXT4
-#define RT_USING_DFS_LWEXT4
-#define PKG_USING_LWEXT4_LATEST_VERSION
 
 /* peripheral libraries and drivers */
 
@@ -310,16 +308,20 @@
 /* Select LCD Driver */
 
 #define BSP_USING_LCD
-#define BSP_LCD_WIDTH 1024
+#define BSP_LCD_WIDTH 1000
 #define BSP_LCD_HEIGHT 600
 
 /* Select SDHC Driver */
 
 #define RT_USING_SDIO1
-#define RT_USING_SDIO2
 
 /* Select RTC Driver */
 
 #define BSP_USING_ONCHIP_RTC
 
+/* Select WDT Driver */
+
+#define RT_USING_WDT1
+#define RT_USING_WDT2
+
 #endif