summaryrefslogtreecommitdiff
path: root/bsp/synwit/libraries/SWM341_drivers
diff options
context:
space:
mode:
authorXian Wu <[email protected]>2023-12-27 18:41:52 +0800
committerGitHub <[email protected]>2023-12-27 18:41:52 +0800
commit6360253c129afcb91d34770cb253eea8d837e66a (patch)
tree065167006028882ff4d57208252d1e0ce9f3b4e4 /bsp/synwit/libraries/SWM341_drivers
parent7b4592c2d15bf90c1958bdbc840ea4df3d97cd96 (diff)
Synwit MCU 采用新的 BSP 框架,将 BSP 与 libraries 分离 (#8432)
Diffstat (limited to 'bsp/synwit/libraries/SWM341_drivers')
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/SConscript53
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_adc.c326
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_adc.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_can.c565
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_can.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_crypto.c316
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_crypto.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_dac.c99
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_dac.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_gpio.c624
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_gpio.h28
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.c615
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_log.h27
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_pwm.c408
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_pwm.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.c230
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.h24
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_rtc.c167
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_rtc.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_sdio.c715
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_sdio.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_sdram.c75
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_sdram.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.c219
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_spi.c375
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_spi.h20
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_uart.c366
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_uart.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_wdt.c104
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/drv_wdt.h18
-rw-r--r--bsp/synwit/libraries/SWM341_drivers/rgb_lcd_port.h35
33 files changed, 5607 insertions, 0 deletions
diff --git a/bsp/synwit/libraries/SWM341_drivers/SConscript b/bsp/synwit/libraries/SWM341_drivers/SConscript
new file mode 100644
index 0000000000..8aacb2087f
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/SConscript
@@ -0,0 +1,53 @@
+from building import *
+
+cwd = GetCurrentDir()
+src = []
+
+if GetDepend(['RT_USING_SERIAL']):
+ src += ['drv_uart.c']
+
+if GetDepend(['RT_USING_PIN']):
+ src += ['drv_gpio.c']
+
+if GetDepend(['RT_USING_ADC']):
+ src += ['drv_adc.c']
+
+if GetDepend(['RT_USING_DAC']):
+ src += ['drv_dac.c']
+
+if GetDepend(['RT_USING_CAN']):
+ src += ['drv_can.c']
+
+if GetDepend(['RT_USING_HWTIMER']):
+ src += ['drv_hwtimer.c']
+
+if GetDepend(['RT_USING_I2C']):
+ src += ['drv_soft_i2c.c']
+
+if GetDepend(['RT_USING_PWM']):
+ src += ['drv_pwm.c']
+
+if GetDepend(['RT_USING_RTC']):
+ src += ['drv_rtc.c']
+
+if GetDepend(['RT_USING_SPI']):
+ src += ['drv_spi.c']
+
+if GetDepend(['RT_USING_WDT']):
+ src += ['drv_wdt.c']
+
+if GetDepend(['RT_USING_HWCRYPTO']):
+ src += ['drv_crypto.c']
+
+if GetDepend(['RT_USING_SDIO']):
+ src += ['drv_sdio.c']
+
+if GetDepend(['BSP_USING_SDRAM']):
+ src += ['drv_sdram.c']
+
+if GetDepend(['BSP_USING_RGB_LCD']):
+ src += ['drv_rgb_lcd.c']
+
+group = DefineGroup('Drivers', src, depend = [''], CPPPATH = [cwd])
+
+Return('group')
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_adc.c b/bsp/synwit/libraries/SWM341_drivers/drv_adc.c
new file mode 100644
index 0000000000..1bd06ac20d
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_adc.c
@@ -0,0 +1,326 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_adc.h"
+
+#ifdef RT_USING_ADC
+#ifdef BSP_USING_ADC
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.adc"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_ADC0) && !defined(BSP_USING_ADC1)
+#error "Please define at least one BSP_USING_ADCx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+#ifdef BSP_USING_ADC0
+#ifndef ADC0_CFG
+#define ADC0_CFG \
+ { \
+ .name = "adc0", \
+ .ADCx = ADC0, \
+ .ADC_initstruct.clk_src = ADC_CLKSRC_HRC_DIV8, \
+ .ADC_initstruct.samplAvg = ADC_AVG_SAMPLE1, \
+ .ADC_initstruct.EOC_IEn = 0, \
+ .ADC_initstruct.HalfIEn = 0, \
+ .ADC_SEQ_initstruct.trig_src = ADC_TRIGGER_SW, \
+ .ADC_SEQ_initstruct.conv_cnt = 1, \
+ .ADC_SEQ_initstruct.samp_tim = ADC_SAMPLE_1CLOCK, \
+ }
+#endif /* ADC0_CFG */
+#endif /* BSP_USING_ADC0 */
+
+#ifdef BSP_USING_ADC1
+#ifndef ADC1_CFG
+#define ADC1_CFG \
+ { \
+ .name = "adc1", \
+ .ADCx = ADC1, \
+ .ADC_initstruct.clk_src = ADC_CLKSRC_HRC_DIV8, \
+ .ADC_initstruct.samplAvg = ADC_AVG_SAMPLE1, \
+ .ADC_initstruct.EOC_IEn = 0, \
+ .ADC_initstruct.HalfIEn = 0, \
+ .ADC_SEQ_initstruct.trig_src = ADC_TRIGGER_SW, \
+ .ADC_SEQ_initstruct.conv_cnt = 1, \
+ .ADC_SEQ_initstruct.samp_tim = ADC_SAMPLE_1CLOCK, \
+ }
+#endif /* ADC1_CFG */
+#endif /* BSP_USING_ADC1 */
+
+struct swm_adc_cfg
+{
+ const char *name;
+ ADC_TypeDef *ADCx;
+ ADC_InitStructure ADC_initstruct;
+ ADC_SEQ_InitStructure ADC_SEQ_initstruct;
+};
+
+struct swm_adc_device
+{
+ struct swm_adc_cfg *adc_cfg;
+ struct rt_adc_device adc_device;
+};
+
+static struct swm_adc_cfg swm_adc_cfg[] =
+ {
+#ifdef BSP_USING_ADC0
+ ADC0_CFG,
+#endif
+#ifdef BSP_USING_ADC1
+ ADC1_CFG,
+#endif
+};
+
+static struct swm_adc_device adc_obj[sizeof(swm_adc_cfg) / sizeof(swm_adc_cfg[0])];
+
+static rt_uint32_t swm_adc_get_channel(rt_uint32_t channel)
+{
+ rt_uint32_t swm_channel = 0;
+
+ switch (channel)
+ {
+ case 0:
+ swm_channel = ADC_CH0;
+ break;
+ case 1:
+ swm_channel = ADC_CH1;
+ break;
+ case 2:
+ swm_channel = ADC_CH2;
+ break;
+ case 3:
+ swm_channel = ADC_CH3;
+ break;
+ case 4:
+ swm_channel = ADC_CH4;
+ break;
+ case 5:
+ swm_channel = ADC_CH5;
+ break;
+ case 6:
+ swm_channel = ADC_CH6;
+ break;
+ case 7:
+ swm_channel = ADC_CH7;
+ break;
+ case 8:
+ swm_channel = ADC_CH8;
+ break;
+ case 9:
+ swm_channel = ADC_CH9;
+ break;
+ case 10:
+ swm_channel = ADC_CH10;
+ break;
+ case 11:
+ swm_channel = ADC_CH11;
+ break;
+ }
+
+ return swm_channel;
+}
+
+static rt_err_t swm_adc_enabled(struct rt_adc_device *adc_device, rt_uint32_t channel, rt_bool_t enabled)
+{
+ uint32_t adc_chn;
+ struct swm_adc_cfg *adc_cfg;
+ RT_ASSERT(adc_device != RT_NULL);
+ adc_cfg = adc_device->parent.user_data;
+
+ if (channel < 12)
+ {
+ /* set swm ADC channel */
+ adc_chn = swm_adc_get_channel(channel);
+ }
+ else
+ {
+ LOG_E("ADC channel must be between 0 and 11.");
+ return -RT_ERROR;
+ }
+
+ if (enabled)
+ {
+ adc_cfg->ADCx->SEQCHN0 |= adc_chn;
+ }
+ else
+ {
+ adc_cfg->ADCx->SEQCHN0 &= ~adc_chn;
+ }
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_adc_convert(struct rt_adc_device *adc_device, rt_uint32_t channel, rt_uint32_t *value)
+{
+ uint32_t chn, val, adc_chn;
+ struct swm_adc_cfg *adc_cfg;
+ RT_ASSERT(adc_device != RT_NULL);
+ RT_ASSERT(value != RT_NULL);
+ adc_cfg = adc_device->parent.user_data;
+
+ if (channel < 12)
+ {
+ /* set swm ADC channel */
+ adc_chn = swm_adc_get_channel(channel);
+ }
+ else
+ {
+ LOG_E("ADC channel must be between 0 and 11.");
+ return -RT_ERROR;
+ }
+
+ *value = 0xFFFFFFFF;
+
+ /* start ADC */
+ ADC_Start(adc_cfg->ADCx, ADC_SEQ0);
+
+ /* Wait for the ADC to convert */
+ while (adc_cfg->ADCx->GO & ADC_GO_BUSY_Msk)
+ __NOP();
+ while ((adc_cfg->ADCx->SEQ[0].SR & ADC_SR_EMPTY_Msk) == 0)
+ {
+ val = ADC_Read(adc_cfg->ADCx, ADC_SEQ0, &chn);
+ if (chn == adc_chn)
+ {
+ *value = val;
+ }
+ }
+
+ if (*value == 0xFFFFFFFF)
+ {
+ LOG_E("ADC channel can not find.");
+ return -RT_ERROR;
+ }
+
+ return RT_EOK;
+}
+
+static const struct rt_adc_ops swm_adc_ops =
+ {
+ .enabled = swm_adc_enabled,
+ .convert = swm_adc_convert,
+};
+
+int swm_adc_init(void)
+{
+ int i = 0;
+ int result = RT_EOK;
+
+ for (i = 0; i < sizeof(swm_adc_cfg) / sizeof(swm_adc_cfg[0]); i++)
+ {
+ /* ADC init */
+ adc_obj[i].adc_cfg = &swm_adc_cfg[i];
+
+ if (adc_obj[i].adc_cfg->ADCx == ADC0)
+ {
+#ifdef BSP_USING_ADC0_CHN0
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH0;
+ PORT_Init(PORTC, PIN6, PORTC_PIN6_ADC0_CH0, 0); //PC.6 => ADC.CH0
+#endif
+#ifdef BSP_USING_ADC0_CHN1
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH1;
+ PORT_Init(PORTC, PIN5, PORTC_PIN5_ADC0_CH1, 0); //PC.5 => ADC.CH1
+#endif
+#ifdef BSP_USING_ADC0_CHN2
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH2;
+ PORT_Init(PORTC, PIN4, PORTC_PIN4_ADC0_CH2, 0); //PC.4 => ADC.CH2
+#endif
+#ifdef BSP_USING_ADC0_CHN3
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH3;
+ PORT_Init(PORTC, PIN3, PORTC_PIN3_ADC0_CH3, 0); //PC.3 => ADC.CH3
+#endif
+#ifdef BSP_USING_ADC0_CHN4
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH4;
+ PORT_Init(PORTC, PIN2, PORTC_PIN2_ADC0_CH4, 0); //PC.2 => ADC.CH4
+#endif
+#ifdef BSP_USING_ADC0_CHN5
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH5;
+ PORT_Init(PORTC, PIN1, PORTC_PIN1_ADC0_CH5, 0); //PC.1 => ADC.CH5
+#endif
+#ifdef BSP_USING_ADC0_CHN6
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH6;
+ PORT_Init(PORTC, PIN0, PORTC_PIN0_ADC0_CH6, 0); //PC.0 => ADC.CH6
+#endif
+#ifdef BSP_USING_ADC0_CHN7
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH7;
+ PORT_Init(PORTA, PIN15, PORTA_PIN15_ADC0_CH7, 0); //PA.15 => ADC.CH7
+#endif
+#ifdef BSP_USING_ADC0_CHN8
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH8;
+ PORT_Init(PORTA, PIN14, PORTA_PIN14_ADC0_CH8, 0); //PA.14 => ADC.CH8
+#endif
+#ifdef BSP_USING_ADC0_CHN9
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH9;
+ PORT_Init(PORTA, PIN13, PORTA_PIN13_ADC0_CH9, 0); //PA.13 => ADC.CH9
+#endif
+#ifdef BSP_USING_ADC0_CHN10
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH10;
+ PORT_Init(PORTA, PIN12, PORTA_PIN12_ADC0_CH10, 0); //PA.12 => ADC.CH10
+#endif
+#ifdef BSP_USING_ADC0_CHN11
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH11;
+ PORT_Init(PORTA, PIN10, PORTA_PIN10_ADC0_CH11, 0); //PA.10 => ADC.CH11
+#endif
+ }
+ else if (adc_obj[i].adc_cfg->ADCx == ADC1)
+ {
+#ifdef BSP_USING_ADC1_CHN0
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH0;
+ PORT_Init(PORTD, PIN1, PORTD_PIN1_ADC1_CH0, 0); //PD.1 => ADC1.CH0
+#endif
+#ifdef BSP_USING_ADC1_CHN1
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH1;
+ PORT_Init(PORTD, PIN0, PORTD_PIN0_ADC1_CH1, 0); //PD.0 => ADC1.CH1
+#endif
+#ifdef BSP_USING_ADC1_CHN2
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH2;
+ PORT_Init(PORTC, PIN13, PORTC_PIN13_ADC1_CH2, 0); //PC.13 => ADC1.CH2
+#endif
+#ifdef BSP_USING_ADC1_CHN3
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH3;
+ PORT_Init(PORTC, PIN12, PORTC_PIN12_ADC1_CH3, 0); //PC.12 => ADC1.CH3
+#endif
+#ifdef BSP_USING_ADC1_CHN4
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH4;
+ PORT_Init(PORTC, PIN11, PORTC_PIN11_ADC1_CH4, 0); //PC.11 => ADC1.CH4
+#endif
+#ifdef BSP_USING_ADC1_CHN5
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH5;
+ PORT_Init(PORTC, PIN10, PORTC_PIN10_ADC1_CH5, 0); //PC.10 => ADC1.CH5
+#endif
+#ifdef BSP_USING_ADC1_CHN6
+ adc_obj[i].adc_cfg->ADC_SEQ_initstruct.channels |= ADC_CH6;
+ PORT_Init(PORTC, PIN9, PORTC_PIN9_ADC1_CH6, 0); //PC.9 => ADC1.CH6
+#endif
+ }
+
+ ADC_Init(adc_obj[i].adc_cfg->ADCx, &(adc_obj[i].adc_cfg->ADC_initstruct));
+ ADC_SEQ_Init(adc_obj[i].adc_cfg->ADCx, ADC_SEQ0, &(adc_obj[i].adc_cfg->ADC_SEQ_initstruct));
+ ADC_Open(adc_obj[i].adc_cfg->ADCx);
+ ADC_Calibrate(adc_obj[i].adc_cfg->ADCx);
+
+ result = rt_hw_adc_register(&adc_obj[i].adc_device, adc_obj[i].adc_cfg->name, &swm_adc_ops, adc_obj[i].adc_cfg);
+ if(result != RT_EOK)
+ {
+ LOG_E("%s register fail.", adc_obj[i].adc_cfg->name);
+ }
+ else
+ {
+ LOG_D("%s register success.", adc_obj[i].adc_cfg->name);
+ }
+ }
+
+ return result;
+}
+INIT_BOARD_EXPORT(swm_adc_init);
+#endif /* BSP_USING_ADC */
+#endif /* RT_USING_ADC */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_adc.h b/bsp/synwit/libraries/SWM341_drivers/drv_adc.h
new file mode 100644
index 0000000000..b315c86fa6
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_adc.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_ADC_H__
+#define __DRV_ADC_H__
+
+#include "board.h"
+
+int swm_adc_init(void);
+
+#endif /* __DRV_ADC_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_can.c b/bsp/synwit/libraries/SWM341_drivers/drv_can.c
new file mode 100644
index 0000000000..7bc7bdee62
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_can.c
@@ -0,0 +1,565 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-16 lik first version
+ */
+
+#include "drv_can.h"
+
+#ifdef RT_USING_CAN
+#ifdef BSP_USING_CAN
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.can"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_CAN0) && !defined(BSP_USING_CAN1)
+#error "Please define at least one BSP_USING_CANx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+#ifdef BSP_USING_CAN0
+#ifndef CAN0_CFG
+#define CAN0_CFG \
+ { \
+ .name = "can0", \
+ .CANx = CAN0, \
+ }
+#endif /* CAN0_CFG */
+#endif /* BSP_USING_CAN0 */
+
+#ifdef BSP_USING_CAN1
+#ifndef CAN1_CFG
+#define CAN1_CFG \
+ { \
+ .name = "can1", \
+ .CANx = CAN1, \
+ }
+#endif /* CAN1_CFG */
+#endif /* BSP_USING_CAN1 */
+
+#define PRESCL_Pos 0
+#define BS1_Pos 16
+#define BS2_Pos 20
+#define SJW_Pos 24
+#define PRESCL_Msk (0x3FF << PRESCL_Pos)
+#define BS1_Msk ((0x0F) << BS1_Pos)
+#define BS2_Msk ((0x07) << BS2_Pos)
+#define SJW_Msk (0x3 << SJW_Pos)
+
+struct swm_baud_rate_tab
+{
+ rt_uint32_t baud_rate;
+ rt_uint32_t config_data;
+};
+#define BAUD_DATA(TYPE, NO) ((can_baud_rate_tab[NO].config_data & TYPE##_Msk) >> TYPE##_Pos)
+
+struct swm_can_cfg
+{
+ const char *name;
+ CAN_TypeDef *CANx;
+ CAN_InitStructure CAN_initstruct;
+};
+
+struct swm_can_device
+{
+ struct swm_can_cfg *can_cfg;
+ struct rt_can_device can_device;
+};
+/* SystemCoreClock 152MHz(max) 150MHz不能生成CAN1MBaud */
+static const struct swm_baud_rate_tab can_baud_rate_tab[] =
+ {
+ {CAN1MBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (1 << PRESCL_Pos))},
+ {CAN500kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (3 << PRESCL_Pos))},
+ {CAN250kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (7 << PRESCL_Pos))},
+ {CAN125kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (15 << PRESCL_Pos))},
+ {CAN100kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (19 << PRESCL_Pos))},
+ {CAN50kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (39 << PRESCL_Pos))},
+ {CAN20kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (99 << PRESCL_Pos))},
+ {CAN10kBaud, ((CAN_SJW_4tq << SJW_Pos) | (CAN_BS1_12tq << BS1_Pos) | (CAN_BS2_6tq << BS2_Pos) | (199 << PRESCL_Pos))}};
+
+enum
+{
+#ifdef BSP_USING_CAN0
+ CAN0_INDEX,
+#endif
+#ifdef BSP_USING_CAN1
+ CAN1_INDEX,
+#endif
+};
+
+static struct swm_can_cfg swm_can_cfg[] =
+ {
+#ifdef BSP_USING_CAN0
+ CAN0_CFG,
+#endif
+#ifdef BSP_USING_CAN1
+ CAN1_CFG,
+#endif
+};
+
+static struct swm_can_device can_obj[sizeof(swm_can_cfg) / sizeof(swm_can_cfg[0])];
+
+static rt_uint32_t get_can_baud_index(rt_uint32_t baud)
+{
+ rt_uint32_t len, index;
+
+ len = sizeof(can_baud_rate_tab) / sizeof(can_baud_rate_tab[0]);
+ for (index = 0; index < len; index++)
+ {
+ if (can_baud_rate_tab[index].baud_rate == baud)
+ return index;
+ }
+
+ return 0; /* default baud is CAN1MBaud */
+}
+
+static rt_err_t swm_can_config(struct rt_can_device *can_device, struct can_configure *cfg)
+{
+ struct swm_can_device *can_dev;
+ rt_uint32_t baud_index;
+ rt_uint32_t can_mode;
+
+ RT_ASSERT(can_device);
+ RT_ASSERT(cfg);
+ can_dev = (struct swm_can_device *)can_device->parent.user_data;
+ RT_ASSERT(can_dev);
+
+ switch (cfg->mode)
+ {
+ case RT_CAN_MODE_NORMAL:
+ can_mode = CAN_MODE_NORMAL;
+ break;
+ case RT_CAN_MODE_LISTEN:
+ can_mode = CAN_MODE_LISTEN;
+ break;
+ case RT_CAN_MODE_LOOPBACK:
+ can_mode = CAN_MODE_SELFTEST;
+ break;
+ case RT_CAN_MODE_LOOPBACKANLISTEN:
+ can_mode = CAN_MODE_SELFTEST;
+ break;
+ }
+
+ baud_index = get_can_baud_index(cfg->baud_rate);
+
+ CAN_Close(can_dev->can_cfg->CANx); //一些关键寄存器只能在CAN关闭时设置
+
+ can_dev->can_cfg->CANx->CR &= ~(CAN_CR_LOM_Msk | CAN_CR_STM_Msk);
+ can_dev->can_cfg->CANx->CR |= (can_mode << CAN_CR_LOM_Pos);
+
+ can_dev->can_cfg->CANx->BT1 = (0 << CAN_BT1_SAM_Pos) |
+ (BAUD_DATA(BS1, baud_index) << CAN_BT1_TSEG1_Pos) |
+ (BAUD_DATA(BS2, baud_index) << CAN_BT1_TSEG2_Pos);
+
+ can_dev->can_cfg->CANx->BT0 = (BAUD_DATA(SJW, baud_index) << CAN_BT0_SJW_Pos) |
+ ((BAUD_DATA(PRESCL, baud_index) & 0x3F) << CAN_BT0_BRP_Pos);
+
+ can_dev->can_cfg->CANx->BT2 = ((BAUD_DATA(PRESCL, baud_index) >> 6) << CAN_BT2_BRP_Pos);
+
+ can_dev->can_cfg->CANx->RXERR = 0; //只能在复位模式下清除
+ can_dev->can_cfg->CANx->TXERR = 0;
+
+ /* can start */
+ CAN_Open(can_dev->can_cfg->CANx);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_can_control(struct rt_can_device *can_device, int cmd, void *arg)
+{
+ rt_uint32_t argval;
+ struct swm_can_device *can_dev;
+ struct rt_can_filter_config *filter_cfg;
+
+ RT_ASSERT(can_device != RT_NULL);
+ can_dev = (struct swm_can_device *)can_device->parent.user_data;
+ RT_ASSERT(can_dev != RT_NULL);
+
+ switch (cmd)
+ {
+ case RT_DEVICE_CTRL_CLR_INT:
+ argval = (rt_uint32_t)arg;
+ if (argval == RT_DEVICE_FLAG_INT_RX)
+ {
+ can_dev->can_cfg->CANx->IE &= ~(CAN_IE_RXDA_Msk | CAN_IE_RXOV_Msk);
+ }
+ else if (argval == RT_DEVICE_FLAG_INT_TX)
+ {
+ can_dev->can_cfg->CANx->IE &= ~CAN_IE_TXBR_Msk;
+ }
+ else if (argval == RT_DEVICE_CAN_INT_ERR)
+ {
+ can_dev->can_cfg->CANx->IE &= ~(CAN_IE_ARBLOST_Msk | CAN_IE_BUSERR_Msk | CAN_IE_ERRWARN_Msk | CAN_IE_ERRPASS_Msk);
+ }
+ break;
+ case RT_DEVICE_CTRL_SET_INT:
+ argval = (rt_uint32_t)arg;
+ if (argval == RT_DEVICE_FLAG_INT_RX)
+ {
+ can_dev->can_cfg->CANx->IE |= (CAN_IE_RXDA_Msk | CAN_IE_RXOV_Msk);
+ }
+ else if (argval == RT_DEVICE_FLAG_INT_TX)
+ {
+ can_dev->can_cfg->CANx->IE |= CAN_IE_TXBR_Msk;
+ }
+ else if (argval == RT_DEVICE_CAN_INT_ERR)
+ {
+ can_dev->can_cfg->CANx->IE |= (CAN_IE_ARBLOST_Msk | CAN_IE_BUSERR_Msk | CAN_IE_ERRWARN_Msk | CAN_IE_ERRPASS_Msk);
+ }
+ break;
+ case RT_CAN_CMD_SET_FILTER:
+ {
+ rt_uint32_t filter_idx = 0;
+
+ if (RT_NULL == arg)
+ {
+ /* default filter config */
+ }
+ else
+ {
+ filter_cfg = (struct rt_can_filter_config *)arg;
+ /* get default filter */
+ for (int i = 0; i < filter_cfg->count; i++)
+ {
+ if (filter_cfg->items[i].hdr_bank == -1)
+ {
+ filter_idx = i;
+ }
+ else
+ {
+ filter_idx = filter_cfg->items[i].hdr_bank;
+ }
+
+ if (filter_cfg->items[i].ide == RT_CAN_STDID)
+ {
+ can_dev->can_cfg->CANx->AFM &= ~(1 << filter_idx);
+
+ can_dev->can_cfg->CANx->ACR[filter_idx] = __REV(filter_cfg->items[i].id << 5);
+ can_dev->can_cfg->CANx->AMR[filter_idx] = __REV(~(filter_cfg->items[i].mask << 5));
+
+ can_dev->can_cfg->CANx->AFE |= (1 << filter_idx);
+ }
+ else if (filter_cfg->items[i].ide == RT_CAN_EXTID)
+ {
+ can_dev->can_cfg->CANx->AFM |= (1 << filter_idx);
+
+ can_dev->can_cfg->CANx->ACR[filter_idx] = __REV(filter_cfg->items[i].id << 3);
+ can_dev->can_cfg->CANx->AMR[filter_idx] = __REV(~(filter_cfg->items[i].mask << 3));
+
+ can_dev->can_cfg->CANx->AFE |= (1 << filter_idx);
+ }
+ }
+ }
+ break;
+ }
+ case RT_CAN_CMD_SET_MODE:
+ argval = (rt_uint32_t)arg;
+ if (argval != RT_CAN_MODE_NORMAL &&
+ argval != RT_CAN_MODE_LISTEN &&
+ argval != RT_CAN_MODE_LOOPBACK &&
+ argval != RT_CAN_MODE_LOOPBACKANLISTEN)
+ {
+ return -RT_ERROR;
+ }
+ if (argval != can_dev->can_device.config.mode)
+ {
+ can_dev->can_device.config.mode = argval;
+ return swm_can_config(&can_dev->can_device, &can_dev->can_device.config);
+ }
+ break;
+ case RT_CAN_CMD_SET_BAUD:
+ argval = (rt_uint32_t)arg;
+ if (argval != CAN1MBaud &&
+ argval != CAN800kBaud &&
+ argval != CAN500kBaud &&
+ argval != CAN250kBaud &&
+ argval != CAN125kBaud &&
+ argval != CAN100kBaud &&
+ argval != CAN50kBaud &&
+ argval != CAN20kBaud &&
+ argval != CAN10kBaud)
+ {
+ return -RT_ERROR;
+ }
+ if (argval != can_dev->can_device.config.baud_rate)
+ {
+ can_dev->can_device.config.baud_rate = argval;
+ return swm_can_config(&can_dev->can_device, &can_dev->can_device.config);
+ }
+ break;
+ case RT_CAN_CMD_SET_PRIV:
+ argval = (rt_uint32_t)arg;
+ if (argval != RT_CAN_MODE_PRIV &&
+ argval != RT_CAN_MODE_NOPRIV)
+ {
+ return -RT_ERROR;
+ }
+ if (argval != can_dev->can_device.config.privmode)
+ {
+ can_dev->can_device.config.privmode = argval;
+ return swm_can_config(&can_dev->can_device, &can_dev->can_device.config);
+ }
+ break;
+ case RT_CAN_CMD_GET_STATUS:
+ {
+ can_dev->can_device.status.rcverrcnt = can_dev->can_cfg->CANx->RXERR;
+ can_dev->can_device.status.snderrcnt = can_dev->can_cfg->CANx->TXERR;
+ can_dev->can_device.status.lasterrtype = (can_dev->can_cfg->CANx->ECC >> 6) & 0x03;
+ can_dev->can_device.status.errcode = can_dev->can_cfg->CANx->ECC & 0x1F;
+ rt_memcpy(arg, &can_dev->can_device.status, sizeof(can_dev->can_device.status));
+ }
+ break;
+ }
+
+ return RT_EOK;
+}
+
+static int swm_can_sendmsg(struct rt_can_device *can_device, const void *buf, rt_uint32_t box_num)
+{
+ uint32_t i;
+ struct swm_can_device *can_dev;
+
+ RT_ASSERT(can_device != RT_NULL);
+ can_dev = (struct swm_can_device *)can_device->parent.user_data;
+ struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
+
+ if (RT_CAN_STDID == pmsg->ide)
+ {
+ can_dev->can_cfg->CANx->FRAME.DATA[0] = pmsg->id >> 3;
+ can_dev->can_cfg->CANx->FRAME.DATA[1] = pmsg->id << 5;
+
+ if (RT_CAN_DTR == pmsg->rtr)
+ {
+ can_dev->can_cfg->CANx->FRAME.INFO = (0 << CAN_INFO_FF_Pos) |
+ (0 << CAN_INFO_RTR_Pos) |
+ (pmsg->len << CAN_INFO_DLC_Pos);
+
+ for(i = 0; i < pmsg->len; i++)
+ {
+ can_dev->can_cfg->CANx->FRAME.DATA[i+2] = pmsg->data[i];
+ }
+
+ if(can_dev->can_cfg->CANx->CR & CAN_CR_STM_Msk)
+ {
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_SRR_Pos);
+ }
+ else
+ {
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_TXREQ_Pos);
+ }
+ }
+ else
+ {
+ can_dev->can_cfg->CANx->FRAME.INFO = (0 << CAN_INFO_FF_Pos) |
+ (1 << CAN_INFO_RTR_Pos) |
+ (0 << CAN_INFO_DLC_Pos);
+
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_TXREQ_Pos);
+ }
+ }
+ else
+ {
+ can_dev->can_cfg->CANx->FRAME.DATA[0] = pmsg->id >> 21;
+ can_dev->can_cfg->CANx->FRAME.DATA[1] = pmsg->id >> 13;
+ can_dev->can_cfg->CANx->FRAME.DATA[2] = pmsg->id >> 5;
+ can_dev->can_cfg->CANx->FRAME.DATA[3] = pmsg->id << 3;
+
+ if (RT_CAN_DTR == pmsg->rtr)
+ {
+ can_dev->can_cfg->CANx->FRAME.INFO = (1 << CAN_INFO_FF_Pos) |
+ (0 << CAN_INFO_RTR_Pos) |
+ (pmsg->len << CAN_INFO_DLC_Pos);
+
+ for(i = 0; i < pmsg->len; i++)
+ {
+ can_dev->can_cfg->CANx->FRAME.DATA[i+4] = pmsg->data[i];
+ }
+
+ if(can_dev->can_cfg->CANx->CR & CAN_CR_STM_Msk)
+ {
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_SRR_Pos);
+ }
+ else
+ {
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_TXREQ_Pos);
+ }
+ }
+ else
+ {
+ can_dev->can_cfg->CANx->FRAME.INFO = (1 << CAN_INFO_FF_Pos) |
+ (1 << CAN_INFO_RTR_Pos) |
+ (0 << CAN_INFO_DLC_Pos);
+
+ can_dev->can_cfg->CANx->CMD = (1 << CAN_CMD_TXREQ_Pos);
+ }
+ }
+ return RT_EOK;
+}
+
+static int swm_can_recvmsg(struct rt_can_device *can_device, void *buf, rt_uint32_t fifo)
+{
+ uint32_t i;
+ struct swm_can_device *can_dev;
+ RT_ASSERT(can_device != RT_NULL);
+ can_dev = (struct swm_can_device *)can_device->parent.user_data;
+
+ struct rt_can_msg *pmsg = (struct rt_can_msg *) buf;
+
+ CAN_RXMessage CAN_RXMsg;
+
+ /* get data */
+ CAN_Receive(can_dev->can_cfg->CANx, &CAN_RXMsg);
+ /* get id */
+ if (CAN_RXMsg.format == CAN_FRAME_STD)
+ {
+ pmsg->ide = RT_CAN_STDID;
+ }
+ else
+ {
+ pmsg->ide = RT_CAN_EXTID;
+ }
+ pmsg->id = CAN_RXMsg.id;
+
+ /* get type */
+ if (CAN_RXMsg.remote == 0)
+ {
+ pmsg->rtr = RT_CAN_DTR;
+ }
+ else
+ {
+ pmsg->rtr = RT_CAN_RTR;
+ }
+ /* get len */
+ pmsg->len = CAN_RXMsg.size;
+
+ for(i = 0; i < pmsg->len; i++)
+ {
+ pmsg->data[i] = CAN_RXMsg.data[i];
+ }
+
+ return RT_EOK;
+}
+
+static const struct rt_can_ops swm_can_ops =
+{
+ .configure = swm_can_config,
+ .control = swm_can_control,
+ .sendmsg = swm_can_sendmsg,
+ .recvmsg = swm_can_recvmsg,
+};
+
+static void swm_can_isr(struct rt_can_device *can_device)
+{
+ struct swm_can_device *can_dev;
+ RT_ASSERT(can_device != RT_NULL);
+ can_dev = (struct swm_can_device *)can_device->parent.user_data;
+
+ uint32_t int_sr = CAN_INTStat(can_dev->can_cfg->CANx);
+
+ if(int_sr & CAN_IF_RXDA_Msk)
+ {
+ rt_hw_can_isr(can_device, RT_CAN_EVENT_RX_IND);
+ }
+ else if (int_sr & CAN_IF_RXOV_Msk)
+ {
+ rt_hw_can_isr(can_device, RT_CAN_EVENT_RXOF_IND);
+ }
+ else if (int_sr & CAN_IF_TXBR_Msk)
+ {
+ rt_hw_can_isr(can_device, RT_CAN_EVENT_TX_DONE);
+ }
+ else if (int_sr & CAN_IE_ERRWARN_Msk)
+ {
+ }
+ else if (int_sr & CAN_IE_ERRPASS_Msk)
+ {
+ }
+ else if (int_sr & CAN_IE_ARBLOST_Msk)
+ {
+ }
+ else if (int_sr & CAN_IE_BUSERR_Msk)
+ {
+ }
+}
+
+#ifdef BSP_USING_CAN0
+/**
+ * @brief This function handles CAN0 interrupts.
+ */
+void CAN0_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_can_isr(&(can_obj[CAN0_INDEX].can_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_CAN0 */
+
+#ifdef BSP_USING_CAN1
+/**
+ * @brief This function handles CAN1 interrupts.
+ */
+void CAN1_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_can_isr(&(can_obj[CAN0_INDEX].can_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_CAN1 */
+
+int swm_can_init(void)
+{
+ int i = 0;
+ int result = RT_EOK;
+
+ struct can_configure config = CANDEFAULTCONFIG;
+ config.privmode = RT_CAN_MODE_NOPRIV;
+ config.ticks = 50;
+#ifdef RT_CAN_USING_HDR
+ config.maxhdr = 16;
+#endif
+
+#ifdef BSP_USING_CAN0
+ PORT_Init(PORTB, PIN5, PORTB_PIN5_CAN0_RX, 1);
+ PORT_Init(PORTB, PIN4, PORTB_PIN4_CAN0_TX, 0);
+ SYS->CLKEN0 |= (0x01 << SYS_CLKEN0_CAN0_Pos);
+ NVIC_EnableIRQ(CAN0_IRQn);
+#endif
+
+#ifdef BSP_USING_CAN1
+ PORT_Init(PORTB, PIN3, PORTB_PIN3_CAN1_RX, 1);
+ PORT_Init(PORTB, PIN2, PORTB_PIN2_CAN1_TX, 0);
+ SYS->CLKEN1 |= (0x01 << SYS_CLKEN1_CAN1_Pos);
+ NVIC_EnableIRQ(CAN1_IRQn);
+#endif
+
+ for (i = 0; i < sizeof(swm_can_cfg) / sizeof(swm_can_cfg[0]); i++)
+ {
+ can_obj[i].can_device.config = config;
+ can_obj[i].can_cfg = &swm_can_cfg[i];
+ result = rt_hw_can_register(&can_obj[i].can_device,
+ can_obj[i].can_cfg->name,
+ &swm_can_ops,
+ &can_obj[i]);
+ if (result != RT_EOK)
+ {
+ LOG_E("%s register fail.", can_obj[i].can_cfg->name);
+ }
+ else
+ {
+ LOG_D("%s register success.", can_obj[i].can_cfg->name);
+ }
+ }
+
+ return result;
+ return 0;
+}
+
+INIT_BOARD_EXPORT(swm_can_init);
+
+#endif /* BSP_USING_CAN */
+#endif /* RT_USING_CAN */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_can.h b/bsp/synwit/libraries/SWM341_drivers/drv_can.h
new file mode 100644
index 0000000000..f9f3d266fc
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_can.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-16 lik first version
+ */
+
+#ifndef __DRV_CAN_H__
+#define __DRV_CAN_H__
+
+#include "board.h"
+
+int swm_can_init(void);
+
+#endif /* __DRV_CAN_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_crypto.c b/bsp/synwit/libraries/SWM341_drivers/drv_crypto.c
new file mode 100644
index 0000000000..38d2c20af6
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_crypto.c
@@ -0,0 +1,316 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_crypto.h"
+#include <string.h>
+
+#ifdef RT_USING_HWCRYPTO
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.crypto"
+#include <drv_log.h>
+
+struct swm_hwcrypto_device
+{
+ struct rt_hwcrypto_device dev;
+ struct rt_mutex mutex;
+};
+
+static struct swm_hwcrypto_device hwcrypto_obj;
+
+#ifdef BSP_USING_CRC
+
+struct swm_crc_cfg
+{
+ CRC_TypeDef *CRCx;
+ CRC_InitStructure CRC_initstruct;
+};
+
+static struct hwcrypto_crc_cfg swm_crc_cfg;
+
+static rt_uint32_t swm_crc_update(struct hwcrypto_crc *ctx, const rt_uint8_t *in, rt_size_t length)
+{
+ rt_uint32_t result = 0;
+ struct swm_hwcrypto_device *hwcrypto_dev = (struct swm_hwcrypto_device *)ctx->parent.device->user_data;
+
+ struct swm_crc_cfg *crc_cfg = (struct swm_crc_cfg *)(ctx->parent.contex);
+
+ rt_mutex_take(&hwcrypto_dev->mutex, RT_WAITING_FOREVER);
+
+ if (memcmp(&swm_crc_cfg, &ctx->crc_cfg, sizeof(struct hwcrypto_crc_cfg)) != 0)
+ {
+ crc_cfg->CRCx = CRC;
+
+ crc_cfg->CRC_initstruct.init_crc = ctx->crc_cfg.last_val;
+
+ switch (ctx->crc_cfg.poly)
+ {
+ case 0x07:
+ crc_cfg->CRC_initstruct.Poly = CRC_POLY_107;
+ break;
+ case 0x1021:
+ crc_cfg->CRC_initstruct.Poly = CRC_POLY_11021;
+ break;
+ case 0x8005:
+ crc_cfg->CRC_initstruct.Poly = CRC_POLY_18005;
+ break;
+ case 0x04C11DB7:
+ crc_cfg->CRC_initstruct.Poly = CRC_POLY_104C11DB7;
+ break;
+ default:
+
+ goto _exit;
+ }
+
+ switch (ctx->crc_cfg.width)
+ {
+ case 8:
+ crc_cfg->CRC_initstruct.in_width = CRC_WIDTH_8;
+ break;
+ case 16:
+ crc_cfg->CRC_initstruct.in_width = CRC_WIDTH_16;
+ break;
+ case 32:
+ crc_cfg->CRC_initstruct.in_width = CRC_WIDTH_32;
+ break;
+ default:
+ goto _exit;
+ }
+
+ switch (ctx->crc_cfg.flags)
+ {
+ case 0:
+ crc_cfg->CRC_initstruct.in_not = false;
+ crc_cfg->CRC_initstruct.out_not = false;
+ break;
+ case CRC_FLAG_REFIN:
+ crc_cfg->CRC_initstruct.in_not = true;
+ crc_cfg->CRC_initstruct.out_not = false;
+ break;
+ case CRC_FLAG_REFOUT:
+ crc_cfg->CRC_initstruct.in_not = false;
+ crc_cfg->CRC_initstruct.out_not = true;
+ break;
+ case CRC_FLAG_REFIN | CRC_FLAG_REFOUT:
+ crc_cfg->CRC_initstruct.in_not = true;
+ crc_cfg->CRC_initstruct.out_not = true;
+ break;
+ default:
+ goto _exit;
+ }
+
+ crc_cfg->CRC_initstruct.in_rev = CRC_REV_NOT;
+ crc_cfg->CRC_initstruct.out_rev = CRC_REV_NOT;
+ CRC_Init(crc_cfg->CRCx, &(crc_cfg->CRC_initstruct));
+ memcpy(&swm_crc_cfg, &ctx->crc_cfg, sizeof(struct hwcrypto_crc_cfg));
+ }
+
+ for (uint32_t i = 0; i < length; i++)
+ CRC_Write((uint32_t)in[i]);
+ result = CRC_Result();
+
+ ctx->crc_cfg.last_val = result;
+
+ swm_crc_cfg.last_val = ctx->crc_cfg.last_val;
+ result = (result ? result ^ (ctx->crc_cfg.xorout) : result);
+
+_exit:
+ rt_mutex_release(&hwcrypto_dev->mutex);
+
+ return result;
+}
+
+static const struct hwcrypto_crc_ops swm_crc_ops =
+ {
+ .update = swm_crc_update,
+};
+#endif /* BSP_USING_CRC */
+
+#if defined(BSP_USING_RNG)
+
+struct swm_rng_cfg
+{
+ SYS_TypeDef *SYSx;
+};
+
+static rt_uint32_t swm_rng_update(struct hwcrypto_rng *ctx)
+{
+ rt_uint32_t gen_randoml = 0, gen_randomh = 0;
+
+ struct swm_rng_cfg *rng_cfg = (struct swm_rng_cfg *)(ctx->parent.contex);
+
+ while ((rng_cfg->SYSx->PRNGCR & SYS_PRNGCR_RDY_Msk) == 0)
+ __NOP();
+ gen_randoml = rng_cfg->SYSx->PRNGDL;
+ gen_randomh = rng_cfg->SYSx->PRNGDH;
+ return gen_randoml;
+}
+
+static const struct hwcrypto_rng_ops swm_rng_ops =
+ {
+ .update = swm_rng_update,
+};
+#endif /* BSP_USING_RNG */
+
+static rt_err_t swm_crypto_create(struct rt_hwcrypto_ctx *ctx)
+{
+ rt_err_t res = RT_EOK;
+
+ switch (ctx->type & HWCRYPTO_MAIN_TYPE_MASK)
+ {
+#if defined(BSP_USING_CRC)
+ case HWCRYPTO_TYPE_CRC:
+ {
+ struct swm_crc_cfg *crc_cfg = rt_calloc(1, sizeof(struct swm_crc_cfg));
+ if (RT_NULL == crc_cfg)
+ {
+ res = -RT_ERROR;
+ break;
+ }
+
+ ctx->contex = crc_cfg;
+ ((struct hwcrypto_crc *)ctx)->ops = &swm_crc_ops;
+ break;
+ }
+#endif /* BSP_USING_CRC */
+
+#if defined(BSP_USING_RNG)
+ case HWCRYPTO_TYPE_RNG:
+ {
+ struct swm_rng_cfg *rng_cfg = rt_calloc(1, sizeof(struct swm_rng_cfg));
+ if (RT_NULL == rng_cfg)
+ {
+ res = -RT_ERROR;
+ break;
+ }
+ rng_cfg->SYSx = SYS;
+ rng_cfg->SYSx->HRCCR |= (1 << SYS_HRCCR_ON_Pos);
+ rng_cfg->SYSx->LRCCR |= (1 << SYS_LRCCR_ON_Pos);
+ rng_cfg->SYSx->PRNGCR = (0 << SYS_PRNGCR_CLR_Pos) |
+ (3 << SYS_PRNGCR_MODE_Pos);
+ ctx->contex = rng_cfg;
+ ((struct hwcrypto_rng *)ctx)->ops = &swm_rng_ops;
+
+ break;
+ }
+#endif /* BSP_USING_RNG */
+
+ default:
+ res = -RT_ERROR;
+ break;
+ }
+ return res;
+}
+
+static void swm_crypto_destroy(struct rt_hwcrypto_ctx *ctx)
+{
+ struct swm_crc_cfg *crc_cfg = (struct swm_crc_cfg *)(ctx->contex);
+ switch (ctx->type & HWCRYPTO_MAIN_TYPE_MASK)
+ {
+#if defined(BSP_USING_CRC)
+ case HWCRYPTO_TYPE_CRC:
+ crc_cfg->CRCx->CR &= ~CRC_CR_EN_Msk;
+ break;
+#endif /* BSP_USING_CRC */
+
+#if defined(BSP_USING_RNG)
+ case HWCRYPTO_TYPE_RNG:
+ break;
+#endif /* BSP_USING_RNG */
+
+ default:
+ break;
+ }
+
+ rt_free(ctx->contex);
+}
+
+static rt_err_t swm_crypto_clone(struct rt_hwcrypto_ctx *des, const struct rt_hwcrypto_ctx *src)
+{
+ rt_err_t res = RT_EOK;
+
+ switch (src->type & HWCRYPTO_MAIN_TYPE_MASK)
+ {
+#if defined(BSP_USING_CRC)
+ case HWCRYPTO_TYPE_CRC:
+ if (des->contex && src->contex)
+ {
+ rt_memcpy(des->contex, src->contex, sizeof(struct swm_crc_cfg));
+ }
+ break;
+#endif /* BSP_USING_CRC */
+
+#if defined(BSP_USING_RNG)
+ case HWCRYPTO_TYPE_RNG:
+ if (des->contex && src->contex)
+ {
+ rt_memcpy(des->contex, src->contex, sizeof(struct swm_rng_cfg));
+ }
+ break;
+#endif /* BSP_USING_RNG */
+
+ default:
+ res = -RT_ERROR;
+ break;
+ }
+ return res;
+}
+
+static void swm_crypto_reset(struct rt_hwcrypto_ctx *ctx)
+{
+ struct swm_crc_cfg *crc_cfg = (struct swm_crc_cfg *)(ctx->contex);
+ switch (ctx->type & HWCRYPTO_MAIN_TYPE_MASK)
+ {
+#if defined(BSP_USING_CRC)
+ case HWCRYPTO_TYPE_CRC:
+ crc_cfg->CRCx->CR &= ~CRC_CR_EN_Msk;
+ break;
+#endif /* BSP_USING_CRC */
+
+#if defined(BSP_USING_RNG)
+ case HWCRYPTO_TYPE_RNG:
+ break;
+#endif /* BSP_USING_RNG */
+
+ default:
+ break;
+ }
+}
+
+static const struct rt_hwcrypto_ops swm_hwcrypto_ops =
+ {
+ .create = swm_crypto_create,
+ .destroy = swm_crypto_destroy,
+ .copy = swm_crypto_clone,
+ .reset = swm_crypto_reset,
+};
+
+int swm_crypto_init(void)
+{
+ rt_uint32_t cpuid[2] = {0};
+
+ hwcrypto_obj.dev.ops = &swm_hwcrypto_ops;
+
+ cpuid[0] = SCB->CPUID;
+ hwcrypto_obj.dev.id = 0;
+ rt_memcpy(&hwcrypto_obj.dev.id, cpuid, 8);
+
+ hwcrypto_obj.dev.user_data = &hwcrypto_obj;
+
+ if (rt_hwcrypto_register(&hwcrypto_obj.dev, RT_HWCRYPTO_DEFAULT_NAME) != RT_EOK)
+ {
+ return -1;
+ }
+ rt_mutex_init(&hwcrypto_obj.mutex, RT_HWCRYPTO_DEFAULT_NAME, RT_IPC_FLAG_FIFO);
+ return 0;
+}
+INIT_BOARD_EXPORT(swm_crypto_init);
+
+#endif /* RT_USING_HWCRYPTO */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_crypto.h b/bsp/synwit/libraries/SWM341_drivers/drv_crypto.h
new file mode 100644
index 0000000000..177c1d30d8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_crypto.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_CRYPTO_H__
+#define __DRV_CRYPTO_H__
+
+#include "board.h"
+
+int swm_crypto_init(void);
+
+#endif /* __DRV_CRYPTO_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_dac.c b/bsp/synwit/libraries/SWM341_drivers/drv_dac.c
new file mode 100644
index 0000000000..b9fbda77a9
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_dac.c
@@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-10 lik first version
+ */
+
+#include "drv_dac.h"
+
+#ifdef BSP_USING_DAC
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.dac"
+#include <drv_log.h>
+
+static struct rt_dac_device swm_dac_device;
+
+static rt_err_t swm_dac_enabled(struct rt_dac_device *device, rt_uint32_t channel)
+{
+ RT_ASSERT(device != RT_NULL);
+
+ if (channel != 0)
+ {
+ LOG_E("dac channel must be 0.");
+ return -RT_ERROR;
+ }
+ DAC_Open(DAC);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_dac_disabled(struct rt_dac_device *device, rt_uint32_t channel)
+{
+ RT_ASSERT(device != RT_NULL);
+
+ if (channel != 0)
+ {
+ LOG_E("dac channel must be 0.");
+ return -RT_ERROR;
+ }
+ DAC_Close(DAC);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_dac_convert(struct rt_dac_device *device, rt_uint32_t channel, rt_uint32_t *value)
+{
+ RT_ASSERT(device != RT_NULL);
+ RT_ASSERT(value != RT_NULL);
+
+ if (channel != 0)
+ {
+ LOG_E("dac channel must be 0.");
+ return -RT_ERROR;
+ }
+
+ DAC->DHR = *value;
+ while(DAC->SR & DAC_SR_DHRFULL_Msk) __NOP();
+
+ return RT_EOK;
+}
+
+static const struct rt_dac_ops swm_dac_ops =
+ {
+ .disabled = swm_dac_disabled,
+ .enabled = swm_dac_enabled,
+ .convert = swm_dac_convert,
+};
+
+int swm_dac_init(void)
+{
+ int result = RT_EOK;
+
+ PORT_Init(PORTD, PIN2, PORTD_PIN2_DAC_OUT, 0);
+
+ DAC_Init(DAC, DAC_FORMAT_LSB12B);
+
+ SYS->DACCR &= ~SYS_DACCR_VRADJ_Msk;
+ SYS->DACCR |= (17 << SYS_DACCR_VRADJ_Pos);
+
+ /* register dac device */
+ result = rt_hw_dac_register(&swm_dac_device, "dac", &swm_dac_ops, RT_NULL);
+ if(result != RT_EOK)
+ {
+ LOG_E("dac register fail.");
+ }
+ else
+ {
+ LOG_D("dac register success.");
+ }
+
+ return result;
+}
+INIT_DEVICE_EXPORT(swm_dac_init);
+
+#endif /* BSP_USING_DAC */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_dac.h b/bsp/synwit/libraries/SWM341_drivers/drv_dac.h
new file mode 100644
index 0000000000..08d822dcf9
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_dac.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-10 lik first version
+ */
+
+#ifndef __DRV_DAC_H__
+#define __DRV_DAC_H__
+
+#include "board.h"
+
+int swm_dac_init(void);
+
+#endif /* __DRV_DAC_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_gpio.c b/bsp/synwit/libraries/SWM341_drivers/drv_gpio.c
new file mode 100644
index 0000000000..586530359b
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_gpio.c
@@ -0,0 +1,624 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_gpio.h"
+
+#ifdef RT_USING_PIN
+#ifdef BSP_USING_GPIO
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.gpio"
+#include <drv_log.h>
+
+#define __SWM_PIN(index, gpio, pin_index) \
+ { \
+ index, GPIO##gpio, PIN##pin_index, GPIO##gpio##_IRQn \
+ }
+
+struct swm_pin_device
+{
+ uint32_t index;
+ GPIO_TypeDef *gpio;
+ uint32_t pin;
+ IRQn_Type irq;
+};
+
+static const struct swm_pin_device pin_obj[] =
+ {
+ __SWM_PIN(0, A, 0),
+ __SWM_PIN(1, A, 1),
+ __SWM_PIN(2, A, 2),
+ __SWM_PIN(3, A, 3),
+ __SWM_PIN(4, A, 4),
+ __SWM_PIN(5, A, 5),
+ __SWM_PIN(6, A, 6),
+ __SWM_PIN(7, A, 7),
+ __SWM_PIN(8, A, 8),
+ __SWM_PIN(9, A, 9),
+ __SWM_PIN(10, A, 10),
+ __SWM_PIN(11, A, 11),
+ __SWM_PIN(12, A, 12),
+ __SWM_PIN(13, A, 13),
+ __SWM_PIN(14, A, 14),
+ __SWM_PIN(15, A, 15),
+
+ __SWM_PIN(16, B, 0),
+ __SWM_PIN(17, B, 1),
+ __SWM_PIN(18, B, 2),
+ __SWM_PIN(19, B, 3),
+ __SWM_PIN(20, B, 4),
+ __SWM_PIN(21, B, 5),
+ __SWM_PIN(22, B, 6),
+ __SWM_PIN(23, B, 7),
+ __SWM_PIN(24, B, 8),
+ __SWM_PIN(25, B, 9),
+ __SWM_PIN(26, B, 10),
+ __SWM_PIN(27, B, 11),
+ __SWM_PIN(28, B, 12),
+ __SWM_PIN(29, B, 13),
+ __SWM_PIN(30, B, 14),
+ __SWM_PIN(31, B, 15),
+
+ __SWM_PIN(32, C, 0),
+ __SWM_PIN(33, C, 1),
+ __SWM_PIN(34, C, 2),
+ __SWM_PIN(35, C, 3),
+ __SWM_PIN(36, C, 4),
+ __SWM_PIN(37, C, 5),
+ __SWM_PIN(38, C, 6),
+ __SWM_PIN(39, C, 7),
+ __SWM_PIN(40, C, 8),
+ __SWM_PIN(41, C, 9),
+ __SWM_PIN(42, C, 10),
+ __SWM_PIN(43, C, 11),
+ __SWM_PIN(44, C, 12),
+ __SWM_PIN(45, C, 13),
+ __SWM_PIN(46, C, 14),
+ __SWM_PIN(47, C, 15),
+
+ __SWM_PIN(48, D, 0),
+ __SWM_PIN(49, D, 1),
+ __SWM_PIN(50, D, 2),
+ __SWM_PIN(51, D, 3),
+ __SWM_PIN(52, D, 4),
+ __SWM_PIN(53, D, 5),
+ __SWM_PIN(54, D, 6),
+ __SWM_PIN(55, D, 7),
+ __SWM_PIN(56, D, 8),
+ __SWM_PIN(57, D, 9),
+ __SWM_PIN(58, D, 10),
+ __SWM_PIN(59, D, 11),
+ __SWM_PIN(60, D, 12),
+ __SWM_PIN(61, D, 13),
+ __SWM_PIN(62, D, 14),
+ __SWM_PIN(63, D, 15),
+
+ __SWM_PIN(64, E, 0),
+ __SWM_PIN(65, E, 1),
+ __SWM_PIN(66, E, 2),
+ __SWM_PIN(67, E, 3),
+ __SWM_PIN(68, E, 4),
+ __SWM_PIN(69, E, 5),
+ __SWM_PIN(70, E, 6),
+ __SWM_PIN(71, E, 7),
+ __SWM_PIN(72, E, 8),
+ __SWM_PIN(73, E, 9),
+ __SWM_PIN(74, E, 10),
+ __SWM_PIN(75, E, 11),
+ __SWM_PIN(76, E, 12),
+ __SWM_PIN(77, E, 13),
+ __SWM_PIN(78, E, 14),
+ __SWM_PIN(79, E, 15),
+
+ __SWM_PIN(80, M, 0),
+ __SWM_PIN(81, M, 1),
+ __SWM_PIN(82, M, 2),
+ __SWM_PIN(83, M, 3),
+ __SWM_PIN(84, M, 4),
+ __SWM_PIN(85, M, 5),
+ __SWM_PIN(86, M, 6),
+ __SWM_PIN(87, M, 7),
+ __SWM_PIN(88, M, 8),
+ __SWM_PIN(89, M, 9),
+ __SWM_PIN(90, M, 10),
+ __SWM_PIN(91, M, 11),
+ __SWM_PIN(92, M, 12),
+ __SWM_PIN(93, M, 13),
+ __SWM_PIN(94, M, 14),
+ __SWM_PIN(95, M, 15),
+
+ __SWM_PIN(96, N, 0),
+ __SWM_PIN(97, N, 1),
+ __SWM_PIN(98, N, 2),
+ __SWM_PIN(99, N, 3),
+ __SWM_PIN(100, N, 4),
+ __SWM_PIN(101, N, 5),
+ __SWM_PIN(102, N, 6),
+ __SWM_PIN(103, N, 7),
+ __SWM_PIN(104, N, 8),
+ __SWM_PIN(105, N, 9),
+ __SWM_PIN(106, N, 10),
+ __SWM_PIN(107, N, 11),
+ __SWM_PIN(108, N, 12),
+ __SWM_PIN(109, N, 13),
+ __SWM_PIN(110, N, 14),
+ __SWM_PIN(111, N, 15)};
+
+static struct rt_pin_irq_hdr pin_irq_hdr_tab[] =
+ {
+ {0, 0, RT_NULL, RT_NULL},
+ {1, 0, RT_NULL, RT_NULL},
+ {2, 0, RT_NULL, RT_NULL},
+ {3, 0, RT_NULL, RT_NULL},
+ {4, 0, RT_NULL, RT_NULL},
+ {5, 0, RT_NULL, RT_NULL},
+ {6, 0, RT_NULL, RT_NULL},
+ {7, 0, RT_NULL, RT_NULL},
+ {8, 0, RT_NULL, RT_NULL},
+ {9, 0, RT_NULL, RT_NULL},
+ {10, 0, RT_NULL, RT_NULL},
+ {11, 0, RT_NULL, RT_NULL},
+ {12, 0, RT_NULL, RT_NULL},
+ {13, 0, RT_NULL, RT_NULL},
+ {14, 0, RT_NULL, RT_NULL},
+ {15, 0, RT_NULL, RT_NULL},
+ {16, 0, RT_NULL, RT_NULL},
+ {17, 0, RT_NULL, RT_NULL},
+ {18, 0, RT_NULL, RT_NULL},
+ {19, 0, RT_NULL, RT_NULL},
+ {20, 0, RT_NULL, RT_NULL},
+ {21, 0, RT_NULL, RT_NULL},
+ {22, 0, RT_NULL, RT_NULL},
+ {23, 0, RT_NULL, RT_NULL},
+ {24, 0, RT_NULL, RT_NULL},
+ {25, 0, RT_NULL, RT_NULL},
+ {26, 0, RT_NULL, RT_NULL},
+ {27, 0, RT_NULL, RT_NULL},
+ {28, 0, RT_NULL, RT_NULL},
+ {29, 0, RT_NULL, RT_NULL},
+ {30, 0, RT_NULL, RT_NULL},
+ {31, 0, RT_NULL, RT_NULL},
+ {32, 0, RT_NULL, RT_NULL},
+ {33, 0, RT_NULL, RT_NULL},
+ {34, 0, RT_NULL, RT_NULL},
+ {35, 0, RT_NULL, RT_NULL},
+ {36, 0, RT_NULL, RT_NULL},
+ {37, 0, RT_NULL, RT_NULL},
+ {38, 0, RT_NULL, RT_NULL},
+ {39, 0, RT_NULL, RT_NULL},
+ {40, 0, RT_NULL, RT_NULL},
+ {41, 0, RT_NULL, RT_NULL},
+ {42, 0, RT_NULL, RT_NULL},
+ {43, 0, RT_NULL, RT_NULL},
+ {44, 0, RT_NULL, RT_NULL},
+ {45, 0, RT_NULL, RT_NULL},
+ {46, 0, RT_NULL, RT_NULL},
+ {47, 0, RT_NULL, RT_NULL},
+ {48, 0, RT_NULL, RT_NULL},
+ {49, 0, RT_NULL, RT_NULL},
+ {50, 0, RT_NULL, RT_NULL},
+ {51, 0, RT_NULL, RT_NULL},
+ {52, 0, RT_NULL, RT_NULL},
+ {53, 0, RT_NULL, RT_NULL},
+ {54, 0, RT_NULL, RT_NULL},
+ {55, 0, RT_NULL, RT_NULL},
+ {56, 0, RT_NULL, RT_NULL},
+ {57, 0, RT_NULL, RT_NULL},
+ {58, 0, RT_NULL, RT_NULL},
+ {59, 0, RT_NULL, RT_NULL},
+ {60, 0, RT_NULL, RT_NULL},
+ {61, 0, RT_NULL, RT_NULL},
+ {62, 0, RT_NULL, RT_NULL},
+ {63, 0, RT_NULL, RT_NULL},
+ {64, 0, RT_NULL, RT_NULL},
+ {65, 0, RT_NULL, RT_NULL},
+ {66, 0, RT_NULL, RT_NULL},
+ {67, 0, RT_NULL, RT_NULL},
+ {68, 0, RT_NULL, RT_NULL},
+ {69, 0, RT_NULL, RT_NULL},
+ {70, 0, RT_NULL, RT_NULL},
+ {71, 0, RT_NULL, RT_NULL},
+ {72, 0, RT_NULL, RT_NULL},
+ {73, 0, RT_NULL, RT_NULL},
+ {74, 0, RT_NULL, RT_NULL},
+ {75, 0, RT_NULL, RT_NULL},
+ {76, 0, RT_NULL, RT_NULL},
+ {77, 0, RT_NULL, RT_NULL},
+ {78, 0, RT_NULL, RT_NULL},
+ {79, 0, RT_NULL, RT_NULL},
+ {80, 0, RT_NULL, RT_NULL},
+ {81, 0, RT_NULL, RT_NULL},
+ {82, 0, RT_NULL, RT_NULL},
+ {83, 0, RT_NULL, RT_NULL},
+ {84, 0, RT_NULL, RT_NULL},
+ {85, 0, RT_NULL, RT_NULL},
+ {86, 0, RT_NULL, RT_NULL},
+ {87, 0, RT_NULL, RT_NULL},
+ {88, 0, RT_NULL, RT_NULL},
+ {89, 0, RT_NULL, RT_NULL},
+ {90, 0, RT_NULL, RT_NULL},
+ {91, 0, RT_NULL, RT_NULL},
+ {92, 0, RT_NULL, RT_NULL},
+ {93, 0, RT_NULL, RT_NULL},
+ {94, 0, RT_NULL, RT_NULL},
+ {95, 0, RT_NULL, RT_NULL},
+ {96, 0, RT_NULL, RT_NULL},
+ {97, 0, RT_NULL, RT_NULL},
+ {98, 0, RT_NULL, RT_NULL},
+ {99, 0, RT_NULL, RT_NULL},
+ {100, 0, RT_NULL, RT_NULL},
+ {101, 0, RT_NULL, RT_NULL},
+ {102, 0, RT_NULL, RT_NULL},
+ {103, 0, RT_NULL, RT_NULL},
+ {104, 0, RT_NULL, RT_NULL},
+ {105, 0, RT_NULL, RT_NULL},
+ {106, 0, RT_NULL, RT_NULL},
+ {107, 0, RT_NULL, RT_NULL},
+ {108, 0, RT_NULL, RT_NULL},
+ {109, 0, RT_NULL, RT_NULL},
+ {110, 0, RT_NULL, RT_NULL},
+ {111, 0, RT_NULL, RT_NULL}};
+
+#define ITEM_NUM(items) sizeof(items) / sizeof(items[0])
+
+static const struct swm_pin_device *_pin2struct(uint8_t pin)
+{
+ const struct swm_pin_device *gpio_obj;
+
+ if (pin < ITEM_NUM(pin_obj))
+ {
+ gpio_obj = &pin_obj[pin];
+ }
+ else
+ {
+ gpio_obj = RT_NULL;
+ }
+
+ return gpio_obj;
+}
+
+static void swm_pin_mode(rt_device_t dev, rt_base_t pin, rt_uint8_t mode)
+{
+ const struct swm_pin_device *gpio_obj;
+ int dir = 0;
+ int pull_up = 0;
+ int pull_down = 0;
+ int open_drain = 0;
+
+ gpio_obj = _pin2struct(pin);
+ if (gpio_obj == RT_NULL)
+ {
+ return;
+ }
+ /* Configure GPIO_InitStructure */
+ switch (mode)
+ {
+ case PIN_MODE_OUTPUT:
+ /* output setting */
+ dir = 1;
+ break;
+ case PIN_MODE_INPUT:
+ /* input setting: not pull. */
+ dir = 0;
+ break;
+ case PIN_MODE_INPUT_PULLUP:
+ /* input setting: pull up. */
+ dir = 0;
+ pull_up = 1;
+ break;
+ case PIN_MODE_INPUT_PULLDOWN:
+ /* input setting: pull down. */
+ dir = 0;
+ pull_down = 1;
+ break;
+ case PIN_MODE_OUTPUT_OD:
+ /* output setting: od. */
+ dir = 1;
+ open_drain = 1;
+ break;
+ }
+
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, dir, pull_up, pull_down, open_drain);
+}
+
+static void swm_pin_write(rt_device_t dev, rt_base_t pin, rt_uint8_t value)
+{
+ const struct swm_pin_device *gpio_obj;
+
+ gpio_obj = _pin2struct(pin);
+ if (gpio_obj == RT_NULL)
+ {
+ return;
+ }
+ if (value)
+ {
+ GPIO_AtomicSetBit(gpio_obj->gpio, gpio_obj->pin);
+ }
+ else
+ {
+ GPIO_AtomicClrBit(gpio_obj->gpio, gpio_obj->pin);
+ }
+}
+
+static rt_int8_t swm_pin_read(rt_device_t dev, rt_base_t pin)
+{
+ const struct swm_pin_device *gpio_obj;
+
+ gpio_obj = _pin2struct(pin);
+ if (gpio_obj == RT_NULL)
+ {
+ return PIN_LOW;
+ }
+ return (rt_int8_t)GPIO_GetBit(gpio_obj->gpio, gpio_obj->pin);
+}
+
+static rt_err_t swm_pin_attach_irq(struct rt_device *device,
+ rt_base_t pin,
+ rt_uint8_t mode,
+ void (*hdr)(void *args),
+ void *args)
+{
+ rt_base_t level;
+
+ level = rt_hw_interrupt_disable();
+ if (pin_irq_hdr_tab[pin].pin == pin &&
+ pin_irq_hdr_tab[pin].mode == mode &&
+ pin_irq_hdr_tab[pin].hdr == hdr &&
+ pin_irq_hdr_tab[pin].args == args)
+ {
+ rt_hw_interrupt_enable(level);
+ return RT_EOK;
+ }
+ pin_irq_hdr_tab[pin].pin = pin;
+ pin_irq_hdr_tab[pin].mode = mode;
+ pin_irq_hdr_tab[pin].hdr = hdr;
+ pin_irq_hdr_tab[pin].args = args;
+ rt_hw_interrupt_enable(level);
+ return RT_EOK;
+}
+
+static rt_err_t swm_pin_detach_irq(struct rt_device *device, rt_base_t pin)
+{
+ rt_base_t level;
+
+ level = rt_hw_interrupt_disable();
+ pin_irq_hdr_tab[pin].mode = 0;
+ pin_irq_hdr_tab[pin].hdr = RT_NULL;
+ pin_irq_hdr_tab[pin].args = RT_NULL;
+ rt_hw_interrupt_enable(level);
+ return RT_EOK;
+}
+
+static rt_err_t swm_pin_irq_enable(struct rt_device *device,
+ rt_base_t pin,
+ rt_uint8_t enabled)
+{
+ const struct swm_pin_device *gpio_obj;
+ rt_base_t level = 0;
+
+ gpio_obj = _pin2struct(pin);
+ if (gpio_obj == RT_NULL)
+ {
+ return -RT_ENOSYS;
+ }
+
+ if (enabled == PIN_IRQ_ENABLE)
+ {
+ switch (pin_irq_hdr_tab[pin].mode)
+ {
+ case PIN_IRQ_MODE_RISING:
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, 0, 0, 1, 0);
+ EXTI_Init(gpio_obj->gpio, gpio_obj->pin, EXTI_RISE_EDGE);
+ break;
+ case PIN_IRQ_MODE_FALLING:
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, 0, 1, 0, 0);
+ EXTI_Init(gpio_obj->gpio, gpio_obj->pin, EXTI_FALL_EDGE);
+ break;
+ case PIN_IRQ_MODE_RISING_FALLING:
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, 0, 1, 1, 0);
+ EXTI_Init(gpio_obj->gpio, gpio_obj->pin, EXTI_BOTH_EDGE);
+ break;
+ case PIN_IRQ_MODE_HIGH_LEVEL:
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, 0, 0, 1, 0);
+ EXTI_Init(gpio_obj->gpio, gpio_obj->pin, EXTI_HIGH_LEVEL);
+ break;
+ case PIN_IRQ_MODE_LOW_LEVEL:
+ GPIO_Init(gpio_obj->gpio, gpio_obj->pin, 0, 1, 0, 0);
+ EXTI_Init(gpio_obj->gpio, gpio_obj->pin, EXTI_LOW_LEVEL);
+ break;
+ default:
+ return -RT_EINVAL;
+ }
+
+ level = rt_hw_interrupt_disable();
+ NVIC_EnableIRQ(gpio_obj->irq);
+ EXTI_Open(gpio_obj->gpio, gpio_obj->pin);
+ rt_hw_interrupt_enable(level);
+ }
+ else if (enabled == PIN_IRQ_DISABLE)
+ {
+ level = rt_hw_interrupt_disable();
+ // NVIC_DisableIRQ(gpio_obj->irq);
+ EXTI_Close(gpio_obj->gpio, gpio_obj->pin);
+ rt_hw_interrupt_enable(level);
+ }
+ else
+ {
+ return -RT_ENOSYS;
+ }
+ return RT_EOK;
+}
+
+static rt_base_t swm_pin_get(const char *name)
+{
+ rt_base_t pin = 0;
+ int pin_num = 0;
+ int i, name_len;
+
+ name_len = rt_strlen(name);
+
+ if ((name_len < 4) || (name_len >= 6))
+ {
+ goto out;
+ }
+ if ((name[0] != 'P') || (name[2] != '.'))
+ {
+ goto out;
+ }
+
+ switch(name[1])
+ {
+ case 'A':
+ pin = 0;
+ break;
+ case 'B':
+ pin = 16;
+ break;
+ case 'C':
+ pin = 32;
+ break;
+ case 'D':
+ pin = 48;
+ break;
+ case 'E':
+ pin = 64;
+ break;
+ case 'M':
+ pin = 80;
+ break;
+ case 'N':
+ pin = 96;
+ break;
+ default:
+ goto out;
+ }
+
+ for (i = 3; i < name_len; i++)
+ {
+ pin_num *= 10;
+ pin_num += name[i] - '0';
+ }
+ if(pin_num < 16)
+ {
+ pin += pin_num;
+ }
+ else
+ {
+ goto out;
+ }
+
+ return pin;
+out:
+ rt_kprintf("Px.y x:A/B/C/D/E/M/N y:0~15, e.g. PA.0\n");
+ return -RT_EINVAL;
+}
+
+static const struct rt_pin_ops swm_pin_ops =
+ {
+ .pin_mode = swm_pin_mode,
+ .pin_write = swm_pin_write,
+ .pin_read = swm_pin_read,
+ .pin_attach_irq = swm_pin_attach_irq,
+ .pin_detach_irq = swm_pin_detach_irq,
+ .pin_irq_enable = swm_pin_irq_enable,
+ .pin_get = swm_pin_get};
+
+static void swm_pin_isr(GPIO_TypeDef *GPIOx)
+{
+ static int gpio[16];
+ int index = 0;
+ static int init = 0;
+ const struct swm_pin_device *gpio_obj;
+
+ if (init == 0)
+ {
+ init = 1;
+ for (gpio_obj = &pin_obj[0];
+ gpio_obj->index < ITEM_NUM(pin_obj);
+ gpio_obj++)
+ {
+ if (gpio_obj->gpio == GPIOx)
+ {
+ gpio[index] = gpio_obj->index;
+ index++;
+ RT_ASSERT(index <= 16)
+ }
+ }
+ }
+ for (index = 0; index < 16; index++)
+ {
+ gpio_obj = _pin2struct(gpio[index]);
+ if (EXTI_State(gpio_obj->gpio, gpio_obj->pin))
+ {
+ EXTI_Clear(gpio_obj->gpio, gpio_obj->pin);
+ if (pin_irq_hdr_tab[gpio_obj->index].hdr)
+ {
+ pin_irq_hdr_tab[gpio_obj->index].hdr(pin_irq_hdr_tab[gpio_obj->index].args);
+ }
+ }
+ }
+}
+
+void GPIOA_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOA);
+ rt_interrupt_leave();
+}
+
+void GPIOB_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOB);
+ rt_interrupt_leave();
+}
+
+void GPIOC_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOC);
+ rt_interrupt_leave();
+}
+
+void GPIOD_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOD);
+ rt_interrupt_leave();
+}
+
+void GPIOE_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOE);
+ rt_interrupt_leave();
+}
+
+void GPIOM_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPIOM);
+ rt_interrupt_leave();
+}
+
+void GPION_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_pin_isr(GPION);
+ rt_interrupt_leave();
+}
+
+int swm_pin_init(void)
+{
+ return rt_device_pin_register("pin", &swm_pin_ops, RT_NULL);
+}
+
+#endif /* BSP_USING_GPIO */
+#endif /* RT_USING_PIN */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_gpio.h b/bsp/synwit/libraries/SWM341_drivers/drv_gpio.h
new file mode 100644
index 0000000000..c4cbc01d1c
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_gpio.h
@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_GPIO_H__
+#define __DRV_GPIO_H__
+
+#include "board.h"
+
+#define GET_PIN(GPIOx,PIN) (rt_uint8_t)__SWM_GET_PIN_##GPIOx(PIN)
+
+#define __SWM_GET_PIN_A(PIN) (PIN)
+#define __SWM_GET_PIN_B(PIN) (16 + PIN)
+#define __SWM_GET_PIN_C(PIN) (32 + PIN)
+#define __SWM_GET_PIN_D(PIN) (48 + PIN)
+#define __SWM_GET_PIN_E(PIN) (64 + PIN)
+#define __SWM_GET_PIN_M(PIN) (80 + PIN)
+#define __SWM_GET_PIN_N(PIN) (96 + PIN)
+
+int swm_pin_init(void);
+
+#endif /* __DRV_GPIO_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.c b/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.c
new file mode 100644
index 0000000000..c66836b32f
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.c
@@ -0,0 +1,615 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_hwtimer.h"
+
+#ifdef RT_USING_HWTIMER
+#ifdef BSP_USING_TIM
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.hwtimer"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_TIM0) && !defined(BSP_USING_TIM1) && !defined(BSP_USING_TIM2) && !defined(BSP_USING_TIM3) \
+&& !defined(BSP_USING_TIM4) && !defined(BSP_USING_BTIM0) && !defined(BSP_USING_BTIM1) && !defined(BSP_USING_BTIM2) \
+&& !defined(BSP_USING_BTIM3) && !defined(BSP_USING_BTIM4) && !defined(BSP_USING_BTIM5) && !defined(BSP_USING_BTIM6) \
+&& !defined(BSP_USING_BTIM7) && !defined(BSP_USING_BTIM8) && !defined(BSP_USING_BTIM9) && !defined(BSP_USING_BTIM10) \
+&& !defined(BSP_USING_BTIM11)
+#error "Please define at least one BSP_USING_TIMx or BSP_USING_BTIMx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+#ifndef TIM_DEV_INFO_CONFIG
+#define TIM_DEV_INFO_CONFIG \
+ { \
+ .maxfreq = 1000000, \
+ .minfreq = 1000000, \
+ .maxcnt = 0xFFFFFFFF, \
+ .cntmode = HWTIMER_CNTMODE_DW, \
+ }
+#endif /* TIM_DEV_INFO_CONFIG */
+
+#ifdef BSP_USING_TIM0
+#ifndef TIM0_CFG
+#define TIM0_CFG \
+ { \
+ .name = "timer0", \
+ .TIMRx = TIMR0, \
+ }
+#endif /* TIM0_CFG */
+#endif /* BSP_USING_TIM0 */
+
+#ifdef BSP_USING_TIM1
+#ifndef TIM1_CFG
+#define TIM1_CFG \
+ { \
+ .name = "timer1", \
+ .TIMRx = TIMR1, \
+ }
+#endif /* TIM1_CFG */
+#endif /* BSP_USING_TIM1 */
+
+#ifdef BSP_USING_TIM2
+#ifndef TIM2_CFG
+#define TIM2_CFG \
+ { \
+ .name = "timer2", \
+ .TIMRx = TIMR2, \
+ }
+#endif /* TIM2_CFG */
+#endif /* BSP_USING_TIM2 */
+
+#ifdef BSP_USING_TIM3
+#ifndef TIM3_CFG
+#define TIM3_CFG \
+ { \
+ .name = "timer3", \
+ .TIMRx = TIMR3, \
+ }
+#endif /* TIM3_CFG */
+#endif /* BSP_USING_TIM3 */
+
+#ifdef BSP_USING_TIM4
+#ifndef TIM4_CFG
+#define TIM4_CFG \
+ { \
+ .name = "timer4", \
+ .TIMRx = TIMR4, \
+ }
+#endif /* TIM4_CFG */
+#endif /* BSP_USING_TIM4 */
+
+#ifdef BSP_USING_BTIM0
+#ifndef BTIM0_CFG
+#define BTIM0_CFG \
+ { \
+ .name = "btimer0", \
+ .TIMRx = BTIMR0, \
+ }
+#endif /* BTIM0_CFG */
+#endif /* BSP_USING_BTIM0 */
+
+#ifdef BSP_USING_BTIM1
+#ifndef BTIM1_CFG
+#define BTIM1_CFG \
+ { \
+ .name = "btimer1", \
+ .TIMRx = BTIMR1, \
+ }
+#endif /* BTIM1_CFG */
+#endif /* BSP_USING_BTIM1 */
+
+#ifdef BSP_USING_BTIM2
+#ifndef BTIM2_CFG
+#define BTIM2_CFG \
+ { \
+ .name = "btimer2", \
+ .TIMRx = BTIMR2, \
+ }
+#endif /* BTIM2_CFG */
+#endif /* BSP_USING_BTIM2 */
+
+#ifdef BSP_USING_BTIM3
+#ifndef BTIM3_CFG
+#define BTIM3_CFG \
+ { \
+ .name = "btimer3", \
+ .TIMRx = BTIMR3, \
+ }
+#endif /* BTIM3_CFG */
+#endif /* BSP_USING_BTIM3 */
+
+#ifdef BSP_USING_BTIM4
+#ifndef BTIM4_CFG
+#define BTIM4_CFG \
+ { \
+ .name = "btimer4", \
+ .TIMRx = BTIMR4, \
+ }
+#endif /* BTIM4_CFG */
+#endif /* BSP_USING_BTIM4 */
+
+#ifdef BSP_USING_BTIM5
+#ifndef BTIM5_CFG
+#define BTIM5_CFG \
+ { \
+ .name = "btimer5", \
+ .TIMRx = BTIMR5, \
+ }
+#endif /* BTIM5_CFG */
+#endif /* BSP_USING_BTIM5 */
+
+#ifdef BSP_USING_BTIM6
+#ifndef BTIM6_CFG
+#define BTIM6_CFG \
+ { \
+ .name = "btimer6", \
+ .TIMRx = BTIMR6, \
+ }
+#endif /* BTIM6_CFG */
+#endif /* BSP_USING_BTIM6 */
+
+#ifdef BSP_USING_BTIM7
+#ifndef BTIM7_CFG
+#define BTIM7_CFG \
+ { \
+ .name = "btimer7", \
+ .TIMRx = BTIMR7, \
+ }
+#endif /* BTIM7_CFG */
+#endif /* BSP_USING_BTIM7 */
+
+#ifdef BSP_USING_BTIM8
+#ifndef BTIM8_CFG
+#define BTIM8_CFG \
+ { \
+ .name = "btimer8", \
+ .TIMRx = BTIMR8, \
+ }
+#endif /* BTIM8_CFG */
+#endif /* BSP_USING_BTIM8 */
+
+#ifdef BSP_USING_BTIM9
+#ifndef BTIM9_CFG
+#define BTIM9_CFG \
+ { \
+ .name = "btimer9", \
+ .TIMRx = BTIMR9, \
+ }
+#endif /* BTIM9_CFG */
+#endif /* BSP_USING_BTIM9 */
+
+#ifdef BSP_USING_BTIM10
+#ifndef BTIM10_CFG
+#define BTIM10_CFG \
+ { \
+ .name = "btimer10", \
+ .TIMRx = BTIMR10, \
+ }
+#endif /* BTIM10_CFG */
+#endif /* BSP_USING_BTIM10 */
+
+#ifdef BSP_USING_BTIM11
+#ifndef BTIM11_CFG
+#define BTIM11_CFG \
+ { \
+ .name = "btimer11", \
+ .TIMRx = BTIMR11, \
+ }
+#endif /* BTIM11_CFG */
+#endif /* BSP_USING_BTIM11 */
+
+struct swm_hwtimer_cfg
+{
+ char *name;
+ TIMR_TypeDef *TIMRx;
+};
+
+struct swm_hwtimer_device
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg;
+ rt_hwtimer_t time_device;
+};
+
+enum
+{
+#ifdef BSP_USING_TIM0
+ TIM0_INDEX,
+#endif
+#ifdef BSP_USING_TIM1
+ TIM1_INDEX,
+#endif
+#ifdef BSP_USING_TIM2
+ TIM2_INDEX,
+#endif
+#ifdef BSP_USING_TIM3
+ TIM3_INDEX,
+#endif
+#ifdef BSP_USING_TIM4
+ TIM4_INDEX,
+#endif
+#ifdef BSP_USING_BTIM0
+ BTIM0_INDEX,
+#endif
+#ifdef BSP_USING_BTIM1
+ BTIM1_INDEX,
+#endif
+#ifdef BSP_USING_BTIM2
+ BTIM2_INDEX,
+#endif
+#ifdef BSP_USING_BTIM3
+ BTIM3_INDEX,
+#endif
+#ifdef BSP_USING_BTIM4
+ BTIM4_INDEX,
+#endif
+#ifdef BSP_USING_BTIM5
+ BTIM5_INDEX,
+#endif
+#ifdef BSP_USING_BTIM6
+ BTIM6_INDEX,
+#endif
+#ifdef BSP_USING_BTIM7
+ BTIM7_INDEX,
+#endif
+#ifdef BSP_USING_BTIM8
+ BTIM8_INDEX,
+#endif
+#ifdef BSP_USING_BTIM9
+ BTIM9_INDEX,
+#endif
+#ifdef BSP_USING_BTIM10
+ BTIM10_INDEX,
+#endif
+#ifdef BSP_USING_BTIM11
+ BTIM11_INDEX,
+#endif
+};
+
+static struct swm_hwtimer_cfg swm_hwtimer_cfg[] =
+ {
+#ifdef BSP_USING_TIM0
+ TIM0_CFG,
+#endif
+#ifdef BSP_USING_TIM1
+ TIM1_CFG,
+#endif
+#ifdef BSP_USING_TIM2
+ TIM2_CFG,
+#endif
+#ifdef BSP_USING_TIM3
+ TIM3_CFG,
+#endif
+#ifdef BSP_USING_TIM4
+ TIM4_CFG,
+#endif
+#ifdef BSP_USING_BTIM0
+ BTIM0_CFG,
+#endif
+#ifdef BSP_USING_BTIM1
+ BTIM1_CFG,
+#endif
+#ifdef BSP_USING_BTIM2
+ BTIM2_CFG,
+#endif
+#ifdef BSP_USING_BTIM3
+ BTIM3_CFG,
+#endif
+#ifdef BSP_USING_BTIM4
+ BTIM4_CFG,
+#endif
+#ifdef BSP_USING_BTIM5
+ BTIM5_CFG,
+#endif
+#ifdef BSP_USING_BTIM6
+ BTIM6_CFG,
+#endif
+#ifdef BSP_USING_BTIM7
+ BTIM7_CFG,
+#endif
+#ifdef BSP_USING_BTIM8
+ BTIM8_CFG,
+#endif
+#ifdef BSP_USING_BTIM9
+ BTIM9_CFG,
+#endif
+#ifdef BSP_USING_BTIM10
+ BTIM10_CFG,
+#endif
+#ifdef BSP_USING_BTIM11
+ BTIM11_CFG,
+#endif
+};
+
+static struct swm_hwtimer_device hwtimer_obj[sizeof(swm_hwtimer_cfg) / sizeof(swm_hwtimer_cfg[0])] = {0};
+
+static void swm_timer_configure(struct rt_hwtimer_device *timer_device, rt_uint32_t state)
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ RT_ASSERT(timer_device != RT_NULL);
+
+ if (state)
+ {
+ hwtimer_cfg = timer_device->parent.user_data;
+ TIMR_Init(hwtimer_cfg->TIMRx, TIMR_MODE_TIMER, CyclesPerUs, 1000000, 1);
+ timer_device->freq = 1000000;
+ }
+}
+
+static rt_err_t swm_timer_start(rt_hwtimer_t *timer_device, rt_uint32_t cnt, rt_hwtimer_mode_t opmode)
+{
+ rt_err_t result = RT_EOK;
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ RT_ASSERT(timer_device != RT_NULL);
+ hwtimer_cfg = timer_device->parent.user_data;
+
+ if (opmode == HWTIMER_MODE_ONESHOT)
+ {
+ /* set timer to single mode */
+ timer_device->mode = HWTIMER_MODE_ONESHOT;
+ }
+ else
+ {
+ timer_device->mode = HWTIMER_MODE_PERIOD;
+ }
+ hwtimer_cfg->TIMRx->LOAD = cnt - 1;
+ TIMR_Stop(hwtimer_cfg->TIMRx);
+ TIMR_Start(hwtimer_cfg->TIMRx);
+
+ return result;
+}
+
+static void swm_timer_stop(rt_hwtimer_t *timer_device)
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ RT_ASSERT(timer_device != RT_NULL);
+ hwtimer_cfg = timer_device->parent.user_data;
+
+ /* stop timer */
+ TIMR_Stop(hwtimer_cfg->TIMRx);
+}
+
+static rt_uint32_t swm_timer_count_get(rt_hwtimer_t *timer_device)
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ RT_ASSERT(timer_device != RT_NULL);
+ hwtimer_cfg = timer_device->parent.user_data;
+
+ return TIMR_GetCurValue(hwtimer_cfg->TIMRx);
+}
+
+static rt_err_t swm_timer_control(rt_hwtimer_t *timer_device, rt_uint32_t cmd, void *args)
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ rt_err_t result = RT_EOK;
+ RT_ASSERT(timer_device != RT_NULL);
+ RT_ASSERT(args != RT_NULL);
+ hwtimer_cfg = timer_device->parent.user_data;
+
+ switch (cmd)
+ {
+ case HWTIMER_CTRL_FREQ_SET:
+ {
+ rt_uint32_t freq;
+ freq = *(rt_uint32_t *)args;
+
+ TIMR_Init(hwtimer_cfg->TIMRx, TIMR_MODE_TIMER, CyclesPerUs, freq, 1);
+ }
+ break;
+ default:
+ {
+ result = -RT_ENOSYS;
+ }
+ break;
+ }
+
+ return result;
+}
+
+static const struct rt_hwtimer_info _info = TIM_DEV_INFO_CONFIG;
+
+static const struct rt_hwtimer_ops swm_timer_ops =
+ {
+ .init = swm_timer_configure,
+ .start = swm_timer_start,
+ .stop = swm_timer_stop,
+ .count_get = swm_timer_count_get,
+ .control = swm_timer_control};
+
+void swm_timer_isr(rt_hwtimer_t *timer_device)
+{
+ struct swm_hwtimer_cfg *hwtimer_cfg = RT_NULL;
+ RT_ASSERT(timer_device != RT_NULL);
+ hwtimer_cfg = timer_device->parent.user_data;
+
+ TIMR_INTClr(hwtimer_cfg->TIMRx);
+ rt_device_hwtimer_isr(timer_device);
+}
+
+#ifdef BSP_USING_TIM0
+void TIMR0_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[TIM0_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_TIM0
+
+#ifdef BSP_USING_TIM1
+void TIMR1_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[TIM1_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_TIM1
+
+#ifdef BSP_USING_TIM2
+void TIMR2_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[TIM2_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_TIM2
+
+#ifdef BSP_USING_TIM3
+void TIMR3_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[TIM3_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_TIM3
+
+#ifdef BSP_USING_TIM4
+void TIMR4_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[TIM4_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_TIM4
+
+#ifdef BSP_USING_BTIM0
+void BTIMR0_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM0_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM0
+
+#ifdef BSP_USING_BTIM1
+void BTIMR1_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM1_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM1
+
+#ifdef BSP_USING_BTIM2
+void BTIMR2_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM2_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM2
+
+#ifdef BSP_USING_BTIM3
+void BTIMR3_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM3_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM3
+
+#ifdef BSP_USING_BTIM4
+void BTIMR4_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM4_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM4
+
+#ifdef BSP_USING_BTIM5
+void BTIMR5_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM5_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM5
+
+#ifdef BSP_USING_BTIM6
+void BTIMR6_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM6_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM6
+
+#ifdef BSP_USING_BTIM7
+void BTIMR7_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM7_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM7
+
+#ifdef BSP_USING_BTIM8
+void BTIMR8_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM8_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM8
+
+#ifdef BSP_USING_BTIM9
+void BTIMR9_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM9_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM9
+
+#ifdef BSP_USING_BTIM10
+void BTIMR10_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM10_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM10
+
+#ifdef BSP_USING_BTIM11
+void BTIMR11_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_timer_isr(&(hwtimer_obj[BTIM11_INDEX].time_device));
+ rt_interrupt_leave();
+}
+#endif // BSP_USING_BTIM11
+
+int swm_timer_init(void)
+{
+ int i = 0;
+ int result = RT_EOK;
+
+ for (i = 0; i < sizeof(swm_hwtimer_cfg) / sizeof(swm_hwtimer_cfg[0]); i++)
+ {
+ hwtimer_obj[i].hwtimer_cfg = &swm_hwtimer_cfg[i];
+ hwtimer_obj[i].time_device.info = &_info;
+ hwtimer_obj[i].time_device.ops = &swm_timer_ops;
+ result = rt_device_hwtimer_register(&hwtimer_obj[i].time_device, hwtimer_obj[i].hwtimer_cfg->name, hwtimer_obj[i].hwtimer_cfg);
+ if (result != RT_EOK)
+ {
+ LOG_E("%s register fail.", hwtimer_obj[i].hwtimer_cfg->name);
+ }
+ else
+ {
+ LOG_D("%s register success.", hwtimer_obj[i].hwtimer_cfg->name);
+ }
+ }
+
+ return result;
+}
+INIT_BOARD_EXPORT(swm_timer_init);
+
+#endif /* BSP_USING_TIM */
+#endif /* RT_USING_HWTIMER */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.h b/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.h
new file mode 100644
index 0000000000..861d447b7b
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_hwtimer.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_HWTIMER_H__
+#define __DRV_HWTIMER_H__
+
+#include "board.h"
+
+int swm_timer_init(void);
+
+#endif /* __DRV_HWTIMER_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_log.h b/bsp/synwit/libraries/SWM341_drivers/drv_log.h
new file mode 100644
index 0000000000..de007648c3
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_log.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2006-2022, 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/synwit/libraries/SWM341_drivers/drv_pwm.c b/bsp/synwit/libraries/SWM341_drivers/drv_pwm.c
new file mode 100644
index 0000000000..2e9c9837d8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_pwm.c
@@ -0,0 +1,408 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_pwm.h"
+
+#ifdef RT_USING_PWM
+#ifdef BSP_USING_PWM
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.pwm"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_PWM0) && !defined(BSP_USING_PWM1) && !defined(BSP_USING_PWM2) && !defined(BSP_USING_PWM3) && !defined(BSP_USING_PWM4)
+#error "Please define at least one BSP_USING_PWMx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+#define MIN_PERIOD 2
+#define MIN_PULSE 1
+
+#ifdef BSP_USING_PWM0
+#ifndef PWM0_CFG
+#define PWM0_CFG \
+ { \
+ .name = "pwm0", \
+ .PWMx = PWM0, \
+ .pwm_initstruct.Mode = PWM_CENTER_ALIGNED, \
+ .pwm_initstruct.Clkdiv = 15, \
+ .pwm_initstruct.Period = 10000, \
+ .pwm_initstruct.HdutyA = 5000, \
+ .pwm_initstruct.DeadzoneA = 0, \
+ .pwm_initstruct.IdleLevelA = 0, \
+ .pwm_initstruct.IdleLevelAN = 0, \
+ .pwm_initstruct.OutputInvA = 0, \
+ .pwm_initstruct.OutputInvAN = 1, \
+ .pwm_initstruct.HdutyB = 5000, \
+ .pwm_initstruct.DeadzoneB = 0, \
+ .pwm_initstruct.IdleLevelB = 0, \
+ .pwm_initstruct.IdleLevelBN = 0, \
+ .pwm_initstruct.OutputInvB = 0, \
+ .pwm_initstruct.OutputInvBN = 1, \
+ .pwm_initstruct.UpOvfIE = 0, \
+ .pwm_initstruct.DownOvfIE = 0, \
+ .pwm_initstruct.UpCmpAIE = 0, \
+ .pwm_initstruct.DownCmpAIE = 0, \
+ .pwm_initstruct.UpCmpBIE = 0, \
+ .pwm_initstruct.DownCmpBIE = 0, \
+ .pwm_mask = PWM0_MSK, \
+ }
+#endif /* PWM0_CFG */
+#endif /* BSP_USING_PWM0 */
+
+#ifdef BSP_USING_PWM1
+#ifndef PWM1_CFG
+#define PWM1_CFG \
+ { \
+ .name = "pwm1", \
+ .PWMx = PWM1, \
+ .pwm_initstruct.Mode = PWM_CENTER_ALIGNED, \
+ .pwm_initstruct.Clkdiv = 15, \
+ .pwm_initstruct.Period = 10000, \
+ .pwm_initstruct.HdutyA = 5000, \
+ .pwm_initstruct.DeadzoneA = 0, \
+ .pwm_initstruct.IdleLevelA = 0, \
+ .pwm_initstruct.IdleLevelAN = 0, \
+ .pwm_initstruct.OutputInvA = 0, \
+ .pwm_initstruct.OutputInvAN = 1, \
+ .pwm_initstruct.HdutyB = 5000, \
+ .pwm_initstruct.DeadzoneB = 0, \
+ .pwm_initstruct.IdleLevelB = 0, \
+ .pwm_initstruct.IdleLevelBN = 0, \
+ .pwm_initstruct.OutputInvB = 0, \
+ .pwm_initstruct.OutputInvBN = 1, \
+ .pwm_initstruct.UpOvfIE = 0, \
+ .pwm_initstruct.DownOvfIE = 0, \
+ .pwm_initstruct.UpCmpAIE = 0, \
+ .pwm_initstruct.DownCmpAIE = 0, \
+ .pwm_initstruct.UpCmpBIE = 0, \
+ .pwm_initstruct.DownCmpBIE = 0, \
+ .pwm_mask = PWM1_MSK, \
+ }
+#endif /* PWM1_CFG */
+#endif /* BSP_USING_PWM1 */
+
+#ifdef BSP_USING_PWM2
+#ifndef PWM2_CFG
+#define PWM2_CFG \
+ { \
+ .name = "pwm2", \
+ .PWMx = PWM2, \
+ .pwm_initstruct.Mode = PWM_CENTER_ALIGNED, \
+ .pwm_initstruct.Clkdiv = 15, \
+ .pwm_initstruct.Period = 10000, \
+ .pwm_initstruct.HdutyA = 5000, \
+ .pwm_initstruct.DeadzoneA = 0, \
+ .pwm_initstruct.IdleLevelA = 0, \
+ .pwm_initstruct.IdleLevelAN = 0, \
+ .pwm_initstruct.OutputInvA = 0, \
+ .pwm_initstruct.OutputInvAN = 1, \
+ .pwm_initstruct.HdutyB = 5000, \
+ .pwm_initstruct.DeadzoneB = 0, \
+ .pwm_initstruct.IdleLevelB = 0, \
+ .pwm_initstruct.IdleLevelBN = 0, \
+ .pwm_initstruct.OutputInvB = 0, \
+ .pwm_initstruct.OutputInvBN = 1, \
+ .pwm_initstruct.UpOvfIE = 0, \
+ .pwm_initstruct.DownOvfIE = 0, \
+ .pwm_initstruct.UpCmpAIE = 0, \
+ .pwm_initstruct.DownCmpAIE = 0, \
+ .pwm_initstruct.UpCmpBIE = 0, \
+ .pwm_initstruct.DownCmpBIE = 0, \
+ .pwm_mask = PWM2_MSK, \
+ }
+#endif /* PWM2_CFG */
+#endif /* BSP_USING_PWM2 */
+
+#ifdef BSP_USING_PWM3
+#ifndef PWM3_CFG
+#define PWM3_CFG \
+ { \
+ .name = "pwm3", \
+ .PWMx = PWM3, \
+ .pwm_initstruct.Mode = PWM_CENTER_ALIGNED, \
+ .pwm_initstruct.Clkdiv = 15, \
+ .pwm_initstruct.Period = 10000, \
+ .pwm_initstruct.HdutyA = 5000, \
+ .pwm_initstruct.DeadzoneA = 0, \
+ .pwm_initstruct.IdleLevelA = 0, \
+ .pwm_initstruct.IdleLevelAN = 0, \
+ .pwm_initstruct.OutputInvA = 0, \
+ .pwm_initstruct.OutputInvAN = 1, \
+ .pwm_initstruct.HdutyB = 5000, \
+ .pwm_initstruct.DeadzoneB = 0, \
+ .pwm_initstruct.IdleLevelB = 0, \
+ .pwm_initstruct.IdleLevelBN = 0, \
+ .pwm_initstruct.OutputInvB = 0, \
+ .pwm_initstruct.OutputInvBN = 1, \
+ .pwm_initstruct.UpOvfIE = 0, \
+ .pwm_initstruct.DownOvfIE = 0, \
+ .pwm_initstruct.UpCmpAIE = 0, \
+ .pwm_initstruct.DownCmpAIE = 0, \
+ .pwm_initstruct.UpCmpBIE = 0, \
+ .pwm_initstruct.DownCmpBIE = 0, \
+ .pwm_mask = PWM3_MSK, \
+ }
+#endif /* PWM3_CFG */
+#endif /* BSP_USING_PWM3 */
+
+#ifdef BSP_USING_PWM4
+#ifndef PWM4_CFG
+#define PWM4_CFG \
+ { \
+ .name = "pwm4", \
+ .PWMx = PWM4, \
+ .pwm_initstruct.Mode = PWM_CENTER_ALIGNED, \
+ .pwm_initstruct.Clkdiv = 15, \
+ .pwm_initstruct.Period = 10000, \
+ .pwm_initstruct.HdutyA = 5000, \
+ .pwm_initstruct.DeadzoneA = 0, \
+ .pwm_initstruct.IdleLevelA = 0, \
+ .pwm_initstruct.IdleLevelAN = 0, \
+ .pwm_initstruct.OutputInvA = 0, \
+ .pwm_initstruct.OutputInvAN = 1, \
+ .pwm_initstruct.HdutyB = 5000, \
+ .pwm_initstruct.DeadzoneB = 0, \
+ .pwm_initstruct.IdleLevelB = 0, \
+ .pwm_initstruct.IdleLevelBN = 0, \
+ .pwm_initstruct.OutputInvB = 0, \
+ .pwm_initstruct.OutputInvBN = 1, \
+ .pwm_initstruct.UpOvfIE = 0, \
+ .pwm_initstruct.DownOvfIE = 0, \
+ .pwm_initstruct.UpCmpAIE = 0, \
+ .pwm_initstruct.DownCmpAIE = 0, \
+ .pwm_initstruct.UpCmpBIE = 0, \
+ .pwm_initstruct.DownCmpBIE = 0, \
+ .pwm_mask = PWM4_MSK, \
+ }
+#endif /* PWM4_CFG */
+#endif /* BSP_USING_PWM4 */
+
+struct swm_pwm_cfg
+{
+ const char *name;
+ PWM_TypeDef *PWMx;
+ PWM_InitStructure pwm_initstruct;
+ uint32_t pwm_mask;
+};
+
+struct swm_pwm_device
+{
+ struct swm_pwm_cfg *pwm_cfg;
+ struct rt_device_pwm pwm_device;
+};
+
+static struct swm_pwm_cfg swm_pwm_cfg[] =
+ {
+#ifdef BSP_USING_PWM0
+ PWM0_CFG,
+#endif
+#ifdef BSP_USING_PWM1
+ PWM1_CFG,
+#endif
+#ifdef BSP_USING_PWM2
+ PWM2_CFG,
+#endif
+#ifdef BSP_USING_PWM3
+ PWM3_CFG,
+#endif
+#ifdef BSP_USING_PWM4
+ PWM4_CFG,
+#endif
+};
+
+static struct swm_pwm_device pwm_obj[sizeof(swm_pwm_cfg) / sizeof(swm_pwm_cfg[0])] = {0};
+
+static rt_err_t swm_pwm_enable(struct rt_device_pwm *pwm_device, struct rt_pwm_configuration *configuration, rt_bool_t enable)
+{
+ struct swm_pwm_cfg *pwm_cfg = RT_NULL;
+ RT_ASSERT(pwm_device != RT_NULL);
+ pwm_cfg = pwm_device->parent.user_data;
+
+ if (!enable)
+ {
+ PWM_Stop(pwm_cfg->pwm_mask);
+ }
+ else
+ {
+ PWM_Start(pwm_cfg->pwm_mask);
+ }
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_pwm_get(struct rt_device_pwm *pwm_device, struct rt_pwm_configuration *configuration)
+{
+ rt_uint64_t tim_clock;
+
+ struct swm_pwm_cfg *pwm_cfg = RT_NULL;
+ RT_ASSERT(pwm_device != RT_NULL);
+ pwm_cfg = pwm_device->parent.user_data;
+
+ configuration->period = PWM_GetPeriod(pwm_cfg->PWMx) * 1000UL; //中心对称模式下频率降低一半
+ configuration->pulse = PWM_GetHDuty(pwm_cfg->PWMx, configuration->channel) * 1000UL;
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_pwm_set(struct rt_device_pwm *pwm_device, struct rt_pwm_configuration *configuration)
+{
+ rt_uint32_t period, pulse;
+ rt_uint64_t tim_clock;
+
+ struct swm_pwm_cfg *pwm_cfg = RT_NULL;
+ RT_ASSERT(pwm_device != RT_NULL);
+ pwm_cfg = pwm_device->parent.user_data;
+
+ period = (unsigned long long)configuration->period / 1000UL; //中心对称模式下频率降低一半
+ pulse = (unsigned long long)configuration->pulse / 1000UL;
+ if (period < MIN_PERIOD)
+ {
+ period = MIN_PERIOD;
+ }
+ if (pulse < MIN_PULSE)
+ {
+ pulse = MIN_PULSE;
+ }
+ PWM_SetPeriod(pwm_cfg->PWMx, period);
+ PWM_SetHDuty(pwm_cfg->PWMx, PWM_CH_A, pulse);
+ PWM_SetHDuty(pwm_cfg->PWMx, PWM_CH_B, pulse);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_pwm_control(struct rt_device_pwm *pwm_device, int cmd, void *arg)
+{
+ RT_ASSERT(pwm_device != RT_NULL);
+
+ struct rt_pwm_configuration *configuration = (struct rt_pwm_configuration *)arg;
+
+ switch (cmd)
+ {
+ case PWM_CMD_ENABLE:
+ return swm_pwm_enable(pwm_device, configuration, RT_TRUE);
+ case PWM_CMD_DISABLE:
+ return swm_pwm_enable(pwm_device, configuration, RT_FALSE);
+ case PWM_CMD_SET:
+ return swm_pwm_set(pwm_device, configuration);
+ case PWM_CMD_GET:
+ return swm_pwm_get(pwm_device, configuration);
+ default:
+ return -RT_EINVAL;
+ }
+}
+
+static const struct rt_pwm_ops pwm_ops =
+ {
+ .control = swm_pwm_control};
+
+int swm_pwm_init(void)
+{
+ int i = 0;
+ int result = RT_EOK;
+
+ for (i = 0; i < sizeof(swm_pwm_cfg) / sizeof(swm_pwm_cfg[0]); i++)
+ {
+ pwm_obj[i].pwm_cfg = &swm_pwm_cfg[i];
+
+ if (pwm_obj[i].pwm_cfg->PWMx == PWM0)
+ {
+#ifdef BSP_USING_PWM0A
+ PORT_Init(PORTM, PIN1, PORTM_PIN1_PWM0A, 0);
+#endif
+#ifdef BSP_USING_PWM0AN
+ PORT_Init(PORTM, PIN4, PORTM_PIN4_PWM0AN, 0);
+#endif
+#ifdef BSP_USING_PWM0B
+ PORT_Init(PORTM, PIN2, PORTM_PIN2_PWM0B, 0);
+#endif
+#ifdef BSP_USING_PWM0BN
+ PORT_Init(PORTM, PIN5, PORTM_PIN5_PWM0BN, 0);
+#endif
+ }
+ else if (pwm_obj[i].pwm_cfg->PWMx == PWM1)
+ {
+#ifdef BSP_USING_PWM1A
+ PORT_Init(PORTM, PIN3, PORTM_PIN3_PWM1A, 0);
+#endif
+#ifdef BSP_USING_PWM1AN
+ PORT_Init(PORTM, PIN6, PORTM_PIN6_PWM1AN, 0);
+#endif
+#ifdef BSP_USING_PWM1B
+ PORT_Init(PORTD, PIN9, PORTD_PIN9_PWM1B, 0);
+#endif
+#ifdef BSP_USING_PWM1BN
+ PORT_Init(PORTD, PIN8, PORTD_PIN8_PWM1BN, 0);
+#endif
+ }
+ else if (pwm_obj[i].pwm_cfg->PWMx == PWM2)
+ {
+#ifdef BSP_USING_PWM2A
+ PORT_Init(PORTM, PIN12, PORTM_PIN12_PWM2A, 0);
+#endif
+#ifdef BSP_USING_PWM2AN
+ PORT_Init(PORTM, PIN9, PORTM_PIN9_PWM2AN, 0);
+#endif
+#ifdef BSP_USING_PWM2B
+ PORT_Init(PORTM, PIN11, PORTM_PIN11_PWM2B, 0);
+#endif
+#ifdef BSP_USING_PWM2BN
+ PORT_Init(PORTM, PIN8, PORTM_PIN8_PWM2BN, 0);
+#endif
+ }
+ else if (pwm_obj[i].pwm_cfg->PWMx == PWM3)
+ {
+#ifdef BSP_USING_PWM3A
+ PORT_Init(PORTC, PIN2, PORTC_PIN2_PWM3A, 0);
+#endif
+#ifdef BSP_USING_PWM3AN
+ PORT_Init(PORTC, PIN3, PORTC_PIN3_PWM3AN, 0);
+#endif
+#ifdef BSP_USING_PWM3B
+ PORT_Init(PORTB, PIN1, PORTB_PIN1_PWM3B, 0);
+#endif
+#ifdef BSP_USING_PWM3BN
+ PORT_Init(PORTB, PIN0, PORTB_PIN0_PWM3BN, 0);
+#endif
+ }
+ else if (pwm_obj[i].pwm_cfg->PWMx == PWM4)
+ {
+#ifdef BSP_USING_PWM4A
+ PORT_Init(PORTB, PIN15, PORTB_PIN15_PWM4A, 0);
+#endif
+#ifdef BSP_USING_PWM4AN
+ // PORT_Init(PORTB, PIN14, PORTB_PIN14_PWM4AN, 0); //SWDIO
+#endif
+#ifdef BSP_USING_PWM4B
+ PORT_Init(PORTB, PIN13, PORTB_PIN13_PWM4B, 0);
+#endif
+#ifdef BSP_USING_PWM4BN
+ // PORT_Init(PORTB, PIN12, PORTB_PIN12_PWM4BN, 0); //SWDCK
+#endif
+ }
+
+ pwm_obj[i].pwm_cfg->pwm_initstruct.Clkdiv = SystemCoreClock / 1000000UL / 2; //中心对称模式下频率降低一半
+ PWM_Init(pwm_obj[i].pwm_cfg->PWMx, &(pwm_obj[i].pwm_cfg->pwm_initstruct));
+ result = rt_device_pwm_register(&pwm_obj[i].pwm_device, pwm_obj[i].pwm_cfg->name, &pwm_ops, pwm_obj[i].pwm_cfg);
+ if(result != RT_EOK)
+ {
+ LOG_E("%s register fail.", pwm_obj[i].pwm_cfg->name);
+ }
+ else
+ {
+ LOG_D("%s register success.", pwm_obj[i].pwm_cfg->name);
+ }
+ }
+ return result;
+}
+INIT_DEVICE_EXPORT(swm_pwm_init);
+
+#endif /* BSP_USING_PWM */
+#endif /* RT_USING_PWM */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_pwm.h b/bsp/synwit/libraries/SWM341_drivers/drv_pwm.h
new file mode 100644
index 0000000000..3b39ec9000
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_pwm.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_PWM_H__
+#define __DRV_PWM_H__
+
+#include "board.h"
+
+int swm_pwm_init(void);
+
+#endif /* __DRV_PWM_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.c b/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.c
new file mode 100644
index 0000000000..f0f33f4ca4
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.c
@@ -0,0 +1,230 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-25 lik first version
+ */
+
+#include "drv_rgb_lcd.h"
+
+#ifdef BSP_USING_RGB_LCD
+#include "rgb_lcd_port.h"
+
+#define DRV_DEBUG
+#define LOG_TAG "drv.rgb_lcd"
+#include <drv_log.h>
+
+#define LCD_DEVICE(dev) (struct swm_rgb_lcd_device *)(dev)
+
+struct swm_rgb_lcd_device rgb_lcd_obj;
+
+static rt_err_t swm_rgb_lcd_configure(struct rt_device *device)
+{
+ struct swm_rgb_lcd_device *rgb_lcd = LCD_DEVICE(device);
+ /* nothing, right now */
+ rgb_lcd = rgb_lcd;
+ return RT_EOK;
+}
+
+static rt_err_t swm_rgb_lcd_control(struct rt_device *device, int cmd, void *args)
+{
+ struct swm_rgb_lcd_device *rgb_lcd = LCD_DEVICE(device);
+
+ switch (cmd)
+ {
+ 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 = rgb_lcd->lcd_info.pixel_format;
+ info->bits_per_pixel = rgb_lcd->lcd_info.bits_per_pixel;
+ info->width = rgb_lcd->lcd_info.width;
+ info->height = rgb_lcd->lcd_info.height;
+ info->framebuffer = rgb_lcd->lcd_info.framebuffer;
+ }
+ break;
+
+ default:
+ return -RT_EINVAL;
+ }
+
+ return RT_EOK;
+}
+
+#if defined(LCD_BACKLIGHT_USING_PWM)
+static 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)
+static void turn_on_lcd_backlight(void)
+{
+ rt_pin_mode(LCD_DISP_GPIO, PIN_MODE_OUTPUT);
+ rt_pin_write(LCD_DISP_GPIO, PIN_HIGH);
+
+ rt_pin_mode(LCD_BL_GPIO, PIN_MODE_OUTPUT);
+ rt_pin_write(LCD_BL_GPIO, PIN_HIGH);
+}
+#else
+static void turn_on_lcd_backlight(void)
+{
+}
+#endif
+
+#ifdef RT_USING_DEVICE_OPS
+static const struct rt_device_ops swm_lcd_ops =
+ {
+ .init = swm_rgb_lcd_configure,
+ .open = RT_NULL,
+ .close = RT_NULL,
+ .read = RT_NULL,
+ .write = RT_NULL,
+ .control = swm_rgb_lcd_control};
+#endif
+
+int swm_rgb_lcd_init(void)
+{
+ rt_err_t result = RT_EOK;
+ struct rt_device *device = &rgb_lcd_obj.parent;
+
+ /* memset rgb_lcd_obj to zero */
+ memset(&rgb_lcd_obj, 0x00, sizeof(rgb_lcd_obj));
+
+ /* config LCD dev info */
+ rgb_lcd_obj.lcd_info.height = LCD_HEIGHT;
+ rgb_lcd_obj.lcd_info.width = LCD_WIDTH;
+ rgb_lcd_obj.lcd_info.bits_per_pixel = LCD_BITS_PER_PIXEL;
+ rgb_lcd_obj.lcd_info.pixel_format = LCD_PIXEL_FORMAT;
+
+ /* malloc memory for Triple Buffering */
+ rgb_lcd_obj.lcd_info.framebuffer = rt_malloc_align(LCD_BUF_SIZE,4);
+ if (rgb_lcd_obj.lcd_info.framebuffer == RT_NULL)
+ {
+ LOG_E("init frame buffer failed!\n");
+ result = -RT_ENOMEM;
+ goto __exit;
+ }
+ /* memset buff to 0xFF */
+ memset(rgb_lcd_obj.lcd_info.framebuffer, 0xFF, LCD_BUF_SIZE);
+
+ device->type = RT_Device_Class_Graphic;
+#ifdef RT_USING_DEVICE_OPS
+ device->ops = &swm_lcd_ops;
+#else
+ device->init = swm_rgb_lcd_configure;
+ device->control = swm_rgb_lcd_control;
+#endif
+ /* register lcd device */
+ rt_device_register(device, "rgb_lcd", RT_DEVICE_FLAG_RDWR);
+
+ LCD_InitStructure LCD_initStruct;
+
+ // PORT_Init(PORTB, PIN1, PORTB_PIN1_LCD_B0, 0);
+ // PORT_Init(PORTB, PIN11, PORTB_PIN11_LCD_B1, 0);
+ // PORT_Init(PORTB, PIN13, PORTB_PIN13_LCD_B2, 0);
+ PORT_Init(PORTB, PIN15, PORTB_PIN15_LCD_B3, 0);
+ PORT_Init(PORTA, PIN2, PORTA_PIN2_LCD_B4, 0);
+ PORT_Init(PORTA, PIN9, PORTA_PIN9_LCD_B5, 0);
+ PORT_Init(PORTA, PIN10, PORTA_PIN10_LCD_B6, 0);
+ PORT_Init(PORTA, PIN11, PORTA_PIN11_LCD_B7, 0);
+
+ // PORT_Init(PORTA, PIN12, PORTA_PIN12_LCD_G0, 0);
+ // PORT_Init(PORTA, PIN13, PORTA_PIN13_LCD_G1, 0);
+ PORT_Init(PORTA, PIN14, PORTA_PIN14_LCD_G2, 0);
+ PORT_Init(PORTA, PIN15, PORTA_PIN15_LCD_G3, 0);
+ PORT_Init(PORTC, PIN0, PORTC_PIN0_LCD_G4, 0);
+ PORT_Init(PORTC, PIN1, PORTC_PIN1_LCD_G5, 0);
+ PORT_Init(PORTC, PIN2, PORTC_PIN2_LCD_G6, 0);
+ PORT_Init(PORTC, PIN3, PORTC_PIN3_LCD_G7, 0);
+
+ // PORT_Init(PORTC, PIN4, PORTC_PIN4_LCD_R0, 0);
+ // PORT_Init(PORTC, PIN5, PORTC_PIN5_LCD_R1, 0);
+ // PORT_Init(PORTC, PIN8, PORTC_PIN8_LCD_R2, 0);
+ PORT_Init(PORTC, PIN9, PORTC_PIN9_LCD_R3, 0);
+ PORT_Init(PORTC, PIN10, PORTC_PIN10_LCD_R4, 0);
+ PORT_Init(PORTC, PIN11, PORTC_PIN11_LCD_R5, 0);
+ PORT_Init(PORTC, PIN12, PORTC_PIN12_LCD_R6, 0);
+ PORT_Init(PORTC, PIN13, PORTC_PIN13_LCD_R7, 0);
+
+ PORT_Init(PORTB, PIN2, PORTB_PIN2_LCD_VSYNC, 0);
+ PORT_Init(PORTB, PIN3, PORTB_PIN3_LCD_HSYNC, 0);
+ PORT_Init(PORTB, PIN4, PORTB_PIN4_LCD_DEN, 0);
+ PORT_Init(PORTB, PIN5, PORTB_PIN5_LCD_DCLK, 0);
+
+ LCD_initStruct.ClkDiv = LCD_CLK_DIV;
+ LCD_initStruct.Format = ((LCD_BITS_PER_PIXEL == 16) ? LCD_FMT_RGB565 : LCD_FMT_RGB888);
+ LCD_initStruct.HnPixel = LCD_WIDTH;
+ LCD_initStruct.VnPixel = LCD_HEIGHT;
+ LCD_initStruct.Hfp = LCD_HFP;
+ LCD_initStruct.Hbp = LCD_HBP;
+ LCD_initStruct.Vfp = LCD_VFP;
+ LCD_initStruct.Vbp = LCD_VBP;
+ LCD_initStruct.HsyncWidth = LCD_HSYNC_WIDTH;
+ LCD_initStruct.VsyncWidth = LCD_VSYNC_WIDTH;
+
+ LCD_initStruct.DataSource = (uint32_t)rgb_lcd_obj.lcd_info.framebuffer;
+ LCD_initStruct.Background = 0xFFFFFF;
+ LCD_initStruct.SampleEdge = LCD_SAMPLE_FALL;
+ LCD_initStruct.IntEOTEn = 0;
+ LCD_Init(LCD, &LCD_initStruct);
+ LCD_Start(LCD);
+ turn_on_lcd_backlight();
+__exit:
+ if (result != RT_EOK)
+ {
+ if (rgb_lcd_obj.lcd_info.framebuffer)
+ {
+ rt_free(rgb_lcd_obj.lcd_info.framebuffer);
+ }
+ }
+ return result;
+}
+INIT_BOARD_EXPORT(swm_rgb_lcd_init);
+
+int lcd_test(void)
+{
+ struct swm_rgb_lcd_device *rgb_lcd;
+ rgb_lcd = (struct swm_rgb_lcd_device *)rt_device_find("rgb_lcd");
+
+ // while (1)
+ {
+ /* red */
+ for (int i = 0; i < LCD_BUF_SIZE / 2; i++)
+ {
+ rgb_lcd->lcd_info.framebuffer[2 * i] = 0x00;
+ rgb_lcd->lcd_info.framebuffer[2 * i + 1] = 0xF8;
+ }
+ rgb_lcd->parent.control(&rgb_lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+ rt_thread_mdelay(1000);
+ /* green */
+ for (int i = 0; i < LCD_BUF_SIZE / 2; i++)
+ {
+ rgb_lcd->lcd_info.framebuffer[2 * i] = 0xE0;
+ rgb_lcd->lcd_info.framebuffer[2 * i + 1] = 0x07;
+ }
+ rgb_lcd->parent.control(&rgb_lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+ rt_thread_mdelay(1000);
+ /* blue */
+ for (int i = 0; i < LCD_BUF_SIZE / 2; i++)
+ {
+ rgb_lcd->lcd_info.framebuffer[2 * i] = 0x1F;
+ rgb_lcd->lcd_info.framebuffer[2 * i + 1] = 0x00;
+ }
+ rgb_lcd->parent.control(&rgb_lcd->parent, RTGRAPHIC_CTRL_RECT_UPDATE, RT_NULL);
+ rt_thread_mdelay(1000);
+ }
+ return 0;
+}
+MSH_CMD_EXPORT(lcd_test, lcd_test);
+
+#endif /* BSP_USING_RGB_LCD */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.h b/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.h
new file mode 100644
index 0000000000..27ab323d8d
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_rgb_lcd.h
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_RGB_LCD_H__
+#define __DRV_RGB_LCD_H__
+
+#include "board.h"
+
+struct swm_rgb_lcd_device
+{
+ struct rt_device parent;
+ struct rt_device_graphic_info lcd_info;
+};
+
+int swm_rgb_lcd_init(void);
+
+#endif /* __DRV_RGB_LCD_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_rtc.c b/bsp/synwit/libraries/SWM341_drivers/drv_rtc.c
new file mode 100644
index 0000000000..2fd1a243aa
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_rtc.c
@@ -0,0 +1,167 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_rtc.h"
+
+#ifdef RT_USING_RTC
+#ifdef BSP_USING_RTC
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.rtc"
+#include <drv_log.h>
+
+static rt_rtc_dev_t swm_rtc_device;
+
+static uint32_t calcWeekDay(uint32_t year, uint32_t month, uint32_t date)
+{
+ uint32_t i, cnt = 0;
+ const uint32_t daysOfMonth[13] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
+
+ for (i = 1; i < month; i++)
+ cnt += daysOfMonth[i];
+
+ cnt += date;
+
+ if ((year % 4 == 0) && ((year % 100 != 0) || (year % 400 == 0)) && (month >= 3))
+ cnt += 1;
+
+ cnt += (year - 1901) * 365;
+
+ for (i = 1901; i < year; i++)
+ {
+ if ((i % 4 == 0) && ((i % 100 != 0) || (i % 400 == 0)))
+ cnt += 1;
+ }
+
+ return (cnt + 1) % 7;
+}
+
+static time_t swm_get_rtc_time_stamp(void)
+{
+ RTC_DateTime get_datetime = {0};
+ struct tm tm_new;
+
+ RTC_GetDateTime(RTC, &get_datetime);
+
+ tm_new.tm_sec = get_datetime.Second;
+ tm_new.tm_min = get_datetime.Minute;
+ tm_new.tm_hour = get_datetime.Hour;
+ tm_new.tm_mday = get_datetime.Date;
+ tm_new.tm_mon = get_datetime.Month - 1;
+ tm_new.tm_year = get_datetime.Year - 1900;
+
+ LOG_D("get rtc time.");
+ return mktime(&tm_new);
+}
+static rt_err_t swm_set_rtc_time_stamp(time_t time_stamp)
+{
+ RTC_DateTime set_datetime = {0};
+ struct tm now;
+
+ gmtime_r(&time_stamp, &now);
+ set_datetime.Second = now.tm_sec;
+ set_datetime.Minute = now.tm_min;
+ set_datetime.Hour = now.tm_hour;
+ set_datetime.Date = now.tm_mday;
+ set_datetime.Month = now.tm_mon + 1;
+ set_datetime.Year = now.tm_year + 1900;
+ // set_datetime.Day = now.tm_wday;
+
+ RTC_Stop(RTC);
+ while (RTC->CFGABLE == 0)
+ ;
+ RTC->MINSEC = (set_datetime.Second << RTC_MINSEC_SEC_Pos) |
+ (set_datetime.Minute << RTC_MINSEC_MIN_Pos);
+ RTC->DATHUR = (set_datetime.Hour << RTC_DATHUR_HOUR_Pos) |
+ ((set_datetime.Date) << RTC_DATHUR_DATE_Pos);
+ RTC->MONDAY = (calcWeekDay(set_datetime.Year, set_datetime.Month, set_datetime.Date)
+ << RTC_MONDAY_DAY_Pos) |
+ ((set_datetime.Month) << RTC_MONDAY_MON_Pos);
+ RTC->YEAR = set_datetime.Year;
+ RTC->LOAD = 1 << RTC_LOAD_TIME_Pos;
+ RTC_Start(RTC);
+
+ LOG_D("set rtc time.");
+ return RT_EOK;
+}
+
+static rt_err_t swm_rtc_configure(void)
+{
+ RTC_InitStructure rtc_initstruct;
+
+ rtc_initstruct.clksrc = RTC_CLKSRC_XTAL32K;
+ rtc_initstruct.Year = 2020;
+ rtc_initstruct.Month = 2;
+ rtc_initstruct.Date = 28;
+ rtc_initstruct.Hour = 23;
+ rtc_initstruct.Minute = 59;
+ rtc_initstruct.Second = 55;
+ rtc_initstruct.SecondIEn = 0;
+ rtc_initstruct.MinuteIEn = 0;
+ RTC_Init(RTC, &rtc_initstruct);
+ RTC_Start(RTC);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_rtc_get_secs(time_t *args)
+{
+ *args = swm_get_rtc_time_stamp();
+ LOG_D("RTC: get rtc_time %x\n", *args);
+
+ return RT_EOK;
+}
+
+static rt_err_t swm_rtc_set_secs(time_t *args)
+{
+ rt_err_t result = RT_EOK;
+
+ if (swm_set_rtc_time_stamp(*args))
+ {
+ result = -RT_ERROR;
+ }
+ LOG_D("RTC: set rtc_time %x\n", *args);
+
+ return result;
+}
+
+static const struct rt_rtc_ops swm_rtc_ops =
+{
+ .init = swm_rtc_configure,
+ .get_secs = swm_rtc_get_secs,
+ .set_secs = swm_rtc_set_secs,
+ RT_NULL,
+ RT_NULL,
+ RT_NULL,
+ RT_NULL,
+};
+
+int swm_rtc_init(void)
+{
+ rt_err_t result;
+
+ swm_rtc_configure();
+
+ swm_rtc_device.ops = &swm_rtc_ops;
+ result = rt_hw_rtc_register(&swm_rtc_device, "rtc", RT_DEVICE_FLAG_RDWR,RT_NULL);
+ if (result != RT_EOK)
+ {
+ LOG_E("rtc register err code: %d", result);
+ }
+ else
+ {
+ LOG_D("rtc register success.");
+ }
+ return result;
+}
+INIT_DEVICE_EXPORT(swm_rtc_init);
+
+#endif /* BSP_USING_RTC */
+#endif /* RT_USING_RTC */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_rtc.h b/bsp/synwit/libraries/SWM341_drivers/drv_rtc.h
new file mode 100644
index 0000000000..5cdc9ed114
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_rtc.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_RTC_H__
+#define __DRV_RTC_H__
+
+#include "board.h"
+
+int swm_rtc_init(void);
+
+#endif /* __DRV_RTC_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_sdio.c b/bsp/synwit/libraries/SWM341_drivers/drv_sdio.c
new file mode 100644
index 0000000000..f85ea63cd8
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_sdio.c
@@ -0,0 +1,715 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_sdio.h"
+
+#ifdef RT_USING_SDIO
+#ifdef BSP_USING_SDIO
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.sdio"
+#include <drv_log.h>
+
+#define SDIO_BUFF_SIZE 4096
+#define SDIO_ALIGN_LEN 4
+
+#ifndef SDIO_MAX_FREQ
+#define SDIO_MAX_FREQ (37500000)
+#endif
+
+struct swm_sdio_pkg
+{
+ struct rt_mmcsd_cmd *cmd;
+ void *buff;
+ rt_uint32_t flag;
+};
+
+typedef rt_err_t (*sdio_txconfig)(struct swm_sdio_pkg *pkg, rt_uint32_t *buff, int size);
+typedef rt_err_t (*sdio_rxconfig)(struct swm_sdio_pkg *pkg, rt_uint32_t *buff, int size);
+typedef rt_uint32_t (*sdio_clk_get)(SDIO_TypeDef *swm_sdio);
+
+struct swm_sdio_des
+{
+ SDIO_TypeDef *swm_sdio;
+ sdio_txconfig txconfig;
+ sdio_rxconfig rxconfig;
+ sdio_clk_get clk_get;
+};
+
+static struct rt_mmcsd_host *host;
+
+#define RTHW_SDIO_LOCK(_sdio) rt_mutex_take(&_sdio->mutex, RT_WAITING_FOREVER)
+#define RTHW_SDIO_UNLOCK(_sdio) rt_mutex_release(&_sdio->mutex);
+
+struct swm_sdio_device
+{
+ struct rt_mmcsd_host *host;
+ struct swm_sdio_des sdio_des;
+ struct rt_event event;
+ struct rt_mutex mutex;
+ struct swm_sdio_pkg *pkg;
+};
+
+rt_align(SDIO_ALIGN_LEN)
+static rt_uint8_t cache_buf[SDIO_BUFF_SIZE];
+
+/**
+ * @brief This function wait sdio completed.
+ * @param sdio swm_sdio_device
+ * @retval None
+ */
+static void swm_sdio_wait_completed(struct swm_sdio_device *sdio)
+{
+ rt_uint32_t status;
+ struct rt_mmcsd_cmd *cmd = sdio->pkg->cmd;
+ struct rt_mmcsd_data *data = cmd->data;
+ SDIO_TypeDef *swm_sdio = sdio->sdio_des.swm_sdio;
+
+ if (rt_event_recv(&sdio->event, 0xffffffff, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
+ rt_tick_from_millisecond(2000), &status) != RT_EOK)
+ {
+ LOG_E("wait completed timeout");
+ cmd->err = -RT_ETIMEOUT;
+ return;
+ }
+
+ if (sdio->pkg == RT_NULL)
+ {
+ return;
+ }
+
+ if (resp_type(cmd) == RESP_NONE)
+ {
+ ;
+ }
+ else if (resp_type(cmd) == RESP_R2)
+ {
+ LOG_D("R2");
+ cmd->resp[0] = (swm_sdio->RESP[3] << 8) + ((swm_sdio->RESP[2] >> 24) & 0xFF);
+ cmd->resp[1] = (swm_sdio->RESP[2] << 8) + ((swm_sdio->RESP[1] >> 24) & 0xFF);
+ cmd->resp[2] = (swm_sdio->RESP[1] << 8) + ((swm_sdio->RESP[0] >> 24) & 0xFF);
+ cmd->resp[3] = (swm_sdio->RESP[0] << 8) + 0x00;
+ }
+ else
+ {
+ cmd->resp[0] = swm_sdio->RESP[0];
+ }
+
+ if (status & SDIO_IF_ERROR_Msk)
+ {
+ if ((status & SDIO_IF_CMDCRCERR_Msk) && (resp_type(cmd) & (RESP_R3 | RESP_R4)))
+ {
+ cmd->err = RT_EOK;
+ }
+ else
+ {
+ cmd->err = -RT_ERROR;
+ }
+
+ if (status & SDIO_IF_CMDCRCERR_Msk)
+ {
+ SDIO->CR2 |= (1 << SDIO_CR2_RSTCMD_Pos);
+ data->err = -RT_ERROR;
+ }
+
+ if (status & SDIO_IF_CMDTIMEOUT_Msk)
+ {
+ SDIO->CR2 |= (1 << SDIO_CR2_RSTCMD_Pos);
+ cmd->err = -RT_ETIMEOUT;
+ }
+
+ if (status & SDIO_IF_DATCRCERR_Msk)
+ {
+ SDIO->CR2 |= (1 << SDIO_CR2_RSTDAT_Pos);
+ data->err = -RT_ERROR;
+ }
+
+ if (status & SDIO_IF_DATTIMEOUT_Msk)
+ {
+ SDIO->CR2 |= (1 << SDIO_CR2_RSTDAT_Pos);
+ data->err = -RT_ETIMEOUT;
+ }
+
+ if (cmd->err == RT_EOK)
+ {
+ LOG_D("sta:0x%08X [%08X %08X %08X %08X]", status, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
+ }
+ else
+ {
+ LOG_D("err:0x%08x, %s%s%s%s%s cmd:%d arg:0x%08x rw:%c len:%d blksize:%d",
+ status,
+ status & SDIO_IF_CMDCRCERR_Msk ? "CCRCFAIL " : "",
+ status & SDIO_IF_DATCRCERR_Msk ? "DCRCFAIL " : "",
+ status & SDIO_IF_CMDTIMEOUT_Msk ? "CTIMEOUT " : "",
+ status & SDIO_IF_DATTIMEOUT_Msk ? "DTIMEOUT " : "",
+ status == 0 ? "NULL" : "",
+ cmd->cmd_code,
+ cmd->arg,
+ data ? (data->flags & DATA_DIR_WRITE ? 'w' : 'r') : '-',
+ data ? data->blks * data->blksize : 0,
+ data ? data->blksize : 0);
+ }
+ }
+ else
+ {
+ cmd->err = RT_EOK;
+ LOG_D("sta:0x%08X [%08X %08X %08X %08X]", status, cmd->resp[0], cmd->resp[1], cmd->resp[2], cmd->resp[3]);
+ }
+}
+
+/**
+ * @brief This function transfer data by dma.
+ * @param sdio swm_sdio_device
+ * @param pkg sdio package
+ * @retval None
+ */
+static void swm_sdio_transfer(struct swm_sdio_device *sdio, struct swm_sdio_pkg *pkg)
+{
+ struct rt_mmcsd_data *data;
+ int size;
+ void *buff;
+
+ if ((RT_NULL == pkg) || (RT_NULL == sdio))
+ {
+ LOG_E("swm_sdio_transfer invalid args");
+ return;
+ }
+
+ data = pkg->cmd->data;
+ if (RT_NULL == data)
+ {
+ LOG_E("swm_sdio_transfer invalid args");
+ return;
+ }
+
+ buff = pkg->buff;
+ if (RT_NULL == buff)
+ {
+ LOG_E("swm_sdio_transfer invalid args");
+ return;
+ }
+
+ size = data->blks * data->blksize;
+
+ if (data->flags & DATA_DIR_WRITE)
+ {
+ sdio->sdio_des.txconfig(pkg, (rt_uint32_t *)buff, size);
+ }
+ else if (data->flags & DATA_DIR_READ)
+ {
+ sdio->sdio_des.rxconfig(pkg, (rt_uint32_t *)buff, size);
+ }
+}
+
+/**
+ * @brief This function send command.
+ * @param sdio swm_sdio_device
+ * @param pkg sdio package
+ * @retval None
+ */
+static void swm_sdio_send_command(struct swm_sdio_device *sdio, struct swm_sdio_pkg *pkg)
+{
+ struct rt_mmcsd_cmd *cmd = pkg->cmd;
+ struct rt_mmcsd_data *data = cmd->data;
+ SDIO_TypeDef *swm_sdio = sdio->sdio_des.swm_sdio;
+ rt_uint32_t reg_cmd;
+
+ /* save pkg */
+ sdio->pkg = pkg;
+
+ LOG_D("CMD:%d ARG:0x%08x RES:%s%s%s%s%s%s%s%s%s rw:%c len:%d blksize:%d",
+ cmd->cmd_code,
+ cmd->arg,
+ resp_type(cmd) == RESP_NONE ? "NONE" : "",
+ resp_type(cmd) == RESP_R1 ? "R1" : "",
+ resp_type(cmd) == RESP_R1B ? "R1B" : "",
+ resp_type(cmd) == RESP_R2 ? "R2" : "",
+ resp_type(cmd) == RESP_R3 ? "R3" : "",
+ resp_type(cmd) == RESP_R4 ? "R4" : "",
+ resp_type(cmd) == RESP_R5 ? "R5" : "",
+ resp_type(cmd) == RESP_R6 ? "R6" : "",
+ resp_type(cmd) == RESP_R7 ? "R7" : "",
+ data ? (data->flags & DATA_DIR_WRITE ? 'w' : 'r') : '-',
+ data ? data->blks * data->blksize : 0,
+ data ? data->blksize : 0);
+
+ /* config cmd reg */
+ reg_cmd = (cmd->cmd_code << SDIO_CMD_CMDINDX_Pos) |
+ (0 << SDIO_CMD_CMDTYPE_Pos) |
+ (0 << SDIO_CMD_IDXCHECK_Pos) |
+ (0 << SDIO_CMD_CRCCHECK_Pos) |
+ (0 << SDIO_CMD_DMAEN_Pos);
+ if (resp_type(cmd) == RESP_NONE)
+ reg_cmd |= SD_RESP_NO << SDIO_CMD_RESPTYPE_Pos;
+ else if (resp_type(cmd) == RESP_R2)
+ reg_cmd |= SD_RESP_128b << SDIO_CMD_RESPTYPE_Pos;
+ else
+ reg_cmd |= SD_RESP_32b << SDIO_CMD_RESPTYPE_Pos;
+
+ /* config data reg */
+ if (data != RT_NULL)
+ {
+ rt_uint32_t dir = 0;
+ dir = (data->flags & DATA_DIR_READ) ? 1 : 0;
+
+ swm_sdio->BLK = (data->blks << SDIO_BLK_COUNT_Pos) | (data->blksize << SDIO_BLK_SIZE_Pos);
+
+ reg_cmd |= (1 << SDIO_CMD_HAVEDATA_Pos) |
+ (dir << SDIO_CMD_DIRREAD_Pos) |
+ ((data->blks > 1) << SDIO_CMD_MULTBLK_Pos) |
+ ((data->blks > 1) << SDIO_CMD_BLKCNTEN_Pos) |
+ (0 << SDIO_CMD_AUTOCMD12_Pos);
+ }
+ else
+ {
+ reg_cmd |= (0 << SDIO_CMD_HAVEDATA_Pos);
+ }
+
+ /* send cmd */
+ swm_sdio->ARG = cmd->arg;
+ swm_sdio->CMD = reg_cmd;
+
+ /* transfer config */
+ if (data != RT_NULL)
+ {
+ swm_sdio_transfer(sdio, pkg);
+ }
+
+ /* wait completed */
+ swm_sdio_wait_completed(sdio);
+
+ /* clear pkg */
+ sdio->pkg = RT_NULL;
+}
+
+/**
+ * @brief This function send sdio request.
+ * @param sdio swm_sdio_device
+ * @param req request
+ * @retval None
+ */
+static void swm_sdio_request(struct rt_mmcsd_host *host, struct rt_mmcsd_req *req)
+{
+ struct swm_sdio_pkg pkg;
+ struct swm_sdio_device *sdio = host->private_data;
+ struct rt_mmcsd_data *data;
+
+ RTHW_SDIO_LOCK(sdio);
+
+ if (req->cmd != RT_NULL)
+ {
+ rt_memset(&pkg, 0, sizeof(pkg));
+ data = req->cmd->data;
+ pkg.cmd = req->cmd;
+
+ if (data != RT_NULL)
+ {
+ rt_uint32_t size = data->blks * data->blksize;
+
+ RT_ASSERT(size <= SDIO_BUFF_SIZE);
+
+ pkg.buff = data->buf;
+ if ((rt_uint32_t)data->buf & (SDIO_ALIGN_LEN - 1))
+ {
+ pkg.buff = cache_buf;
+ if (data->flags & DATA_DIR_WRITE)
+ {
+ rt_memcpy(cache_buf, data->buf, size);
+ }
+ }
+ }
+
+ swm_sdio_send_command(sdio, &pkg);
+
+ if ((data != RT_NULL) && (data->flags & DATA_DIR_READ) && ((rt_uint32_t)data->buf & (SDIO_ALIGN_LEN - 1)))
+ {
+ rt_memcpy(data->buf, cache_buf, data->blksize * data->blks);
+ }
+ }
+
+ if (req->stop != RT_NULL)
+ {
+ rt_memset(&pkg, 0, sizeof(pkg));
+ pkg.cmd = req->stop;
+ swm_sdio_send_command(sdio, &pkg);
+ }
+
+ RTHW_SDIO_UNLOCK(sdio);
+
+ mmcsd_req_complete(sdio->host);
+}
+
+/**
+ * @brief This function config sdio.
+ * @param host rt_mmcsd_host
+ * @param io_cfg rt_mmcsd_io_cfg
+ * @retval None
+ */
+static void swm_sdio_set_iocfg(struct rt_mmcsd_host *host, struct rt_mmcsd_io_cfg *io_cfg)
+{
+ rt_uint32_t clkcr, div, clk_src;
+ rt_uint32_t clk = io_cfg->clock;
+ struct swm_sdio_device *sdio = host->private_data;
+ SDIO_TypeDef *swm_sdio = sdio->sdio_des.swm_sdio;
+
+ clk_src = sdio->sdio_des.clk_get(sdio->sdio_des.swm_sdio);
+ if (clk_src < 400 * 1000)
+ {
+ LOG_E("The clock rate is too low! rata:%d", clk_src);
+ return;
+ }
+
+ if (clk > host->freq_max)
+ clk = host->freq_max;
+
+ if (clk > clk_src)
+ {
+ LOG_W("Setting rate is greater than clock source rate.");
+ clk = clk_src;
+ }
+
+ LOG_D("clk:%d width:%s%s%s power:%s%s%s",
+ clk,
+ io_cfg->bus_width == MMCSD_BUS_WIDTH_8 ? "8" : "",
+ io_cfg->bus_width == MMCSD_BUS_WIDTH_4 ? "4" : "",
+ io_cfg->bus_width == MMCSD_BUS_WIDTH_1 ? "1" : "",
+ io_cfg->power_mode == MMCSD_POWER_OFF ? "OFF" : "",
+ io_cfg->power_mode == MMCSD_POWER_UP ? "UP" : "",
+ io_cfg->power_mode == MMCSD_POWER_ON ? "ON" : "");
+
+ RTHW_SDIO_LOCK(sdio);
+
+ swm_sdio->CR1 = (1 << SDIO_CR1_CDSRC_Pos) | (7 << SDIO_CR1_VOLT_Pos);
+ if (io_cfg->bus_width == MMCSD_BUS_WIDTH_8)
+ {
+ swm_sdio->CR1 |= (1 << SDIO_CR1_8BIT_Pos);
+ }
+ else
+ {
+ swm_sdio->CR1 &= ~SDIO_CR1_8BIT_Msk;
+ if (io_cfg->bus_width == MMCSD_BUS_WIDTH_4)
+ {
+ swm_sdio->CR1 |= (1 << SDIO_CR1_4BIT_Pos);
+ }
+ else
+ {
+ swm_sdio->CR1 &= ~SDIO_CR1_4BIT_Msk;
+ }
+ }
+ switch (io_cfg->power_mode)
+ {
+ case MMCSD_POWER_OFF:
+ swm_sdio->CR1 &= ~SDIO_CR1_PWRON_Msk;
+ break;
+ case MMCSD_POWER_UP:
+ case MMCSD_POWER_ON:
+ swm_sdio->CR1 |= (1 << SDIO_CR1_PWRON_Pos);
+ break;
+ default:
+ LOG_W("unknown power_mode %d", io_cfg->power_mode);
+ break;
+ }
+
+ div = clk_src / clk;
+ if ((clk == 0) || (div == 0))
+ {
+ clkcr = 0;
+ }
+ else
+ {
+ if (div > 128)
+ clkcr = 0x80;
+ else if (div > 64)
+ clkcr = 0x40;
+ else if (div > 32)
+ clkcr = 0x20;
+ else if (div > 16)
+ clkcr = 0x10;
+ else if (div > 8)
+ clkcr = 0x08;
+ else if (div > 4)
+ clkcr = 0x04;
+ else if (div > 2)
+ clkcr = 0x02;
+ else if (div > 1)
+ clkcr = 0x01;
+ else
+ clkcr = 0x00;
+ }
+
+ SDIO->CR2 = (1 << SDIO_CR2_CLKEN_Pos) |
+ (1 << SDIO_CR2_SDCLKEN_Pos) |
+ (clkcr << SDIO_CR2_SDCLKDIV_Pos) |
+ (0xC << SDIO_CR2_TIMEOUT_Pos); // 2**25 SDIO_CLK
+
+ while ((SDIO->CR2 & SDIO_CR2_CLKRDY_Msk) == 0)
+ ;
+
+ RTHW_SDIO_UNLOCK(sdio);
+}
+
+/**
+ * @brief This function delect sdcard.
+ * @param host rt_mmcsd_host
+ * @retval 0x01
+ */
+static rt_int32_t swm_sdio_get_card_status(struct rt_mmcsd_host *host)
+{
+ LOG_D("try to detect device");
+ return 0x01;
+}
+
+/**
+ * @brief This function update sdio interrupt.
+ * @param host rt_mmcsd_host
+ * @param enable
+ * @retval None
+ */
+void swm_sdio_enable_irq(struct rt_mmcsd_host *host, rt_int32_t enable)
+{
+ struct swm_sdio_device *sdio = host->private_data;
+ SDIO_TypeDef *swm_sdio = sdio->sdio_des.swm_sdio;
+
+ if (enable)
+ {
+ LOG_D("enable sdio irq");
+ swm_sdio->IM = 0xFFFFFFFF;
+ swm_sdio->IE = 0xFFFF000F;
+ }
+ else
+ {
+ LOG_D("disable sdio irq");
+ swm_sdio->IM &= ~0xFFFFFFFF;
+ swm_sdio->IE &= ~0xFFFFFFFF;
+ }
+}
+
+static const struct rt_mmcsd_host_ops swm_sdio_ops =
+ {
+ .request = swm_sdio_request,
+ .set_iocfg = swm_sdio_set_iocfg,
+ .get_card_status = swm_sdio_get_card_status,
+ .enable_sdio_irq = swm_sdio_enable_irq,
+};
+
+struct rt_mmcsd_host *swm_sdio_host_create(struct swm_sdio_des *sdio_des)
+{
+ struct rt_mmcsd_host *host;
+ struct swm_sdio_device *sdio = RT_NULL;
+
+ if ((sdio_des == RT_NULL) || (sdio_des->txconfig == RT_NULL) || (sdio_des->rxconfig == RT_NULL))
+ {
+ LOG_E("L:%d F:%s %s %s %s",
+ (sdio_des == RT_NULL ? "sdio_des is NULL" : ""),
+ (sdio_des ? (sdio_des->txconfig ? "txconfig is NULL" : "") : ""),
+ (sdio_des ? (sdio_des->rxconfig ? "rxconfig is NULL" : "") : ""));
+ return RT_NULL;
+ }
+
+ sdio = rt_malloc(sizeof(struct swm_sdio_device));
+ if (sdio == RT_NULL)
+ {
+ LOG_E("L:%d F:%s malloc swm_sdio_device fail");
+ return RT_NULL;
+ }
+ rt_memset(sdio, 0, sizeof(struct swm_sdio_device));
+
+ host = mmcsd_alloc_host();
+ if (host == RT_NULL)
+ {
+ LOG_E("L:%d F:%s mmcsd alloc host fail");
+ rt_free(sdio);
+ return RT_NULL;
+ }
+
+ rt_memcpy(&sdio->sdio_des, sdio_des, sizeof(struct swm_sdio_des));
+
+ rt_event_init(&sdio->event, "sdio", RT_IPC_FLAG_FIFO);
+ rt_mutex_init(&sdio->mutex, "sdio", RT_IPC_FLAG_FIFO);
+
+ /* set host defautl attributes */
+ host->ops = &swm_sdio_ops;
+ host->freq_min = 400 * 1000;
+ host->freq_max = SDIO_MAX_FREQ;
+ host->valid_ocr = 0X00FFFF80; /* The voltage range supported is 1.65v-3.6v */
+#ifndef SDIO_USING_1_BIT
+ host->flags = MMCSD_BUSWIDTH_4 | MMCSD_MUTBLKWRITE | MMCSD_SUP_SDIO_IRQ;
+#else
+ host->flags = MMCSD_MUTBLKWRITE | MMCSD_SUP_SDIO_IRQ;
+#endif
+ host->max_seg_size = SDIO_BUFF_SIZE;
+ host->max_dma_segs = 1;
+ host->max_blk_size = 512;
+ host->max_blk_count = 512;
+
+ /* link up host and sdio */
+ sdio->host = host;
+ host->private_data = sdio;
+
+ swm_sdio_enable_irq(host, 1);
+
+ /* ready to change */
+ mmcsd_change(host);
+
+ return host;
+}
+
+static rt_uint32_t swm_sdio_clock_get(SDIO_TypeDef *swm_sdio)
+{
+ uint32_t prediv;
+ switch((SYS->CLKSEL & SYS_CLKSEL_SDIO_Msk) >> SYS_CLKSEL_SDIO_Pos)
+ {
+ case 0: prediv = 1; break;
+ case 1: prediv = 3; break;
+ case 2: prediv = 2; break;
+ case 3: prediv = 0; break;
+ }
+ return (SystemCoreClock / (1 << prediv));
+}
+
+static rt_err_t swm_sdio_rxconfig(struct swm_sdio_pkg *pkg, rt_uint32_t *buff, int size)
+{
+ struct rt_mmcsd_cmd *cmd = pkg->cmd;
+ struct rt_mmcsd_data *data = cmd->data;
+ int offset = 0;
+ for (uint32_t i = 0; i < data->blks; i++)
+ {
+ offset = i* data->blksize / 4;
+ while ((SDIO->IF & SDIO_IF_BUFRDRDY_Msk) == 0)
+ __NOP();
+ SDIO->IF = SDIO_IF_BUFRDRDY_Msk;
+ for (uint32_t j = 0; j < data->blksize / 4; j++)
+ {
+ buff[offset + j] = SDIO->DATA;
+ }
+ }
+ return RT_EOK;
+}
+
+static rt_err_t swm_sdio_txconfig(struct swm_sdio_pkg *pkg, rt_uint32_t *buff, int size)
+{
+ struct rt_mmcsd_cmd *cmd = pkg->cmd;
+ struct rt_mmcsd_data *data = cmd->data;
+ int offset = 0;
+ for (uint32_t i = 0; i < data->blks; i++)
+ {
+ offset = i* data->blksize / 4;
+ while ((SDIO->IF & SDIO_IF_BUFWRRDY_Msk) == 0)
+ __NOP();
+ SDIO->IF = SDIO_IF_BUFWRRDY_Msk;
+ for (uint32_t j = 0; j < data->blksize / 4; j++)
+ {
+ SDIO->DATA = buff[offset + j];
+ }
+ }
+ return RT_EOK;
+}
+
+/**
+ * @brief This function interrupt process function.
+ * @param host rt_mmcsd_host
+ * @retval None
+ */
+static void swm_sdio_irq_process(struct rt_mmcsd_host *host)
+{
+ int complete = 0;
+ struct swm_sdio_device *sdio = host->private_data;
+ SDIO_TypeDef *swm_sdio = sdio->sdio_des.swm_sdio;
+ rt_uint32_t intstatus = swm_sdio->IF;
+
+ if (intstatus & SDIO_IF_ERROR_Msk)
+ {
+ swm_sdio->IF = 0xFFFFFFFF;
+ complete = 1;
+ }
+ else
+ {
+ if (intstatus & SDIO_IF_CMDDONE_Msk)
+ {
+ swm_sdio->IF = SDIO_IF_CMDDONE_Msk;
+ if (sdio->pkg != RT_NULL)
+ {
+ if (!sdio->pkg->cmd->data)
+ {
+ complete = 1;
+ }
+ }
+ }
+
+ if (intstatus & SDIO_IF_TRXDONE_Msk)
+ {
+ swm_sdio->IF = SDIO_IF_TRXDONE_Msk;
+ complete = 1;
+ }
+ }
+
+ if (complete)
+ {
+ rt_event_send(&sdio->event, intstatus);
+ }
+}
+
+void SDIO_Handler(void)
+{
+ /* enter interrupt */
+ rt_interrupt_enter();
+ /* Process All SDIO Interrupt Sources */
+ swm_sdio_irq_process(host);
+ /* leave interrupt */
+ rt_interrupt_leave();
+}
+
+int swm_sdio_init(void)
+{
+ int result = RT_EOK;
+
+ struct swm_sdio_des sdio_des;
+
+ PORT_Init(PORTM, PIN2, PORTM_PIN2_SD_CLK, 0);
+ PORT_Init(PORTM, PIN4, PORTM_PIN4_SD_CMD, 1);
+ PORT_Init(PORTM, PIN5, PORTM_PIN5_SD_D0, 1);
+ PORT_Init(PORTM, PIN6, PORTM_PIN6_SD_D1, 1);
+ PORT_Init(PORTN, PIN0, PORTN_PIN0_SD_D2, 1);
+ PORT_Init(PORTN, PIN1, PORTN_PIN1_SD_D3, 1);
+
+ NVIC_EnableIRQ(SDIO_IRQn);
+ SYS->CLKSEL &= ~SYS_CLKSEL_SDIO_Msk;
+ if (SystemCoreClock > 80000000) //SDIO时钟需要小于52MHz
+ SYS->CLKSEL |= (2 << SYS_CLKSEL_SDIO_Pos); //SDCLK = SYSCLK / 4
+ else
+ SYS->CLKSEL |= (0 << SYS_CLKSEL_SDIO_Pos); //SDCLK = SYSCLK / 2
+
+ SYS->CLKEN0 |= (0x01 << SYS_CLKEN0_SDIO_Pos);
+
+ SDIO->CR2 = (1 << SDIO_CR2_RSTALL_Pos);
+
+ NVIC_EnableIRQ(SDIO_IRQn);
+ sdio_des.clk_get = swm_sdio_clock_get;
+ sdio_des.swm_sdio = SDIO;
+ sdio_des.rxconfig = swm_sdio_rxconfig;
+ sdio_des.txconfig = swm_sdio_txconfig;
+
+ host = swm_sdio_host_create(&sdio_des);
+ if (host == RT_NULL)
+ {
+ LOG_E("host create fail.");
+ result = -1;
+ }
+ else
+ {
+ LOG_D("host create success.");
+ result = 0;
+ }
+ return result;
+}
+INIT_DEVICE_EXPORT(swm_sdio_init);
+
+#endif /* BSP_USING_SDIO */
+#endif /* RT_USING_SDIO */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_sdio.h b/bsp/synwit/libraries/SWM341_drivers/drv_sdio.h
new file mode 100644
index 0000000000..7064ef4123
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_sdio.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_SDIO_H__
+#define __DRV_SDIO_H__
+
+#include "board.h"
+
+int swm_sdio_init(void);
+
+#endif /* __DRV_SDIO_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_sdram.c b/bsp/synwit/libraries/SWM341_drivers/drv_sdram.c
new file mode 100644
index 0000000000..32c6deaa32
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_sdram.c
@@ -0,0 +1,75 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_sdram.h"
+
+#ifdef BSP_USING_SDRAM
+
+#define DRV_DEBUG
+#define LOG_TAG "drv.sdram"
+#include <drv_log.h>
+
+int swm_sdram_init(void)
+{
+ SDRAM_InitStructure SDRAM_InitStruct;
+
+ PORT_Init(PORTM, PIN13, PORTM_PIN13_SDR_CLK, 0);
+ PORT_Init(PORTM, PIN14, PORTM_PIN14_SDR_CKE, 0);
+ PORT_Init(PORTB, PIN7, PORTB_PIN7_SDR_WE, 0);
+ PORT_Init(PORTB, PIN8, PORTB_PIN8_SDR_CAS, 0);
+ PORT_Init(PORTB, PIN9, PORTB_PIN9_SDR_RAS, 0);
+ PORT_Init(PORTB, PIN10, PORTB_PIN10_SDR_CS, 0);
+ PORT_Init(PORTE, PIN15, PORTE_PIN15_SDR_BA0, 0);
+ PORT_Init(PORTE, PIN14, PORTE_PIN14_SDR_BA1, 0);
+ PORT_Init(PORTN, PIN14, PORTN_PIN14_SDR_A0, 0);
+ PORT_Init(PORTN, PIN13, PORTN_PIN13_SDR_A1, 0);
+ PORT_Init(PORTN, PIN12, PORTN_PIN12_SDR_A2, 0);
+ PORT_Init(PORTN, PIN11, PORTN_PIN11_SDR_A3, 0);
+ PORT_Init(PORTN, PIN10, PORTN_PIN10_SDR_A4, 0);
+ PORT_Init(PORTN, PIN9, PORTN_PIN9_SDR_A5, 0);
+ PORT_Init(PORTN, PIN8, PORTN_PIN8_SDR_A6, 0);
+ PORT_Init(PORTN, PIN7, PORTN_PIN7_SDR_A7, 0);
+ PORT_Init(PORTN, PIN6, PORTN_PIN6_SDR_A8, 0);
+ PORT_Init(PORTN, PIN3, PORTN_PIN3_SDR_A9, 0);
+ PORT_Init(PORTN, PIN15, PORTN_PIN15_SDR_A10, 0);
+ PORT_Init(PORTN, PIN2, PORTN_PIN2_SDR_A11, 0);
+ PORT_Init(PORTM, PIN15, PORTM_PIN15_SDR_A12, 0);
+ PORT_Init(PORTE, PIN7, PORTE_PIN7_SDR_D0, 1);
+ PORT_Init(PORTE, PIN6, PORTE_PIN6_SDR_D1, 1);
+ PORT_Init(PORTE, PIN5, PORTE_PIN5_SDR_D2, 1);
+ PORT_Init(PORTE, PIN4, PORTE_PIN4_SDR_D3, 1);
+ PORT_Init(PORTE, PIN3, PORTE_PIN3_SDR_D4, 1);
+ PORT_Init(PORTE, PIN2, PORTE_PIN2_SDR_D5, 1);
+ PORT_Init(PORTE, PIN1, PORTE_PIN1_SDR_D6, 1);
+ PORT_Init(PORTE, PIN0, PORTE_PIN0_SDR_D7, 1);
+ PORT_Init(PORTE, PIN8, PORTE_PIN8_SDR_D8, 1);
+ PORT_Init(PORTE, PIN9, PORTE_PIN9_SDR_D9, 1);
+ PORT_Init(PORTE, PIN10, PORTE_PIN10_SDR_D10, 1);
+ PORT_Init(PORTE, PIN11, PORTE_PIN11_SDR_D11, 1);
+ PORT_Init(PORTE, PIN12, PORTE_PIN12_SDR_D12, 1);
+ PORT_Init(PORTE, PIN13, PORTE_PIN13_SDR_D13, 1);
+ PORT_Init(PORTC, PIN14, PORTC_PIN14_SDR_D14, 1);
+ PORT_Init(PORTC, PIN15, PORTC_PIN15_SDR_D15, 1);
+ PORT_Init(PORTB, PIN6, PORTB_PIN6_SDR_LDQM, 0);
+ PORT_Init(PORTM, PIN12, PORTM_PIN12_SDR_UDQM, 0);
+
+ SDRAM_InitStruct.Size = SDRAM_SIZE_8MB;
+ SDRAM_InitStruct.ClkDiv = SDRAM_CLKDIV_1;
+ SDRAM_InitStruct.CASLatency = SDRAM_CASLATENCY_3;
+ SDRAM_InitStruct.RefreshTime = 64;
+ SDRAM_InitStruct.TimeTRP = SDRAM_TRP_2;
+ SDRAM_InitStruct.TimeTRCD = SDRAM_TRCD_2;
+ SDRAM_InitStruct.TimeTRC = SDRAM_TRC_7;
+ SDRAM_Init(&SDRAM_InitStruct);
+
+ return 0;
+}
+
+#endif /* BSP_USING_SDRAM */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_sdram.h b/bsp/synwit/libraries/SWM341_drivers/drv_sdram.h
new file mode 100644
index 0000000000..e060746305
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_sdram.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_SDRAM_H__
+#define __DRV_SDRAM_H__
+
+#include "board.h"
+
+int swm_sdram_init(void);
+
+#endif /* __DRV_SDRAM_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.c b/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.c
new file mode 100644
index 0000000000..92228f3a4f
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.c
@@ -0,0 +1,219 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_soft_i2c.h"
+
+#ifdef RT_USING_I2C
+#ifdef BSP_USING_I2C
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.i2c"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_I2C0) && !defined(BSP_USING_I2C1)
+#error "Please define at least one BSP_USING_I2Cx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+#ifdef BSP_USING_I2C0
+#define I2C0_BUS_CFG \
+ { \
+ .scl = BSP_I2C0_SCL_PIN, \
+ .sda = BSP_I2C0_SDA_PIN, \
+ .name = "i2c0", \
+ }
+#endif
+
+#ifdef BSP_USING_I2C1
+#define I2C1_BUS_CFG \
+ { \
+ .scl = BSP_I2C1_SCL_PIN, \
+ .sda = BSP_I2C1_SDA_PIN, \
+ .name = "i2c1", \
+ }
+#endif
+
+/* swm config class */
+struct swm_soft_i2c_cfg
+{
+ rt_uint8_t scl;
+ rt_uint8_t sda;
+ const char *name;
+};
+/* swm i2c dirver class */
+struct swm_soft_i2c_device
+{
+ struct rt_i2c_bit_ops ops;
+ struct rt_i2c_bus_device i2c2_bus;
+};
+
+static const struct swm_soft_i2c_cfg swm_soft_i2c_cfg[] =
+ {
+#ifdef BSP_USING_I2C0
+ I2C0_BUS_CFG,
+#endif
+#ifdef BSP_USING_I2C1
+ I2C1_BUS_CFG,
+#endif
+};
+
+static struct swm_soft_i2c_device i2c_obj[sizeof(swm_soft_i2c_cfg) / sizeof(swm_soft_i2c_cfg[0])];
+
+/**
+ * This function initializes the i2c pin.
+ *
+ * @param swm i2c dirver class.
+ */
+static void swm_i2c_gpio_init(struct swm_soft_i2c_device *i2c)
+{
+ struct swm_soft_i2c_cfg *soft_i2c_cfg = (struct swm_soft_i2c_cfg *)i2c->ops.data;
+
+ rt_pin_mode(soft_i2c_cfg->scl, PIN_MODE_OUTPUT_OD);
+ rt_pin_mode(soft_i2c_cfg->sda, PIN_MODE_OUTPUT_OD);
+
+ rt_pin_write(soft_i2c_cfg->scl, PIN_HIGH);
+ rt_pin_write(soft_i2c_cfg->sda, PIN_HIGH);
+}
+
+/**
+ * This function sets the sda pin.
+ *
+ * @param swm config class.
+ * @param The sda pin state.
+ */
+static void swm_i2c_set_sda(void *data, rt_int32_t state)
+{
+ struct swm_soft_i2c_cfg *soft_i2c_cfg = (struct swm_soft_i2c_cfg *)data;
+ rt_pin_mode(soft_i2c_cfg->sda, PIN_MODE_OUTPUT_OD);
+ if (state)
+ {
+ rt_pin_write(soft_i2c_cfg->sda, PIN_HIGH);
+ }
+ else
+ {
+ rt_pin_write(soft_i2c_cfg->sda, PIN_LOW);
+ }
+}
+
+/**
+ * This function sets the scl pin.
+ *
+ * @param swm config class.
+ * @param The scl pin state.
+ */
+static void swm_i2c_set_scl(void *data, rt_int32_t state)
+{
+ struct swm_soft_i2c_cfg *soft_i2c_cfg = (struct swm_soft_i2c_cfg *)data;
+ rt_pin_mode(soft_i2c_cfg->scl, PIN_MODE_OUTPUT_OD);
+ if (state)
+ {
+ rt_pin_write(soft_i2c_cfg->scl, PIN_HIGH);
+ }
+ else
+ {
+ rt_pin_write(soft_i2c_cfg->scl, PIN_LOW);
+ }
+}
+
+/**
+ * This function gets the sda pin state.
+ *
+ * @param The sda pin state.
+ */
+static rt_int32_t swm_i2c_get_sda(void *data)
+{
+ struct swm_soft_i2c_cfg *soft_i2c_cfg = (struct swm_soft_i2c_cfg *)data;
+ rt_pin_mode(soft_i2c_cfg->sda, PIN_MODE_INPUT_PULLDOWN);
+ return rt_pin_read(soft_i2c_cfg->sda);
+}
+
+/**
+ * This function gets the scl pin state.
+ *
+ * @param The scl pin state.
+ */
+static rt_int32_t swm_i2c_get_scl(void *data)
+{
+ struct swm_soft_i2c_cfg *soft_i2c_cfg = (struct swm_soft_i2c_cfg *)data;
+ rt_pin_mode(soft_i2c_cfg->scl, PIN_MODE_INPUT_PULLDOWN);
+ return rt_pin_read(soft_i2c_cfg->scl);
+}
+
+/**
+ * The time delay function.
+ *
+ * @param microseconds.
+ */
+static void swm_i2c_udelay(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;
+ }
+ }
+ }
+}
+
+static const struct rt_i2c_bit_ops swm_i2c_bit_ops =
+ {
+ .data = RT_NULL,
+ .set_sda = swm_i2c_set_sda,
+ .set_scl = swm_i2c_set_scl,
+ .get_sda = swm_i2c_get_sda,
+ .get_scl = swm_i2c_get_scl,
+ .udelay = swm_i2c_udelay,
+ .delay_us = 1,
+ .timeout = 100};
+
+/* I2C initialization function */
+int swm_i2c_init(void)
+{
+ rt_err_t result;
+
+ for (int i = 0; i < sizeof(i2c_obj) / sizeof(struct swm_soft_i2c_device); i++)
+ {
+ i2c_obj[i].ops = swm_i2c_bit_ops;
+ i2c_obj[i].ops.data = (void *)&swm_soft_i2c_cfg[i];
+ i2c_obj[i].i2c2_bus.priv = &i2c_obj[i].ops;
+ swm_i2c_gpio_init(&i2c_obj[i]);
+ result = rt_i2c_bit_add_bus(&i2c_obj[i].i2c2_bus, swm_soft_i2c_cfg[i].name);
+ RT_ASSERT(result == RT_EOK);
+
+ LOG_D("software simulation %s init done, pin scl: %d, pin sda %d",
+ swm_soft_i2c_cfg[i].name,
+ swm_soft_i2c_cfg[i].scl,
+ swm_soft_i2c_cfg[i].sda);
+ }
+
+ return RT_EOK;
+}
+INIT_DEVICE_EXPORT(swm_i2c_init);
+#endif /* BSP_USING_I2C */
+#endif /* RT_USING_I2C */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.h b/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.h
new file mode 100644
index 0000000000..60151d0e50
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_soft_i2c.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_SOFT_I2C_H__
+#define __DRV_SOFT_I2C_H__
+
+#include "board.h"
+
+int swm_i2c_init(void);
+
+#endif /* __DRV_SOFT_I2C_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_spi.c b/bsp/synwit/libraries/SWM341_drivers/drv_spi.c
new file mode 100644
index 0000000000..51080fd7dc
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_spi.c
@@ -0,0 +1,375 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_spi.h"
+
+#ifdef RT_USING_SPI
+#ifdef BSP_USING_SPI
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.spi"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_SPI0) && !defined(BSP_USING_SPI1)
+#error "Please define at least one BSP_USING_SPIx"
+/* this driver can be disabled at menuconfig ? RT-Thread Components ? Device Drivers */
+#endif
+
+struct swm_spi_cs
+{
+ GPIO_TypeDef *GPIOx;
+ uint32_t gpio_pin;
+};
+
+struct swm_spi_cfg
+{
+ const char *name;
+ SPI_TypeDef *SPIx;
+ SPI_InitStructure spi_initstruct;
+};
+
+/* swm spi dirver class */
+struct swm_spi_device
+{
+ struct swm_spi_cfg *spi_cfg;
+ struct rt_spi_configuration *configure;
+ struct rt_spi_bus spi_bus;
+};
+
+#ifdef BSP_USING_SPI0
+#ifndef SPI0_BUS_CONFIG
+#define SPI0_BUS_CONFIG \
+ { \
+ .name = "spi0", \
+ .SPIx = SPI0, \
+ .spi_initstruct.clkDiv = SPI_CLKDIV_16, \
+ .spi_initstruct.FrameFormat = SPI_FORMAT_SPI, \
+ .spi_initstruct.SampleEdge = SPI_SECOND_EDGE, \
+ .spi_initstruct.IdleLevel = SPI_HIGH_LEVEL, \
+ .spi_initstruct.WordSize = 8, \
+ .spi_initstruct.Master = 1, \
+ .spi_initstruct.RXThreshold = 0, \
+ .spi_initstruct.RXThresholdIEn = 0, \
+ .spi_initstruct.TXThreshold = 0, \
+ .spi_initstruct.TXThresholdIEn = 0, \
+ .spi_initstruct.TXCompleteIEn = 0, \
+ }
+#endif /* SPI0_BUS_CONFIG */
+#endif /* BSP_USING_SPI0 */
+
+#ifdef BSP_USING_SPI1
+#ifndef SPI1_BUS_CONFIG
+#define SPI1_BUS_CONFIG \
+ { \
+ .name = "spi1", \
+ .SPIx = SPI1, \
+ .spi_initstruct.clkDiv = SPI_CLKDIV_16, \
+ .spi_initstruct.FrameFormat = SPI_FORMAT_SPI, \
+ .spi_initstruct.SampleEdge = SPI_SECOND_EDGE, \
+ .spi_initstruct.IdleLevel = SPI_HIGH_LEVEL, \
+ .spi_initstruct.WordSize = 8, \
+ .spi_initstruct.Master = 1, \
+ .spi_initstruct.RXThreshold = 0, \
+ .spi_initstruct.RXThresholdIEn = 0, \
+ .spi_initstruct.TXThreshold = 0, \
+ .spi_initstruct.TXThresholdIEn = 0, \
+ .spi_initstruct.TXCompleteIEn = 0, \
+ }
+#endif /* SPI1_BUS_CONFIG */
+#endif /* BSP_USING_SPI1 */
+
+static struct swm_spi_cfg swm_spi_cfg[] =
+ {
+#ifdef BSP_USING_SPI0
+ SPI0_BUS_CONFIG,
+#endif
+#ifdef BSP_USING_SPI1
+ SPI1_BUS_CONFIG,
+#endif
+};
+
+static struct swm_spi_device spi_bus_obj[sizeof(swm_spi_cfg) / sizeof(swm_spi_cfg[0])] = {0};
+
+static rt_err_t swm_spi_configure(struct rt_spi_device *device,
+ struct rt_spi_configuration *configure)
+{
+ RT_ASSERT(device != RT_NULL);
+ RT_ASSERT(configure != RT_NULL);
+
+ struct swm_spi_device *spi_drv = rt_container_of(device->bus, struct swm_spi_device, spi_bus);
+ spi_drv->configure = configure;
+ struct swm_spi_cfg *spi_cfg = spi_drv->spi_cfg;
+
+ if (configure->mode & RT_SPI_SLAVE)
+ {
+ spi_cfg->spi_initstruct.Master = 0;
+ }
+ else
+ {
+ spi_cfg->spi_initstruct.Master = 1;
+ }
+
+ if (configure->mode & RT_SPI_3WIRE)
+ {
+ return -RT_EINVAL;
+ }
+
+ if (configure->data_width == 8)
+ {
+ spi_cfg->spi_initstruct.WordSize = 8;
+ }
+ else if (configure->data_width == 16)
+ {
+ spi_cfg->spi_initstruct.WordSize = 16;
+ }
+ else
+ {
+ return -RT_EIO;
+ }
+
+ if (configure->mode & RT_SPI_CPHA)
+ {
+ spi_cfg->spi_initstruct.SampleEdge = SPI_SECOND_EDGE;
+ }
+ else
+ {
+ spi_cfg->spi_initstruct.SampleEdge = SPI_FIRST_EDGE;
+ }
+
+ if (configure->mode & RT_SPI_CPOL)
+ {
+ spi_cfg->spi_initstruct.IdleLevel = SPI_HIGH_LEVEL;
+ }
+ else
+ {
+ spi_cfg->spi_initstruct.IdleLevel = SPI_LOW_LEVEL;
+ }
+
+ if (configure->max_hz >= SystemCoreClock / 2)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_2;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 4)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_4;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 8)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_8;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 16)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_16;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 32)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_32;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 64)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_64;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 128)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_128;
+ }
+ else if (configure->max_hz >= SystemCoreClock / 256)
+ {
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_256;
+ }
+ else
+ {
+ /* min prescaler 512 */
+ spi_cfg->spi_initstruct.clkDiv = SPI_CLKDIV_512;
+ }
+
+ SPI_Init(spi_cfg->SPIx, &(spi_cfg->spi_initstruct));
+ SPI_Open(spi_cfg->SPIx);
+ LOG_D("%s init done", spi_cfg->name);
+ return RT_EOK;
+}
+
+#define SPISTEP(datalen) (((datalen) == 8) ? 1 : 2)
+#define SPISEND_1(reg, ptr, datalen) \
+ do \
+ { \
+ if (datalen == 8) \
+ { \
+ (reg) = *(rt_uint8_t *)(ptr); \
+ } \
+ else \
+ { \
+ (reg) = *(rt_uint16_t *)(ptr); \
+ } \
+ } while (0)
+#define SPIRECV_1(reg, ptr, datalen) \
+ do \
+ { \
+ if (datalen == 8) \
+ { \
+ *(rt_uint8_t *)(ptr) = (reg); \
+ } \
+ else \
+ { \
+ *(rt_uint16_t *)(ptr) = reg; \
+ } \
+ } while (0)
+
+static rt_err_t swm_spi_txrx1b(struct swm_spi_device *spi_drv, void *rcvb, const void *sndb)
+{
+ rt_uint32_t padrcv = 0;
+ rt_uint32_t padsnd = 0xFF;
+ if (!rcvb && !sndb)
+ {
+ return -RT_ERROR;
+ }
+ if (!rcvb)
+ {
+ rcvb = &padrcv;
+ }
+ if (!sndb)
+ {
+ sndb = &padsnd;
+ }
+ while (SPI_IsTXFull(spi_drv->spi_cfg->SPIx))
+ ;
+ SPISEND_1(spi_drv->spi_cfg->SPIx->DATA, sndb, spi_drv->spi_cfg->spi_initstruct.WordSize);
+ while (SPI_IsRXEmpty(spi_drv->spi_cfg->SPIx))
+ ;
+ SPIRECV_1(spi_drv->spi_cfg->SPIx->DATA, rcvb, spi_drv->spi_cfg->spi_initstruct.WordSize);
+ return RT_EOK;
+}
+
+static rt_uint32_t swm_spi_xfer(struct rt_spi_device *device, struct rt_spi_message *message)
+{
+ rt_err_t res;
+
+ RT_ASSERT(device != RT_NULL);
+ RT_ASSERT(device->bus != RT_NULL);
+ RT_ASSERT(device->bus->parent.user_data != RT_NULL);
+ RT_ASSERT(message != RT_NULL);
+
+ struct swm_spi_device *spi_drv = rt_container_of(device->bus, struct swm_spi_device, spi_bus);
+ struct swm_spi_cfg *spi_cfg = spi_drv->spi_cfg;
+ struct swm_spi_cs *cs = device->parent.user_data;
+
+ if (message->cs_take)
+ {
+ GPIO_ClrBit(cs->GPIOx, cs->gpio_pin);
+ }
+
+ LOG_D("%s transfer prepare and start", spi_cfg->name);
+ LOG_D("%s sendbuf: %X, recvbuf: %X, length: %d",
+ spi_cfg->name, (uint32_t)message->send_buf, (uint32_t)message->recv_buf, message->length);
+
+ const rt_uint8_t *sndb = message->send_buf;
+ rt_uint8_t *rcvb = message->recv_buf;
+ rt_int32_t length = message->length;
+
+ while (length)
+ {
+ res = swm_spi_txrx1b(spi_drv, rcvb, sndb);
+ if (rcvb)
+ {
+ rcvb += SPISTEP(spi_cfg->spi_initstruct.WordSize);
+ }
+ if (sndb)
+ {
+ sndb += SPISTEP(spi_cfg->spi_initstruct.WordSize);
+ }
+ if (res != RT_EOK)
+ {
+ break;
+ }
+ length--;
+ }
+ /* Wait until Busy flag is reset before disabling SPI */
+ while (!SPI_IsTXEmpty(spi_cfg->SPIx) && !SPI_IsRXEmpty(spi_cfg->SPIx))
+ ;
+ if (message->cs_release)
+ {
+ GPIO_SetBit(cs->GPIOx, cs->gpio_pin);
+ }
+ return message->length - length;
+}
+
+static const struct rt_spi_ops swm_spi_ops =
+ {
+ .configure = swm_spi_configure,
+ .xfer = swm_spi_xfer,
+};
+
+//cannot be used before completion init
+rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, GPIO_TypeDef *cs_gpiox, uint32_t cs_gpio_pin)
+{
+ RT_ASSERT(bus_name != RT_NULL);
+ RT_ASSERT(device_name != RT_NULL);
+
+ rt_err_t result;
+ struct rt_spi_device *spi_device;
+ struct swm_spi_cs *cs_pin;
+
+ GPIO_Init(cs_gpiox, cs_gpio_pin, 1, 1, 0, 0);
+ GPIO_SetBit(cs_gpiox, cs_gpio_pin);
+
+ spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device));
+ RT_ASSERT(spi_device != RT_NULL);
+ cs_pin = (struct swm_spi_cs *)rt_malloc(sizeof(struct swm_spi_cs));
+ RT_ASSERT(cs_pin != RT_NULL);
+ cs_pin->GPIOx = cs_gpiox;
+ cs_pin->gpio_pin = cs_gpio_pin;
+
+ result = rt_spi_bus_attach_device(spi_device, device_name, bus_name, (void *)cs_pin);
+ if (result != RT_EOK)
+ {
+ LOG_E("%s attach to %s faild, %d\n", device_name, bus_name, result);
+ }
+ RT_ASSERT(result == RT_EOK);
+ LOG_D("%s attach to %s done", device_name, bus_name);
+ return result;
+}
+
+int swm_spi_init(void)
+{
+ rt_err_t result;
+
+#ifdef BSP_USING_SPI0
+ PORT_Init(PORTM, PIN2, PORTM_PIN2_SPI0_SCLK, 0);
+ PORT_Init(PORTM, PIN4, PORTM_PIN4_SPI0_MISO, 1);
+ PORT_Init(PORTM, PIN5, PORTM_PIN5_SPI0_MOSI, 0);
+#endif //BSP_USING_SPI0
+
+#ifdef BSP_USING_SPI1
+ PORT_Init(PORTB, PIN2, PORTB_PIN2_SPI1_SCLK, 0);
+ PORT_Init(PORTB, PIN3, PORTB_PIN3_SPI1_MISO, 1);
+ PORT_Init(PORTB, PIN4, PORTB_PIN4_SPI1_MOSI, 0);
+#endif //BSP_USING_SPI1
+
+ for (int i = 0; i < sizeof(swm_spi_cfg) / sizeof(swm_spi_cfg[0]); i++)
+ {
+ spi_bus_obj[i].spi_cfg = &swm_spi_cfg[i];
+ spi_bus_obj[i].spi_bus.parent.user_data = &swm_spi_cfg[i];
+ result = rt_spi_bus_register(&spi_bus_obj[i].spi_bus, swm_spi_cfg[i].name, &swm_spi_ops);
+ if (result != RT_EOK)
+ {
+ LOG_E("%s bus register fail.", swm_spi_cfg[i].name);
+ }
+ else
+ {
+ LOG_D("%s bus register success.", swm_spi_cfg[i].name);
+ }
+ }
+
+ return result;
+}
+INIT_BOARD_EXPORT(swm_spi_init);
+
+#endif /* BSP_USING_SPI */
+#endif /* RT_USING_SPI */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_spi.h b/bsp/synwit/libraries/SWM341_drivers/drv_spi.h
new file mode 100644
index 0000000000..d4425e87c0
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_spi.h
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_SPI_H__
+#define __DRV_SPI_H__
+
+#include "board.h"
+
+//cannot be used before completion init
+rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, GPIO_TypeDef *GPIOx, uint32_t n);
+int swm_spi_init(void);
+
+#endif /* __DRV_SPI_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_uart.c b/bsp/synwit/libraries/SWM341_drivers/drv_uart.c
new file mode 100644
index 0000000000..c64c759525
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_uart.c
@@ -0,0 +1,366 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_uart.h"
+
+#ifdef RT_USING_SERIAL
+#ifdef BSP_USING_UART
+
+//#define DRV_DEBUG
+#define LOG_TAG "drv.uart"
+#include <drv_log.h>
+
+#if !defined(BSP_USING_UART0) && !defined(BSP_USING_UART1) && !defined(BSP_USING_UART2) && \
+ !defined(BSP_USING_UART3)
+#error "Please define at least one BSP_USING_UARTx"
+/* this driver can be disabled at menuconfig -> RT-Thread Components -> Device Drivers */
+#endif
+
+#ifdef BSP_USING_UART0
+#ifndef UART0_CFG
+#define UART0_CFG \
+ { \
+ .name = "uart0", \
+ .UARTx = UART0, \
+ .irq = UART0_IRQn, \
+ .uart_initstruct.Baudrate = 115200, \
+ .uart_initstruct.DataBits = UART_DATA_8BIT, \
+ .uart_initstruct.Parity = UART_PARITY_NONE, \
+ .uart_initstruct.StopBits = UART_STOP_1BIT, \
+ .uart_initstruct.RXThreshold = 0, \
+ .uart_initstruct.RXThresholdIEn = 1, \
+ .uart_initstruct.TXThresholdIEn = 0, \
+ .uart_initstruct.TimeoutTime = 10, \
+ .uart_initstruct.TimeoutIEn = 1, \
+ }
+#endif /* UART0_CFG */
+#endif /* BSP_USING_UART0 */
+
+#ifdef BSP_USING_UART1
+#ifndef UART1_CFG
+#define UART1_CFG \
+ { \
+ .name = "uart1", \
+ .UARTx = UART1, \
+ .irq = UART1_IRQn, \
+ .uart_initstruct.Baudrate = 115200, \
+ .uart_initstruct.DataBits = UART_DATA_8BIT, \
+ .uart_initstruct.Parity = UART_PARITY_NONE, \
+ .uart_initstruct.StopBits = UART_STOP_1BIT, \
+ .uart_initstruct.RXThreshold = 0, \
+ .uart_initstruct.RXThresholdIEn = 1, \
+ .uart_initstruct.TXThresholdIEn = 0, \
+ .uart_initstruct.TimeoutTime = 10, \
+ .uart_initstruct.TimeoutIEn = 1, \
+ }
+#endif /* UART1_CFG */
+#endif /* BSP_USING_UART1 */
+
+#ifdef BSP_USING_UART2
+#ifndef UART2_CFG
+#define UART2_CFG \
+ { \
+ .name = "uart2", \
+ .UARTx = UART2, \
+ .irq = UART2_IRQn, \
+ .uart_initstruct.Baudrate = 115200, \
+ .uart_initstruct.DataBits = UART_DATA_8BIT, \
+ .uart_initstruct.Parity = UART_PARITY_NONE, \
+ .uart_initstruct.StopBits = UART_STOP_1BIT, \
+ .uart_initstruct.RXThreshold = 0, \
+ .uart_initstruct.RXThresholdIEn = 1, \
+ .uart_initstruct.TXThresholdIEn = 0, \
+ .uart_initstruct.TimeoutTime = 10, \
+ .uart_initstruct.TimeoutIEn = 1, \
+ }
+#endif /* UART2_CFG */
+#endif /* BSP_USING_UART2 */
+
+#ifdef BSP_USING_UART3
+#ifndef UART3_CFG
+#define UART3_CFG \
+ { \
+ .name = "uart3", \
+ .UARTx = UART3, \
+ .irq = UART3_IRQn, \
+ .uart_initstruct.Baudrate = 115200, \
+ .uart_initstruct.DataBits = UART_DATA_8BIT, \
+ .uart_initstruct.Parity = UART_PARITY_NONE, \
+ .uart_initstruct.StopBits = UART_STOP_1BIT, \
+ .uart_initstruct.RXThreshold = 0, \
+ .uart_initstruct.RXThresholdIEn = 1, \
+ .uart_initstruct.TXThresholdIEn = 0, \
+ .uart_initstruct.TimeoutTime = 10, \
+ .uart_initstruct.TimeoutIEn = 1, \
+ }
+#endif /* UART3_CFG */
+#endif /* BSP_USING_UART3 */
+
+/* swm config class */
+struct swm_uart_cfg
+{
+ const char *name;
+ UART_TypeDef *UARTx;
+ IRQn_Type irq;
+ UART_InitStructure uart_initstruct;
+};
+
+/* swm uart dirver class */
+struct swm_uart_device
+{
+ struct swm_uart_cfg *uart_cfg;
+ struct rt_serial_device serial_device;
+};
+
+enum
+{
+#ifdef BSP_USING_UART0
+ UART0_INDEX,
+#endif
+#ifdef BSP_USING_UART1
+ UART1_INDEX,
+#endif
+#ifdef BSP_USING_UART2
+ UART2_INDEX,
+#endif
+#ifdef BSP_USING_UART3
+ UART3_INDEX,
+#endif
+};
+
+static struct swm_uart_cfg swm_uart_cfg[] =
+ {
+#ifdef BSP_USING_UART0
+ UART0_CFG,
+#endif
+#ifdef BSP_USING_UART1
+ UART1_CFG,
+#endif
+#ifdef BSP_USING_UART2
+ UART2_CFG,
+#endif
+#ifdef BSP_USING_UART3
+ UART3_CFG,
+#endif
+};
+
+static struct swm_uart_device uart_obj[sizeof(swm_uart_cfg) / sizeof(swm_uart_cfg[0])] = {0};
+
+static rt_err_t swm_uart_configure(struct rt_serial_device *serial_device, struct serial_configure *configure)
+{
+ struct swm_uart_cfg *uart_cfg;
+ RT_ASSERT(serial_device != RT_NULL);
+ RT_ASSERT(configure != RT_NULL);
+ uart_cfg = serial_device->parent.user_data;
+
+ uart_cfg->uart_initstruct.Baudrate = configure->baud_rate;
+ switch (configure->data_bits)
+ {
+ case DATA_BITS_8:
+ uart_cfg->uart_initstruct.DataBits = UART_DATA_8BIT;
+ break;
+ case DATA_BITS_9:
+ uart_cfg->uart_initstruct.DataBits = UART_DATA_9BIT;
+ break;
+ default:
+ uart_cfg->uart_initstruct.DataBits = UART_DATA_8BIT;
+ break;
+ }
+ switch (configure->stop_bits)
+ {
+ case STOP_BITS_1:
+ uart_cfg->uart_initstruct.StopBits = UART_STOP_1BIT;
+ break;
+ case STOP_BITS_2:
+ uart_cfg->uart_initstruct.StopBits = UART_STOP_2BIT;
+ break;
+ default:
+ uart_cfg->uart_initstruct.StopBits = UART_STOP_1BIT;
+ break;
+ }
+ switch (configure->parity)
+ {
+ case PARITY_NONE:
+ uart_cfg->uart_initstruct.Parity = UART_PARITY_NONE;
+ break;
+ case PARITY_ODD:
+ uart_cfg->uart_initstruct.Parity = UART_PARITY_ODD;
+ break;
+ case PARITY_EVEN:
+ uart_cfg->uart_initstruct.Parity = UART_PARITY_EVEN;
+ break;
+ default:
+ uart_cfg->uart_initstruct.Parity = UART_PARITY_NONE;
+ break;
+ }
+
+ UART_Init(uart_cfg->UARTx, &(uart_cfg->uart_initstruct));
+ UART_Open(uart_cfg->UARTx);
+ return RT_EOK;
+}
+
+static rt_err_t swm_uart_control(struct rt_serial_device *serial_device, int cmd, void *arg)
+{
+ struct swm_uart_cfg *uart_cfg;
+ RT_ASSERT(serial_device != RT_NULL);
+ uart_cfg = serial_device->parent.user_data;
+
+ switch (cmd)
+ {
+ case RT_DEVICE_CTRL_CLR_INT:
+ /* disable rx irq */
+ NVIC_DisableIRQ(uart_cfg->irq);
+ break;
+ case RT_DEVICE_CTRL_SET_INT:
+ /* enable rx irq */
+ NVIC_EnableIRQ(uart_cfg->irq);
+ break;
+ }
+ return RT_EOK;
+}
+
+static int swm_uart_putc(struct rt_serial_device *serial_device, char c)
+{
+ struct swm_uart_cfg *uart_cfg;
+ RT_ASSERT(serial_device != RT_NULL);
+ uart_cfg = serial_device->parent.user_data;
+
+ UART_WriteByte(uart_cfg->UARTx, c);
+ while (UART_IsTXBusy(uart_cfg->UARTx))
+ ;
+ return 1;
+}
+
+static int swm_uart_getc(struct rt_serial_device *serial_device)
+{
+ int ch;
+ struct swm_uart_cfg *uart_cfg;
+ RT_ASSERT(serial_device != RT_NULL);
+ uart_cfg = serial_device->parent.user_data;
+
+ ch = -1;
+ if (UART_IsRXFIFOEmpty(uart_cfg->UARTx) == 0)
+ {
+ UART_ReadByte(uart_cfg->UARTx, (uint32_t *)&ch);
+ }
+ return ch;
+}
+
+static const struct rt_uart_ops swm_uart_ops =
+ {
+ .configure = swm_uart_configure,
+ .control = swm_uart_control,
+ .putc = swm_uart_putc,
+ .getc = swm_uart_getc,
+ .dma_transmit = RT_NULL};
+
+/**
+ * Uart common interrupt process. This need add to uart ISR.
+ *
+ * @param serial serial device
+ */
+static void swm_uart_isr(struct rt_serial_device *serial_device)
+{
+ struct swm_uart_cfg *uart_cfg;
+ RT_ASSERT(serial_device != RT_NULL);
+ uart_cfg = serial_device->parent.user_data;
+
+ /* UART in mode Receiver -------------------------------------------------*/
+ if (UART_INTStat(uart_cfg->UARTx, UART_IT_RX_THR) || UART_INTStat(uart_cfg->UARTx, UART_IT_RX_TOUT))
+ {
+ if(!UART_IsRXFIFOEmpty(uart_cfg->UARTx))
+ {
+ rt_hw_serial_isr(serial_device, RT_SERIAL_EVENT_RX_IND);
+ }
+
+ if(UART_INTStat(uart_cfg->UARTx, UART_IT_RX_TOUT))
+ {
+ UART_INTClr(uart_cfg->UARTx, UART_IT_RX_TOUT);
+
+ rt_hw_serial_isr(serial_device, RT_SERIAL_EVENT_RX_TIMEOUT);
+ }
+ }
+}
+
+#if defined(BSP_USING_UART0)
+void UART0_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_uart_isr(&(uart_obj[UART0_INDEX].serial_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART0 */
+
+#if defined(BSP_USING_UART1)
+void UART1_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_uart_isr(&(uart_obj[UART1_INDEX].serial_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART1 */
+
+#if defined(BSP_USING_UART2)
+void UART2_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_uart_isr(&(uart_obj[UART2_INDEX].serial_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART2 */
+
+#if defined(BSP_USING_UART3)
+void UART3_Handler(void)
+{
+ rt_interrupt_enter();
+ swm_uart_isr(&(uart_obj[UART3_INDEX].serial_device));
+ rt_interrupt_leave();
+}
+#endif /* BSP_USING_UART3 */
+
+int swm_uart_init(void)
+{
+ struct serial_configure serial_cfg = RT_SERIAL_CONFIG_DEFAULT;
+ int i = 0;
+ rt_err_t result = RT_EOK;
+
+#ifdef BSP_USING_UART0
+ PORT_Init(PORTM, PIN0, PORTM_PIN0_UART0_RX, 1);
+ PORT_Init(PORTM, PIN1, PORTM_PIN1_UART0_TX, 0);
+#endif
+#ifdef BSP_USING_UART1
+ PORT_Init(PORTD, PIN4, PORTD_PIN4_UART1_RX, 1);
+ PORT_Init(PORTD, PIN3, PORTD_PIN3_UART1_TX, 0);
+#endif
+#ifdef BSP_USING_UART2
+ PORT_Init(PORTC, PIN1, PORTC_PIN1_UART2_RX, 1);
+ PORT_Init(PORTC, PIN0, PORTC_PIN0_UART2_TX, 0);
+#endif
+#ifdef BSP_USING_UART3
+ PORT_Init(PORTC, PIN2, PORTC_PIN2_UART3_RX, 1);
+ PORT_Init(PORTC, PIN3, PORTC_PIN3_UART3_TX, 0);
+#endif
+
+ for (i = 0; i < sizeof(swm_uart_cfg) / sizeof(swm_uart_cfg[0]); i++)
+ {
+ uart_obj[i].uart_cfg = &swm_uart_cfg[i];
+ uart_obj[i].serial_device.ops = &swm_uart_ops;
+ uart_obj[i].serial_device.config = serial_cfg;
+
+ result = rt_hw_serial_register(&uart_obj[i].serial_device, uart_obj[i].uart_cfg->name,
+ RT_DEVICE_FLAG_RDWR | RT_DEVICE_FLAG_INT_RX, uart_obj[i].uart_cfg);
+ RT_ASSERT(result == RT_EOK);
+ }
+
+ return result;
+}
+
+#endif /* BSP_USING_UART */
+#endif /* RT_USING_SERIAL */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_uart.h b/bsp/synwit/libraries/SWM341_drivers/drv_uart.h
new file mode 100644
index 0000000000..3a078bfd9e
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_uart.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_UART_H__
+#define __DRV_UART_H__
+
+#include "board.h"
+
+int swm_uart_init(void);
+
+#endif /* __DRV_UART_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_wdt.c b/bsp/synwit/libraries/SWM341_drivers/drv_wdt.c
new file mode 100644
index 0000000000..d4cd12fbfd
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_wdt.c
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#include "drv_wdt.h"
+
+#ifdef RT_USING_WDT
+#ifdef BSP_USING_WDT
+//#define DRV_DEBUG
+#define LOG_TAG "drv.wdt"
+#include <drv_log.h>
+
+struct swm_wdt_cfg
+{
+ const char *name;
+ WDT_TypeDef *WDTx;
+};
+
+struct swm_wdt_device
+{
+ struct swm_wdt_cfg *wdt_cfg;
+ struct rt_watchdog_device wdt_device;
+};
+
+static struct swm_wdt_cfg swm_wdt_cfg =
+ {
+ .name = "wdt",
+ .WDTx = WDT,
+};
+
+static struct swm_wdt_device wdt_obj;
+
+static rt_err_t swm_wdt_configure(rt_watchdog_t *wdt_device)
+{
+ return RT_EOK;
+}
+
+static rt_err_t swm_wdt_control(rt_watchdog_t *wdt_device, int cmd, void *arg)
+{
+ struct swm_wdt_cfg *wdt_cfg;
+ RT_ASSERT(wdt_device != RT_NULL);
+ wdt_cfg = wdt_device->parent.user_data;
+
+ switch (cmd)
+ {
+ case RT_DEVICE_CTRL_WDT_KEEPALIVE:
+ WDT_Feed(wdt_cfg->WDTx);
+ break;
+ case RT_DEVICE_CTRL_WDT_SET_TIMEOUT:
+ WDT_Init(wdt_cfg->WDTx, 0, (1024 * (*(rt_uint32_t *)arg)));
+ break;
+ case RT_DEVICE_CTRL_WDT_GET_TIMEOUT:
+ *(rt_uint32_t *)arg = (wdt_cfg->WDTx->RSTVAL) / 1024;
+ break;
+ case RT_DEVICE_CTRL_WDT_GET_TIMELEFT:
+ // not support
+ break;
+ case RT_DEVICE_CTRL_WDT_START:
+ WDT_Start(wdt_cfg->WDTx);
+ break;
+ case RT_DEVICE_CTRL_WDT_STOP:
+ WDT_Stop(wdt_cfg->WDTx);
+ break;
+ default:
+ LOG_W("This command is not supported.");
+ return -RT_ERROR;
+ }
+
+ return RT_EOK;
+}
+
+static const struct rt_watchdog_ops swm_wdt_ops =
+ {
+ .init = swm_wdt_configure,
+ .control = swm_wdt_control};
+
+int swm_wdt_init(void)
+{
+ int result = RT_EOK;
+
+ wdt_obj.wdt_cfg = &swm_wdt_cfg;
+ wdt_obj.wdt_device.ops = &swm_wdt_ops;
+
+ result = rt_hw_watchdog_register(&wdt_obj.wdt_device, wdt_obj.wdt_cfg->name, RT_DEVICE_FLAG_RDWR, wdt_obj.wdt_cfg);
+ if(result != RT_EOK)
+ {
+ LOG_E("wdt device register fail.");
+ }
+ else
+ {
+ LOG_D("wdt device register success.");
+ }
+ return result;
+}
+INIT_BOARD_EXPORT(swm_wdt_init);
+
+#endif /* BSP_USING_WDT */
+#endif /* RT_USING_WDT */
diff --git a/bsp/synwit/libraries/SWM341_drivers/drv_wdt.h b/bsp/synwit/libraries/SWM341_drivers/drv_wdt.h
new file mode 100644
index 0000000000..a3d0600d96
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/drv_wdt.h
@@ -0,0 +1,18 @@
+/*
+ * Copyright (c) 2006-2022, Synwit Technology Co.,Ltd.
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2021-07-01 lik first version
+ */
+
+#ifndef __DRV_WDT_H__
+#define __DRV_WDT_H__
+
+#include "board.h"
+
+int swm_wdt_init(void);
+
+#endif /* __DRV_WDT_H__ */
diff --git a/bsp/synwit/libraries/SWM341_drivers/rgb_lcd_port.h b/bsp/synwit/libraries/SWM341_drivers/rgb_lcd_port.h
new file mode 100644
index 0000000000..4c578dcdb0
--- /dev/null
+++ b/bsp/synwit/libraries/SWM341_drivers/rgb_lcd_port.h
@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2006-2022, RT-Thread Development Team
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Change Logs:
+ * Date Author Notes
+ * 2022-02-26 lik first version
+ */
+
+#ifndef __LCD_PORT_H__
+#define __LCD_PORT_H__
+
+#include "board.h"
+
+/* atk 4.3 inch screen, 480 * 272 */
+#define LCD_WIDTH 480
+#define LCD_HEIGHT 272
+#define LCD_BITS_PER_PIXEL 16
+#define LCD_BUF_SIZE (LCD_WIDTH * LCD_HEIGHT * LCD_BITS_PER_PIXEL / 8)
+#define LCD_PIXEL_FORMAT RTGRAPHIC_PIXEL_FORMAT_RGB565
+
+#define LCD_CLK_DIV 15
+#define LCD_HSYNC_WIDTH 5
+#define LCD_VSYNC_WIDTH 5
+#define LCD_HBP 40
+#define LCD_VBP 8
+#define LCD_HFP 5
+#define LCD_VFP 8
+
+#define LCD_BACKLIGHT_USING_GPIO
+#define LCD_BL_GPIO GET_PIN(D, 9)
+#define LCD_DISP_GPIO GET_PIN(D, 1)
+
+#endif /* __LCD_PORT_H__ */