summaryrefslogtreecommitdiff
path: root/bsp/tkm32F499/drivers
diff options
context:
space:
mode:
authorguo <[email protected]>2021-10-26 07:50:40 +0800
committerGitHub <[email protected]>2021-10-26 07:50:40 +0800
commitc8ee4cc67dd1815d1b0ead1bcd24156da6ab87de (patch)
tree1f392373790a657725dd47def54196a42b1e57f5 /bsp/tkm32F499/drivers
parentab36707b681ad8d3374e1d6a01fdeab309de80e7 (diff)
parent8a180d5dd31bced87082af4ee819e5b1fa79211d (diff)
Merge pull request #5182 from NU-LL/tkm32f499
Diffstat (limited to 'bsp/tkm32F499/drivers')
-rw-r--r--bsp/tkm32F499/drivers/Kconfig154
-rw-r--r--bsp/tkm32F499/drivers/SConscript30
-rw-r--r--bsp/tkm32F499/drivers/board.c96
-rw-r--r--bsp/tkm32F499/drivers/board.h38
-rw-r--r--bsp/tkm32F499/drivers/drv_gpio.c577
-rw-r--r--bsp/tkm32F499/drivers/drv_gpio.h21
-rw-r--r--bsp/tkm32F499/drivers/drv_lcd.c298
-rw-r--r--bsp/tkm32F499/drivers/drv_log.h27
-rw-r--r--bsp/tkm32F499/drivers/drv_uart.c254
-rw-r--r--bsp/tkm32F499/drivers/drv_uart.h30
-rw-r--r--bsp/tkm32F499/drivers/lcd/lcd.c1184
-rw-r--r--bsp/tkm32F499/drivers/lcd/lcd.h75
-rw-r--r--bsp/tkm32F499/drivers/lcd_port.h34
-rw-r--r--bsp/tkm32F499/drivers/linker_scripts/link.icf34
-rw-r--r--bsp/tkm32F499/drivers/linker_scripts/link.lds137
-rw-r--r--bsp/tkm32F499/drivers/linker_scripts/link.sct16
16 files changed, 3005 insertions, 0 deletions
diff --git a/bsp/tkm32F499/drivers/Kconfig b/bsp/tkm32F499/drivers/Kconfig
new file mode 100644
index 0000000000..4e7e9a19d6
--- /dev/null
+++ b/bsp/tkm32F499/drivers/Kconfig
@@ -0,0 +1,154 @@
+menu "Hardware Drivers Config"
+
+config SOC_SERIES_TKM32F4
+ bool
+ default y
+
+config SOC_TKM32F499
+ bool
+ select RT_USING_COMPONENTS_INIT
+ select RT_USING_USER_MAIN
+ select SOC_SERIES_TKM32F4
+ default y
+
+menu "Onboard Peripheral Drivers"
+
+ config BSP_USING_USB_TO_USART
+ bool "Enable USB TO USART (uart1)"
+ select BSP_USING_UART
+ select BSP_USING_UART1
+ default y
+
+ config BSP_USING_SDCARD
+ bool "Enable SDCARD (sdio)"
+ select BSP_USING_SDIO
+ select RT_USING_DFS
+ select RT_USING_DFS_ELMFAT
+ default n
+
+endmenu
+
+menu "On-chip Peripheral Drivers"
+
+ config BSP_USING_GPIO
+ bool "Enable GPIO"
+ select RT_USING_PIN
+ default y
+
+ menuconfig BSP_USING_UART
+ bool "Enable UART"
+ default y
+ select RT_USING_SERIAL
+ if BSP_USING_UART
+ config BSP_USING_UART1
+ bool "Enable UART1 PA9/10(T/R)"
+ default y
+
+ config BSP_USING_UART2
+ bool "Enable UART2 PA2/3(T/R)"
+ default n
+ endif
+
+ config BSP_USING_ON_CHIP_FLASH
+ bool "Enable on-chip FLASH"
+ default n
+
+ menuconfig BSP_USING_SPI
+ bool "Enable SPI BUS"
+ default n
+ select RT_USING_SPI
+ if BSP_USING_SPI
+ config BSP_USING_SPI1
+ bool "Enable SPI1 BUS"
+ default n
+
+ config BSP_USING_SPI2
+ bool "Enable SPI2 BUS"
+ default n
+ endif
+
+ menuconfig BSP_USING_I2C1
+ bool "Enable I2C1 BUS (software simulation)"
+ default n
+ select RT_USING_I2C
+ select RT_USING_I2C_BITOPS
+ select RT_USING_PIN
+ if BSP_USING_I2C1
+ config BSP_I2C1_SCL_PIN
+ int "i2c1 scl pin number"
+ range 0 175
+ default 22
+ config BSP_I2C1_SDA_PIN
+ int "I2C1 sda pin number"
+ range 0 175
+ default 23
+ endif
+
+ menuconfig BSP_USING_TIM
+ bool "Enable timer"
+ default n
+ select RT_USING_HWTIMER
+ if BSP_USING_TIM
+ config BSP_USING_TIM2
+ bool "Enable TIM2"
+ default n
+
+ config BSP_USING_TIM3
+ bool "Enable TIM3"
+ default n
+ endif
+
+ menuconfig BSP_USING_ADC
+ bool "Enable ADC"
+ default n
+ select RT_USING_ADC
+ if BSP_USING_ADC
+ config BSP_USING_ADC1
+ bool "Enable ADC1"
+ default n
+ endif
+
+ menuconfig BSP_USING_ONCHIP_RTC
+ bool "Enable RTC"
+ select RT_USING_RTC
+ default n
+ if BSP_USING_ONCHIP_RTC
+ choice
+ prompt "Select clock source"
+ default BSP_RTC_USING_LSE
+
+ config BSP_RTC_USING_LSE
+ bool "RTC USING LSE"
+
+ config BSP_RTC_USING_LSI
+ bool "RTC USING LSI"
+ endchoice
+ endif
+
+ config BSP_USING_WDT
+ bool "Enable Watchdog Timer"
+ select RT_USING_WDT
+ default n
+
+ config BSP_USING_SDIO
+ bool "Enable SDIO"
+ select RT_USING_SDIO
+ select RT_USING_DFS
+ default n
+
+ config BSP_USING_LCD
+ bool "Enable LCD"
+ select BSP_USING_GPIO
+ select BSP_USING_PWM
+ select BSP_USING_PWM2
+ select BSP_USING_PWM2_CH1
+ default n
+
+
+endmenu
+
+menu "Board extended module Drivers"
+
+endmenu
+
+endmenu
diff --git a/bsp/tkm32F499/drivers/SConscript b/bsp/tkm32F499/drivers/SConscript
new file mode 100644
index 0000000000..e8e9e7de78
--- /dev/null
+++ b/bsp/tkm32F499/drivers/SConscript
@@ -0,0 +1,30 @@
+# RT-Thread building script for component
+
+from building import *
+
+cwd = GetCurrentDir()
+
+# add the general drivers.
+src = Split("""
+board.c
+""")
+
+# add serial driver code
+if GetDepend('RT_USING_SERIAL'):
+ src += ['drv_uart.c']
+
+# add gpio driver code
+if GetDepend(['RT_USING_PIN']):
+ src += ['drv_gpio.c']
+
+# add lcd driver code
+if GetDepend(['BSP_USING_LCD']):
+ src += Glob('./lcd/*.c')
+ src += ['drv_lcd.c']
+
+CPPPATH = [cwd]
+CPPPATH += [cwd+'/lcd']
+
+group = DefineGroup('Drivers', src, depend = [''], CPPPATH = CPPPATH)
+
+Return('group')
diff --git a/bsp/tkm32F499/drivers/board.c b/bsp/tkm32F499/drivers/board.c
new file mode 100644
index 0000000000..6e5eb5791d
--- /dev/null
+++ b/bsp/tkm32F499/drivers/board.c
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2017-2019, MindMotion AE Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+#include <rtthread.h>
+#include <rthw.h>
+#include <board.h>
+#include <drv_uart.h>
+// extern uint32_t SystemCoreClock;
+// extern void SystemInit(void);
+
+#ifdef RT_USING_FINSH
+#include <finsh.h>
+static void reboot(uint8_t argc, char **argv)
+{
+ rt_hw_cpu_reset();
+}
+MSH_CMD_EXPORT(reboot, Reboot System);
+#endif /* RT_USING_FINSH */
+
+static void bsp_clock_config(void)
+{
+ RemapVtorTable();
+ SystemClk_HSEInit(RCC_PLLMul_20);//启动PLL时钟，12MHz*20=240MHz
+ NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2);//2：2，全局性函数，仅需设置一次
+
+ uint32_t sysclk = 0;
+ getSystemClock(&sysclk);
+
+ SysTick_Config(sysclk / RT_TICK_PER_SECOND);
+ SysTick->CTRL |= 0x00000004UL;
+}
+
+void SysTick_Handler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+
+ rt_tick_increase();
+
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+
+void rt_hw_us_delay(rt_uint32_t us)
+{
+ rt_uint32_t ticks;
+ rt_uint32_t told, tnow, tcnt = 0;
+ rt_uint32_t reload = SysTick->LOAD;
+
+ ticks = us * reload / (1000000 / RT_TICK_PER_SECOND);
+ told = SysTick->VAL;
+ while (1)
+ {
+ tnow = SysTick->VAL;
+ if (tnow != told)
+ {
+ if (tnow < told)
+ {
+ tcnt += told - tnow;
+ }
+ else
+ {
+ tcnt += reload - tnow + told;
+ }
+ told = tnow;
+ if (tcnt >= ticks)
+ {
+ break;
+ }
+ }
+ }
+}
+
+void rt_hw_board_init()
+{
+ bsp_clock_config();
+#if defined(RT_USING_HEAP)
+ rt_system_heap_init((void *)HEAP_BEGIN, (void *)HEAP_END);
+#endif
+ // volatile uint16_t i=0;
+ // rt_hw_uart_init();
+ // i = UINT16_MAX;
+ // while(i--); //wait for a while after uart initiated.
+#ifdef RT_USING_COMPONENTS_INIT
+ rt_components_board_init();
+#endif
+#ifdef RT_USING_CONSOLE
+ rt_console_set_device(RT_CONSOLE_DEVICE_NAME);
+#endif
+}
diff --git a/bsp/tkm32F499/drivers/board.h b/bsp/tkm32F499/drivers/board.h
new file mode 100644
index 0000000000..eb5390829a
--- /dev/null
+++ b/bsp/tkm32F499/drivers/board.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2017-2019, MindMotion AE Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+
+#ifndef BOARD_H__
+#define BOARD_H__
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <hal_device.h>
+#include "sys.h"
+
+
+
+#define SRAM_SIZE (8 * 1024 * 1024)
+// #define SRAM_BASE ((uint32_t)0x70000000)
+
+
+#define SRAM_END (T_SDRAM_BASE + SRAM_SIZE)
+#ifdef __CC_ARM
+ extern int Image$$RW_IRAM1$$ZI$$Limit;
+ #define HEAP_BEGIN ((void *)&Image$$RW_IRAM1$$ZI$$Limit)
+#elif __ICCARM__
+ #pragma section = "HEAP"
+ #define HEAP_BEGIN (__segment_end("HEAP"))
+#else
+ extern int __bss_end;
+ #define HEAP_BEGIN ((void *)&__bss_end)
+#endif
+#define HEAP_END SRAM_END
+#define HEAP_SIZE (HEAP_END - (rt_uint32_t)HEAP_BEGIN)
+extern void rt_hw_board_init(void);
+#endif
diff --git a/bsp/tkm32F499/drivers/drv_gpio.c b/bsp/tkm32F499/drivers/drv_gpio.c
new file mode 100644
index 0000000000..2fe9418d72
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_gpio.c
@@ -0,0 +1,577 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <board.h>
+#include <rthw.h>
+#include <drv_gpio.h>
+
+#ifdef RT_USING_PIN
+
+#define TKM32_PIN(index, rcc, gpio, gpio_index) { index, RCC_##rcc##Periph_GPIO##gpio, GPIO##gpio, GPIO_Pin_##gpio_index, \
+ ((rt_base_t)__TKM32_PORT(gpio)-(rt_base_t)GPIOA_BASE)/(0x0400UL), gpio_index}
+#define TKM32_PIN_DEFAULT {-1, 0, 0, 0, 0, 0}
+/* TKM32 GPIO driver */
+struct pin_index
+{
+ int index;
+ uint32_t rcc;
+ GPIO_TypeDef *gpio;
+ uint32_t pin;
+ uint8_t port_source;
+ uint8_t pin_source;
+};
+static const struct pin_index tkm32_pin_map[] =
+{
+ TKM32_PIN_DEFAULT,
+ TKM32_PIN(0, AHB, A, 0),
+ TKM32_PIN(1, AHB, A, 1),
+ TKM32_PIN(2, AHB, A, 2),
+ TKM32_PIN(3, AHB, A, 3),
+ TKM32_PIN(4, AHB, A, 4),
+ TKM32_PIN(5, AHB, A, 5),
+ TKM32_PIN(6, AHB, A, 6),
+ TKM32_PIN(7, AHB, A, 7),
+ TKM32_PIN(8, AHB, A, 8),
+ TKM32_PIN(9, AHB, A, 9),
+ TKM32_PIN(10, AHB, A, 10),
+ TKM32_PIN(11, AHB, A, 11),
+ TKM32_PIN(12, AHB, A, 12),
+ TKM32_PIN(13, AHB, A, 13),
+ TKM32_PIN(14, AHB, A, 14),
+ TKM32_PIN(15, AHB, A, 15),
+ TKM32_PIN(16, AHB, B, 0),
+ TKM32_PIN(17, AHB, B, 1),
+ TKM32_PIN(18, AHB, B, 2),
+ TKM32_PIN(19, AHB, B, 3),
+ TKM32_PIN(20, AHB, B, 4),
+ TKM32_PIN(21, AHB, B, 5),
+ TKM32_PIN(22, AHB, B, 6),
+ TKM32_PIN(23, AHB, B, 7),
+ TKM32_PIN(24, AHB, B, 8),
+ TKM32_PIN(25, AHB, B, 9),
+ TKM32_PIN(26, AHB, B, 10),
+ TKM32_PIN(27, AHB, B, 11),
+ TKM32_PIN(28, AHB, B, 12),
+ TKM32_PIN(29, AHB, B, 13),
+ TKM32_PIN(30, AHB, B, 14),
+ TKM32_PIN(31, AHB, B, 15),
+ TKM32_PIN(32, AHB, C, 0),
+ TKM32_PIN(33, AHB, C, 1),
+ TKM32_PIN(34, AHB, C, 2),
+ TKM32_PIN(35, AHB, C, 3),
+ TKM32_PIN(36, AHB, C, 4),
+ TKM32_PIN(37, AHB, C, 5),
+ TKM32_PIN(38, AHB, C, 6),
+ TKM32_PIN(39, AHB, C, 7),
+ TKM32_PIN(40, AHB, C, 8),
+ TKM32_PIN(41, AHB, C, 9),
+ TKM32_PIN(42, AHB, C, 10),
+ TKM32_PIN(43, AHB, C, 11),
+ TKM32_PIN(44, AHB, C, 12),
+ TKM32_PIN(45, AHB, C, 13),
+ TKM32_PIN(46, AHB, C, 14),
+ TKM32_PIN(47, AHB, C, 15),
+ TKM32_PIN(48, AHB, D, 0),
+ TKM32_PIN(49, AHB, D, 1),
+ TKM32_PIN(50, AHB, D, 2),
+ TKM32_PIN(51, AHB, D, 3),
+ TKM32_PIN(52, AHB, D, 4),
+ TKM32_PIN(53, AHB, D, 5),
+ TKM32_PIN(54, AHB, D, 6),
+ TKM32_PIN(55, AHB, D, 7),
+ TKM32_PIN(56, AHB, D, 8),
+ TKM32_PIN(57, AHB, D, 9),
+ TKM32_PIN(58, AHB, D, 10),
+ TKM32_PIN(59, AHB, D, 11),
+ TKM32_PIN(60, AHB, D, 12),
+ TKM32_PIN(61, AHB, D, 13),
+ TKM32_PIN(62, AHB, D, 14),
+ TKM32_PIN(63, AHB, D, 15),
+ TKM32_PIN(64, AHB, E, 0),
+ TKM32_PIN(65, AHB, E, 1),
+ TKM32_PIN(66, AHB, E, 2),
+ TKM32_PIN(67, AHB, E, 3),
+ TKM32_PIN(68, AHB, E, 4),
+ TKM32_PIN(69, AHB, E, 5),
+ TKM32_PIN(70, AHB, E, 6),
+ TKM32_PIN(71, AHB, E, 7),
+ TKM32_PIN(72, AHB, E, 8),
+ TKM32_PIN(73, AHB, E, 9),
+ TKM32_PIN(74, AHB, E, 10),
+ TKM32_PIN(75, AHB, E, 11),
+ TKM32_PIN(76, AHB, E, 12),
+ TKM32_PIN(77, AHB, E, 13),
+ TKM32_PIN(78, AHB, E, 14),
+ TKM32_PIN(79, AHB, E, 15),
+ TKM32_PIN(80, AHB, E, 16),
+ TKM32_PIN(81, AHB, E, 17),
+ TKM32_PIN(82, AHB, E, 18),
+ TKM32_PIN(83, AHB, E, 19),
+ TKM32_PIN(84, AHB, E, 20),
+ TKM32_PIN(85, AHB, E, 21),
+ TKM32_PIN(86, AHB, E, 22),
+ TKM32_PIN(87, AHB, E, 23),
+};
+
+struct pin_irq_map
+{
+ rt_uint16_t pinbit;
+ rt_uint32_t irqbit;
+ enum IRQn irqno;
+};
+const struct pin_irq_map tkm32_pin_irq_map[] =
+{
+ {GPIO_Pin_0, EXTI_Line0, EXTI0_IRQn },
+ {GPIO_Pin_1, EXTI_Line1, EXTI1_IRQn },
+ {GPIO_Pin_2, EXTI_Line2, EXTI2_IRQn },
+ {GPIO_Pin_3, EXTI_Line3, EXTI3_IRQn },
+ {GPIO_Pin_4, EXTI_Line4, EXTI4_IRQn },
+ {GPIO_Pin_5, EXTI_Line5, EXTI9_5_IRQn },
+ {GPIO_Pin_6, EXTI_Line6, EXTI9_5_IRQn },
+ {GPIO_Pin_7, EXTI_Line7, EXTI9_5_IRQn },
+ {GPIO_Pin_8, EXTI_Line8, EXTI9_5_IRQn },
+ {GPIO_Pin_9, EXTI_Line9, EXTI9_5_IRQn },
+ {GPIO_Pin_10, EXTI_Line10, EXTI15_10_IRQn},
+ {GPIO_Pin_11, EXTI_Line11, EXTI15_10_IRQn},
+ {GPIO_Pin_12, EXTI_Line12, EXTI15_10_IRQn},
+ {GPIO_Pin_13, EXTI_Line13, EXTI15_10_IRQn},
+ {GPIO_Pin_14, EXTI_Line14, EXTI15_10_IRQn},
+ {GPIO_Pin_15, EXTI_Line15, EXTI15_10_IRQn},
+};
+struct rt_pin_irq_hdr tkm32_pin_irq_hdr_tab[] =
+{
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+ {-1, 0, RT_NULL, RT_NULL},
+};
+#define ITEM_NUM(items) sizeof(items) / sizeof(items[0])
+const struct pin_index *get_pin(uint8_t pin)
+{
+ const struct pin_index *index;
+
+ if (pin+1 < ITEM_NUM(tkm32_pin_map))
+ {
+ index = &tkm32_pin_map[pin+1];
+ if (index->gpio == 0)
+ index = RT_NULL;
+ }
+ else
+ {
+ index = RT_NULL;
+ }
+
+ return index;
+};
+
+void tkm32_pin_write(rt_device_t dev, rt_base_t pin, rt_base_t value)
+{
+ const struct pin_index *index;
+
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return;
+ }
+ if (value == PIN_LOW)
+ {
+ GPIO_ResetBits(index->gpio, index->pin);
+ }
+ else
+ {
+ GPIO_SetBits(index->gpio, index->pin);
+ }
+}
+
+int tkm32_pin_read(rt_device_t dev, rt_base_t pin)
+{
+ int value;
+ const struct pin_index *index;
+
+ value = PIN_LOW;
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return PIN_LOW;
+ }
+ if (GPIO_ReadInputDataBit(index->gpio, index->pin) == Bit_RESET)
+ {
+ value = PIN_LOW;
+ }
+ else
+ {
+ value = PIN_HIGH;
+ }
+ return value;
+}
+
+void tkm32_pin_mode(rt_device_t dev, rt_base_t pin, rt_base_t mode)
+{
+ const struct pin_index *index;
+ GPIO_InitTypeDef GPIO_InitStructure;
+
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return;
+ }
+ /* GPIO Periph clock enable */
+ RCC_AHBPeriphClockCmd(index->rcc, ENABLE);
+ /* Configure GPIO_InitStructure */
+ GPIO_InitStructure.GPIO_Pin = index->pin;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+ if (mode == PIN_MODE_OUTPUT)
+ {
+ /* output setting */
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+ }
+ else if (mode == PIN_MODE_OUTPUT_OD)
+ {
+ /* output setting: od. */
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_OD;
+ }
+ else if (mode == PIN_MODE_INPUT)
+ {
+ /* input setting: not pull. */
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
+ }
+ else if (mode == PIN_MODE_INPUT_PULLUP)
+ {
+ /* input setting: pull up. */
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+ }
+ else
+ {
+ /* input setting:default. */
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
+ }
+ GPIO_Init( index->gpio, &GPIO_InitStructure);
+ GPIO_PinAFConfig(index->gpio, index->pin, GPIO_AF_GPIO);
+}
+rt_inline rt_int32_t bit2bitno(rt_uint32_t bit)
+{
+ int i;
+ for (i = 0; i < 32; i++)
+ {
+ if ((0x01 << i) == bit)
+ {
+ return i;
+ }
+ }
+ return -1;
+}
+rt_inline const struct pin_irq_map *get_pin_irq_map(uint32_t pinbit)
+{
+ rt_int32_t mapindex = bit2bitno(pinbit);
+ if (mapindex < 0 || mapindex >= ITEM_NUM(tkm32_pin_irq_map))
+ {
+ return RT_NULL;
+ }
+ return &tkm32_pin_irq_map[mapindex];
+};
+rt_err_t tkm32_pin_attach_irq(struct rt_device *device, rt_int32_t pin,
+ rt_uint32_t mode, void (*hdr)(void *args), void *args)
+{
+ const struct pin_index *index;
+ rt_base_t level;
+ rt_int32_t irqindex = -1;
+
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return -RT_ENOSYS;
+ }
+ irqindex = bit2bitno(index->pin);
+ if (irqindex < 0 || irqindex >= ITEM_NUM(tkm32_pin_irq_map))
+ {
+ return -RT_ENOSYS;
+ }
+
+ level = rt_hw_interrupt_disable();
+ if (tkm32_pin_irq_hdr_tab[irqindex].pin == pin &&
+ tkm32_pin_irq_hdr_tab[irqindex].hdr == hdr &&
+ tkm32_pin_irq_hdr_tab[irqindex].mode == mode &&
+ tkm32_pin_irq_hdr_tab[irqindex].args == args
+ )
+ {
+ rt_hw_interrupt_enable(level);
+ return RT_EOK;
+ }
+ if (tkm32_pin_irq_hdr_tab[irqindex].pin != -1)
+ {
+ rt_hw_interrupt_enable(level);
+ return -RT_EBUSY;
+ }
+ tkm32_pin_irq_hdr_tab[irqindex].pin = pin;
+ tkm32_pin_irq_hdr_tab[irqindex].hdr = hdr;
+ tkm32_pin_irq_hdr_tab[irqindex].mode = mode;
+ tkm32_pin_irq_hdr_tab[irqindex].args = args;
+ rt_hw_interrupt_enable(level);
+
+ return RT_EOK;
+}
+rt_err_t tkm32_pin_detach_irq(struct rt_device *device, rt_int32_t pin)
+{
+ const struct pin_index *index;
+ rt_base_t level;
+ rt_int32_t irqindex = -1;
+
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return RT_ENOSYS;
+ }
+ irqindex = bit2bitno(index->pin);
+ if (irqindex < 0 || irqindex >= ITEM_NUM(tkm32_pin_irq_map))
+ {
+ return RT_ENOSYS;
+ }
+
+ level = rt_hw_interrupt_disable();
+ if (tkm32_pin_irq_hdr_tab[irqindex].pin == -1)
+ {
+ rt_hw_interrupt_enable(level);
+ return RT_EOK;
+ }
+ tkm32_pin_irq_hdr_tab[irqindex].pin = -1;
+ tkm32_pin_irq_hdr_tab[irqindex].hdr = RT_NULL;
+ tkm32_pin_irq_hdr_tab[irqindex].mode = 0;
+ tkm32_pin_irq_hdr_tab[irqindex].args = RT_NULL;
+ rt_hw_interrupt_enable(level);
+
+ return RT_EOK;
+}
+rt_err_t tkm32_pin_irq_enable(struct rt_device *device, rt_base_t pin,
+ rt_uint32_t enabled)
+{
+ const struct pin_index *index;
+ const struct pin_irq_map *irqmap;
+ rt_base_t level;
+ rt_int32_t irqindex = -1;
+ GPIO_InitTypeDef GPIO_InitStructure;
+ NVIC_InitTypeDef NVIC_InitStructure;
+ EXTI_InitTypeDef EXTI_InitStructure;
+
+ index = get_pin(pin);
+ if (index == RT_NULL)
+ {
+ return -RT_ENOSYS;
+ }
+ if (enabled == PIN_IRQ_ENABLE)
+ {
+ irqindex = bit2bitno(index->pin);
+ if (irqindex < 0 || irqindex >= ITEM_NUM(tkm32_pin_irq_map))
+ {
+ return -RT_ENOSYS;
+ }
+ level = rt_hw_interrupt_disable();
+ if (tkm32_pin_irq_hdr_tab[irqindex].pin == -1)
+ {
+ rt_hw_interrupt_enable(level);
+ return -RT_ENOSYS;
+ }
+ irqmap = &tkm32_pin_irq_map[irqindex];
+ /* GPIO Periph clock enable */
+ RCC_AHBPeriphClockCmd(index->rcc, ENABLE);
+ /* Configure GPIO_InitStructure */
+ GPIO_InitStructure.GPIO_Pin = index->pin;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+ GPIO_Init(index->gpio, &GPIO_InitStructure);
+
+ NVIC_InitStructure.NVIC_IRQChannel = irqmap->irqno;
+ NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 2;
+ NVIC_InitStructure.NVIC_IRQChannelSubPriority = 2;
+ NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
+ NVIC_Init(&NVIC_InitStructure);
+
+ // GPIO_EXTILineConfig(index->port_source, index->pin_source);
+ // EXTI_InitStructure.EXTI_Line = irqmap->irqbit;
+ // EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
+ switch (tkm32_pin_irq_hdr_tab[irqindex].mode)
+ {
+ case PIN_IRQ_MODE_RISING:
+ Ex_NVIC_Config(index->port_source, index->pin_source, 2);
+ // EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
+ break;
+ case PIN_IRQ_MODE_FALLING:
+ Ex_NVIC_Config(index->port_source, index->pin_source, 1);
+ // EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Falling;
+ break;
+ case PIN_IRQ_MODE_RISING_FALLING:
+ Ex_NVIC_Config(index->port_source, index->pin_source, 3);
+ // EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising_Falling;
+ break;
+ }
+ // EXTI_InitStructure.EXTI_LineCmd = ENABLE;
+ // EXTI_Init(&EXTI_InitStructure);
+ rt_hw_interrupt_enable(level);
+ }
+ else if (enabled == PIN_IRQ_DISABLE)
+ {
+ irqmap = get_pin_irq_map(index->pin);
+ if (irqmap == RT_NULL)
+ {
+ return -RT_ENOSYS;
+ }
+ EXTI_InitStructure.EXTI_Line = irqmap->irqbit;
+ EXTI_InitStructure.EXTI_Mode = EXTI_Mode_Interrupt;
+ EXTI_InitStructure.EXTI_Trigger = EXTI_Trigger_Rising;
+ EXTI_InitStructure.EXTI_LineCmd = DISABLE;
+ EXTI_Init(&EXTI_InitStructure);
+ }
+ else
+ {
+ return -RT_ENOSYS;
+ }
+
+ return RT_EOK;
+}
+const static struct rt_pin_ops _tkm32_pin_ops =
+{
+ tkm32_pin_mode,
+ tkm32_pin_write,
+ tkm32_pin_read,
+ tkm32_pin_attach_irq,
+ tkm32_pin_detach_irq,
+ tkm32_pin_irq_enable,
+ RT_NULL,
+};
+
+int rt_hw_pin_init(void)
+{
+ int result;
+
+ result = rt_device_pin_register("pin", &_tkm32_pin_ops, RT_NULL);
+ return result;
+}
+INIT_BOARD_EXPORT(rt_hw_pin_init);
+
+rt_inline void pin_irq_hdr(int irqno)
+{
+ EXTI_ClearITPendingBit(tkm32_pin_irq_map[irqno].irqbit);
+ if (tkm32_pin_irq_hdr_tab[irqno].hdr)
+ {
+ tkm32_pin_irq_hdr_tab[irqno].hdr(tkm32_pin_irq_hdr_tab[irqno].args);
+ }
+}
+void EXTI0_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ pin_irq_hdr(0);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI1_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ pin_irq_hdr(1);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI2_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ pin_irq_hdr(2);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI3_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ pin_irq_hdr(3);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI4_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ pin_irq_hdr(4);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI9_5_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ if (EXTI_GetITStatus(EXTI_Line5) != RESET)
+ {
+ pin_irq_hdr(5);
+ }
+ if (EXTI_GetITStatus(EXTI_Line6) != RESET)
+ {
+ pin_irq_hdr(6);
+ }
+ if (EXTI_GetITStatus(EXTI_Line7) != RESET)
+ {
+ pin_irq_hdr(7);
+ }
+ if (EXTI_GetITStatus(EXTI_Line8) != RESET)
+ {
+ pin_irq_hdr(8);
+ }
+ if (EXTI_GetITStatus(EXTI_Line9) != RESET)
+ {
+ pin_irq_hdr(9);
+ }
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+void EXTI15_10_IRQHandler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ if (EXTI_GetITStatus(EXTI_Line10) != RESET)
+ {
+ pin_irq_hdr(10);
+ }
+ if (EXTI_GetITStatus(EXTI_Line11) != RESET)
+ {
+ pin_irq_hdr(11);
+ }
+ if (EXTI_GetITStatus(EXTI_Line12) != RESET)
+ {
+ pin_irq_hdr(12);
+ }
+ if (EXTI_GetITStatus(EXTI_Line13) != RESET)
+ {
+ pin_irq_hdr(13);
+ }
+ if (EXTI_GetITStatus(EXTI_Line14) != RESET)
+ {
+ pin_irq_hdr(14);
+ }
+ if (EXTI_GetITStatus(EXTI_Line15) != RESET)
+ {
+ pin_irq_hdr(15);
+ }
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+
+#endif /* RT_USING_PIN */
diff --git a/bsp/tkm32F499/drivers/drv_gpio.h b/bsp/tkm32F499/drivers/drv_gpio.h
new file mode 100644
index 0000000000..1f52cacba5
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_gpio.h
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+#ifndef DRV_GPIO_H__
+#define DRV_GPIO_H__
+
+#define __TKM32_PORT(port) GPIO##port##_BASE
+
+#define GET_PIN(PORTx,PIN) (rt_base_t)((16 * ( ((rt_base_t)__TKM32_PORT(PORTx) - (rt_base_t)GPIOA_BASE)/(0x0400UL) )) + PIN)
+
+
+
+int rt_hw_pin_init(void);
+
+#endif
diff --git a/bsp/tkm32F499/drivers/drv_lcd.c b/bsp/tkm32F499/drivers/drv_lcd.c
new file mode 100644
index 0000000000..0857d5210d
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_lcd.c
@@ -0,0 +1,298 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-14 spaceman first version
+ */
+
+#include <board.h>
+
+#ifdef BSP_USING_LCD
+#include <lcd_port.h>
+#include "lcd.h"
+#include "drv_gpio.h"
+
+#define DRV_DEBUG
+#define LOG_TAG "drv.lcd"
+#include <drv_log.h>
+
+#define LCD_DEVICE(dev) (struct drv_lcd_device*)(dev)
+
+
+static __align(256) volatile rt_uint32_t LTDC_Buf1[LCD_WIDTH * LCD_HEIGHT] = {0x00};
+static __align(256) volatile rt_uint32_t LTDC_Buf2[LCD_WIDTH * LCD_HEIGHT] = {0x00};
+
+
+struct drv_lcd_device
+{
+ struct rt_device parent;
+
+ struct rt_device_graphic_info lcd_info;
+
+ struct rt_semaphore lcd_lock;
+
+ /* 0:front_buf is being used 1: back_buf is being used*/
+ rt_uint8_t cur_buf;
+ rt_uint8_t *front_buf;
+ rt_uint8_t *back_buf;
+};
+
+struct drv_lcd_device _lcd;
+
+static rt_err_t drv_lcd_init(struct rt_device *device)
+{
+ struct drv_lcd_device *lcd = LCD_DEVICE(device);
+ /* nothing, right now */
+ lcd = lcd;
+ return RT_EOK;
+}
+
+static rt_err_t drv_lcd_control(struct rt_device *device, int cmd, void *args)
+{
+ struct drv_lcd_device *lcd = LCD_DEVICE(device);
+
+ switch (cmd)
+ {
+ case RTGRAPHIC_CTRL_RECT_UPDATE:
+ {
+ /* update */
+ if (_lcd.cur_buf)
+ {
+ /* back_buf is being used */
+ _lcd.lcd_info.framebuffer = _lcd.back_buf;
+ /* Configure the color frame buffer start address */
+ LTDC->DP_SWT = 0;
+ _lcd.cur_buf = 0;
+ }
+ else
+ {
+ /* front_buf is being used */
+ _lcd.lcd_info.framebuffer = _lcd.front_buf;
+ /* Configure the color frame buffer start address */
+ LTDC->DP_SWT = 1;
+ _lcd.cur_buf = 1;
+ }
+ rt_sem_take(&_lcd.lcd_lock, RT_TICK_PER_SECOND / 20);
+ }
+ break;
+
+ case RTGRAPHIC_CTRL_GET_INFO:
+ {
+ struct rt_device_graphic_info *info = (struct rt_device_graphic_info *)args;
+
+ RT_ASSERT(info != RT_NULL);
+ info->pixel_format = lcd->lcd_info.pixel_format;
+ info->bits_per_pixel = LCD_BITS_PER_PIXEL;
+ info->width = lcd->lcd_info.width;
+ info->height = lcd->lcd_info.height;
+ info->framebuffer = lcd->lcd_info.framebuffer;
+ }
+ break;
+ }
+
+ return RT_EOK;
+}
+
+
+
+
+
+rt_err_t stm32_lcd_init(struct drv_lcd_device *lcd)
+{
+ LCD_Initial((rt_uint32_t)lcd->front_buf, (rt_uint32_t)lcd->back_buf);
+ return RT_EOK;
+}
+#if defined(LCD_BACKLIGHT_USING_PWM)
+void turn_on_lcd_backlight(void)
+{
+ struct rt_device_pwm *pwm_dev;
+
+ /* turn on the LCD backlight */
+ pwm_dev = (struct rt_device_pwm *)rt_device_find(LCD_PWM_DEV_NAME);
+ /* pwm frequency:100K = 10000ns */
+ rt_pwm_set(pwm_dev, LCD_PWM_DEV_CHANNEL, 10000, 10000);
+ rt_pwm_enable(pwm_dev, LCD_PWM_DEV_CHANNEL);
+}
+#elif defined(LCD_BACKLIGHT_USING_GPIO)
+void turn_on_lcd_backlight(void)
+{
+ rt_pin_mode(LCD_BL_GPIO_NUM, PIN_MODE_OUTPUT);
+ rt_pin_mode(LCD_DISP_GPIO_NUM, PIN_MODE_OUTPUT);
+
+ rt_pin_write(LCD_DISP_GPIO_NUM, PIN_HIGH);
+ rt_pin_write(LCD_BL_GPIO_NUM, PIN_HIGH);
+}
+#else
+void turn_on_lcd_backlight(void)
+{
+
+}
+#endif
+
+#ifdef RT_USING_DEVICE_OPS
+const static struct rt_device_ops lcd_ops =
+{
+ drv_lcd_init,
+ RT_NULL,
+ RT_NULL,
+ RT_NULL,
+ RT_NULL,
+ drv_lcd_control
+};
+#endif
+
+
+void Lcd_ColorBox(struct drv_lcd_device *lcd, rt_uint16_t xStart, rt_uint16_t yStart, rt_uint16_t xLong, rt_uint16_t yLong, rt_uint32_t Color)
+{
+ rt_uint16_t i, j;
+ rt_uint32_t temp;
+ rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ temp = lcd->lcd_info.height * xStart;
+ for (i = 0; i < yLong; i++)
+ {
+ for (j = 0; j < xLong; j++)
+ LTDC_Buf[yStart + i + lcd->lcd_info.height * j + temp] = Color;
+ }
+ lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+}
+
+void LCD_Fill_Pic(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t *pic)
+{
+ rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ rt_uint16_t i, j;
+ rt_uint32_t Xstart, k = 0;
+ Xstart = lcd->lcd_info.height * x;
+ for (i = 0; i < pic_V; i++)
+ {
+ for (j = 0; j < pic_H; j++)
+ LTDC_Buf[Xstart + i + lcd->lcd_info.height * j + y] = pic[k++];
+ }
+}
+
+void DrawPixel(struct drv_lcd_device *lcd, rt_uint16_t x, rt_uint16_t y, int Color)
+{
+ rt_uint32_t *LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ LTDC_Buf[y + lcd->lcd_info.height * x] = Color;
+}
+
+
+
+
+int drv_lcd_hw_init(void)
+{
+ rt_err_t result = RT_EOK;
+ struct rt_device *device = &_lcd.parent;
+
+ /* memset _lcd to zero */
+ rt_memset(&_lcd, 0x00, sizeof(_lcd));
+
+ /* init lcd_lock semaphore */
+ result = rt_sem_init(&_lcd.lcd_lock, "lcd_lock", 0, RT_IPC_FLAG_FIFO);
+ if (result != RT_EOK)
+ {
+ LOG_E("init semaphore failed!\n");
+ result = -RT_ENOMEM;
+ goto __exit;
+ }
+
+ /* config LCD dev info */
+ _lcd.lcd_info.height = LCD_HEIGHT;
+ _lcd.lcd_info.width = LCD_WIDTH;
+ _lcd.lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL;
+ _lcd.lcd_info.pixel_format = LCD_PIXEL_FORMAT;
+
+ /* malloc memory for Triple Buffering */
+ _lcd.back_buf = (rt_uint8_t *)LTDC_Buf1;
+ _lcd.front_buf = (rt_uint8_t *)LTDC_Buf2;
+ _lcd.lcd_info.framebuffer = _lcd.back_buf;
+ if (_lcd.lcd_info.framebuffer == RT_NULL || _lcd.back_buf == RT_NULL || _lcd.front_buf == RT_NULL)
+ {
+ LOG_E("init frame buffer failed!\n");
+ result = -RT_ENOMEM;
+ goto __exit;
+ }
+
+ /* memset buff to 0xFF */
+ rt_memset(_lcd.back_buf, 0xFF, LCD_BUF_SIZE);
+ rt_memset(_lcd.front_buf, 0xFF, LCD_BUF_SIZE);
+
+ device->type = RT_Device_Class_Graphic;
+#ifdef RT_USING_DEVICE_OPS
+ device->ops = &lcd_ops;
+#else
+ device->init = drv_lcd_init;
+ device->control = drv_lcd_control;
+#endif
+
+ /* register lcd device */
+ rt_device_register(device, "lcd", RT_DEVICE_FLAG_RDWR);
+
+ /* init stm32 LTDC */
+ if (stm32_lcd_init(&_lcd) != RT_EOK)
+ {
+ result = -RT_ERROR;
+ goto __exit;
+ }
+ else
+ {
+ turn_on_lcd_backlight();
+ }
+ LOG_D("lcd register successful!");
+
+__exit:
+ if (result != RT_EOK)
+ {
+ rt_sem_detach(&_lcd.lcd_lock);
+ }
+ return result;
+}
+INIT_DEVICE_EXPORT(drv_lcd_hw_init);
+
+#ifdef DRV_DEBUG
+#ifdef FINSH_USING_MSH
+int lcd_test()
+{
+ struct drv_lcd_device *lcd;
+ lcd = (struct drv_lcd_device *)rt_device_find("lcd");
+ if(lcd == RT_NULL)
+ {
+ LOG_E("find lcd device failed!\n");
+ return -1;
+ }
+ rt_uint32_t *LTDC_Buf = RT_NULL;
+
+ LOG_D("red");
+ /* red */
+ LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
+ LTDC_Buf[i] = Red;
+ lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+ rt_thread_mdelay(1000);
+ LOG_D("green");
+ /* green */
+ LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
+ LTDC_Buf[i] = Green;
+ lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+ rt_thread_mdelay(1000);
+ LOG_D("blue");
+ /* blue */
+ LTDC_Buf = (rt_uint32_t *)lcd->lcd_info.framebuffer;
+ for (int i = 0; i < LCD_BUF_SIZE / 4; i++)
+ LTDC_Buf[i] = Blue;
+ lcd->parent.control(&lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+
+ return 0;
+}
+MSH_CMD_EXPORT(lcd_test, lcd_test);
+
+
+
+
+
+#endif /* FINSH_USING_MSH */
+#endif /* DRV_DEBUG */
+#endif /* BSP_USING_LCD */
diff --git a/bsp/tkm32F499/drivers/drv_log.h b/bsp/tkm32F499/drivers/drv_log.h
new file mode 100644
index 0000000000..3fe511789b
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_log.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2018-11-15 SummerGift first version
+ */
+
+/*
+ * NOTE: DO NOT include this file on the header file.
+ */
+
+#ifndef LOG_TAG
+#define DBG_TAG "drv"
+#else
+#define DBG_TAG LOG_TAG
+#endif /* LOG_TAG */
+
+#ifdef DRV_DEBUG
+#define DBG_LVL DBG_LOG
+#else
+#define DBG_LVL DBG_INFO
+#endif /* DRV_DEBUG */
+
+#include <rtdbg.h>
diff --git a/bsp/tkm32F499/drivers/drv_uart.c b/bsp/tkm32F499/drivers/drv_uart.c
new file mode 100644
index 0000000000..336367d9be
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_uart.c
@@ -0,0 +1,254 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+#include <rtthread.h>
+#include <rtdevice.h>
+#include <board.h>
+#include "drv_uart.h"
+
+#ifdef RT_USING_SERIAL
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.uart"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2) && !defined(BSP_USING_UART3) && \
+ !defined(BSP_USING_UART4)
+#error "Please define at least one BSP_USING_UARTx"
+/* this driver can be disabled at menuconfig -> RT-Thread Components -> Device Drivers */
+#endif
+
+
+/* UART1 */
+#define UART1_GPIO_TX GPIO_Pin_9
+#define UART1_GPIO_RX GPIO_Pin_10
+#define UART1_GPIO_AF GPIO_AF_UART_1
+#define UART1_GPIO GPIOA
+
+/* UART2 */
+#define UART2_GPIO_TX GPIO_Pin_2
+#define UART2_GPIO_RX GPIO_Pin_3
+#define UART2_GPIO_AF GPIO_AF_UART_2345
+#define UART2_GPIO GPIOA
+
+
+static rt_err_t tkm32_uart_configure(struct rt_serial_device *serial, struct serial_configure *cfg)
+{
+ struct tkm32_uart *uart;
+ UART_InitTypeDef UART_InitStructure;
+ RT_ASSERT(serial != RT_NULL);
+ RT_ASSERT(cfg != RT_NULL);
+ uart = (struct tkm32_uart *)serial->parent.user_data;
+ UART_InitStructure.UART_BaudRate = cfg->baud_rate;
+ if (cfg->data_bits == DATA_BITS_8)
+ UART_InitStructure.UART_WordLength = UART_WordLength_8b;
+ if (cfg->stop_bits == STOP_BITS_1)
+ UART_InitStructure.UART_StopBits = UART_StopBits_1;
+ else if (cfg->stop_bits == STOP_BITS_2)
+ UART_InitStructure.UART_StopBits = UART_StopBits_2;
+ UART_InitStructure.UART_Parity = UART_Parity_No;
+ UART_InitStructure.UART_HardwareFlowControl = UART_HardwareFlowControl_None;
+ UART_InitStructure.UART_Mode = UART_Mode_Rx | UART_Mode_Tx;
+ UART_Init(uart->uart, &UART_InitStructure);
+ /* Enable UART */
+ UART_Cmd(uart->uart, ENABLE);
+ return RT_EOK;
+}
+
+static rt_err_t tkm32_uart_control(struct rt_serial_device *serial, int cmd, void *arg)
+{
+ struct tkm32_uart *uart;
+ RT_ASSERT(serial != RT_NULL);
+ uart = (struct tkm32_uart *)serial->parent.user_data;
+ switch (cmd)
+ {
+ case RT_DEVICE_CTRL_CLR_INT:
+ /* disable rx irq */
+ NVIC_DisableIRQ(uart->irq);
+ UART_ITConfig(uart->uart, UART_IT_RXIEN, DISABLE);
+ break;
+ case RT_DEVICE_CTRL_SET_INT:
+ /* enable rx irq */
+ NVIC_EnableIRQ(uart->irq);
+ /* enable interrupt */
+ UART_ITConfig(uart->uart, UART_IT_RXIEN, ENABLE);
+ break;
+ }
+ return RT_EOK;
+}
+
+static int tkm32_uart_putc(struct rt_serial_device *serial, char c)
+{
+ struct tkm32_uart *uart;
+ RT_ASSERT(serial != RT_NULL);
+ uart = (struct tkm32_uart *)serial->parent.user_data;
+ while ((uart->uart->CSR & UART_IT_TXIEN) == 0);
+ uart->uart->TDR = (c & (uint16_t)0x00FF);
+ return 1;
+}
+
+static int tkm32_uart_getc(struct rt_serial_device *serial)
+{
+ int ch;
+ struct tkm32_uart *uart;
+ RT_ASSERT(serial != RT_NULL);
+ uart = (struct tkm32_uart *)serial->parent.user_data;
+ ch = -1;
+ if (uart->uart->CSR & UART_FLAG_RXAVL)
+ {
+ ch = uart->uart->RDR & 0xff;
+ }
+ return ch;
+}
+
+static const struct rt_uart_ops tkm32_uart_ops =
+{
+ tkm32_uart_configure,
+ tkm32_uart_control,
+ tkm32_uart_putc,
+ tkm32_uart_getc,
+};
+
+#if defined(BSP_USING_UART1)
+/* UART1 device driver structure */
+static struct tkm32_uart uart1;
+struct rt_serial_device serial1;
+void UART1_IRQHandler(void)
+{
+ struct tkm32_uart *uart;
+ uart = &uart1;
+ /* enter interrupt */
+ rt_interrupt_enter();
+ if (UART_GetITStatus(uart->uart, UART_IT_RXIEN) != RESET)
+ {
+ UART_ClearITPendingBit(uart->uart, UART_IT_RXIEN);
+ rt_hw_serial_isr(&serial1, RT_SERIAL_EVENT_RX_IND);
+ }
+ if (UART_GetITStatus(uart->uart, UART_IT_TXIEN) != RESET)
+ {
+ /* clear interrupt */
+ UART_ClearITPendingBit(uart->uart, UART_IT_TXIEN);
+ }
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART1 */
+
+#if defined(BSP_USING_UART2)
+/* UART2 device driver structure */
+static struct tkm32_uart uart2;
+struct rt_serial_device serial2;
+void UART2_IRQHandler(void)
+{
+ struct tkm32_uart *uart;
+ uart = &uart2;
+ /* enter interrupt */
+ rt_interrupt_enter();
+ if (UART_GetITStatus(uart->uart, UART_IT_RXIEN) != RESET)
+ {
+ UART_ClearITPendingBit(uart->uart, UART_IT_RXIEN);
+ rt_hw_serial_isr(&serial2, RT_SERIAL_EVENT_RX_IND);
+ }
+ if (UART_GetITStatus(uart->uart, UART_IT_TXIEN) != RESET)
+ {
+ /* clear interrupt */
+ UART_ClearITPendingBit(uart->uart, UART_IT_TXIEN);
+ }
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART2 */
+
+#ifdef BSP_USING_UART1
+static void UART1PINconfigStepA(void)
+{
+ /* Enable UART clock */
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
+ RCC_APB2PeriphClockCmd(RCC_APB2Periph_UART1, ENABLE);
+}
+
+static void UART1PINconfigStepB(void)
+{
+
+ GPIO_InitTypeDef GPIO_InitStructure;
+ /* Configure USART Rx/tx PIN */
+ GPIO_InitStructure.GPIO_Pin = UART1_GPIO_TX;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
+ GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
+ GPIO_InitStructure.GPIO_Pin = UART1_GPIO_RX;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+ GPIO_Init(UART1_GPIO, &GPIO_InitStructure);
+ GPIO_PinAFConfig(UART1_GPIO, UART1_GPIO_TX | UART1_GPIO_RX, UART1_GPIO_AF);
+ UART_ClearITPendingBit(UART1, 0xFF);
+}
+#endif
+
+#ifdef BSP_USING_UART2
+static void UART2PINconfigStepA(void)
+{
+ /* Enable UART clock */
+ RCC_APB1PeriphClockCmd(RCC_APB1Periph_UART2, ENABLE);
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
+}
+
+static void UART2PINconfigStepB(void)
+{
+ GPIO_InitTypeDef GPIO_InitStructure;
+ /* Configure USART Rx/tx PIN */
+ GPIO_InitStructure.GPIO_Pin = UART2_GPIO_TX;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
+ GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
+ GPIO_InitStructure.GPIO_Pin = UART2_GPIO_RX;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;
+ GPIO_Init(UART2_GPIO, &GPIO_InitStructure);
+ GPIO_PinAFConfig(UART2_GPIO, UART2_GPIO_TX | UART2_GPIO_RX, UART2_GPIO_AF);
+ UART_ClearITPendingBit(UART2, 0xFF);
+}
+#endif
+
+int rt_hw_uart_init(void)
+{
+ struct tkm32_uart *uart;
+ struct serial_configure config = RT_SERIAL_CONFIG_DEFAULT;
+#ifdef BSP_USING_UART1
+ UART1PINconfigStepA();
+ uart = &uart1;
+ uart->uart = UART1;
+ uart->irq = UART1_IRQn;
+ config.baud_rate = BAUD_RATE_115200;
+ serial1.ops = &tkm32_uart_ops;
+ serial1.config = config;
+ /* register UART1 device */
+ rt_hw_serial_register(&serial1, "uart1",
+ RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX,
+ uart);
+ UART1PINconfigStepB();
+#endif /* BSP_USING_UART1 */
+
+#ifdef BSP_USING_UART2
+ UART2PINconfigStepA();
+ uart = &uart2;
+ uart->uart = UART2;
+ uart->irq = UART2_IRQn;
+ config.baud_rate = BAUD_RATE_115200;
+ serial2.ops = &tkm32_uart_ops;
+ serial2.config = config;
+ /* register UART2 device */
+ rt_hw_serial_register(&serial2, "uart2",
+ RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX | RT_DEVICE_FLAG_INT_TX,
+ uart);
+ UART2PINconfigStepB();
+#endif /* BSP_USING_UART2 */
+ return 0;
+}
+INIT_BOARD_EXPORT(rt_hw_uart_init);
+
+#endif /* RT_USING_SERIAL */
diff --git a/bsp/tkm32F499/drivers/drv_uart.h b/bsp/tkm32F499/drivers/drv_uart.h
new file mode 100644
index 0000000000..4615c9db3d
--- /dev/null
+++ b/bsp/tkm32F499/drivers/drv_uart.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-02 spaceman first version
+ */
+
+#ifndef DRV_UART_H__
+#define DRV_UART_H__
+
+#include <rtthread.h>
+#include "rtdevice.h"
+#include <rthw.h>
+
+
+int rt_hw_uart_init(void);
+
+/* uart driver */
+struct tkm32_uart
+{
+ UART_TypeDef *uart;
+ IRQn_Type irq;
+};
+
+
+
+#endif
diff --git a/bsp/tkm32F499/drivers/lcd/lcd.c b/bsp/tkm32F499/drivers/lcd/lcd.c
new file mode 100644
index 0000000000..abfd677c9d
--- /dev/null
+++ b/bsp/tkm32F499/drivers/lcd/lcd.c
@@ -0,0 +1,1184 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-14 spaceman first version
+ */
+
+#include "lcd.h"
+
+// __align(256) rt_uint32_t LTDC_Buf[XSIZE_PHYS * YSIZE_PHYS];
+
+volatile void LCD_delay(volatile int time) //简单软件延时
+{
+ // volatile rt_uint32_t i;
+ // while (time--)
+ // for (i = 500; i > 0; i--)
+ // ;
+ rt_thread_mdelay(time);
+}
+void LTDC_Clock_Set(void) //设置LTDC时钟
+{
+ RCC->AHB1ENR |= 1 << 31;
+ RCC->CR |= 1 << 28;
+ RCC->PLLDCKCFGR = 0x1 << 16; //分频系数 0~3 --> 2,4,6,8
+ RCC->PLLLCDCFGR = 6 << 6; //倍频系数
+}
+void GPIO_RGB_INIT(void)
+{
+ GPIO_InitTypeDef GPIO_InitStructure; //定义GPIO初始化结构体变量
+
+ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOD | RCC_AHBPeriph_GPIOE, ENABLE);
+
+ //DE=PB4, PCLK=PB5, HSYNC=PB6, VSYNC=PB7
+ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
+ GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+ //lcd_reset:PD6 LCD_Black_Light On Off :PD8
+ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_8;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+ GPIO_Init(GPIOD, &GPIO_InitStructure);
+
+ // GPIO模拟SPI初始化液晶屏 SPI_SDA SPI_DCLK LCD_SPI_CS
+ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_9 | GPIO_Pin_11;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
+ GPIO_Init(GPIOB, &GPIO_InitStructure);
+
+ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_All;
+ GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
+ GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
+ GPIO_Init(GPIOE, &GPIO_InitStructure);
+
+ GPIO_PinAFConfig(GPIOB, GPIO_Pin_4 | GPIO_Pin_5 | GPIO_Pin_6 | GPIO_Pin_7, GPIO_AF_LTDC); //PB4~7复用为LTDC的同步信号线
+ GPIO_PinAFConfig(GPIOE, GPIO_Pin_All, GPIO_AF_LTDC); //GPIOE所有的IO全部复用为LTDC的数据线
+}
+static void LCD_Reset(void)
+{
+ //注意，现在科学发达，有的屏不用复位也行
+ LCD_RST(0);
+ LCD_delay(200);
+ LCD_RST(1);
+ LCD_delay(200);
+}
+void set_resolutionXX(LCD_FORM_TypeDef *LCD_FORM)
+{
+ rt_uint32_t aHorStart;
+ rt_uint32_t aHorEnd;
+ rt_uint32_t aVerStart;
+ rt_uint32_t aVerEnd;
+
+ aHorStart = LCD_FORM->blkHorEnd + 1;
+ aHorEnd = aHorStart + LCD_FORM->aHorLen;
+ aVerStart = LCD_FORM->blkVerEnd + 1;
+ aVerEnd = aVerStart + LCD_FORM->aVerLen;
+
+ LTDC->P_HOR = aHorEnd; //总宽度
+ LTDC->HSYNC = (LCD_FORM->sHsyncStart << 16) | LCD_FORM->sHsyncEnd; //水平同步信号起始和结束，位于背景色中间
+ LTDC->A_HOR = (aHorStart << 16) | aHorEnd; //水平激活起始和结束
+ LTDC->A_HOR_LEN = LCD_FORM->aHorLen; //水平激活域宽度
+ LTDC->BLK_HOR = (0 << 16) | LCD_FORM->blkHorEnd; //背景开始和结束宽度0~激活地址
+ LTDC->P_VER = aVerEnd;
+ LTDC->VSYNC = (LCD_FORM->sVsyncStart << 16) | LCD_FORM->sVsyncEnd;
+ LTDC->A_VER = (aVerStart << 16) | aVerEnd;
+ LTDC->A_VER_LEN = LCD_FORM->aVerLen;
+ LTDC->BLK_VER = (0 << 16) | LCD_FORM->blkVerEnd;
+}
+
+void Set_LCD_Timing_to_LTDC(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2)
+{
+ LCD_FORM_TypeDef LCD_FORM;
+ LTDC->OUT_EN = 0;
+ LTDC->DP_ADDR0 = LTDC_Buf1; //第0层地址
+ LTDC->DP_ADDR1 = LTDC_Buf2;//第一层地址
+ LTDC->BLK_DATA = 0x0000; //背景色
+
+ LCD_FORM.sHsyncStart = 0x2; //水平激活起始
+ LCD_FORM.sHsyncEnd = 0x3; //水平激活结束
+ LCD_FORM.aHorLen = 480 - 1; //水平分辨率
+ LCD_FORM.blkHorEnd = 0xf; //水平消隐
+
+ LCD_FORM.sVsyncStart = 0x2; //垂直激活起始
+ LCD_FORM.sVsyncEnd = 0x3; //垂直激活结束
+ LCD_FORM.aVerLen = 800 - 1; //垂直分辨率
+ LCD_FORM.blkVerEnd = 0xF; //垂直消隐
+
+ set_resolutionXX(&LCD_FORM);
+
+ LTDC->VI_FORMAT = 0;
+ LTDC->POL_CTL = 0x8 + 3;
+ LTDC->OUT_EN |= 0x107;
+}
+void LTDC_IRQHandler(void)
+{
+ LTDC->INTR_CLR = 2;
+ LTDC->DP_SWT ^= 1; //连续显示两幅图片
+ if (LTDC->DP_SWT != 0)
+ {
+ // fun_test(SDRAM_RGB_ADD);
+ }
+ else
+ {
+ // fun_test(SDRAM_RGB_ADD+SDRAM_RGB_OFFSET);
+ }
+ // if(LTDC->INTR_STA & 2)
+ // {
+
+ // }
+}
+
+void LCD_WriteByteSPI(unsigned char byte)
+{
+ unsigned char n;
+
+ for (n = 0; n < 8; n++)
+ {
+ if (byte & 0x80)
+ SPI_SDA(1)
+ else
+ SPI_SDA(0)
+ byte <<= 1;
+
+ SPI_DCLK(0);
+ SPI_DCLK(1);
+ }
+}
+void SPI_WriteComm(rt_uint16_t CMD)
+{
+ LCD_SPI_CS(0);
+ LCD_WriteByteSPI(0X20);
+ LCD_WriteByteSPI(CMD >> 8);
+ LCD_WriteByteSPI(0X00);
+ LCD_WriteByteSPI(CMD);
+
+ LCD_SPI_CS(1);
+}
+void SPI_WriteData(rt_uint16_t tem_data)
+{
+ LCD_SPI_CS(0);
+ LCD_WriteByteSPI(0x40);
+ LCD_WriteByteSPI(tem_data);
+ LCD_SPI_CS(1);
+}
+void BlockWrite(unsigned int Xstart, unsigned int Xend, unsigned int Ystart, unsigned int Yend)
+{
+ SPI_WriteComm(0x2a00);
+ SPI_WriteData(Xstart >> 8);
+ SPI_WriteComm(0x2a01);
+ SPI_WriteData(Xstart & 0xff);
+ SPI_WriteComm(0x2a02);
+ SPI_WriteData(Xend >> 8);
+ SPI_WriteComm(0x2a03);
+ SPI_WriteData(Xend & 0xff);
+
+ SPI_WriteComm(0x2b00);
+ SPI_WriteData(Ystart >> 8);
+ SPI_WriteComm(0x2b01);
+ SPI_WriteData(Ystart & 0xff);
+ SPI_WriteComm(0x2b02);
+ SPI_WriteData(Yend >> 8);
+ SPI_WriteComm(0x2b03);
+ SPI_WriteData(Yend & 0xff);
+
+ SPI_WriteComm(0x2c00);
+ // for(Xstart=0;Xstart<1000;Xstart++)SPI_WriteData(0x55);
+}
+void Lcd_Initialize(void)
+{
+ LCD_SPI_CS(1);
+ LCD_delay(20);
+ LCD_SPI_CS(0);
+ LCD_Reset();
+
+ //ENABLE PAGE 1
+ SPI_WriteComm(0xF000);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xF001);
+ SPI_WriteData(0xAA);
+ SPI_WriteComm(0xF002);
+ SPI_WriteData(0x52);
+ SPI_WriteComm(0xF003);
+ SPI_WriteData(0x08);
+ SPI_WriteComm(0xF004);
+ SPI_WriteData(0x01);
+
+ //GAMMA SETING RED
+ SPI_WriteComm(0xD100);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD101);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD102);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD103);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD104);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD105);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD106);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD107);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD108);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD109);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD10A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD10B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD10C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD10D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD10E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD10F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD110);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD111);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD112);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD113);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD114);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD115);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD116);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD117);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD118);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD119);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD11A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD11B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD11C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD11D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD11E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD11F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD120);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD121);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD122);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD123);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD124);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD125);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD126);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD127);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD128);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD129);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD12A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD12B);
+ SPI_WriteData(0x4A);
+ SPI_WriteComm(0xD12C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD12D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD12E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD12F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD130);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD131);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD132);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD133);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD134);
+ SPI_WriteData(0xff);
+ //GAMMA SETING GREEN
+ SPI_WriteComm(0xD200);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD201);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD202);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD203);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD204);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD205);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD206);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD207);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD208);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD209);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD20A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD20B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD20C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD20D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD20E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD20F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD210);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD211);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD212);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD213);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD214);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD215);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD216);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD217);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD218);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD219);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD21A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD21B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD21C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD21D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD21E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD21F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD220);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD221);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD222);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD223);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD224);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD225);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD226);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD227);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD228);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD229);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD22A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD22B);
+ SPI_WriteData(0x4a);
+ SPI_WriteComm(0xD22C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD22D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD22E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD22F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD230);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD231);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD232);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD233);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD234);
+ SPI_WriteData(0xff);
+
+ //GAMMA SETING BLUE
+ SPI_WriteComm(0xD300);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD301);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD302);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD303);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD304);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD305);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD306);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD307);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD308);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD309);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD30A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD30B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD30C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD30D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD30E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD30F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD310);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD311);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD312);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD313);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD314);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD315);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD316);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD317);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD318);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD319);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD31A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD31B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD31C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD31D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD31E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD31F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD320);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD321);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD322);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD323);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD324);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD325);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD326);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD327);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD328);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD329);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD32A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD32B);
+ SPI_WriteData(0x4A);
+ SPI_WriteComm(0xD32C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD32D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD32E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD32F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD330);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD331);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD332);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD333);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD334);
+ SPI_WriteData(0xff);
+
+ //GAMMA SETING RED
+ SPI_WriteComm(0xD400);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD401);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD402);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD403);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD404);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD405);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD406);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD407);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD408);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD409);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD40A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD40B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD40C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD40D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD40E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD40F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD410);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD411);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD412);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD413);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD414);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD415);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD416);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD417);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD418);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD419);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD41A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD41B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD41C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD41D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD41E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD41F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD420);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD421);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD422);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD423);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD424);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD425);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD426);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD427);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD428);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD429);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD42A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD42B);
+ SPI_WriteData(0x4A);
+ SPI_WriteComm(0xD42C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD42D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD42E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD42F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD430);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD431);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD432);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD433);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD434);
+ SPI_WriteData(0xff);
+
+ //GAMMA SETING GREEN
+ SPI_WriteComm(0xD500);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD501);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD502);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD503);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD504);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD505);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD506);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD507);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD508);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD509);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD50A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD50B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD50C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD50D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD50E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD50F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD510);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD511);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD512);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD513);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD514);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD515);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD516);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD517);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD518);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD519);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD51A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD51B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD51C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD51D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD51E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD51F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD520);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD521);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD522);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD523);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD524);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD525);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD526);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD527);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD528);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD529);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD52A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD52B);
+ SPI_WriteData(0x4a);
+ SPI_WriteComm(0xD52C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD52D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD52E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD52F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD530);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD531);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD532);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD533);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD534);
+ SPI_WriteData(0xff);
+
+ //GAMMA SETING BLUE
+ SPI_WriteComm(0xD600);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD601);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD602);
+ SPI_WriteData(0x1b);
+ SPI_WriteComm(0xD603);
+ SPI_WriteData(0x44);
+ SPI_WriteComm(0xD604);
+ SPI_WriteData(0x62);
+ SPI_WriteComm(0xD605);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xD606);
+ SPI_WriteData(0x7b);
+ SPI_WriteComm(0xD607);
+ SPI_WriteData(0xa1);
+ SPI_WriteComm(0xD608);
+ SPI_WriteData(0xc0);
+ SPI_WriteComm(0xD609);
+ SPI_WriteData(0xee);
+ SPI_WriteComm(0xD60A);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD60B);
+ SPI_WriteData(0x10);
+ SPI_WriteComm(0xD60C);
+ SPI_WriteData(0x2c);
+ SPI_WriteComm(0xD60D);
+ SPI_WriteData(0x43);
+ SPI_WriteComm(0xD60E);
+ SPI_WriteData(0x57);
+ SPI_WriteComm(0xD60F);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD610);
+ SPI_WriteData(0x68);
+ SPI_WriteComm(0xD611);
+ SPI_WriteData(0x78);
+ SPI_WriteComm(0xD612);
+ SPI_WriteData(0x87);
+ SPI_WriteComm(0xD613);
+ SPI_WriteData(0x94);
+ SPI_WriteComm(0xD614);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD615);
+ SPI_WriteData(0xa0);
+ SPI_WriteComm(0xD616);
+ SPI_WriteData(0xac);
+ SPI_WriteComm(0xD617);
+ SPI_WriteData(0xb6);
+ SPI_WriteComm(0xD618);
+ SPI_WriteData(0xc1);
+ SPI_WriteComm(0xD619);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xD61A);
+ SPI_WriteData(0xcb);
+ SPI_WriteComm(0xD61B);
+ SPI_WriteData(0xcd);
+ SPI_WriteComm(0xD61C);
+ SPI_WriteData(0xd6);
+ SPI_WriteComm(0xD61D);
+ SPI_WriteData(0xdf);
+ SPI_WriteComm(0xD61E);
+ SPI_WriteData(0x95);
+ SPI_WriteComm(0xD61F);
+ SPI_WriteData(0xe8);
+ SPI_WriteComm(0xD620);
+ SPI_WriteData(0xf1);
+ SPI_WriteComm(0xD621);
+ SPI_WriteData(0xfa);
+ SPI_WriteComm(0xD622);
+ SPI_WriteData(0x02);
+ SPI_WriteComm(0xD623);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD624);
+ SPI_WriteData(0x0b);
+ SPI_WriteComm(0xD625);
+ SPI_WriteData(0x13);
+ SPI_WriteComm(0xD626);
+ SPI_WriteData(0x1d);
+ SPI_WriteComm(0xD627);
+ SPI_WriteData(0x26);
+ SPI_WriteComm(0xD628);
+ SPI_WriteData(0xaa);
+ SPI_WriteComm(0xD629);
+ SPI_WriteData(0x30);
+ SPI_WriteComm(0xD62A);
+ SPI_WriteData(0x3c);
+ SPI_WriteComm(0xD62B);
+ SPI_WriteData(0x4A);
+ SPI_WriteComm(0xD62C);
+ SPI_WriteData(0x63);
+ SPI_WriteComm(0xD62D);
+ SPI_WriteData(0xea);
+ SPI_WriteComm(0xD62E);
+ SPI_WriteData(0x79);
+ SPI_WriteComm(0xD62F);
+ SPI_WriteData(0xa6);
+ SPI_WriteComm(0xD630);
+ SPI_WriteData(0xd0);
+ SPI_WriteComm(0xD631);
+ SPI_WriteData(0x20);
+ SPI_WriteComm(0xD632);
+ SPI_WriteData(0x0f);
+ SPI_WriteComm(0xD633);
+ SPI_WriteData(0x8e);
+ SPI_WriteComm(0xD634);
+ SPI_WriteData(0xff);
+
+ //AVDD VOLTAGE SETTING
+ SPI_WriteComm(0xB000);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xB001);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xB002);
+ SPI_WriteData(0x05);
+ //AVEE VOLTAGE SETTING
+ SPI_WriteComm(0xB100);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xB101);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xB102);
+ SPI_WriteData(0x05);
+
+ //AVDD Boosting
+ SPI_WriteComm(0xB600);
+ SPI_WriteData(0x34);
+ SPI_WriteComm(0xB601);
+ SPI_WriteData(0x34);
+ SPI_WriteComm(0xB603);
+ SPI_WriteData(0x34);
+ //AVEE Boosting
+ SPI_WriteComm(0xB700);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB701);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB702);
+ SPI_WriteData(0x24);
+ //VCL Boosting
+ SPI_WriteComm(0xB800);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB801);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB802);
+ SPI_WriteData(0x24);
+ //VGLX VOLTAGE SETTING
+ SPI_WriteComm(0xBA00);
+ SPI_WriteData(0x14);
+ SPI_WriteComm(0xBA01);
+ SPI_WriteData(0x14);
+ SPI_WriteComm(0xBA02);
+ SPI_WriteData(0x14);
+ //VCL Boosting
+ SPI_WriteComm(0xB900);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB901);
+ SPI_WriteData(0x24);
+ SPI_WriteComm(0xB902);
+ SPI_WriteData(0x24);
+ //Gamma Voltage
+ SPI_WriteComm(0xBc00);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xBc01);
+ SPI_WriteData(0xa0); //vgmp=5.0
+ SPI_WriteComm(0xBc02);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xBd00);
+ SPI_WriteData(0x00);
+ SPI_WriteComm(0xBd01);
+ SPI_WriteData(0xa0); //vgmn=5.0
+ SPI_WriteComm(0xBd02);
+ SPI_WriteData(0x00);
+ //VCOM Setting
+ SPI_WriteComm(0xBe01);
+ SPI_WriteData(0x3d); //3
+ //ENABLE PAGE 0
+ SPI_WriteComm(0xF000);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xF001);
+ SPI_WriteData(0xAA);
+ SPI_WriteComm(0xF002);
+ SPI_WriteData(0x52);
+ SPI_WriteComm(0xF003);
+ SPI_WriteData(0x08);
+ SPI_WriteComm(0xF004);
+ SPI_WriteData(0x00);
+ //Vivid Color Function Control
+ SPI_WriteComm(0xB400);
+ SPI_WriteData(0x10);
+ //Z-INVERSION
+ SPI_WriteComm(0xBC00);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xBC01);
+ SPI_WriteData(0x05);
+ SPI_WriteComm(0xBC02);
+ SPI_WriteData(0x05);
+
+ //*************** add on 20111021**********************//
+ SPI_WriteComm(0xB700);
+ SPI_WriteData(0x22); //GATE EQ CONTROL
+ SPI_WriteComm(0xB701);
+ SPI_WriteData(0x22); //GATE EQ CONTROL
+
+ SPI_WriteComm(0xC80B);
+ SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL
+ SPI_WriteComm(0xC80C);
+ SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL
+ SPI_WriteComm(0xC80F);
+ SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL
+ SPI_WriteComm(0xC810);
+ SPI_WriteData(0x2A); //DISPLAY TIMING CONTROL
+ //*************** add on 20111021**********************//
+ //PWM_ENH_OE =1
+ SPI_WriteComm(0xd000);
+ SPI_WriteData(0x01);
+ //DM_SEL =1
+ SPI_WriteComm(0xb300);
+ SPI_WriteData(0x10);
+ //VBPDA=07h
+ SPI_WriteComm(0xBd02);
+ SPI_WriteData(0x07);
+ //VBPDb=07h
+ SPI_WriteComm(0xBe02);
+ SPI_WriteData(0x07);
+ //VBPDc=07h
+ SPI_WriteComm(0xBf02);
+ SPI_WriteData(0x07);
+ //ENABLE PAGE 2
+ SPI_WriteComm(0xF000);
+ SPI_WriteData(0x55);
+ SPI_WriteComm(0xF001);
+ SPI_WriteData(0xAA);
+ SPI_WriteComm(0xF002);
+ SPI_WriteData(0x52);
+ SPI_WriteComm(0xF003);
+ SPI_WriteData(0x08);
+ SPI_WriteComm(0xF004);
+ SPI_WriteData(0x02);
+ //SDREG0 =0
+ SPI_WriteComm(0xc301);
+ SPI_WriteData(0xa9);
+ //DS=14
+ SPI_WriteComm(0xfe01);
+ SPI_WriteData(0x94);
+ //OSC =60h
+ SPI_WriteComm(0xf600);
+ SPI_WriteData(0x60);
+ //TE ON
+ SPI_WriteComm(0x3500);
+ SPI_WriteData(0x00);
+
+ SPI_WriteComm(0x3600);
+ SPI_WriteData(0x0048);
+ SPI_WriteComm(0x1100);
+ LCD_delay(120);
+
+ SPI_WriteComm(0x2900);
+
+ SPI_WriteComm(0x2c00);
+ SPI_WriteComm(0x3c00);
+}
+void LCD_Initial(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2) //LCD初始化函数
+{
+ GPIO_RGB_INIT(); //初始化液晶屏相关GPIO
+ LCD_Reset(); //复位液晶屏
+
+ LTDC_Clock_Set();
+ Set_LCD_Timing_to_LTDC(LTDC_Buf1, LTDC_Buf2);
+ Lcd_Initialize();
+ Lcd_Light_ON; //打开背光
+}
+
+
+
+/**********************************************
+函数名：Lcd矩形填充函数
+
+入口参数：xStart x方向的起始点
+ ySrart y方向的终止点
+ xLong 要选定矩形的x方向长度
+ yLong 要选定矩形的y方向长度
+返回值：无
+***********************************************/
+// void Lcd_ColorBox(rt_uint16_t xStart, rt_uint16_t yStart, rt_uint16_t xLong, rt_uint16_t yLong, rt_uint32_t Color)
+// {
+// rt_uint16_t i, j;
+// rt_uint32_t temp;
+// temp = YSIZE_PHYS * xStart;
+// for (i = 0; i < yLong; i++)
+// {
+// for (j = 0; j < xLong; j++)
+// LTDC_Buf[yStart + i + YSIZE_PHYS * j + temp] = Color;
+// }
+
+// // rt_uint16_t i,j;
+// // rt_uint32_t temp;
+// // temp = XSIZE_PHYS*yStart;
+// // for(i=0;i<yLong;i++)
+// // {
+// // for(j=0;j<xLong;j++)
+// // LTDC_Buf[xStart+j+XSIZE_PHYS*i+temp]=Color;
+// // }
+// }
+
+/******************************************
+函数名：Lcd图像填充
+功能：向Lcd指定位置填充图像
+入口参数：
+ (x,y): 图片左上角起始坐标
+ (pic_H,pic_V): 图片的宽高
+ pic 指向存储图片数组的指针
+LCD_Fill_Pic(400,100,320,480,(rt_uint32_t*)gImage_MM_T035);
+******************************************/
+// void LCD_Fill_Pic(rt_uint16_t x, rt_uint16_t y, rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t *pic)
+// {
+// rt_uint16_t i, j;
+// rt_uint32_t Xstart, k = 0;
+// Xstart = YSIZE_PHYS * x;
+// for (i = 0; i < pic_V; i++)
+// {
+// for (j = 0; j < pic_H; j++)
+// LTDC_Buf[Xstart + i + YSIZE_PHYS * j + y] = pic[k++];
+// }
+
+// // rt_uint16_t i,j;
+// // rt_uint32_t Ystart,k=0;
+// // Ystart = YSIZE_PHYS*y;
+// // for(i=0;i<pic_V;i++)
+// // {
+// // for(j=0;j<pic_H;j++)
+// // LTDC_Buf[x+j+YSIZE_PHYS*i+Ystart]=pic[k++];
+// // }
+// }
+//=============== 在x，y 坐标上打一个颜色为Color的点 ===============
+// void DrawPixel(rt_uint16_t x, rt_uint16_t y, int Color)
+// {
+// LTDC_Buf[y + YSIZE_PHYS * x] = Color;
+// // LTDC_Buf[x+XSIZE_PHYS*y] = Color;
+// }
+/**********8*16字体 ASCII码 显示*************
+(x,y): 显示字母的起始坐标
+num: 要显示的字符:" "--->"~"
+fColor 前景色
+bColor 背景色
+flag: 有背景色(1)无背景色(0)
+*********************************************/
+// void SPILCD_ShowChar(unsigned short x, unsigned short y, unsigned char num, unsigned int fColor, unsigned int bColor, unsigned char flag)
+// {
+// unsigned char temp;
+// unsigned int pos, i, j;
+
+// num = num - ' '; //得到偏移后的值
+// i = num * 16;
+// for (pos = 0; pos < 16; pos++)
+// {
+// temp = nAsciiDot[i + pos]; //调通调用ASCII字体
+// for (j = 0; j < 8; j++)
+// {
+// if (temp & 0x80)
+// DrawPixel(x + j, y, fColor);
+// else if (flag)
+// DrawPixel(x + j, y, bColor); //如果背景色标志flag为1
+// temp <<= 1;
+// }
+// y++;
+// }
+// }
+
+/**********写一个16x16的汉字*****************
+(x,y): 显示汉字的起始坐标
+c[2]: 要显示的汉字
+fColor 前景色
+bColor 背景色
+flag: 有背景色(1)无背景色(0)
+*********************************************/
+// void PutGB1616(unsigned short x, unsigned short y, unsigned char c[2], unsigned int fColor, unsigned int bColor, unsigned char flag)
+// {
+// unsigned int i, j, k;
+// unsigned short m;
+// for (k = 0; k < 64; k++)
+// { //64标示自建汉字库中的个数，循环查询内码
+// if ((codeGB_16[k].Index[0] == c[0]) && (codeGB_16[k].Index[1] == c[1]))
+// {
+// for (i = 0; i < 32; i++)
+// {
+// m = codeGB_16[k].Msk[i];
+// for (j = 0; j < 8; j++)
+// {
+// if ((m & 0x80) == 0x80)
+// {
+// DrawPixel(x + j, y, fColor);
+// }
+// else
+// {
+// if (flag)
+// DrawPixel(x + j, y, bColor);
+// }
+// m = m << 1;
+// }
+// if (i % 2)
+// {
+// y++;
+// x = x - 8;
+// }
+// else
+// x = x + 8;
+// }
+// }
+// }
+// }
+/**********显示一串字*****************
+(x,y): 字符串的起始坐标
+*s: 要显示的字符串指针
+fColor 前景色
+bColor 背景色
+flag: 有背景色(1)无背景色(0)
+*********************************************/
+// void LCD_PutString(unsigned short x, unsigned short y, char *s, unsigned int fColor, unsigned int bColor, unsigned char flag)
+// {
+// unsigned char l = 0;
+// while (*s)
+// {
+// if (*s < 0x80)
+// {
+// SPILCD_ShowChar(x + l * 8, y, *s, fColor, bColor, flag);
+// s++;
+// l++;
+// }
+// else
+// {
+// PutGB1616(x + l * 8, y, (unsigned char *)s, fColor, bColor, flag);
+// s += 2;
+// l += 2;
+// }
+// }
+// }
diff --git a/bsp/tkm32F499/drivers/lcd/lcd.h b/bsp/tkm32F499/drivers/lcd/lcd.h
new file mode 100644
index 0000000000..ba925eb896
--- /dev/null
+++ b/bsp/tkm32F499/drivers/lcd/lcd.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-14 spaceman first version
+ */
+
+#include <board.h>
+
+// #define XSIZE_PHYS 800
+// #define YSIZE_PHYS 480
+// extern __align(256) rt_uint32_t LTDC_Buf[XSIZE_PHYS*YSIZE_PHYS];
+#define LCD_SPI_CS(a) \
+ if (a) \
+ GPIOB->BSRR = GPIO_Pin_11; \
+ else \
+ GPIOB->BRR = GPIO_Pin_11;
+#define SPI_DCLK(a) \
+ if (a) \
+ GPIOB->BSRR = GPIO_Pin_9; \
+ else \
+ GPIOB->BRR = GPIO_Pin_9;
+#define SPI_SDA(a) \
+ if (a) \
+ GPIOB->BSRR = GPIO_Pin_0; \
+ else \
+ GPIOB->BRR = GPIO_Pin_0;
+
+#define LCD_RST(a) \
+ if (a) \
+ GPIOD->BSRR = GPIO_Pin_6; \
+ else \
+ GPIOD->BRR = GPIO_Pin_6;
+#define Set_Rst GPIOD->BSRR = GPIO_Pin_6
+#define Clr_Rst GPIOD->BRR = GPIO_Pin_6
+#define Lcd_Light_ON GPIOD->BSRR = GPIO_Pin_8 //PD8为高电平 背光打开
+#define Lcd_Light_OFF GPIOD->BRR = GPIO_Pin_8 //PD8为低电平 背光关闭
+
+//************* 24位色（1600万色）定义 *************//
+#define White 0xFFFFFF
+#define Black 0x000000
+#define Blue 0xFF0000
+#define Blue2 0xFF3F3F
+#define Red 0x0000FF
+#define Magenta 0xFF00FF
+#define Green 0x00FF00
+#define Cyan 0xFFFF00
+#define Yellow 0x00FFFF
+
+//************* 16位色定义 *************//
+//#define White 0xFFFF
+//#define Black 0x0000
+//#define Blue 0x001F
+//#define Blue2 0x051F
+//#define Red 0xF800
+//#define Magenta 0xF81F
+//#define Green 0x07E0
+//#define Cyan 0x7FFF
+//#define Yellow 0xFFE0
+
+
+
+void LCD_Initial(rt_uint32_t LTDC_Buf1, rt_uint32_t LTDC_Buf2); //LCD初始化函数
+// volatile void LCD_delay(volatile int time);
+// void WriteComm(unsigned char CMD);
+// void WriteData(rt_uint32_t dat);
+// void LCD_WR_REG(rt_uint16_t Index,rt_uint16_t CongfigTemp);
+// void Lcd_ColorBox(rt_uint16_t xStart,rt_uint16_t yStart,rt_uint16_t xLong,rt_uint16_t yLong,rt_uint32_t Color);
+//void SPILCD_DrawLine(unsigned short x1,unsigned short y1,unsigned short x2,unsigned short y2,unsigned short color);
+//void SPILCD_ShowChar(unsigned short x,unsigned short y,unsigned char num, unsigned int fColor, unsigned int bColor,unsigned char flag) ;
+// void LCD_PutString(unsigned short x, unsigned short y, char *s, unsigned int fColor, unsigned int bColor,unsigned char flag);
+// void LCD_Fill_Pic(rt_uint16_t x, rt_uint16_t y,rt_uint16_t pic_H, rt_uint16_t pic_V, rt_uint32_t* pic);
diff --git a/bsp/tkm32F499/drivers/lcd_port.h b/bsp/tkm32F499/drivers/lcd_port.h
new file mode 100644
index 0000000000..e11e757b93
--- /dev/null
+++ b/bsp/tkm32F499/drivers/lcd_port.h
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2006-2021, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-10-14 spaceman first version
+ */
+
+#ifndef __LCD_PORT_H__
+#define __LCD_PORT_H__
+
+/* TK043F1508 RM68120 5 inch screen, 800 * 480 */
+#define LCD_WIDTH 800
+#define LCD_HEIGHT 480
+#define LCD_BITS_PER_PIXEL 32
+#define LCD_BUF_SIZE (LCD_WIDTH * LCD_HEIGHT * LCD_BITS_PER_PIXEL / 8)
+#define LCD_PIXEL_FORMAT RTGRAPHIC_PIXEL_FORMAT_RGB565
+
+#define LCD_HSYNC_WIDTH 96
+#define LCD_VSYNC_HEIGHT 2
+#define LCD_HBP 10
+#define LCD_VBP 10
+#define LCD_HFP 10
+#define LCD_VFP 10
+
+#define LCD_BACKLIGHT_USING_GPIO
+#define LCD_BL_GPIO_NUM -1
+#define LCD_DISP_GPIO_NUM -1
+
+/* TK043F1508 RM68120 5 inch screen, 800 * 480 */
+
+#endif /* __LCD_PORT_H__ */
diff --git a/bsp/tkm32F499/drivers/linker_scripts/link.icf b/bsp/tkm32F499/drivers/linker_scripts/link.icf
new file mode 100644
index 0000000000..a2e05e53a6
--- /dev/null
+++ b/bsp/tkm32F499/drivers/linker_scripts/link.icf
@@ -0,0 +1,34 @@
+/*###ICF### Section handled by ICF editor, don't touch! ****/
+/*-Editor annotation file-*/
+/* IcfEditorFile="$TOOLKIT_DIR$\config\ide\IcfEditor\cortex_v1_4.xml" */
+/*-Specials-*/
+define symbol __ICFEDIT_intvec_start__ = 0x08000000;
+/*-Memory Regions-*/
+define symbol __ICFEDIT_region_IROM_start__ = 0x08000000;
+define symbol __ICFEDIT_region_IROM_end__ = 0x0001FFFF;
+define symbol __ICFEDIT_region_IRAM_start__ = 0x20000000;
+define symbol __ICFEDIT_region_IRAM_end__ = 0x20004FFF;
+/*-Sizes-*/
+define symbol __ICFEDIT_size_cstack__ = 0x0800;
+define symbol __ICFEDIT_size_proc_stack__ = 0x0;
+define symbol __ICFEDIT_size_heap__ = 0x0800;
+/**** End of ICF editor section. ###ICF###*/
+define memory mem with size = 4G;
+define region IROM_region = mem:[from __ICFEDIT_region_IROM_start__ to __ICFEDIT_region_IROM_end__];
+define region IRAM_region = mem:[from __ICFEDIT_region_IRAM_start__ to __ICFEDIT_region_IRAM_end__];
+define block CSTACK with alignment = 8, size = __ICFEDIT_size_cstack__ { };
+define block PROC_STACK with alignment = 8, size = __ICFEDIT_size_proc_stack__ { };
+define block HEAP with alignment = 8, size = __ICFEDIT_size_heap__ { };
+
+do not initialize { section .noinit };
+initialize by copy { readwrite };
+if (isdefinedsymbol(__USE_DLIB_PERTHREAD))
+{
+ // Required in a multi-threaded application
+ initialize by copy with packing = none { section __DLIB_PERTHREAD };
+}
+
+place at address mem:__ICFEDIT_intvec_start__ { readonly section .intvec };
+
+place in IROM_region { readonly };
+place in IRAM_region { readwrite, block CSTACK, block PROC_STACK, block HEAP };
diff --git a/bsp/tkm32F499/drivers/linker_scripts/link.lds b/bsp/tkm32F499/drivers/linker_scripts/link.lds
new file mode 100644
index 0000000000..aad42bdb39
--- /dev/null
+++ b/bsp/tkm32F499/drivers/linker_scripts/link.lds
@@ -0,0 +1,137 @@
+/* Program Entry, set to mark it as "used" and avoid gc */
+MEMORY
+{
+ CODE (rx) : ORIGIN = 0x08000000, LENGTH = 128k /* 128KB flash */
+ DATA (rw) : ORIGIN = 0x20000000, LENGTH = 20k /* 8K sram */
+}
+ENTRY(Reset_Handler)
+_system_stack_size = 0x200;
+
+SECTIONS
+{
+ .text :
+ {
+ . = ALIGN(4);
+ _stext = .;
+ KEEP(*(.isr_vector)) /* Startup code */
+ . = ALIGN(4);
+ *(.text) /* remaining code */
+ *(.text.*) /* remaining code */
+ *(.rodata) /* read-only data (constants) */
+ *(.rodata*)
+ *(.glue_7)
+ *(.glue_7t)
+ *(.gnu.linkonce.t*)
+
+ /* section information for finsh shell */
+ . = ALIGN(4);
+ __fsymtab_start = .;
+ KEEP(*(FSymTab))
+ __fsymtab_end = .;
+ . = ALIGN(4);
+ __vsymtab_start = .;
+ KEEP(*(VSymTab))
+ __vsymtab_end = .;
+ . = ALIGN(4);
+
+ /* section information for initial. */
+ . = ALIGN(4);
+ __rt_init_start = .;
+ KEEP(*(SORT(.rti_fn*)))
+ __rt_init_end = .;
+ . = ALIGN(4);
+
+ . = ALIGN(4);
+ _etext = .;
+ } > CODE = 0
+
+ /* .ARM.exidx is sorted, so has to go in its own output section. */
+ __exidx_start = .;
+ .ARM.exidx :
+ {
+ *(.ARM.exidx* .gnu.linkonce.armexidx.*)
+
+ /* This is used by the startup in order to initialize the .data secion */
+ _sidata = .;
+ } > CODE
+ __exidx_end = .;
+
+ /* .data section which is used for initialized data */
+
+ .data : AT (_sidata)
+ {
+ . = ALIGN(4);
+ /* This is used by the startup in order to initialize the .data secion */
+ _sdata = . ;
+
+ *(.data)
+ *(.data.*)
+ *(.gnu.linkonce.d*)
+
+ . = ALIGN(4);
+ /* This is used by the startup in order to initialize the .data secion */
+ _edata = . ;
+ } >DATA
+
+ .stack :
+ {
+ . = . + _system_stack_size;
+ . = ALIGN(4);
+ _estack = .;
+ } >DATA
+
+ __bss_start = .;
+ .bss :
+ {
+ . = ALIGN(4);
+ /* This is used by the startup in order to initialize the .bss secion */
+ _sbss = .;
+
+ *(.bss)
+ *(.bss.*)
+ *(COMMON)
+
+ . = ALIGN(4);
+ /* This is used by the startup in order to initialize the .bss secion */
+ _ebss = . ;
+
+ *(.bss.init)
+ } > DATA
+ __bss_end = .;
+
+ _end = .;
+
+ /* Stabs debugging sections. */
+ .stab 0 : { *(.stab) }
+ .stabstr 0 : { *(.stabstr) }
+ .stab.excl 0 : { *(.stab.excl) }
+ .stab.exclstr 0 : { *(.stab.exclstr) }
+ .stab.index 0 : { *(.stab.index) }
+ .stab.indexstr 0 : { *(.stab.indexstr) }
+ .comment 0 : { *(.comment) }
+ /* DWARF debug sections.
+ * Symbols in the DWARF debugging sections are relative to the beginning
+ * of the section so we begin them at 0. */
+ /* DWARF 1 */
+ .debug 0 : { *(.debug) }
+ .line 0 : { *(.line) }
+ /* GNU DWARF 1 extensions */
+ .debug_srcinfo 0 : { *(.debug_srcinfo) }
+ .debug_sfnames 0 : { *(.debug_sfnames) }
+ /* DWARF 1.1 and DWARF 2 */
+ .debug_aranges 0 : { *(.debug_aranges) }
+ .debug_pubnames 0 : { *(.debug_pubnames) }
+ /* DWARF 2 */
+ .debug_info 0 : { *(.debug_info .gnu.linkonce.wi.*) }
+ .debug_abbrev 0 : { *(.debug_abbrev) }
+ .debug_line 0 : { *(.debug_line) }
+ .debug_frame 0 : { *(.debug_frame) }
+ .debug_str 0 : { *(.debug_str) }
+ .debug_loc 0 : { *(.debug_loc) }
+ .debug_macinfo 0 : { *(.debug_macinfo) }
+ /* SGI/MIPS DWARF 2 extensions */
+ .debug_weaknames 0 : { *(.debug_weaknames) }
+ .debug_funcnames 0 : { *(.debug_funcnames) }
+ .debug_typenames 0 : { *(.debug_typenames) }
+ .debug_varnames 0 : { *(.debug_varnames) }
+}
diff --git a/bsp/tkm32F499/drivers/linker_scripts/link.sct b/bsp/tkm32F499/drivers/linker_scripts/link.sct
new file mode 100644
index 0000000000..b2d98ef44a
--- /dev/null
+++ b/bsp/tkm32F499/drivers/linker_scripts/link.sct
@@ -0,0 +1,16 @@
+; *************************************************************
+; *** Scatter-Loading Description File generated by uVision ***
+; *************************************************************
+
+LR_IROM1 0x70020000 0x00200000 { ; load region size_region
+ ER_IROM1 0x70020000 0x00200000 { ; load address = execution address
+ *.o (RESET, +First)
+ *(InRoot$$Sections)
+ .ANY (+RO)
+ .ANY (+XO)
+ }
+ RW_IRAM1 0x70220000 0x005DFFFF { ; RW data
+ .ANY (+RW +ZI)
+ }
+}
+
generated by cgit v1.3.1 (git 2.54.0) at 2026-10-30 10:39:45 +0000