diff --git a/bsp/maxim/MAX32660_EVSYS/board/Kconfig b/bsp/maxim/MAX32660_EVSYS/board/Kconfig index 924b74f04ccd7e57c5c3dc154a8be6fe845f301a..fa4ec1d0cd1e5fbe67c5d7a31c3a34b81be7566e 100644 --- a/bsp/maxim/MAX32660_EVSYS/board/Kconfig +++ b/bsp/maxim/MAX32660_EVSYS/board/Kconfig @@ -43,6 +43,25 @@ menu "On-chip Peripheral Drivers" depends on BSP_USING_UART1 && RT_SERIAL_USING_DMA default n endif + config BSP_USING_SPI + bool "Enable SPI" + select RT_USING_SPI + default n + + if BSP_USING_SPI + config BSP_USING_SPI0 + bool "Enable SPI0 bus [MISO P0.4;MOSI P0.5;SCL P0.6;SS P0.7]" + default y + + config BSP_USING_SPI1 + bool "Enable SPI1 bus [MISO P0.0;MOSI P0.1;SCL P0.2;SS P0.3]" + default n + if BSP_USING_SPI1 + config BSP_USING_SPI1A + bool "Use SPI1A. [MISO P0.10;MOSI P0.11;SCL P0.12;SS P0.13]" + default n + endif + endif config BSP_USING_ON_CHIP_FLASH select PKG_USING_FAL bool "Enable on-chip FLASH" diff --git a/bsp/maxim/libraries/HAL_Drivers/drv_spi.c b/bsp/maxim/libraries/HAL_Drivers/drv_spi.c new file mode 100644 index 0000000000000000000000000000000000000000..32e5194fd6313f91bd4661b1dcdd9cc8ba2b8808 --- /dev/null +++ b/bsp/maxim/libraries/HAL_Drivers/drv_spi.c @@ -0,0 +1,231 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-02-14 supperthomas first version + */ + +#include +#include +#include "board.h" +#include "drv_spi.h" + +#define DBG_LEVEL DBG_LOG +#include +#define LOG_TAG "drv.spi" + +#ifdef BSP_USING_SPI + +#if defined(BSP_USING_SPI0) || defined(BSP_USING_SPI1) || defined(BSP_USING_SPI2) +static struct mcu_drv_spi_config spi_config[] = +{ +#ifdef BSP_USING_SPI0 + MCU_SPI0_CONFIG, +#endif +#ifdef BSP_USING_SPI1 + MCU_SPI1_CONFIG, +#endif + +}; + +static struct mcu_drv_spi spi_bus_obj[sizeof(spi_config) / sizeof(spi_config[0])]; + + +/** + * @brief This function config spi bus + * @param device + * @param configuration + * @retval RT_EOK / RT_ERROR + */ +static rt_err_t spi_configure(struct rt_spi_device *device, + struct rt_spi_configuration *configuration) +{ + RT_ASSERT(device != RT_NULL); + RT_ASSERT(device->bus != RT_NULL); + RT_ASSERT(device->bus->parent.user_data != RT_NULL); + RT_ASSERT(configuration != RT_NULL); + struct mcu_drv_spi *tmp_spi; + tmp_spi = rt_container_of(device->bus, struct mcu_drv_spi, spi_bus); + int mode; + + ///init + + switch (configuration->mode & RT_SPI_MODE_3) + { + case RT_SPI_MODE_0/* RT_SPI_CPOL:0 , RT_SPI_CPHA:0 */: + case RT_SPI_MODE_1/* RT_SPI_CPOL:0 , RT_SPI_CPHA:1 */: + case RT_SPI_MODE_2/* RT_SPI_CPOL:1 , RT_SPI_CPHA:0 */: + case RT_SPI_MODE_3/* RT_SPI_CPOL:1 , RT_SPI_CPHA:1 */: + mode = configuration->mode & RT_SPI_MODE_3; + break; + default: + LOG_E("spi_configure mode error %x\n", configuration->mode); + return RT_ERROR; + } + + tmp_spi->spixfer_req.width = SPI17Y_WIDTH_1; + tmp_spi->spixfer_req.bits = configuration->data_width; + tmp_spi->spixfer_req.ssel = 0; + tmp_spi->spixfer_req.deass = 1; + tmp_spi->spixfer_req.tx_num = 0; + tmp_spi->spixfer_req.rx_num = 0; + tmp_spi->spixfer_req.callback = NULL; + LOG_D("spi init mode:%d, rate:%d", mode, configuration->max_hz); + if (SPI_Init(tmp_spi->spi_instance, mode, configuration->max_hz) != 0) + { + LOG_E("Error configuring SPI\n"); + while (1) {} + } + //init + return RT_EOK; +} + +static rt_uint32_t spixfer(struct rt_spi_device *device, struct rt_spi_message *message) +{ + RT_ASSERT(device != RT_NULL); + RT_ASSERT(device->bus != RT_NULL); + RT_ASSERT(device->bus->parent.user_data != RT_NULL); + + int ret = 0; + struct mcu_drv_spi *tmp_spi; + tmp_spi = rt_container_of(device->bus, struct mcu_drv_spi, spi_bus); + + + tmp_spi->spixfer_req.tx_data = message->send_buf; + tmp_spi->spixfer_req.rx_data = message->recv_buf; + tmp_spi->spixfer_req.len = message->length; + ret = SPI_MasterTrans(tmp_spi->spi_instance, &tmp_spi->spixfer_req); + if (ret == E_NO_ERROR) + { + return message->length; + } + else + { + LOG_E("spixfer faild, ret %d", ret); + return 0; + } +} + +/* spi bus callback function */ +static const struct rt_spi_ops nrfx_spi_ops = +{ + .configure = spi_configure, + .xfer = spixfer, +}; + +/*spi bus init*/ +static int rt_hw_spi_bus_init(void) +{ + rt_err_t result = RT_ERROR; + for (int i = 0; i < sizeof(spi_config) / sizeof(spi_config[0]); i++) + { + spi_bus_obj[i].spi_instance = spi_config[i].spi_instance; + spi_bus_obj[i].spi_bus.parent.user_data = &spi_config[i]; //SPI INSTANCE + result = rt_spi_bus_register(&spi_bus_obj[i].spi_bus, spi_config[i].bus_name, &nrfx_spi_ops); + RT_ASSERT(result == RT_EOK); + } + return result; +} + +int rt_hw_spi_init(void) +{ + return rt_hw_spi_bus_init(); +} +INIT_BOARD_EXPORT(rt_hw_spi_init); + +/** + * Attach the spi device to SPI bus, this function must be used after initialization. + */ +rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, rt_uint32_t cs_pin) +{ + RT_ASSERT(bus_name != RT_NULL); + RT_ASSERT(device_name != RT_NULL); + RT_ASSERT(cs_pin != RT_NULL); + + rt_err_t result; + struct rt_spi_device *spi_device; + /* attach the device to spi bus*/ + spi_device = (struct rt_spi_device *)rt_malloc(sizeof(struct rt_spi_device)); + RT_ASSERT(spi_device != RT_NULL); + /* initialize the cs 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", device_name, bus_name, result); + result = RT_ERROR; + } + /* TODO: SET THE GPIO */ + + RT_ASSERT(result == RT_EOK); + return result; +} + +#endif /* BSP_USING_SPI0 || BSP_USING_SPI1 || BSP_USING_SPI2 */ +#endif /*BSP_USING_SPI*/ + +#define SPI_DEVICE_BUS "spi0" +#define SPI_DEVICE_NAME "spi01" + +#define TEST_LEN 10 +uint8_t rx_data[TEST_LEN]; +uint8_t tx_data[TEST_LEN]; + +static void spi_sample(int argc, char *argv[]) +{ + struct rt_spi_device *spi_dev; + char name[RT_NAME_MAX]; + + rt_kprintf("\n************** SPI Loopback Demo ****************\n"); + rt_kprintf("This example configures the SPI to send data between the MISO (P0.4) and\n"); + rt_kprintf("MOSI (P0.5) pins. Connect these two pins together. \n"); + + for (int j = 0; j < TEST_LEN; j++) + { + tx_data[j] = j ; + } + if (argc == 2) + { + rt_strncpy(name, argv[1], RT_NAME_MAX); + } + else + { + rt_strncpy(name, SPI_DEVICE_NAME, RT_NAME_MAX); + } + + /* ?? spi ???????? */ + spi_dev = (struct rt_spi_device *)rt_device_find(name); + if (!spi_dev) + { + rt_kprintf("spi sample run failed! can't find %s device!\n", name); + } + else + { + rt_spi_transfer(spi_dev, tx_data, rx_data, TEST_LEN); + for (int i = 0; i < TEST_LEN; i++) + { + rt_kprintf(" 0x%02x, ", rx_data[i]); + } + } +} +MSH_CMD_EXPORT(spi_sample, spi sample); + +static int rt_hw_spi_sample_init(void) +{ + + struct rt_spi_device *spi_dev; + rt_hw_spi_device_attach(SPI_DEVICE_BUS, SPI_DEVICE_NAME, PIN_0); + spi_dev = (struct rt_spi_device *)rt_device_find(SPI_DEVICE_NAME); + struct rt_spi_configuration spi_cfg = + { + .mode = 0, + .data_width = 8, + .max_hz = 1000000, + }; + rt_spi_configure(spi_dev, &spi_cfg); + + return RT_EOK; +} +INIT_COMPONENT_EXPORT(rt_hw_spi_sample_init); \ No newline at end of file diff --git a/bsp/maxim/libraries/HAL_Drivers/drv_spi.h b/bsp/maxim/libraries/HAL_Drivers/drv_spi.h new file mode 100644 index 0000000000000000000000000000000000000000..9c60496855f54a573b39b93281411dc93bdc0bd9 --- /dev/null +++ b/bsp/maxim/libraries/HAL_Drivers/drv_spi.h @@ -0,0 +1,71 @@ +/* + * Copyright (c) 2006-2018, RT-Thread Development Team + * + * SPDX-License-Identifier: Apache-2.0 + * + * Change Logs: + * Date Author Notes + * 2021-02-14 supperthomas first version + */ + +#include +#include +#include + +#include "spi.h" + +#ifndef __DRV_SPI_H_ +#define __DRV_SPI_H_ + +/** + * @brief Attach the spi device to SPI bus, this function must be used after initialization. + * @param bus_name spi bus name "spi0"/"spi1"/"spi2" + * @param device_name spi device name "spi0x"/"spi1x"/"spi2x" + * @param ss_pin spi ss pin number + * @retval RT_ERROR / RT_EOK +*/ +rt_err_t rt_hw_spi_device_attach(const char *bus_name, const char *device_name, rt_uint32_t ss_pin); + +//SPI bus config +#ifdef BSP_USING_SPI0 +#define MCU_SPI0_CONFIG \ +{ \ + .bus_name = "spi0", \ + .spi_instance = SPI0A, \ +} +#endif +#ifdef BSP_USING_SPI1 +#ifdef BSP_USING_SPI1A //The SPI1A is conflit with UART1 TX RX P0.10 P0.11 +#define MCU_SPI1_CONFIG \ +{ \ + .bus_name = "spi1", \ + .spi_instance = SPI1A \ +} +#else +#define MCU_SPI1_CONFIG \ +{ \ + .bus_name = "spi1", \ + .spi_instance = SPI1B \ +} +#endif + +//TODO LIST SPI1A SPI1B +#endif + + + +struct mcu_drv_spi_config +{ + char *bus_name; + spi_type spi_instance; +}; + +struct mcu_drv_spi +{ + spi_type spi_instance; + spi_req_t spixfer_req; + struct rt_spi_configuration *cfg; + struct rt_spi_bus spi_bus; +}; + +#endif /*__DRV_SPI_H_*/ diff --git a/bsp/maxim/libraries/MAX32660PeriphDriver/SConscript b/bsp/maxim/libraries/MAX32660PeriphDriver/SConscript index fa62f76fb707581bd4289b0b3eefd1bcb6fa7d2f..b0f2840147c94453c753ba90856db2a7313e78cd 100644 --- a/bsp/maxim/libraries/MAX32660PeriphDriver/SConscript +++ b/bsp/maxim/libraries/MAX32660PeriphDriver/SConscript @@ -30,6 +30,9 @@ if GetDepend(['RT_USING_I2C']): if GetDepend(['RT_USING_SPI']): src += ['Source/spi.c'] + src += ['Source/spi17y.c'] + src += ['Source/spimss.c'] + if GetDepend(['RT_USING_RTC']): src += ['Source/rtc.c']