diff options
| author | Xian Wu <[email protected]> | 2023-12-27 18:41:52 +0800 |
|---|---|---|
| committer | GitHub <[email protected]> | 2023-12-27 18:41:52 +0800 |
| commit | 6360253c129afcb91d34770cb253eea8d837e66a (patch) | |
| tree | 065167006028882ff4d57208252d1e0ce9f3b4e4 /bsp/synwit/libraries/SWM341_drivers | |
| parent | 7b4592c2d15bf90c1958bdbc840ea4df3d97cd96 (diff) | |
Synwit MCU 采用新的 BSP 框架,将 BSP 与 libraries 分离 (#8432)
Diffstat (limited to 'bsp/synwit/libraries/SWM341_drivers')
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__ */ |
