[EEPROM emulation] Rework for buffered access

The current EEPROM emulation didn't had any buffered access to the
data on the flash. Every access to a byte would trigger a whole
page read / write. For writes it would mean, that the whole page
would be erased. For backward compability we will keep
the current functions as they are, but will add functions
to fill/flush the buffer and read from it.

The buffer size is static and is one page in size.

Fixes: #296

Signed-off-by: Nils Hasenbanck <nils.hasenbanck@trendig.com>

Author: Nils Hasenbanck

cores/arduino/stm32/stm32_eeprom.c

@@ -136,7 +136,7 @@ static inline uint32_t get_flash_end(void) {
 /** @addtogroup STM32F4xx_System_Private_Variables
   * @{
   */
-static uint8_t tmpEE[E2END] = {0};
+static uint8_t eeprom_buffer[E2END] = {0};
 
 /**
   * @}
@@ -145,58 +145,72 @@ static uint8_t tmpEE[E2END] = {0};
 /** @addtogroup STM32F4xx_System_Private_FunctionPrototypes
   * @{
   */
-void get_data_from_flash(void);
-void set_data_to_flash(void);
 
 /**
   * @}
   */
 
 /**
-  * @brief  Function read a byte from eeprom
-  * @param  __p : address to read
+  * @brief  Function reads a byte from emulated eeprom (flash)
+  * @param  pos : address to read
   * @retval byte : data read from eeprom
   */
-uint8_t eeprom_read_byte(const uint16_t __p)
+uint8_t eeprom_read_byte(const uint16_t pos)
 {
-  uint8_t byte = 0;
+  eeprom_buffer_fill();
+  return eeprom_buffered_read_byte(pos);
+}
 
-  get_data_from_flash();
-  byte = tmpEE[__p];
+/**
+  * @brief  Function writes a byte to emulated eeprom (flash)
+  * @param  pos : address to write
+  * @param  value : value to write
+  * @retval none
+  */
+void eeprom_write_byte(uint16_t pos, uint8_t value)
+{
+  eeprom_buffered_write_byte(pos, value);
+  eeprom_buffer_flush();
+}
 
-  return byte;
+/**
+  * @brief  Function reads a byte from the eeprom buffer
+  * @param  pos : address to read
+  * @retval byte : data read from eeprom
+  */
+uint8_t eeprom_buffered_read_byte(const uint16_t pos)
+{
+  return eeprom_buffer[pos];
 }
 
 /**
-  * @brief  Function write a byte to eeprom
-  * @param  __p : address to write
-  * @param  __value : value to write
+  * @brief  Function writes a byte to the eeprom buffer
+  * @param  pos : address to write
+  * @param  value : value to write
   * @retval none
   */
-void eeprom_write_byte(uint16_t __p, uint8_t __value)
+void eeprom_buffered_write_byte(uint16_t pos, uint8_t value)
 {
-  tmpEE[__p] = __value;
-  set_data_to_flash();
+  eeprom_buffer[pos] = value;
 }
 
 /**
-  * @brief  The function read into the flash.
+  * @brief  This function copies the data from flash into the buffer
   * @param  none
   * @retval none
   */
-void get_data_from_flash(void)
+void eeprom_buffer_fill(void)
 {
-  memcpy(tmpEE, (uint8_t*)(FLASH_BASE_ADDRESS), E2END);
+  memcpy(eeprom_buffer, (uint8_t*)(FLASH_BASE_ADDRESS), E2END);
 }
 
 /**
-  * @brief  The function write into the flash.
+  * @brief  This function writes the buffer content into the flash
   * @param  none
   * @retval none
   */
-void set_data_to_flash(void)
+void eeprom_buffer_flush(void)
 {
-  //copy in flash
   FLASH_EraseInitTypeDef EraseInitStruct;
   uint32_t offset = 0;
   uint32_t address = FLASH_BASE_ADDRESS;
@@ -240,12 +254,12 @@ void set_data_to_flash(void)
     if(HAL_FLASHEx_Erase(&EraseInitStruct, &pageError) == HAL_OK) {
       while(address < address_end) {
 #if defined(STM32L0xx) || defined(STM32L1xx)
-      memcpy(&data, tmpEE + offset, sizeof(uint32_t));
+      memcpy(&data, eeprom_buffer + offset, sizeof(uint32_t));
       if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data) == HAL_OK) {
         address += 4;
         offset += 4;
 #else
-        data = *((uint64_t*)(((uint8_t*)tmpEE + offset)));
+        data = *((uint64_t*)(((uint8_t*)eeprom_buffer + offset)));
 
         if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD, address, data) == HAL_OK) {
           address += 8;
@@ -273,7 +287,7 @@ void set_data_to_flash(void)
   if(HAL_FLASHEx_Erase(&EraseInitStruct, &SectorError) == HAL_OK)
   {
     while(address < address_end) {
-      memcpy(&data, tmpEE + offset, sizeof(uint32_t));
+      memcpy(&data, eeprom_buffer + offset, sizeof(uint32_t));
       if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, address, data) == HAL_OK) {
         address += 4;
         offset += 4;

cores/arduino/stm32/stm32_eeprom.h

@@ -58,8 +58,13 @@
 /* Exported macro ------------------------------------------------------------*/
 /* Exported functions ------------------------------------------------------- */
 
-uint8_t eeprom_read_byte(const uint16_t __p);
-void eeprom_write_byte(uint16_t __p, uint8_t __value);
+uint8_t eeprom_read_byte(const uint16_t pos);
+void eeprom_write_byte(uint16_t pos, uint8_t value);
+
+void eeprom_buffer_fill();
+void eeprom_buffer_flush();
+uint8_t eeprom_buffered_read_byte(const uint16_t pos);
+void eeprom_buffered_write_byte(uint16_t pos, uint8_t value);
 
 #ifdef __cplusplus
 }