j3d1/esp-open-rtos
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

sysparam fixes, tests, spi flash refactoring (#299)

Browse source 
Original work by @ourairquality
* Sysparam threadsafe and SPI access
* Sysparam test cases
* Fix for negative int8
* Sysparam getting bool without memory allocation. Bool tests.
* SPI flash refactoring.
* Extract common spiflash.c into core.
* Use spiflash.c in sysparam.
* Use memcpy in spiflash.c insted of hand-written version.
* Tests for spiflash.c
This commit is contained in:
sheinz 2017-03-21 23:18:04 +02:00 committed by Ruslan V. Uss
parent 07ca0d2e9e
commit a91ec6eb61
10 changed files with 724 additions and 406 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
core/include/flashchip.h
View file

@ -36,4 +36,6 @@ typedef struct {
uint32_t status_mask; uint32_t status_mask;
} sdk_flashchip_t; } sdk_flashchip_t;
extern sdk_flashchip_t sdk_flashchip;
#endif /* _FLASHCHIP_H */ #endif /* _FLASHCHIP_H */

22
extras/spiffs/esp_spiffs_flash.h → core/include/spiflash.h
View file

@ -21,14 +21,14 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#ifndef __ESP_SPIFFS_FLASH_H__ #ifndef __SPIFLASH_H__
#define __ESP_SPIFFS_FLASH_H__ #define __SPIFLASH_H__
#include <stdint.h> #include <stdint.h>
#include <stdbool.h>
#include "common_macros.h" #include "common_macros.h"
#define ESP_SPIFFS_FLASH_OK 0 #define SPI_FLASH_SECTOR_SIZE 4096
#define ESP_SPIFFS_FLASH_ERROR 1
/** /**
* Read data from SPI flash. * Read data from SPI flash.
@ -37,9 +37,9 @@
* @param buf Buffer to read to. Doesn't have to be aligned. * @param buf Buffer to read to. Doesn't have to be aligned.
* @param size Size of data to read. Buffer size must be >= than data size. * @param size Size of data to read. Buffer size must be >= than data size.
* *
* @return ESP_SPIFFS_FLASH_OK or ESP_SPIFFS_FLASH_ERROR * @return true if success, otherwise false
*/ */
uint32_t IRAM esp_spiffs_flash_read(uint32_t addr, uint8_t *buf, uint32_t size); bool IRAM spiflash_read(uint32_t addr, uint8_t *buf, uint32_t size);
/** /**
* Write data to SPI flash. * Write data to SPI flash.
@ -48,17 +48,17 @@ uint32_t IRAM esp_spiffs_flash_read(uint32_t addr, uint8_t *buf, uint32_t size);
* @param buf Buffer of data to write to flash. Doesn't have to be aligned. * @param buf Buffer of data to write to flash. Doesn't have to be aligned.
* @param size Size of data to write. Buffer size must be >= than data size. * @param size Size of data to write. Buffer size must be >= than data size.
* *
* @return ESP_SPIFFS_FLASH_OK or ESP_SPIFFS_FLASH_ERROR * @return true if success, otherwise false
*/ */
uint32_t IRAM esp_spiffs_flash_write(uint32_t addr, uint8_t *buf, uint32_t size); bool IRAM spiflash_write(uint32_t addr, uint8_t *buf, uint32_t size);
/** /**
* Erase a sector. * Erase a sector.
* *
* @param addr Address of sector to erase. Must be sector aligned. * @param addr Address of sector to erase. Must be sector aligned.
* *
* @return ESP_SPIFFS_FLASH_OK or ESP_SPIFFS_FLASH_ERROR * @return true if success, otherwise false
*/ */
uint32_t IRAM esp_spiffs_flash_erase_sector(uint32_t addr); bool IRAM spiflash_erase_sector(uint32_t addr);
#endif // __ESP_SPIFFS_FLASH_H__ #endif // __SPIFLASH_H__

43
core/include/sysparam.h
View file

@ -180,24 +180,20 @@ sysparam_status_t sysparam_compact();
*/ */
sysparam_status_t sysparam_get_data(const char *key, uint8_t **destptr, size_t *actual_length, bool *is_binary); sysparam_status_t sysparam_get_data(const char *key, uint8_t **destptr, size_t *actual_length, bool *is_binary);
/** Get the value associated with a key (static buffers only) /** Get the value associated with a key (static value buffer)
* *
* This performs the same function as sysparam_get_data() but without * This performs the same function as sysparam_get_data() but without
* performing any memory allocations. It can thus be used before the heap has * allocating memory for the result value. It can thus be used before the heap
* been configured or in other cases where using the heap would be a problem * has been configured or in other cases where using the heap would be a
* (i.e. in an OOM handler, etc). It requires that the caller pass in a * problem (i.e. in an OOM handler, etc). It requires that the caller pass in
* suitably sized buffer for the value to be read (if the supplied buffer is * a suitably sized buffer for the value to be read (if the supplied buffer is
* not large enough, the returned value will be truncated and the full * not large enough, the returned value will be truncated and the full required
* required length will be returned in `actual_length`). * length will be returned in `actual_length`).
*
* NOTE: In addition to being large enough for the value, the supplied buffer
* must also be at least as large as the length of the key being requested.
* If it is not, an error will be returned.
* *
* @param[in] key Key name (zero-terminated string) * @param[in] key Key name (zero-terminated string)
* @param[in] buffer Pointer to a buffer to hold the returned value * @param[in] dest Pointer to a buffer to hold the returned value.
* @param[in] buffer_size Length of the supplied buffer in bytes * @param[in] dest_size Length of the supplied buffer in bytes.
* @param[out] actual_length pointer to a location to hold the actual length * @param[out] actual_length Pointer to a location to hold the actual length
* of the data which was associated with the key * of the data which was associated with the key
* (may be NULL). * (may be NULL).
* @param[out] is_binary Pointer to a bool to hold whether the returned * @param[out] is_binary Pointer to a bool to hold whether the returned
@ -210,7 +206,7 @@ sysparam_status_t sysparam_get_data(const char *key, uint8_t **destptr, size_t *
* @retval ::SYSPARAM_ERR_CORRUPT Sysparam region has bad/corrupted data * @retval ::SYSPARAM_ERR_CORRUPT Sysparam region has bad/corrupted data
* @retval ::SYSPARAM_ERR_IO I/O error reading/writing flash * @retval ::SYSPARAM_ERR_IO I/O error reading/writing flash
*/ */
sysparam_status_t sysparam_get_data_static(const char *key, uint8_t *buffer, size_t buffer_size, size_t *actual_length, bool *is_binary); sysparam_status_t sysparam_get_data_static(const char *key, uint8_t *dest, size_t dest_size, size_t *actual_length, bool *is_binary);
/** Get the string value associated with a key /** Get the string value associated with a key
* *
@ -242,7 +238,8 @@ sysparam_status_t sysparam_get_string(const char *key, char **destptr);
/** Get the int32_t value associated with a key /** Get the int32_t value associated with a key
* *
* This routine can be used if you know that the value in a key will (or at * This routine can be used if you know that the value in a key will (or at
* least should) be an int32_t value. * least should) be an int32_t value. This is done without allocating any
* memory.
* *
* Note: If the status result is anything other than ::SYSPARAM_OK, the value * Note: If the status result is anything other than ::SYSPARAM_OK, the value
* in `result` is not changed. This means it is possible to set a default * in `result` is not changed. This means it is possible to set a default
@ -266,7 +263,8 @@ sysparam_status_t sysparam_get_int32(const char *key, int32_t *result);
/** Get the int8_t value associated with a key /** Get the int8_t value associated with a key
* *
* This routine can be used if you know that the value in a key will (or at * This routine can be used if you know that the value in a key will (or at
* least should) be a uint8_t binary value. * least should) be a uint8_t binary value. This is done without allocating any
* memory.
* *
* Note: If the status result is anything other than ::SYSPARAM_OK, the value * Note: If the status result is anything other than ::SYSPARAM_OK, the value
* in `result` is not changed. This means it is possible to set a default * in `result` is not changed. This means it is possible to set a default
@ -320,7 +318,7 @@ sysparam_status_t sysparam_get_bool(const char *key, bool *result);
* *
* The supplied value can be any data, up to 255 bytes in length. If `value` * The supplied value can be any data, up to 255 bytes in length. If `value`
* is NULL or `value_len` is 0, this is treated as a request to delete any * is NULL or `value_len` is 0, this is treated as a request to delete any
* current entry matching `key`. * current entry matching `key`. This is done without allocating any memory.
* *
* If `binary` is true, the data will be considered binary (unprintable) data, * If `binary` is true, the data will be considered binary (unprintable) data,
* and this will be annotated in the saved entry. This does not affect the * and this will be annotated in the saved entry. This does not affect the
@ -368,7 +366,8 @@ sysparam_status_t sysparam_set_string(const char *key, const char *value);
/** Set a key's value as a number /** Set a key's value as a number
* *
* Write an int32_t binary value to the specified key. This does the inverse of * Write an int32_t binary value to the specified key. This does the inverse of
* the sysparam_get_int32() function. * the sysparam_get_int32() function. This is done without allocating any
* memory.
* *
* @param[in] key Key name (zero-terminated string) * @param[in] key Key name (zero-terminated string)
* @param[in] value Value to set * @param[in] value Value to set
@ -386,10 +385,8 @@ sysparam_status_t sysparam_set_int32(const char *key, int32_t value);
/** Set a key's value as a number /** Set a key's value as a number
* *
* Write an int8_t binary value to the specified key. This does the inverse of * Write an int8_t binary value to the specified key. This does the inverse of
* the sysparam_get_int8() function. * the sysparam_get_int8() function. This is done without allocating any
* * memory.
* Note that if the key already contains a value which parses to the same
* boolean (true/false) value, it is left unchanged.
* *
* @param[in] key Key name (zero-terminated string) * @param[in] key Key name (zero-terminated string)
* @param[in] value Value to set * @param[in] value Value to set

96
extras/spiffs/esp_spiffs_flash.c → core/spiflash.c
View file

@ -21,12 +21,13 @@
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE. * THE SOFTWARE.
*/ */
#include "esp_spiffs_flash.h" #include "include/spiflash.h"
#include "flashchip.h"
#include "espressif/spi_flash.h" #include "include/flashchip.h"
#include "FreeRTOS.h" #include "include/esp/rom.h"
#include "esp/rom.h" #include "include/esp/spi_regs.h"
#include "esp/spi_regs.h"
#include <FreeRTOS.h>
#include <string.h> #include <string.h>
/** /**
@ -52,25 +53,6 @@
#define SPI_READ_MAX_SIZE 60 #define SPI_READ_MAX_SIZE 60
/**
* Copy unaligned data to 4-byte aligned destination buffer.
*
* @param words Number of 4-byte words to write.
*
* @see unaligned_memcpy.S
*/
void memcpy_unaligned_src(volatile uint32_t *dst, uint8_t *src, uint8_t words);
/**
* Copy 4-byte aligned source data to unaligned destination buffer.
*
* @param bytes Number of byte to copy to dst.
*
* @see unaligned_memcpy.S
*/
void memcpy_unaligned_dst(uint8_t *dst, volatile uint32_t *src, uint8_t bytes);
/** /**
* Low level SPI flash write. Write block of data up to 64 bytes. * Low level SPI flash write. Write block of data up to 64 bytes.
*/ */
@ -86,7 +68,9 @@ static inline void IRAM spi_write_data(sdk_flashchip_t *chip, uint32_t addr,
SPI(0).ADDR = (addr & 0x00FFFFFF) | (size << 24); SPI(0).ADDR = (addr & 0x00FFFFFF) | (size << 24);
memcpy_unaligned_src(SPI(0).W, buf, words); memcpy((void*)SPI(0).W, buf, words<<2);
__asm__ volatile("memw");
SPI_write_enable(chip); SPI_write_enable(chip);
@ -97,16 +81,16 @@ static inline void IRAM spi_write_data(sdk_flashchip_t *chip, uint32_t addr,
/** /**
* Write a page of flash. Data block should not cross page boundary. * Write a page of flash. Data block should not cross page boundary.
*/ */
static uint32_t IRAM spi_write_page(sdk_flashchip_t *flashchip, uint32_t dest_addr, static bool IRAM spi_write_page(sdk_flashchip_t *flashchip, uint32_t dest_addr,
uint8_t *buf, uint32_t size) uint8_t *buf, uint32_t size)
{ {
// check if block to write doesn't cross page boundary // check if block to write doesn't cross page boundary
if (flashchip->page_size < size + (dest_addr % flashchip->page_size)) { if (flashchip->page_size < size + (dest_addr % flashchip->page_size)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
if (size < 1) { if (size < 1) {
return ESP_SPIFFS_FLASH_OK; return true;
} }
while (size >= SPI_WRITE_MAX_SIZE) { while (size >= SPI_WRITE_MAX_SIZE) {
@ -117,58 +101,58 @@ static uint32_t IRAM spi_write_page(sdk_flashchip_t *flashchip, uint32_t dest_ad
buf += SPI_WRITE_MAX_SIZE; buf += SPI_WRITE_MAX_SIZE;
if (size < 1) { if (size < 1) {
return ESP_SPIFFS_FLASH_OK; return true;
} }
} }
spi_write_data(flashchip, dest_addr, buf, size); spi_write_data(flashchip, dest_addr, buf, size);
return ESP_SPIFFS_FLASH_OK; return true;
} }
/** /**
* Split block of data into pages and write pages. * Split block of data into pages and write pages.
*/ */
static uint32_t IRAM spi_write(uint32_t addr, uint8_t *dst, uint32_t size) static bool IRAM spi_write(uint32_t addr, uint8_t *dst, uint32_t size)
{ {
if (sdk_flashchip.chip_size < (addr + size)) { if (sdk_flashchip.chip_size < (addr + size)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
uint32_t write_bytes_to_page = sdk_flashchip.page_size - uint32_t write_bytes_to_page = sdk_flashchip.page_size -
(addr % sdk_flashchip.page_size); // TODO: place for optimization (addr % sdk_flashchip.page_size); // TODO: place for optimization
if (size < write_bytes_to_page) { if (size < write_bytes_to_page) {
if (spi_write_page(&sdk_flashchip, addr, dst, size)) { if (!spi_write_page(&sdk_flashchip, addr, dst, size)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
} else { } else {
if (spi_write_page(&sdk_flashchip, addr, dst, write_bytes_to_page)) { if (!spi_write_page(&sdk_flashchip, addr, dst, write_bytes_to_page)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
uint32_t offset = write_bytes_to_page; uint32_t offset = write_bytes_to_page;
uint32_t pages_to_write = (size - offset) / sdk_flashchip.page_size; uint32_t pages_to_write = (size - offset) / sdk_flashchip.page_size;
for (uint8_t i = 0; i != pages_to_write; i++) { for (uint8_t i = 0; i != pages_to_write; i++) {
if (spi_write_page(&sdk_flashchip, addr + offset, if (!spi_write_page(&sdk_flashchip, addr + offset,
dst + offset, sdk_flashchip.page_size)) { dst + offset, sdk_flashchip.page_size)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
offset += sdk_flashchip.page_size; offset += sdk_flashchip.page_size;
} }
if (spi_write_page(&sdk_flashchip, addr + offset, if (!spi_write_page(&sdk_flashchip, addr + offset,
dst + offset, size - offset)) { dst + offset, size - offset)) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
} }
return ESP_SPIFFS_FLASH_OK; return true;
} }
uint32_t IRAM esp_spiffs_flash_write(uint32_t addr, uint8_t *buf, uint32_t size) bool IRAM spiflash_write(uint32_t addr, uint8_t *buf, uint32_t size)
{ {
uint32_t result = ESP_SPIFFS_FLASH_ERROR; bool result = false;
if (buf) { if (buf) {
vPortEnterCritical(); vPortEnterCritical();
@ -197,21 +181,23 @@ static inline void IRAM read_block(sdk_flashchip_t *chip, uint32_t addr,
while (SPI(0).CMD) {}; while (SPI(0).CMD) {};
memcpy_unaligned_dst(buf, SPI(0).W, size); __asm__ volatile("memw");
memcpy(buf, (const void*)SPI(0).W, size);
} }
/** /**
* Read SPI flash data. Data region doesn't need to be page aligned. * Read SPI flash data. Data region doesn't need to be page aligned.
*/ */
static inline uint32_t IRAM read_data(sdk_flashchip_t *flashchip, uint32_t addr, static inline bool IRAM read_data(sdk_flashchip_t *flashchip, uint32_t addr,
uint8_t *dst, uint32_t size) uint8_t *dst, uint32_t size)
{ {
if (size < 1) { if (size < 1) {
return ESP_SPIFFS_FLASH_OK; return true;
} }
if ((addr + size) > flashchip->chip_size) { if ((addr + size) > flashchip->chip_size) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
while (size >= SPI_READ_MAX_SIZE) { while (size >= SPI_READ_MAX_SIZE) {
@ -225,12 +211,12 @@ static inline uint32_t IRAM read_data(sdk_flashchip_t *flashchip, uint32_t addr,
read_block(flashchip, addr, dst, size); read_block(flashchip, addr, dst, size);
} }
return ESP_SPIFFS_FLASH_OK; return true;
} }
uint32_t IRAM esp_spiffs_flash_read(uint32_t dest_addr, uint8_t *buf, uint32_t size) bool IRAM spiflash_read(uint32_t dest_addr, uint8_t *buf, uint32_t size)
{ {
uint32_t result = ESP_SPIFFS_FLASH_ERROR; bool result = false;
if (buf) { if (buf) {
vPortEnterCritical(); vPortEnterCritical();
@ -245,14 +231,14 @@ uint32_t IRAM esp_spiffs_flash_read(uint32_t dest_addr, uint8_t *buf, uint32_t s
return result; return result;
} }
uint32_t IRAM esp_spiffs_flash_erase_sector(uint32_t addr) bool IRAM spiflash_erase_sector(uint32_t addr)
{ {
if ((addr + sdk_flashchip.sector_size) > sdk_flashchip.chip_size) { if ((addr + sdk_flashchip.sector_size) > sdk_flashchip.chip_size) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
if (addr & 0xFFF) { if (addr & 0xFFF) {
return ESP_SPIFFS_FLASH_ERROR; return false;
} }
vPortEnterCritical(); vPortEnterCritical();
@ -269,5 +255,5 @@ uint32_t IRAM esp_spiffs_flash_erase_sector(uint32_t addr)
Cache_Read_Enable(0, 0, 1); Cache_Read_Enable(0, 0, 1);
vPortExitCritical(); vPortExitCritical();
return ESP_SPIFFS_FLASH_OK; return true;
} }

331
core/sysparam.c
View file

@ -8,14 +8,12 @@
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <sysparam.h> #include <sysparam.h>
#include <espressif/spi_flash.h> #include "spiflash.h"
#include "flashchip.h"
#include <common_macros.h> #include <common_macros.h>
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "semphr.h" #include "semphr.h"
//TODO: make this properly threadsafe
//TODO: reduce stack usage
/* The "magic" value that indicates the start of a sysparam region in flash. /* The "magic" value that indicates the start of a sysparam region in flash.
*/ */
#define SYSPARAM_MAGIC 0x70524f45 // "EORp" in little-endian #define SYSPARAM_MAGIC 0x70524f45 // "EORp" in little-endian
@ -33,11 +31,14 @@
*/ */
#define SCAN_BUFFER_SIZE 8 // words #define SCAN_BUFFER_SIZE 8 // words
/* The size of the temporary buffer used for reading back and verifying data /* The size in words of the buffer used for reading keys when searching for a
* written to flash. Making this larger will make the write-and-verify * match, for reading payloads to check if the value has changed, and reading
* operation slightly faster, but will use more heap during writes * back from the flash to verify writes. Will work well if big enough for
* commonly used keys, and must be at least one word. Stack allocated so not too
* large!
*/ */
#define VERIFY_BUF_SIZE 64 #define BOUNCE_BUFFER_WORDS 3
#define BOUNCE_BUFFER_SIZE (BOUNCE_BUFFER_WORDS * sizeof(uint32_t))
/* Size of region/entry headers. These should not normally need tweaking (and /* Size of region/entry headers. These should not normally need tweaking (and
* will probably require some code changes if they are tweaked). * will probably require some code changes if they are tweaked).
@ -76,14 +77,16 @@
/******************************* Useful Macros *******************************/ /******************************* Useful Macros *******************************/
#define ROUND_TO_WORD_BOUNDARY(x) (((x) + 3) & 0xfffffffc) #define ROUND_TO_WORD_BOUNDARY(x) (((x) + 3) & 0xfffffffc)
#define ENTRY_SIZE(payload_len) (ENTRY_HEADER_SIZE + ROUND_TO_WORD_BOUNDARY(payload_len)) #define ENTRY_SIZE(payload_len) (ENTRY_HEADER_SIZE + payload_len)
#define max(x, y) ((x) > (y) ? (x) : (y)) #define max(x, y) ((x) > (y) ? (x) : (y))
#define min(x, y) ((x) < (y) ? (x) : (y)) #define min(x, y) ((x) < (y) ? (x) : (y))
#define debug(level, format, ...) if (SYSPARAM_DEBUG >= (level)) { printf("%s" format "\n", "sysparam: ", ## __VA_ARGS__); } #define debug(level, format, ...) if (SYSPARAM_DEBUG >= (level)) { printf("%s" format "\n", "sysparam: ", ## __VA_ARGS__); }
#define CHECK_FLASH_OP(x) do { int __x = (x); if ((__x) != SPI_FLASH_RESULT_OK) { debug(1, "FLASH ERR: %d", __x); return SYSPARAM_ERR_IO; } } while (0); #define CHECK_FLASH_OP(x) do { bool __x = (x); if (!(__x)) { \
debug(1, "FLASH ERR: %d", __x); return SYSPARAM_ERR_IO; \
} } while (0);
/********************* Internal datatypes and structures *********************/ /********************* Internal datatypes and structures *********************/
@ -119,50 +122,28 @@ static struct {
/***************************** Internal routines *****************************/ /***************************** Internal routines *****************************/
static inline IRAM sysparam_status_t _do_write(uint32_t addr, const void *data, size_t data_size) { static sysparam_status_t _write_and_verify(uint32_t addr, const void *data, size_t data_size) {
CHECK_FLASH_OP(sdk_spi_flash_write(addr, (void*) data, data_size)); uint8_t bounce[BOUNCE_BUFFER_SIZE];
return SYSPARAM_OK;
}
static inline IRAM sysparam_status_t _do_verify(uint32_t addr, const void *data, void *buffer, size_t len) { for (int i = 0; i < data_size; i += BOUNCE_BUFFER_SIZE) {
CHECK_FLASH_OP(sdk_spi_flash_read(addr, buffer, len)); size_t count = min(data_size - i, BOUNCE_BUFFER_SIZE);
if (memcmp(data, buffer, len)) { memcpy(bounce, data + i, count);
CHECK_FLASH_OP(spiflash_write(addr + i, bounce, count));
CHECK_FLASH_OP(spiflash_read(addr + i, bounce, count));
if (memcmp(data + i, bounce, count) != 0) {
debug(1, "Flash write (@ 0x%08x) verify failed!", addr);
return SYSPARAM_ERR_IO; return SYSPARAM_ERR_IO;
} }
}
return SYSPARAM_OK; return SYSPARAM_OK;
} }
/*FIXME: Eventually, this should probably be implemented down at the SPI flash library layer, where it can just compare bytes/words straight from the SPI hardware buffer instead of allocating a whole separate temp buffer, reading chunks into that, and then doing a memcmp.. */
static IRAM sysparam_status_t _write_and_verify(uint32_t addr, const void *data, size_t data_size) {
int i;
size_t count;
sysparam_status_t status = SYSPARAM_OK;
uint8_t *verify_buf = malloc(VERIFY_BUF_SIZE);
if (!verify_buf) return SYSPARAM_ERR_NOMEM;
do {
status = _do_write(addr, data, data_size);
if (status != SYSPARAM_OK) break;
for (i = 0; i < data_size; i += VERIFY_BUF_SIZE) {
count = min(data_size - i, VERIFY_BUF_SIZE);
status = _do_verify(addr + i, data + i, verify_buf, count);
if (status != SYSPARAM_OK) {
debug(1, "Flash write (@ 0x%08x) verify failed!", addr);
break;
}
}
} while (false);
free(verify_buf);
return status;
}
/** Erase the sectors of a region */ /** Erase the sectors of a region */
static sysparam_status_t _format_region(uint32_t addr, uint16_t num_sectors) { static sysparam_status_t _format_region(uint32_t addr, uint16_t num_sectors) {
uint16_t sector = addr / sdk_flashchip.sector_size;
int i; int i;
for (i = 0; i < num_sectors; i++) { for (i = 0; i < num_sectors; i++) {
CHECK_FLASH_OP(sdk_spi_flash_erase_sector(sector + i)); CHECK_FLASH_OP(spiflash_erase_sector(addr + (i * SPI_FLASH_SECTOR_SIZE)));
} }
return SYSPARAM_OK; return SYSPARAM_OK;
} }
@ -212,7 +193,7 @@ static sysparam_status_t init_write_context(struct sysparam_context *ctx) {
memset(ctx, 0, sizeof(*ctx)); memset(ctx, 0, sizeof(*ctx));
ctx->addr = _sysparam_info.end_addr; ctx->addr = _sysparam_info.end_addr;
debug(3, "read entry header @ 0x%08x", ctx->addr); debug(3, "read entry header @ 0x%08x", ctx->addr);
CHECK_FLASH_OP(sdk_spi_flash_read(ctx->addr, (void*) &ctx->entry, ENTRY_HEADER_SIZE)); CHECK_FLASH_OP(spiflash_read(ctx->addr, (void*) &ctx->entry, ENTRY_HEADER_SIZE));
return SYSPARAM_OK; return SYSPARAM_OK;
} }
@ -238,7 +219,10 @@ static sysparam_status_t _find_entry(struct sysparam_context *ctx, uint16_t matc
// workaround is to make sure that the next write operation // workaround is to make sure that the next write operation
// will always start with a compaction, which will leave off // will always start with a compaction, which will leave off
// the invalid data at the end and fix the issue going forward. // the invalid data at the end and fix the issue going forward.
debug(1, "Encountered entry with invalid length (0x%04x) @ 0x%08x (region end is 0x%08x). Truncating entries.", ctx->entry.len, ctx->addr, _sysparam_info.end_addr); debug(1, "Encountered entry with invalid length (0x%04x) @ 0x%08x (region end is 0x%08x). Truncating entries.",
ctx->entry.len,
ctx->addr, _sysparam_info.end_addr);
_sysparam_info.force_compact = true; _sysparam_info.force_compact = true;
break; break;
} }
@ -251,7 +235,7 @@ static sysparam_status_t _find_entry(struct sysparam_context *ctx, uint16_t matc
} }
debug(3, "read entry header @ 0x%08x", ctx->addr); debug(3, "read entry header @ 0x%08x", ctx->addr);
CHECK_FLASH_OP(sdk_spi_flash_read(ctx->addr, (void*) &ctx->entry, ENTRY_HEADER_SIZE)); CHECK_FLASH_OP(spiflash_read(ctx->addr, (void*) &ctx->entry, ENTRY_HEADER_SIZE));
debug(3, " idflags = 0x%04x", ctx->entry.idflags); debug(3, " idflags = 0x%04x", ctx->entry.idflags);
if (ctx->entry.idflags == 0xffff) { if (ctx->entry.idflags == 0xffff) {
// 0xffff is never a valid id field, so this means we've hit the // 0xffff is never a valid id field, so this means we've hit the
@ -295,17 +279,39 @@ static sysparam_status_t _find_entry(struct sysparam_context *ctx, uint16_t matc
} }
/** Read the payload from the current entry pointed to by `ctx` */ /** Read the payload from the current entry pointed to by `ctx` */
static inline sysparam_status_t _read_payload(struct sysparam_context *ctx, uint8_t *buffer, size_t buffer_size) { static inline sysparam_status_t _read_payload(struct sysparam_context *ctx, uint8_t *buffer, size_t buffer_size) {
debug(3, "read payload (%d) @ 0x%08x", min(buffer_size, ctx->entry.len), ctx->addr); uint32_t addr = ctx->addr + ENTRY_HEADER_SIZE;
CHECK_FLASH_OP(sdk_spi_flash_read(ctx->addr + ENTRY_HEADER_SIZE, (void*) buffer, min(buffer_size, ctx->entry.len))); size_t size = min(buffer_size, ctx->entry.len);
debug(3, "read payload (%d) @ 0x%08x", size, addr);
CHECK_FLASH_OP(spiflash_read(addr, buffer, buffer_size));
return SYSPARAM_OK;
}
static inline sysparam_status_t _compare_payload(struct sysparam_context *ctx, uint8_t *value, size_t size) {
debug(3, "compare payload (%d) @ 0x%08x", size, ctx->addr);
if (ctx->entry.len != size) return SYSPARAM_NOTFOUND;
uint32_t bounce[BOUNCE_BUFFER_WORDS];
uint32_t addr = ctx->addr + ENTRY_HEADER_SIZE;
int i;
for (i = 0; i < size; i += BOUNCE_BUFFER_SIZE) {
int len = min(size - i, BOUNCE_BUFFER_SIZE);
CHECK_FLASH_OP(spiflash_read(addr + i, (void*)bounce, len));
if (memcmp(value + i, bounce, len)) {
// Mismatch.
return SYSPARAM_NOTFOUND;
}
}
return SYSPARAM_OK; return SYSPARAM_OK;
} }
/** Find the entry corresponding to the specified key name */ /** Find the entry corresponding to the specified key name */
static sysparam_status_t _find_key(struct sysparam_context *ctx, const char *key, uint16_t key_len, uint8_t *buffer) { static sysparam_status_t _find_key(struct sysparam_context *ctx, const char *key, uint16_t key_len) {
sysparam_status_t status; sysparam_status_t status;
debug(3, "find key: %s", key ? key : "(null)"); debug(3, "find key len %d: %s", key_len, key ? key : "(null)");
while (true) { while (true) {
// Find the next key entry // Find the next key entry
status = _find_entry(ctx, ENTRY_ID_ANY, false); status = _find_entry(ctx, ENTRY_ID_ANY, false);
@ -316,12 +322,12 @@ static sysparam_status_t _find_key(struct sysparam_context *ctx, const char *key
break; break;
} }
if (ctx->entry.len == key_len) { if (ctx->entry.len == key_len) {
status = _read_payload(ctx, buffer, key_len); status = _compare_payload(ctx, (uint8_t *)key, key_len);
if (status < 0) return status; if (status == SYSPARAM_OK) {
if (!memcmp(key, buffer, key_len)) {
// We have a match // We have a match
break; break;
} }
if (status != SYSPARAM_NOTFOUND) return status;
debug(3, "entry payload does not match"); debug(3, "entry payload does not match");
} else { } else {
debug(3, "key length (%d) does not match (%d)", ctx->entry.len, key_len); debug(3, "key length (%d) does not match (%d)", ctx->entry.len, key_len);
@ -394,13 +400,11 @@ static inline sysparam_status_t _delete_entry(uint32_t addr) {
debug(2, "Deleting entry @ 0x%08x", addr); debug(2, "Deleting entry @ 0x%08x", addr);
debug(3, "read entry header @ 0x%08x", addr); debug(3, "read entry header @ 0x%08x", addr);
CHECK_FLASH_OP(sdk_spi_flash_read(addr, (void*) &entry, ENTRY_HEADER_SIZE)); CHECK_FLASH_OP(spiflash_read(addr, (uint8_t*) &entry, ENTRY_HEADER_SIZE));
// Set the ID to zero to mark it as "deleted" // Set the ID to zero to mark it as "deleted"
entry.idflags &= ~ENTRY_FLAG_ALIVE; entry.idflags &= ~ENTRY_FLAG_ALIVE;
debug(3, "write entry header @ 0x%08x", addr); debug(3, "write entry header @ 0x%08x", addr);
CHECK_FLASH_OP(sdk_spi_flash_write(addr, (void*) &entry, ENTRY_HEADER_SIZE)); return _write_and_verify(addr, &entry, ENTRY_HEADER_SIZE);
return SYSPARAM_OK;
} }
/** Compact the current region, removing all deleted/unused entries, and write /** Compact the current region, removing all deleted/unused entries, and write
@ -424,7 +428,11 @@ static sysparam_status_t _compact_params(struct sysparam_context *ctx, int *key_
uint16_t binary_flag; uint16_t binary_flag;
uint16_t num_sectors = _sysparam_info.region_size / sdk_flashchip.sector_size; uint16_t num_sectors = _sysparam_info.region_size / sdk_flashchip.sector_size;
debug(1, "compacting region (current size %d, expect to recover %d%s bytes)...", _sysparam_info.end_addr - _sysparam_info.cur_base, ctx ? ctx->compactable : 0, (ctx && ctx->unused_keys > 0) ? "+ (unused keys present)" : ""); debug(1, "compacting region (current size %d, expect to recover %d%s bytes)...",
_sysparam_info.end_addr - _sysparam_info.cur_base,
ctx ? ctx->compactable : 0,
(ctx && ctx->unused_keys > 0) ? "+ (unused keys present)" : "");
status = _format_region(new_base, num_sectors); status = _format_region(new_base, num_sectors);
if (status < 0) return status; if (status < 0) return status;
status = sysparam_iter_start(&iter); status = sysparam_iter_start(&iter);
@ -505,7 +513,7 @@ sysparam_status_t sysparam_init(uint32_t base_addr, uint32_t top_addr) {
top_addr = base_addr + sdk_flashchip.sector_size; top_addr = base_addr + sdk_flashchip.sector_size;
} }
for (addr0 = base_addr; addr0 < top_addr; addr0 += sdk_flashchip.sector_size) { for (addr0 = base_addr; addr0 < top_addr; addr0 += sdk_flashchip.sector_size) {
CHECK_FLASH_OP(sdk_spi_flash_read(addr0, (void*) &header0, REGION_HEADER_SIZE)); CHECK_FLASH_OP(spiflash_read(addr0, (void*) &header0, REGION_HEADER_SIZE));
if (header0.magic == SYSPARAM_MAGIC) { if (header0.magic == SYSPARAM_MAGIC) {
// Found a starting point... // Found a starting point...
break; break;
@ -523,7 +531,7 @@ sysparam_status_t sysparam_init(uint32_t base_addr, uint32_t top_addr) {
} else { } else {
addr1 = addr0 + num_sectors * sdk_flashchip.sector_size; addr1 = addr0 + num_sectors * sdk_flashchip.sector_size;
} }
CHECK_FLASH_OP(sdk_spi_flash_read(addr1, (void*) &header1, REGION_HEADER_SIZE)); CHECK_FLASH_OP(spiflash_read(addr1, (uint8_t*) &header1, REGION_HEADER_SIZE));
if (header1.magic == SYSPARAM_MAGIC) { if (header1.magic == SYSPARAM_MAGIC) {
// Yay! Found the other one. Sanity-check it.. // Yay! Found the other one. Sanity-check it..
@ -600,7 +608,7 @@ sysparam_status_t sysparam_create_area(uint32_t base_addr, uint16_t num_sectors,
// we're not going to be clobbering something else important. // we're not going to be clobbering something else important.
for (addr = base_addr; addr < base_addr + region_size * 2; addr += SCAN_BUFFER_SIZE) { for (addr = base_addr; addr < base_addr + region_size * 2; addr += SCAN_BUFFER_SIZE) {
debug(3, "read %d words @ 0x%08x", SCAN_BUFFER_SIZE, addr); debug(3, "read %d words @ 0x%08x", SCAN_BUFFER_SIZE, addr);
CHECK_FLASH_OP(sdk_spi_flash_read(addr, buffer, SCAN_BUFFER_SIZE * 4)); CHECK_FLASH_OP(spiflash_read(addr, (uint8_t*)buffer, SCAN_BUFFER_SIZE * 4));
for (i = 0; i < SCAN_BUFFER_SIZE; i++) { for (i = 0; i < SCAN_BUFFER_SIZE; i++) {
if (buffer[i] != 0xffffffff) { if (buffer[i] != 0xffffffff) {
// Uh oh, not empty. // Uh oh, not empty.
@ -655,29 +663,35 @@ sysparam_status_t sysparam_get_data(const char *key, uint8_t **destptr, size_t *
sysparam_status_t status; sysparam_status_t status;
size_t key_len = strlen(key); size_t key_len = strlen(key);
uint8_t *buffer; uint8_t *buffer;
uint8_t *newbuf;
if (!_sysparam_info.cur_base) return SYSPARAM_ERR_NOINIT; xSemaphoreTake(_sysparam_info.sem, portMAX_DELAY);
if (actual_length) *actual_length = 0;
if (!_sysparam_info.cur_base) {
status = SYSPARAM_ERR_NOINIT;
goto done;
}
buffer = malloc(key_len + 2);
if (!buffer) return SYSPARAM_ERR_NOMEM;
do {
_init_context(&ctx); _init_context(&ctx);
status = _find_key(&ctx, key, key_len, buffer); status = _find_key(&ctx, key, key_len);
if (status != SYSPARAM_OK) break; if (status != SYSPARAM_OK) goto done;
// Find the associated value // Find the associated value
status = _find_value(&ctx, ctx.entry.idflags); status = _find_value(&ctx, ctx.entry.idflags);
if (status != SYSPARAM_OK) break; if (status != SYSPARAM_OK) goto done;
newbuf = realloc(buffer, ctx.entry.len + 1); buffer = malloc(ctx.entry.len + 1);
if (!newbuf) { if (!buffer) {
status = SYSPARAM_ERR_NOMEM; status = SYSPARAM_ERR_NOMEM;
break; goto done;
} }
buffer = newbuf;
status = _read_payload(&ctx, buffer, ctx.entry.len); status = _read_payload(&ctx, buffer, ctx.entry.len);
if (status != SYSPARAM_OK) break; if (status != SYSPARAM_OK) {
free(buffer);
goto done;
}
// Zero-terminate the result, just in case (doesn't hurt anything for // Zero-terminate the result, just in case (doesn't hurt anything for
// non-string data, and can avoid nasty mistakes if the caller wants to // non-string data, and can avoid nasty mistakes if the caller wants to
@ -687,38 +701,41 @@ sysparam_status_t sysparam_get_data(const char *key, uint8_t **destptr, size_t *
*destptr = buffer; *destptr = buffer;
if (actual_length) *actual_length = ctx.entry.len; if (actual_length) *actual_length = ctx.entry.len;
if (is_binary) *is_binary = (bool)(ctx.entry.idflags & ENTRY_FLAG_BINARY); if (is_binary) *is_binary = (bool)(ctx.entry.idflags & ENTRY_FLAG_BINARY);
return SYSPARAM_OK; status = SYSPARAM_OK;
} while (false);
free(buffer); done:
if (actual_length) *actual_length = 0; xSemaphoreGive(_sysparam_info.sem);
return status; return status;
} }
sysparam_status_t sysparam_get_data_static(const char *key, uint8_t *buffer, size_t buffer_size, size_t *actual_length, bool *is_binary) { sysparam_status_t sysparam_get_data_static(const char *key, uint8_t *dest, size_t dest_size, size_t *actual_length, bool *is_binary) {
struct sysparam_context ctx; struct sysparam_context ctx;
sysparam_status_t status = SYSPARAM_OK; sysparam_status_t status = SYSPARAM_OK;
size_t key_len = strlen(key); size_t key_len = strlen(key);
if (!_sysparam_info.cur_base) return SYSPARAM_ERR_NOINIT; xSemaphoreTake(_sysparam_info.sem, portMAX_DELAY);
// Supplied buffer must be at least as large as the key, or 2 bytes,
// whichever is larger.
if (buffer_size < max(key_len, 2)) return SYSPARAM_ERR_NOMEM;
if (actual_length) *actual_length = 0; if (actual_length) *actual_length = 0;
if (!_sysparam_info.cur_base) {
status = SYSPARAM_ERR_NOINIT;
goto done;
}
_init_context(&ctx); _init_context(&ctx);
status = _find_key(&ctx, key, key_len, buffer); status = _find_key(&ctx, key, key_len);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) goto done;
status = _find_value(&ctx, ctx.entry.idflags); status = _find_value(&ctx, ctx.entry.idflags);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) goto done;
status = _read_payload(&ctx, buffer, buffer_size); status = _read_payload(&ctx, dest, dest_size);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) goto done;
if (actual_length) *actual_length = ctx.entry.len; if (actual_length) *actual_length = ctx.entry.len;
if (is_binary) *is_binary = (bool)(ctx.entry.idflags & ENTRY_FLAG_BINARY); if (is_binary) *is_binary = (bool)(ctx.entry.idflags & ENTRY_FLAG_BINARY);
return SYSPARAM_OK;
done:
xSemaphoreGive(_sysparam_info.sem);
return status;
} }
sysparam_status_t sysparam_get_string(const char *key, char **destptr) { sysparam_status_t sysparam_get_string(const char *key, char **destptr) {
@ -741,63 +758,78 @@ sysparam_status_t sysparam_get_string(const char *key, char **destptr) {
} }
sysparam_status_t sysparam_get_int32(const char *key, int32_t *result) { sysparam_status_t sysparam_get_int32(const char *key, int32_t *result) {
char *buffer;
char *endptr;
int32_t value; int32_t value;
size_t actual_length;
bool is_binary;
sysparam_status_t status; sysparam_status_t status;
status = sysparam_get_string(key, &buffer); status = sysparam_get_data_static(key, (uint8_t *)&value, sizeof(int32_t),
&actual_length, &is_binary);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) return status;
value = strtol(buffer, &endptr, 0); if (!is_binary || actual_length != sizeof(int32_t))
if (*endptr) {
// There was extra crap at the end of the string.
free(buffer);
return SYSPARAM_PARSEFAILED; return SYSPARAM_PARSEFAILED;
}
*result = value; *result = value;
free(buffer); return status;
return SYSPARAM_OK;
} }
sysparam_status_t sysparam_get_int8(const char *key, int8_t *result) { sysparam_status_t sysparam_get_int8(const char *key, int8_t *result) {
int32_t value; int8_t value;
size_t actual_length;
bool is_binary;
sysparam_status_t status; sysparam_status_t status;
status = sysparam_get_int32(key, &value); status = sysparam_get_data_static(key, (uint8_t *)&value, sizeof(int8_t),
if (status == SYSPARAM_OK) { &actual_length, &is_binary);
if (status != SYSPARAM_OK) return status;
if (!is_binary || actual_length != sizeof(int8_t))
return SYSPARAM_PARSEFAILED;
*result = value; *result = value;
}
return status; return status;
} }
sysparam_status_t sysparam_get_bool(const char *key, bool *result) { sysparam_status_t sysparam_get_bool(const char *key, bool *result) {
char *buffer; const size_t buf_size = 8;
char buf[buf_size + 1]; // extra byte for zero termination
size_t data_len = 0;
bool binary = false;
sysparam_status_t status; sysparam_status_t status;
status = sysparam_get_string(key, &buffer); status = sysparam_get_data_static(key, (uint8_t*)buf,
buf_size, &data_len, &binary);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) return status;
do { do {
if (!strcasecmp(buffer, "y") || if (binary) {
!strcasecmp(buffer, "yes") || if (data_len == 1) { // int8 value
!strcasecmp(buffer, "t") || *result = (int8_t)(*buf) ? true : false;
!strcasecmp(buffer, "true") || } else if (data_len == 4) { // int32 value
!strcmp(buffer, "1")) { *result = (int32_t)(*buf) ? true : false;
} else {
status = SYSPARAM_PARSEFAILED;
}
break;
}
buf[data_len] = 0;
if (!strcasecmp(buf, "y") ||
!strcasecmp(buf, "yes") ||
!strcasecmp(buf, "t") ||
!strcasecmp(buf, "true") ||
!strcmp(buf, "1")) {
*result = true; *result = true;
break; break;
} }
if (!strcasecmp(buffer, "n") || if (!strcasecmp(buf, "n") ||
!strcasecmp(buffer, "no") || !strcasecmp(buf, "no") ||
!strcasecmp(buffer, "f") || !strcasecmp(buf, "f") ||
!strcasecmp(buffer, "false") || !strcasecmp(buf, "false") ||
!strcmp(buffer, "0")) { !strcmp(buf, "0")) {
*result = false; *result = false;
break; break;
} }
status = SYSPARAM_PARSEFAILED; status = SYSPARAM_PARSEFAILED;
} while (0); } while (0);
free(buffer);
return status; return status;
} }
@ -806,48 +838,30 @@ sysparam_status_t sysparam_set_data(const char *key, const uint8_t *value, size_
struct sysparam_context write_ctx; struct sysparam_context write_ctx;
sysparam_status_t status = SYSPARAM_OK; sysparam_status_t status = SYSPARAM_OK;
uint16_t key_len = strlen(key); uint16_t key_len = strlen(key);
uint8_t *buffer;
uint8_t *newbuf;
size_t free_space; size_t free_space;
size_t needed_space; size_t needed_space;
bool free_value = false;
int key_id = -1; int key_id = -1;
uint32_t old_value_addr = 0; uint32_t old_value_addr = 0;
uint16_t binary_flag; uint16_t binary_flag;
if (!_sysparam_info.cur_base) return SYSPARAM_ERR_NOINIT;
if (!key_len) return SYSPARAM_ERR_BADVALUE; if (!key_len) return SYSPARAM_ERR_BADVALUE;
if (key_len > MAX_KEY_LEN) return SYSPARAM_ERR_BADVALUE; if (key_len > MAX_KEY_LEN) return SYSPARAM_ERR_BADVALUE;
if (value_len > MAX_VALUE_LEN) return SYSPARAM_ERR_BADVALUE; if (value_len > MAX_VALUE_LEN) return SYSPARAM_ERR_BADVALUE;
xSemaphoreTake(_sysparam_info.sem, portMAX_DELAY);
if (!value) value_len = 0; if (!value) value_len = 0;
debug(1, "updating value for '%s' (%d bytes)", key, value_len); debug(1, "updating value for '%s' (%d bytes)", key, value_len);
if (value_len && ((intptr_t)value & 0x3)) {
// The passed value isn't word-aligned. This will be a problem later xSemaphoreTake(_sysparam_info.sem, portMAX_DELAY);
// when calling `sdk_spi_flash_write`, so make a word-aligned copy.
buffer = malloc(value_len); if (!_sysparam_info.cur_base) {
if (!buffer) { status = SYSPARAM_ERR_NOINIT;
status = SYSPARAM_ERR_NOMEM;
goto done;
}
memcpy(buffer, value, value_len);
value = buffer;
free_value = true;
}
// Create a working buffer for `_find_key` to use.
buffer = malloc(key_len);
if (!buffer) {
if (free_value) free((void *)value);
status = SYSPARAM_ERR_NOMEM;
goto done; goto done;
} }
do { do {
_init_context(&ctx); _init_context(&ctx);
status = _find_key(&ctx, key, key_len, buffer); status = _find_key(&ctx, key, key_len);
if (status == SYSPARAM_OK) { if (status == SYSPARAM_OK) {
// Key already exists, see if there's a current value. // Key already exists, see if there's a current value.
key_id = ctx.entry.idflags & ENTRY_MASK_ID; key_id = ctx.entry.idflags & ENTRY_MASK_ID;
@ -862,24 +876,17 @@ sysparam_status_t sysparam_set_data(const char *key, const uint8_t *value, size_
if (value_len) { if (value_len) {
if (old_value_addr) { if (old_value_addr) {
if ((ctx.entry.idflags & ENTRY_FLAG_BINARY) == binary_flag && ctx.entry.len == value_len) { if ((ctx.entry.idflags & ENTRY_FLAG_BINARY) == binary_flag &&
ctx.entry.len == value_len) {
// Are we trying to write the same value that's already there? // Are we trying to write the same value that's already there?
if (value_len > key_len) { status = _compare_payload(&ctx, (uint8_t *)value, value_len);
newbuf = realloc(buffer, value_len); if (status == SYSPARAM_OK) {
if (!newbuf) {
status = SYSPARAM_ERR_NOMEM;
break;
}
buffer = newbuf;
}
status = _read_payload(&ctx, buffer, value_len);
if (status < 0) break;
if (!memcmp(buffer, value, value_len)) {
// Yup, it's a match! No need to do anything further, // Yup, it's a match! No need to do anything further,
// just leave the current value as-is. // just leave the current value as-is.
status = SYSPARAM_OK; status = SYSPARAM_OK;
break; break;
} }
if (status != SYSPARAM_NOTFOUND) goto done;
} }
// Since we will be deleting the old value (if any) make sure // Since we will be deleting the old value (if any) make sure
@ -981,9 +988,6 @@ sysparam_status_t sysparam_set_data(const char *key, const uint8_t *value, size_
debug(1, "New addr is 0x%08x (%d bytes remaining)", _sysparam_info.end_addr, _sysparam_info.cur_base + _sysparam_info.region_size - _sysparam_info.end_addr); debug(1, "New addr is 0x%08x (%d bytes remaining)", _sysparam_info.end_addr, _sysparam_info.cur_base + _sysparam_info.region_size - _sysparam_info.end_addr);
} while (false); } while (false);
if (free_value) free((void *)value);
free(buffer);
done: done:
xSemaphoreGive(_sysparam_info.sem); xSemaphoreGive(_sysparam_info.sem);
@ -995,15 +999,11 @@ sysparam_status_t sysparam_set_string(const char *key, const char *value) {
} }
sysparam_status_t sysparam_set_int32(const char *key, int32_t value) { sysparam_status_t sysparam_set_int32(const char *key, int32_t value) {
uint8_t buffer[12]; return sysparam_set_data(key, (const uint8_t *)&value, sizeof(value), true);
int len;
len = snprintf((char *)buffer, 12, "%d", value);
return sysparam_set_data(key, buffer, len, false);
} }
sysparam_status_t sysparam_set_int8(const char *key, int8_t value) { sysparam_status_t sysparam_set_int8(const char *key, int8_t value) {
return sysparam_set_int32(key, value); return sysparam_set_data(key, (const uint8_t *)&value, sizeof(value), true);
} }
sysparam_status_t sysparam_set_bool(const char *key, bool value) { sysparam_status_t sysparam_set_bool(const char *key, bool value) {
@ -1043,7 +1043,6 @@ sysparam_status_t sysparam_iter_start(sysparam_iter_t *iter) {
} }
sysparam_status_t sysparam_iter_next(sysparam_iter_t *iter) { sysparam_status_t sysparam_iter_next(sysparam_iter_t *iter) {
uint8_t buffer[2];
sysparam_status_t status; sysparam_status_t status;
size_t required_len; size_t required_len;
struct sysparam_context *ctx = iter->ctx; struct sysparam_context *ctx = iter->ctx;
@ -1052,7 +1051,7 @@ sysparam_status_t sysparam_iter_next(sysparam_iter_t *iter) {
char *newbuf; char *newbuf;
while (true) { while (true) {
status = _find_key(ctx, NULL, 0, buffer); status = _find_key(ctx, NULL, 0);
if (status != SYSPARAM_OK) return status; if (status != SYSPARAM_OK) return status;
memcpy(&value_ctx, ctx, sizeof(value_ctx)); memcpy(&value_ctx, ctx, sizeof(value_ctx));
@ -1060,7 +1059,7 @@ sysparam_status_t sysparam_iter_next(sysparam_iter_t *iter) {
if (status < 0) return status; if (status < 0) return status;
if (status == SYSPARAM_NOTFOUND) continue; if (status == SYSPARAM_NOTFOUND) continue;
key_space = ROUND_TO_WORD_BOUNDARY(ctx->entry.len + 1); key_space = ctx->entry.len + 1;
required_len = key_space + value_ctx.entry.len + 1; required_len = key_space + value_ctx.entry.len + 1;
if (required_len > iter->bufsize) { if (required_len > iter->bufsize) {
newbuf = realloc(iter->key, required_len); newbuf = realloc(iter->key, required_len);

12
extras/spiffs/esp_spiffs.c
View file

@ -7,11 +7,10 @@
*/ */
#include "esp_spiffs.h" #include "esp_spiffs.h"
#include "spiffs.h" #include "spiffs.h"
#include <espressif/spi_flash.h> #include <spiflash.h>
#include <stdbool.h> #include <stdbool.h>
#include <esp/uart.h> #include <esp/uart.h>
#include <fcntl.h> #include <fcntl.h>
#include "esp_spiffs_flash.h"
spiffs fs; spiffs fs;
@ -34,7 +33,7 @@ static fs_buf_t cache_buf = {0};
static s32_t esp_spiffs_read(u32_t addr, u32_t size, u8_t *dst) static s32_t esp_spiffs_read(u32_t addr, u32_t size, u8_t *dst)
{ {
if (esp_spiffs_flash_read(addr, dst, size) == ESP_SPIFFS_FLASH_ERROR) { if (!spiflash_read(addr, dst, size)) {
return SPIFFS_ERR_INTERNAL; return SPIFFS_ERR_INTERNAL;
} }
@ -43,7 +42,7 @@ static s32_t esp_spiffs_read(u32_t addr, u32_t size, u8_t *dst)
static s32_t esp_spiffs_write(u32_t addr, u32_t size, u8_t *src) static s32_t esp_spiffs_write(u32_t addr, u32_t size, u8_t *src)
{ {
if (esp_spiffs_flash_write(addr, src, size) == ESP_SPIFFS_FLASH_ERROR) { if (!spiflash_write(addr, src, size)) {
return SPIFFS_ERR_INTERNAL; return SPIFFS_ERR_INTERNAL;
} }
@ -52,11 +51,10 @@ static s32_t esp_spiffs_write(u32_t addr, u32_t size, u8_t *src)
static s32_t esp_spiffs_erase(u32_t addr, u32_t size) static s32_t esp_spiffs_erase(u32_t addr, u32_t size)
{ {
uint32_t sectors = size / SPI_FLASH_SEC_SIZE; uint32_t sectors = size / SPI_FLASH_SECTOR_SIZE;
for (uint32_t i = 0; i < sectors; i++) { for (uint32_t i = 0; i < sectors; i++) {
if (esp_spiffs_flash_erase_sector(addr + (SPI_FLASH_SEC_SIZE * i)) if (!spiflash_erase_sector(addr + (SPI_FLASH_SECTOR_SIZE * i))) {
== ESP_SPIFFS_FLASH_ERROR) {
return SPIFFS_ERR_INTERNAL; return SPIFFS_ERR_INTERNAL;
} }
} }

112
extras/spiffs/unaligned_memcpy.S
View file

@ -1,112 +0,0 @@
/**
* The MIT License (MIT)
*
* Copyright (c) 2016 sheinz (https://github.com/sheinz)
*
* 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.
*/
.text
.section .iram1.text, "x"
.literal_position
/**
* Copy unaligned data to 4-byte aligned buffer.
*/
.align 4
.global memcpy_unaligned_src
.type memcpy_unaligned_src, @function
memcpy_unaligned_src:
/* a2: dst, a3: src, a4: size */
ssa8l a3
srli a3, a3, 2
slli a3, a3, 2
beqz a4, u_src_end
l32i a6, a3, 0
u_src_loop:
l32i a7, a3, 4
src a8, a7, a6
memw
s32i a8, a2, 0
mov a6, a7
addi a3, a3, 4
addi a2, a2, 4
addi a4, a4, -1
bnez a4, u_src_loop
u_src_end:
movi a2, 0
ret.n
/**
* Copy data from 4-byte aligned source to unaligned destination buffer.
*/
.align 4
.global memcpy_unaligned_dst
.type memcpy_unaligned_dst, @function
memcpy_unaligned_dst:
/* a2: dst, a3: src, a4: size */
beqz.n a4, u_dst_end
extui a5, a4, 0, 2
beqz.n a5, aligned_dst_loop
u_dst_loop:
/* Load data word */
memw
l32i.n a5, a3, 0
/* Save byte number 0 */
s8i a5, a2, 0
addi.n a4, a4, -1
beqz a4, u_dst_end
addi.n a2, a2, 1
/* Shift and save byte number 1 */
srli a5, a5, 8
s8i a5, a2, 0
addi.n a4, a4, -1
beqz a4, u_dst_end
addi.n a2, a2, 1
/* Shift and save byte number 2 */
srli a5, a5, 8
s8i a5, a2, 0
addi.n a4, a4, -1
beqz a4, u_dst_end
addi.n a2, a2, 1
/* Shift and save byte number 3 */
srli a5, a5, 8
s8i a5, a2, 0
addi.n a4, a4, -1
addi.n a2, a2, 1
/* Next word */
addi.n a3, a3, 4
bnez.n a4, u_dst_loop
ret.n
aligned_dst_loop:
memw
l32i a5, a3, 0
s32i a5, a2, 0
addi.n a3, a3, 4
addi.n a2, a2, 4
addi.n a4, a4, -4
bnez.n a4, aligned_dst_loop
u_dst_end: ret.n

6
include/espressif/spi_flash.h
View file

@ -46,12 +46,6 @@ sdk_SpiFlashOpResult sdk_spi_flash_write(uint32_t des_addr, uint32_t *src, uint3
*/ */
sdk_SpiFlashOpResult sdk_spi_flash_read(uint32_t src_addr, uint32_t *des, uint32_t size); sdk_SpiFlashOpResult sdk_spi_flash_read(uint32_t src_addr, uint32_t *des, uint32_t size);
/* SDK uses this structure internally to account for flash size.
See flashchip.h for more info.
*/
extern sdk_flashchip_t sdk_flashchip;
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

403
tests/cases/07_sysparam.c Normal file
View file

@ -0,0 +1,403 @@
#include <stdlib.h>
#include <string.h>
#include <FreeRTOS.h>
#include <task.h>
#include <sysparam.h>
#include <testcase.h>
// #define DEBUG
#ifdef DEBUG
#include <stdio.h>
#define debug(fmt, ...) printf("%s" fmt, "test: ", ## __VA_ARGS__);
#else
#define debug(fmt, ...)
#endif
DEFINE_SOLO_TESTCASE(07_sysparam_basic_test);
DEFINE_SOLO_TESTCASE(07_sysparam_load_test);
DEFINE_SOLO_TESTCASE(07_sysparam_bool_test);
#define TEST_ITERATIONS 10
#define KEY_BUF_SIZE 32
#define TEST_STRING_BUF_SIZE 64
#define NUMBER_OF_TEST_DATA 20
typedef struct {
uint32_t start_key_index;
uint32_t key_index;
} test_data_t;
typedef enum {
VALUE_STRING = 0,
VALUE_INT32,
VALUE_INT8,
VALUE_BOOL,
VALUE_ENUM_END
} value_type_t;
static uint32_t get_current_time()
{
return timer_get_count(FRC2) / 5000; // to get roughly 1ms resolution
}
/**
* Recreate sysparam area
*/
static inline void init_sysparam()
{
sysparam_status_t status;
uint32_t base_addr, num_sectors;
status = sysparam_get_info(&base_addr, &num_sectors);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_create_area(base_addr, num_sectors, /*force=*/true);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_init(base_addr, 0);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
debug("sysparam initialized at addr=%x, sectors=%d\n",
base_addr, num_sectors);
}
/**
* Initialize test data with random seed.
*/
static void test_data_init(test_data_t *data)
{
debug("test_data_init\n");
data->start_key_index = data->key_index = rand() % 100;
}
/**
* Reset test data to the initial seed.
*/
static void test_data_reset(test_data_t *data)
{
debug("test_data_reset\n");
data->key_index = data->start_key_index;
}
/**
* Get key string for the current data.
*/
static void test_data_get_key(test_data_t *data, char *key_buf)
{
sprintf(key_buf, "key_%d", data->key_index);
debug("test_data_get_key: key=%s\n", key_buf);
}
/**
* Generate test string for the current data.
*/
static void test_data_get_string(test_data_t *data, char *str_buf)
{
srand(data->key_index);
for (int i = 0; i < TEST_STRING_BUF_SIZE - 1; ++i) {
str_buf[i] = '0' + rand() % 74; // generate a char 0-9,a-z,A-Z and other
}
str_buf[TEST_STRING_BUF_SIZE-1] = 0; // terminate string with zero
debug("test_data_get_string: str=%s\n", str_buf);
}
/**
* Generate test int32 value for the current data.
*/
static int32_t test_data_get_int32(test_data_t *data)
{
srand(data->key_index);
int32_t v = rand();
debug("test_data_get_int32: value=%d\n", v);
return v;
}
/**
* Generate test int8 value for the current data.
*/
int8_t test_data_get_int8(test_data_t *data)
{
srand(data->key_index);
int8_t v = rand() % 256;
debug("test_data_get_int8: value=%d\n", v);
return v;
}
/**
* Generate test bool value for the current data.
*/
bool test_data_get_bool(test_data_t *data)
{
srand(data->key_index);
bool v = rand() % 2;
debug("test_data_get_bool, value=%s\n", v ? "true" : "false");
return v;
}
/**
* Get type of the current data.
*/
value_type_t test_data_get_type(test_data_t *data)
{
srand(data->key_index);
value_type_t t = rand() % VALUE_ENUM_END;
debug("test_data_get_type: type=%d\n", t);
return t;
}
/**
* Generate next data.
*/
void test_data_next(test_data_t *data)
{
data->key_index++;
debug("test_data_next: key_index=%d\n", data->key_index);
}
static void write_test_values(test_data_t *data)
{
sysparam_status_t status = SYSPARAM_ERR_BADVALUE;
char key_buf[KEY_BUF_SIZE];
char str_buf[TEST_STRING_BUF_SIZE];
for (int i = 0; i < NUMBER_OF_TEST_DATA; ++i) {
test_data_get_key(data, key_buf);
switch (test_data_get_type(data)) {
case VALUE_STRING:
test_data_get_string(data, str_buf);
status = sysparam_set_string(key_buf, str_buf);
break;
case VALUE_INT32:
status = sysparam_set_int32(key_buf, test_data_get_int32(data));
break;
case VALUE_INT8:
status = sysparam_set_int8(key_buf, test_data_get_int8(data));
break;
case VALUE_BOOL:
status = sysparam_set_bool(key_buf, test_data_get_bool(data));
break;
case VALUE_ENUM_END:
default:
break;
}
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
test_data_next(data);
}
}
static void verify_test_values(test_data_t *data)
{
sysparam_status_t status = SYSPARAM_ERR_BADVALUE;
char key_buf[KEY_BUF_SIZE];
char expected_str_buf[TEST_STRING_BUF_SIZE];
char *actual_str;
int32_t actual_int32;
int8_t actual_int8;
bool actual_bool;
for (int i = 0; i < NUMBER_OF_TEST_DATA; ++i) {
test_data_get_key(data, key_buf);
switch (test_data_get_type(data)) {
case VALUE_STRING:
test_data_get_string(data, expected_str_buf);
status = sysparam_get_string(key_buf, &actual_str);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_STRING(expected_str_buf, actual_str);
free(actual_str);
break;
case VALUE_INT32:
status = sysparam_get_int32(key_buf, &actual_int32);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_INT(test_data_get_int32(data), actual_int32);
break;
case VALUE_INT8:
status = sysparam_get_int8(key_buf, &actual_int8);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_INT(test_data_get_int8(data), actual_int8);
break;
case VALUE_BOOL:
status = sysparam_get_bool(key_buf, &actual_bool);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_TRUE(test_data_get_bool(data) == actual_bool);
break;
case VALUE_ENUM_END:
default:
break;
}
test_data_next(data);
}
}
static void clear_test_values(test_data_t *data)
{
char key_buf[KEY_BUF_SIZE];
sysparam_status_t status = SYSPARAM_ERR_BADVALUE;
for (int i = 0; i < NUMBER_OF_TEST_DATA; ++i) {
test_data_get_key(data, key_buf);
status = sysparam_set_data(key_buf, NULL, 0, false);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
test_data_next(data);
}
}
static void a_07_sysparam_load_test(void)
{
test_data_t test_data;
init_sysparam();
uint32_t start_time = get_current_time();
uint32_t free_heap_at_start = xPortGetFreeHeapSize();
for (int i = 0; i < TEST_ITERATIONS; ++i) {
test_data_init(&test_data);
write_test_values(&test_data);
test_data_reset(&test_data);
verify_test_values(&test_data);
test_data_reset(&test_data);
clear_test_values(&test_data);
}
TEST_ASSERT_EQUAL_INT_MESSAGE(free_heap_at_start, xPortGetFreeHeapSize(),
"Free heap size is less than at test start. Possible memory leak.");
printf("Test took %d ms\n", get_current_time() - start_time);
TEST_PASS();
}
static void a_07_sysparam_basic_test(void)
{
sysparam_status_t status;
int32_t int32_val = 0;
int8_t int8_val = 0;
char *str;
bool bool_val;
init_sysparam();
status = sysparam_set_int32("int_1", -123);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_get_int32("int_1", &int32_val);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_INT(-123, int32_val);
status = sysparam_set_int8("int_2", -34);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_get_int8("int_2", &int8_val);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_INT(-34, int8_val);
status = sysparam_set_string("str_1", "test string");
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_get_string("str_1", &str);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_EQUAL_STRING("test string", str);
free(str);
status = sysparam_set_bool("bool_true", true);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_get_bool("bool_true", &bool_val);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_TRUE(bool_val);
status = sysparam_set_bool("bool_false", false);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_get_bool("bool_false", &bool_val);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_FALSE(bool_val);
TEST_PASS();
}
typedef struct {
const char *key;
const char *str;
bool value;
} bool_test_data_t;
const static bool_test_data_t bool_data[] = {
{"str_true", "true", true},
{"str_True", "True", true},
{"str_TRUE", "TRUE", true},
{"str_t", "t", true},
{"str_T", "T", true},
{"str_y", "y", true},
{"str_Y", "Y", true},
{"str_yes", "yes", true},
{"str_Yes", "Yes", true},
{"str_YES", "YES", true},
{"str_1", "1", true},
{"str_false", "false", false},
{"str_False", "False", false},
{"str_FALSE", "FALSE", false},
{"str_f", "f", false},
{"str_F", "F", false},
{"str_n", "n", false},
{"str_N", "N", false},
{"str_no", "no", false},
{"str_No", "No", false},
{"str_NO", "NO", false},
{"str_0", "0", false},
};
static void a_07_sysparam_bool_test(void)
{
sysparam_status_t status;
bool value;
init_sysparam();
for (int i = 0; i < sizeof(bool_data) / sizeof(bool_data[0]); ++i) {
status = sysparam_set_string(bool_data[i].key, bool_data[i].str);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
}
status = sysparam_set_int8("int8_0", 0);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_set_int8("int8_1", 1);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_set_int32("int32_0", 0);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
status = sysparam_set_int32("int32_1", 1);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
for (int i = 0; i < sizeof(bool_data) / sizeof(bool_data[0]); ++i) {
debug("Getting bool key=%s\n", bool_data[i].key);
status = sysparam_get_bool(bool_data[i].key, &value);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_TRUE(bool_data[i].value == value);
}
status = sysparam_get_bool("int8_0", &value);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_FALSE(value);
status = sysparam_get_bool("int8_1", &value);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_TRUE(value);
status = sysparam_get_bool("int32_0", &value);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_FALSE(value);
status = sysparam_get_bool("int32_1", &value);
TEST_ASSERT_EQUAL_INT(SYSPARAM_OK, status);
TEST_ASSERT_TRUE(value);
TEST_PASS();
}

51
tests/cases/08_spiflash.c Normal file
View file

@ -0,0 +1,51 @@
#include <string.h>
#include <espressif/esp_common.h>
#include <esp/uart.h>
#include <esp/timer.h>
#include <FreeRTOS.h>
#include <task.h>
#include <esp8266.h>
#include <stdio.h>
#include <testcase.h>
#include <spiflash.h>
DEFINE_SOLO_TESTCASE(08_spiflash_unaligned)
/**
* Test unaligned access to spi flash.
*/
static void a_08_spiflash_unaligned(void)
{
const int test_addr = 0x100000 - (4096 * 8);
const char test_str[] = "test_string";
const int buf_size = 256;
uint8_t buf[buf_size];
TEST_ASSERT_TRUE(spiflash_erase_sector(test_addr));
TEST_ASSERT_TRUE(spiflash_erase_sector(test_addr + 4096));
TEST_ASSERT_TRUE(
spiflash_write(test_addr, (uint8_t*)test_str, sizeof(test_str)));
TEST_ASSERT_TRUE(spiflash_read(test_addr, buf, buf_size));
TEST_ASSERT_EQUAL_STRING(test_str, buf);
TEST_ASSERT_TRUE(
spiflash_write(test_addr + 31, (uint8_t*)test_str, sizeof(test_str)));
TEST_ASSERT_TRUE(spiflash_read(test_addr + 31, buf, buf_size));
TEST_ASSERT_EQUAL_STRING(test_str, buf);
TEST_ASSERT_TRUE(
spiflash_write(test_addr + 101, (uint8_t*)test_str, sizeof(test_str)));
TEST_ASSERT_TRUE(spiflash_read(test_addr + 101, buf + 1, buf_size - 1));
TEST_ASSERT_EQUAL_STRING(test_str, buf + 1);
TEST_ASSERT_TRUE(
spiflash_write(test_addr + 201, (uint8_t*)test_str + 1, sizeof(test_str) - 1));
TEST_ASSERT_TRUE(spiflash_read(test_addr + 201, buf + 1, buf_size - 1));
TEST_ASSERT_EQUAL_STRING(test_str + 1, buf + 1);
TEST_PASS();
}