From 523a5d2f0b3f0d79b16784470870935313dd5775 Mon Sep 17 00:00:00 2001 From: Joey Castillo Date: Wed, 26 Jan 2022 22:39:09 -0500 Subject: [PATCH] implement SPI flash chip --- apps/spi-test/app.c | 28 ++--- apps/spi-test/watch_spi.c | 46 +++++++++ make.mk | 1 + watch-library/hardware/hw/driver_init.c | 10 -- watch-library/hardware/watch/watch_spi.c | 16 ++- watch-library/shared/driver/spiflash.c | 120 ++++++++++++++++++++++ watch-library/shared/driver/spiflash.h | 56 ++++++++++ watch-library/shared/watch/watch_spi.h | 15 ++- watch-library/simulator/watch/watch_spi.c | 6 +- 9 files changed, 265 insertions(+), 33 deletions(-) create mode 100644 apps/spi-test/watch_spi.c create mode 100644 watch-library/shared/driver/spiflash.c create mode 100644 watch-library/shared/driver/spiflash.h diff --git a/apps/spi-test/app.c b/apps/spi-test/app.c index 54b484a..2ce2c1f 100644 --- a/apps/spi-test/app.c +++ b/apps/spi-test/app.c @@ -2,11 +2,20 @@ #include #include #include "watch.h" +#include "spiflash.h" // this is a very basic app to confirm that SPI is working, tested with board OSO-MISC-21-017 and a GD25Q16C Flash chip. void app_init(void) { - watch_enable_spi(); + spi_flash_init(); + + uint8_t buf[3] = {1, 2, 3}; + flash_enable(); + spi_flash_command(CMD_ENABLE_WRITE); + // note that you will need to erase the sector to write different values later: + // spi_flash_sector_command(CMD_SECTOR_ERASE, 0); + spi_flash_write_data(0, buf, 3); + flash_disable(); } void app_wake_from_backup(void) { @@ -23,20 +32,13 @@ void app_wake_from_standby(void) { bool app_loop(void) { - uint8_t get_id_command[1] = {0x9F}; uint8_t buf[3] = {0}; - watch_set_pin_level(A3, false); - - // should print 0, 0, 0 - watch_spi_send(get_id_command, 1); - printf("blank: %x, %x, %x\n", buf[0], buf[1], buf[2]); - - // should print c8, 40, 15 - watch_spi_receive(buf, 3); - printf("ident: %x, %x, %x\n", buf[0], buf[1], buf[2]); - - watch_set_pin_level(A3, true); + flash_enable(); + // should print 1, 2, 3 + spi_flash_read_data(0, buf, 3); + printf("data: %x, %x, %x\n", buf[0], buf[1], buf[2]); + flash_disable(); delay_ms(100); diff --git a/apps/spi-test/watch_spi.c b/apps/spi-test/watch_spi.c new file mode 100644 index 0000000..9227f36 --- /dev/null +++ b/apps/spi-test/watch_spi.c @@ -0,0 +1,46 @@ +/* + * MIT License + * + * Copyright (c) 2022 Joey Castillo + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "watch_spi.h" + +struct io_descriptor *spi_io; + +void watch_enable_spi(void) { + SPI_0_init(); + spi_m_sync_get_io_descriptor(&SPI_0, &spi_io); + spi_m_sync_enable(&SPI_0); +} + +void watch_disable_spi(void) { + spi_m_sync_disable(&SPI_0); + spi_io = NULL; +} + +void watch_spi_read(const uint8_t *buf, uint16_t length) { + io_write(spi_io, buf, length); +} + +void watch_spi_read(uint8_t *buf, uint16_t length) { + io_read(spi_io, buf, length); +} diff --git a/make.mk b/make.mk index 4717096..85d38fe 100644 --- a/make.mk +++ b/make.mk @@ -119,6 +119,7 @@ SRCS += \ $(TOP)/watch-library/hardware/hpl/systick/hpl_systick.c \ $(TOP)/watch-library/shared/driver/lis2dh.c \ $(TOP)/watch-library/shared/driver/lis2dw.c \ + $(TOP)/watch-library/shared/driver/spiflash.c \ $(TOP)/watch-library/shared/watch/watch_private_display.c \ $(TOP)/watch-library/shared/watch/watch_utility.c \ diff --git a/watch-library/hardware/hw/driver_init.c b/watch-library/hardware/hw/driver_init.c index 3e097a8..5eec7bc 100644 --- a/watch-library/hardware/hw/driver_init.c +++ b/watch-library/hardware/hw/driver_init.c @@ -90,16 +90,6 @@ void SPI_0_PORT_init(void) { gpio_set_pin_direction(A1, GPIO_DIRECTION_OUT); gpio_set_pin_function(A1, PINMUX_PB01C_SERCOM3_PAD3); - - gpio_set_pin_level(A3, - // Initial level - // pad_initial_level - // Low - // High - true); - - // Set pin direction to output - gpio_set_pin_direction(A3, GPIO_DIRECTION_OUT); } void SPI_0_CLOCK_init(void) { diff --git a/watch-library/hardware/watch/watch_spi.c b/watch-library/hardware/watch/watch_spi.c index df68bba..8cdebb0 100644 --- a/watch-library/hardware/watch/watch_spi.c +++ b/watch-library/hardware/watch/watch_spi.c @@ -37,10 +37,18 @@ void watch_disable_spi(void) { spi_io = NULL; } -void watch_spi_send(uint8_t *buf, uint16_t length) { - io_write(spi_io, buf, length); +bool watch_spi_write(const uint8_t *buf, uint16_t length) { + return !!io_write(spi_io, buf, length); } -void watch_spi_receive(uint8_t *buf, uint16_t length) { - io_read(spi_io, buf, length); +bool watch_spi_read(uint8_t *buf, uint16_t length) { + return !!io_read(spi_io, buf, length); +} + +bool watch_spi_transfer(const uint8_t *data_out, uint8_t *data_in, uint16_t length) { + struct spi_xfer xfer; + xfer.txbuf = (uint8_t *)data_out; + xfer.rxbuf = data_in; + xfer.size = length; + return !!spi_m_sync_transfer(&SPI_0, &xfer); } diff --git a/watch-library/shared/driver/spiflash.c b/watch-library/shared/driver/spiflash.c new file mode 100644 index 0000000..da6b263 --- /dev/null +++ b/watch-library/shared/driver/spiflash.c @@ -0,0 +1,120 @@ +/* + * MIT License + * + * Copyright (c) 2022 Joey Castillo + * + * Ported from MIT-licensed code from CircuitPython + * Copyright (c) 2016, 2017 Scott Shawcroft for Adafruit Industries + * + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "spiflash.h" + +#define SPI_FLASH_FAST_READ false + +static void flash_enable(void) { + watch_set_pin_level(A3, false); +} + +static void flash_disable(void) { + watch_set_pin_level(A3, true); +} + +static bool transfer(uint8_t *command, uint32_t command_length, uint8_t *data_in, uint8_t *data_out, uint32_t data_length) { + bool status = watch_spi_write(command, command_length); + if (status) { + if (data_in != NULL && data_out != NULL) { + status = watch_spi_transfer(data_out, data_in, data_length); + } else if (data_out != NULL) { + status = watch_spi_read(data_out, data_length); + } else if (data_in != NULL) { + status = watch_spi_write(data_in, data_length); + } + } + flash_disable(); + return status; +} + +static bool transfer_command(uint8_t command, uint8_t *data_in, uint8_t *data_out, uint32_t data_length) { + return transfer(&command, 1, data_in, data_out, data_length); +} + +bool spi_flash_command(uint8_t command) { + return transfer_command(command, NULL, NULL, 0); +} + +bool spi_flash_read_command(uint8_t command, uint8_t *data, uint32_t data_length) { + return transfer_command(command, NULL, data, data_length); +} + +bool spi_flash_write_command(uint8_t command, uint8_t *data, uint32_t data_length) { + return transfer_command(command, data, NULL, data_length); +} + +// Pack the low 24 bits of the address into a uint8_t array. +static void address_to_bytes(uint32_t address, uint8_t *bytes) { + bytes[0] = (address >> 16) & 0xff; + bytes[1] = (address >> 8) & 0xff; + bytes[2] = address & 0xff; +} + +bool spi_flash_sector_command(uint8_t command, uint32_t address) { + uint8_t request[4] = {command, 0x00, 0x00, 0x00}; + address_to_bytes(address, request + 1); + return transfer(request, 4, NULL, NULL, 0); +} + +bool spi_flash_write_data(uint32_t address, uint8_t *data, uint32_t data_length) { + uint8_t request[4] = {CMD_PAGE_PROGRAM, 0x00, 0x00, 0x00}; + // Write the SPI flash write address into the bytes following the command byte. + address_to_bytes(address, request + 1); + flash_enable(); + bool status = watch_spi_write(request, 4); + if (status) { + status = watch_spi_write(data, data_length); + } + flash_disable(); + return status; +} + +bool spi_flash_read_data(uint32_t address, uint8_t *data, uint32_t data_length) { + uint8_t request[5] = {CMD_READ_DATA, 0x00, 0x00, 0x00}; + uint8_t command_length = 4; + if (SPI_FLASH_FAST_READ) { + request[0] = CMD_FAST_READ_DATA; + command_length = 5; + } + // Write the SPI flash read address into the bytes following the command byte. + address_to_bytes(address, request + 1); + flash_enable(); + bool status = watch_spi_write(request, command_length); + if (status) { + status = watch_spi_read(data, data_length); + } + flash_disable(); + return status; +} + +void spi_flash_init(void) { + gpio_set_pin_level(A3, true); + gpio_set_pin_direction(A3, GPIO_DIRECTION_OUT); + watch_enable_spi(); +} diff --git a/watch-library/shared/driver/spiflash.h b/watch-library/shared/driver/spiflash.h new file mode 100644 index 0000000..0d8641a --- /dev/null +++ b/watch-library/shared/driver/spiflash.h @@ -0,0 +1,56 @@ +/* + * MIT License + * + * Copyright (c) 2022 Joey Castillo + * + * Ported from MIT-licensed code from CircuitPython + * Copyright (c) 2016, 2017 Scott Shawcroft for Adafruit Industries + * + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in all + * copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "watch.h" + +#define CMD_READ_JEDEC_ID 0x9f +#define CMD_READ_DATA 0x03 +#define CMD_FAST_READ_DATA 0x0B +#define CMD_SECTOR_ERASE 0x20 +// #define CMD_SECTOR_ERASE CMD_READ_JEDEC_ID +#define CMD_DISABLE_WRITE 0x04 +#define CMD_ENABLE_WRITE 0x06 +#define CMD_PAGE_PROGRAM 0x02 +// #define CMD_PAGE_PROGRAM CMD_READ_JEDEC_ID +#define CMD_READ_STATUS 0x05 +#define CMD_READ_STATUS2 0x35 +#define CMD_WRITE_STATUS_BYTE1 0x01 +#define CMD_WRITE_STATUS_BYTE2 0x31 +#define CMD_DUAL_READ 0x3b +#define CMD_QUAD_READ 0x6b +#define CMD_ENABLE_RESET 0x66 +#define CMD_RESET 0x99 +#define CMD_WAKE 0xab + +bool spi_flash_command(uint8_t command); +bool spi_flash_read_command(uint8_t command, uint8_t *response, uint32_t length); +bool spi_flash_write_command(uint8_t command, uint8_t *data, uint32_t length); +bool spi_flash_sector_command(uint8_t command, uint32_t address); +bool spi_flash_write_data(uint32_t address, uint8_t *data, uint32_t data_length); +bool spi_flash_read_data(uint32_t address, uint8_t *data, uint32_t data_length); +void spi_flash_init(void); diff --git a/watch-library/shared/watch/watch_spi.h b/watch-library/shared/watch/watch_spi.h index 9bb0d19..b72b0e0 100644 --- a/watch-library/shared/watch/watch_spi.h +++ b/watch-library/shared/watch/watch_spi.h @@ -41,19 +41,26 @@ void watch_enable_spi(void); */ void watch_disable_spi(void); -/** @brief Sends a series of values to a device on the SPI bus. +/** @brief Writes a series of values to a device on the SPI bus. * @param buf A series of unsigned bytes; the data you wish to transmit. * @param length The number of bytes in buf that you wish to send. * @note This function does not manage the chip select pin (usually A3). */ -void watch_spi_send(uint8_t *buf, uint16_t length); +bool watch_spi_write(const uint8_t *buf, uint16_t length); -/** @brief Receives a series of values from a device on the SPI bus. +/** @brief Reads a series of values from a device on the SPI bus. * @param buf Storage for the incoming bytes; on return, it will contain the received data. * @param length The number of bytes that you wish to receive. * @note This function does not manage the chip select pin (usually A3). */ -void watch_spi_receive(uint8_t *buf, uint16_t length); +bool watch_spi_read(uint8_t *buf, uint16_t length); + +/** @brief Reads a series of values from a device on the SPI bus. + * @param buf Storage for the incoming bytes; on return, it will contain the received data. + * @param length The number of bytes that you wish to receive. + * @note This function does not manage the chip select pin (usually A3). + */ +bool watch_spi_transfer(const uint8_t *data_out, uint8_t *data_in, uint16_t length); /// @} #endif diff --git a/watch-library/simulator/watch/watch_spi.c b/watch-library/simulator/watch/watch_spi.c index dd2f8fa..9f29a79 100644 --- a/watch-library/simulator/watch/watch_spi.c +++ b/watch-library/simulator/watch/watch_spi.c @@ -28,6 +28,8 @@ void watch_enable_spi(void) {} void watch_disable_spi(void) {} -void watch_spi_send(uint8_t *buf, uint16_t length) {} +bool watch_spi_write(const uint8_t *buf, uint16_t length) { return false; } -void watch_spi_receive(uint8_t *buf, uint16_t length) {} +bool watch_spi_read(uint8_t *buf, uint16_t length) { return false; } + +bool watch_spi_transfer(const uint8_t *data_out, uint8_t *data_in, uint16_t length) { return false; }