logo

qmk_firmware

custom branch of QMK firmware git clone https://anongit.hacktivis.me/git/qmk_firmware.git

eeprom_legacy_emulated_flash.c (22371B)

    

  1. /*
  2.  * This software is experimental and a work in progress.
  3.  * Under no circumstances should these files be used in relation to any critical system(s).
  4.  * Use of these files is at your own risk.
  5.  *
  6.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  7.  * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  8.  * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  9.  * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  10.  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  11.  * DEALINGS IN THE SOFTWARE.
  12.  *
  13.  * This files are free to use from http://engsta.com/stm32-flash-memory-eeprom-emulator/ by
  14.  * Artur F.
  15.  *
  16.  * Modifications for QMK and STM32F303 by Yiancar
  17.  * Modifications to add flash wear leveling by Ilya Zhuravlev
  18.  * Modifications to increase flash density by Don Kjer
  19.  */
  21. #include <stdio.h>
  22. #include <stdbool.h>
  23. #include "util.h"
  24. #include "debug.h"
  25. #include "eeprom_legacy_emulated_flash.h"
  26. #include "legacy_flash_ops.h"
  27. #include "eeprom_driver.h"
  29. /*
  30.  * We emulate eeprom by writing a snapshot compacted view of eeprom contents,
  31.  * followed by a write log of any change since that snapshot:
  32.  *
  33.  * === SIMULATED EEPROM CONTENTS ===
  34.  *
  35.  * ┌─ Compacted ┬ Write Log ─┐
  36.  * │............│[BYTE][BYTE]│
  37.  * │FFFF....FFFF│[WRD0][WRD1]│
  38.  * │FFFFFFFFFFFF│[WORD][NEXT]│
  39.  * │....FFFFFFFF│[BYTE][WRD0]│
  40.  * ├────────────┼────────────┤
  41.  * └──PAGE_BASE │            │
  42.  *    PAGE_LAST─┴─WRITE_BASE │
  43.  *                WRITE_LAST ┘
  44.  *
  45.  * Compacted contents are the 1's complement of the actual EEPROM contents.
  46.  * e.g. An 'FFFF' represents a '0000' value.
  47.  *
  48.  * The size of the 'compacted' area is equal to the size of the 'emulated' eeprom.
  49.  * The size of the compacted-area and write log are configurable, and the combined
  50.  * size of Compacted + WriteLog is a multiple FEE_PAGE_SIZE, which is MCU dependent.
  51.  * Simulated Eeprom contents are located at the end of available flash space.
  52.  *
  53.  * The following configuration defines can be set:
  54.  *
  55.  * FEE_PAGE_COUNT   # Total number of pages to use for eeprom simulation (Compact + Write log)
  56.  * FEE_DENSITY_BYTES   # Size of simulated eeprom. (Defaults to half the space allocated by FEE_PAGE_COUNT)
  57.  * NOTE: The current implementation does not include page swapping,
  58.  * and FEE_DENSITY_BYTES will consume that amount of RAM as a cached view of actual EEPROM contents.
  59.  *
  60.  * The maximum size of FEE_DENSITY_BYTES is currently 16384. The write log size equals
  61.  * FEE_PAGE_COUNT * FEE_PAGE_SIZE - FEE_DENSITY_BYTES.
  62.  * The larger the write log, the less frequently the compacted area needs to be rewritten.
  63.  *
  64.  *
  65.  * *** General Algorithm ***
  66.  *
  67.  * During initialization:
  68.  * The contents of the Compacted-flash area are loaded and the 1's complement value
  69.  * is cached into memory (e.g. 0xFFFF in Flash represents 0x0000 in cache).
  70.  * Write log entries are processed until a 0xFFFF is reached.
  71.  * Each log entry updates a byte or word in the cache.
  72.  *
  73.  * During reads:
  74.  * EEPROM contents are given back directly from the cache in memory.
  75.  *
  76.  * During writes:
  77.  * The contents of the cache is updated first.
  78.  * If the Compacted-flash area corresponding to the write address is unprogrammed, the 1's complement of the value is written directly into Compacted-flash
  79.  * Otherwise:
  80.  * If the write log is full, erase both the Compacted-flash area and the Write log, then write cached contents to the Compacted-flash area.
  81.  * Otherwise a Write log entry is constructed and appended to the next free position in the Write log.
  82.  *
  83.  *
  84.  * *** Write Log Structure ***
  85.  *
  86.  * Write log entries allow for optimized byte writes to addresses below 128. Writing 0 or 1 words are also optimized when word-aligned.
  87.  *
  88.  * === WRITE LOG ENTRY FORMATS ===
  89.  *
  90.  * ╔═══ Byte-Entry ══╗
  91.  * ║0XXXXXXX║YYYYYYYY║
  92.  * ║ └──┬──┘║└──┬───┘║
  93.  * ║ Address║ Value  ║
  94.  * ╚════════╩════════╝
  95.  * 0 <= Address < 0x80 (128)
  96.  *
  97.  * ╔ Word-Encoded 0 ╗
  98.  * ║100XXXXXXXXXXXXX║
  99.  * ║  │└─────┬─────┘║
  100.  * ║  │Address >> 1 ║
  101.  * ║  └── Value: 0  ║
  102.  * ╚════════════════╝
  103.  * 0 <= Address <= 0x3FFE (16382)
  104.  *
  105.  * ╔ Word-Encoded 1 ╗
  106.  * ║101XXXXXXXXXXXXX║
  107.  * ║  │└─────┬─────┘║
  108.  * ║  │Address >> 1 ║
  109.  * ║  └── Value: 1  ║
  110.  * ╚════════════════╝
  111.  * 0 <= Address <= 0x3FFE (16382)
  112.  *
  113.  * ╔═══ Reserved ═══╗
  114.  * ║110XXXXXXXXXXXXX║
  115.  * ╚════════════════╝
  116.  *
  117.  * ╔═══════════ Word-Next ═══════════╗
  118.  * ║111XXXXXXXXXXXXX║YYYYYYYYYYYYYYYY║
  119.  * ║   └─────┬─────┘║└───────┬──────┘║
  120.  * ║(Address-128)>>1║     ~Value     ║
  121.  * ╚════════════════╩════════════════╝
  122.  * (  0 <= Address <  0x0080 (128): Reserved)
  123.  * 0x80 <= Address <= 0x3FFE (16382)
  124.  *
  125.  * Write Log entry ranges:
  126.  * 0x0000 ... 0x7FFF - Byte-Entry;     address is (Entry & 0x7F00) >> 4; value is (Entry & 0xFF)
  127.  * 0x8000 ... 0x9FFF - Word-Encoded 0; address is (Entry & 0x1FFF) << 1; value is 0
  128.  * 0xA000 ... 0xBFFF - Word-Encoded 1; address is (Entry & 0x1FFF) << 1; value is 1
  129.  * 0xC000 ... 0xDFFF - Reserved
  130.  * 0xE000 ... 0xFFBF - Word-Next;      address is (Entry & 0x1FFF) << 1 + 0x80; value is ~(Next_Entry)
  131.  * 0xFFC0 ... 0xFFFE - Reserved
  132.  * 0xFFFF            - Unprogrammed
  133.  *
  134.  */
  136. #include "eeprom_legacy_emulated_flash_defs.h"
  137. /* These bits are used for optimizing encoding of bytes, 0 and 1 */
  138. #define FEE_WORD_ENCODING 0x8000
  139. #define FEE_VALUE_NEXT 0x6000
  140. #define FEE_VALUE_RESERVED 0x4000
  141. #define FEE_VALUE_ENCODED 0x2000
  142. #define FEE_BYTE_RANGE 0x80
  144. /* Flash word value after erase */
  145. #define FEE_EMPTY_WORD ((uint16_t)0xFFFF)
  147. #if !defined(FEE_PAGE_SIZE) || !defined(FEE_PAGE_COUNT) || !defined(FEE_MCU_FLASH_SIZE) || !defined(FEE_PAGE_BASE_ADDRESS)
  148. #    error "not implemented."
  149. #endif
  151. /* In-memory contents of emulated eeprom for faster access */
  152. /* *TODO: Implement page swapping */
  153. static uint16_t WordBuf[FEE_DENSITY_BYTES / 2];
  154. static uint8_t *DataBuf = (uint8_t *)WordBuf;
  156. /* Pointer to the first available slot within the write log */
  157. static uint16_t *empty_slot;
  159. // #define DEBUG_EEPROM_OUTPUT
  161. /*
  162.  * Debug print utils
  163.  */
  165. #if defined(DEBUG_EEPROM_OUTPUT)
  167. #    define debug_eeprom debug_enable
  168. #    define eeprom_println(s) println(s)
  169. #    define eeprom_printf(fmt, ...) xprintf(fmt, ##__VA_ARGS__);
  171. #else /* NO_DEBUG */
  173. #    define debug_eeprom false
  174. #    define eeprom_println(s)
  175. #    define eeprom_printf(fmt, ...)
  177. #endif /* NO_DEBUG */
  179. void print_eeprom(void) {
  180. #ifndef NO_DEBUG
  181.     int empty_rows = 0;
  182.     for (uint16_t i = 0; i < FEE_DENSITY_BYTES; i++) {
  183.         if (i % 16 == 0) {
  184.             if (i >= FEE_DENSITY_BYTES - 16) {
  185.                 /* Make sure we display the last row */
  186.                 empty_rows = 0;
  187.             }
  188.             /* Check if this row is uninitialized */
  189.             ++empty_rows;
  190.             for (uint16_t j = 0; j < 16; j++) {
  191.                 if (DataBuf[i + j]) {
  192.                     empty_rows = 0;
  193.                     break;
  194.                 }
  195.             }
  196.             if (empty_rows > 1) {
  197.                 /* Repeat empty row */
  198.                 if (empty_rows == 2) {
  199.                     /* Only display the first repeat empty row */
  200.                     println("*");
  201.                 }
  202.                 i += 15;
  203.                 continue;
  204.             }
  205.             xprintf("%04x", i);
  206.         }
  207.         if (i % 8 == 0) print(" ");
  209.         xprintf(" %02x", DataBuf[i]);
  210.         if ((i + 1) % 16 == 0) {
  211.             println("");
  212.         }
  213.     }
  214. #endif
  215. }
  217. uint16_t EEPROM_Init(void) {
  218.     /* Load emulated eeprom contents from compacted flash into memory */
  219.     uint16_t *src  = (uint16_t *)FEE_COMPACTED_BASE_ADDRESS;
  220.     uint16_t *dest = (uint16_t *)DataBuf;
  221.     for (; src < (uint16_t *)FEE_COMPACTED_LAST_ADDRESS; ++src, ++dest) {
  222.         *dest = ~*src;
  223.     }
  225.     if (debug_eeprom) {
  226.         println("EEPROM_Init Compacted Pages:");
  227.         print_eeprom();
  228.         println("EEPROM_Init Write Log:");
  229.     }
  231.     /* Replay write log */
  232.     uint16_t *log_addr;
  233.     for (log_addr = (uint16_t *)FEE_WRITE_LOG_BASE_ADDRESS; log_addr < (uint16_t *)FEE_WRITE_LOG_LAST_ADDRESS; ++log_addr) {
  234.         uint16_t address = *log_addr;
  235.         if (address == FEE_EMPTY_WORD) {
  236.             break;
  237.         }
  238.         /* Check for lowest 128-bytes optimization */
  239.         if (!(address & FEE_WORD_ENCODING)) {
  240.             uint8_t bvalue = (uint8_t)address;
  241.             address >>= 8;
  242.             DataBuf[address] = bvalue;
  243.             eeprom_printf("DataBuf[0x%02x] = 0x%02x;\n", address, bvalue);
  244.         } else {
  245.             uint16_t wvalue;
  246.             /* Check if value is in next word */
  247.             if ((address & FEE_VALUE_NEXT) == FEE_VALUE_NEXT) {
  248.                 /* Read value from next word */
  249.                 if (++log_addr >= (uint16_t *)FEE_WRITE_LOG_LAST_ADDRESS) {
  250.                     break;
  251.                 }
  252.                 wvalue = ~*log_addr;
  253.                 if (!wvalue) {
  254.                     eeprom_printf("Incomplete write at log_addr: 0x%04lx;\n", (uint32_t)log_addr);
  255.                     /* Possibly incomplete write.  Ignore and continue */
  256.                     continue;
  257.                 }
  258.                 address &= 0x1FFF;
  259.                 address <<= 1;
  260.                 /* Writes to addresses less than 128 are byte log entries */
  261.                 address += FEE_BYTE_RANGE;
  262.             } else {
  263.                 /* Reserved for future use */
  264.                 if (address & FEE_VALUE_RESERVED) {
  265.                     eeprom_printf("Reserved encoded value at log_addr: 0x%04lx;\n", (uint32_t)log_addr);
  266.                     continue;
  267.                 }
  268.                 /* Optimization for 0 or 1 values. */
  269.                 wvalue = (address & FEE_VALUE_ENCODED) >> 13;
  270.                 address &= 0x1FFF;
  271.                 address <<= 1;
  272.             }
  273.             if (address < FEE_DENSITY_BYTES) {
  274.                 eeprom_printf("DataBuf[0x%04x] = 0x%04x;\n", address, wvalue);
  275.                 *(uint16_t *)(&DataBuf[address]) = wvalue;
  276.             } else {
  277.                 eeprom_printf("DataBuf[0x%04x] cannot be set to 0x%04x [BAD ADDRESS]\n", address, wvalue);
  278.             }
  279.         }
  280.     }
  282.     empty_slot = log_addr;
  284.     if (debug_eeprom) {
  285.         println("EEPROM_Init Final DataBuf:");
  286.         print_eeprom();
  287.     }
  289.     return FEE_DENSITY_BYTES;
  290. }
  292. /* Clear flash contents (doesn't touch in-memory DataBuf) */
  293. static void eeprom_clear(void) {
  294.     FLASH_Unlock();
  296.     for (uint16_t page_num = 0; page_num < FEE_PAGE_COUNT; ++page_num) {
  297.         eeprom_printf("FLASH_ErasePage(0x%04lx)\n", (uint32_t)(FEE_PAGE_BASE_ADDRESS + (page_num * FEE_PAGE_SIZE)));
  298.         FLASH_ErasePage(FEE_PAGE_BASE_ADDRESS + (page_num * FEE_PAGE_SIZE));
  299.     }
  301.     FLASH_Lock();
  303.     empty_slot = (uint16_t *)FEE_WRITE_LOG_BASE_ADDRESS;
  304.     eeprom_printf("eeprom_clear empty_slot: 0x%08lx\n", (uint32_t)empty_slot);
  305. }
  307. /* Erase emulated eeprom */
  308. void EEPROM_Erase(void) {
  309.     eeprom_println("EEPROM_Erase");
  310.     /* Erase compacted pages and write log */
  311.     eeprom_clear();
  312.     /* re-initialize to reset DataBuf */
  313.     EEPROM_Init();
  314. }
  316. /* Compact write log */
  317. static uint8_t eeprom_compact(void) {
  318.     /* Erase compacted pages and write log */
  319.     eeprom_clear();
  321.     FLASH_Unlock();
  323.     FLASH_Status final_status = FLASH_COMPLETE;
  325.     /* Write emulated eeprom contents from memory to compacted flash */
  326.     uint16_t *src  = (uint16_t *)DataBuf;
  327.     uintptr_t dest = FEE_COMPACTED_BASE_ADDRESS;
  328.     uint16_t  value;
  329.     for (; dest < FEE_COMPACTED_LAST_ADDRESS; ++src, dest += 2) {
  330.         value = *src;
  331.         if (value) {
  332.             eeprom_printf("FLASH_ProgramHalfWord(0x%04lx, 0x%04x)\n", (uint32_t)dest, ~value);
  333.             FLASH_Status status = FLASH_ProgramHalfWord(dest, ~value);
  334.             if (status != FLASH_COMPLETE) final_status = status;
  335.         }
  336.     }
  338.     FLASH_Lock();
  340.     if (debug_eeprom) {
  341.         println("eeprom_compacted:");
  342.         print_eeprom();
  343.     }
  345.     return final_status;
  346. }
  348. static uint8_t eeprom_write_direct_entry(uint16_t Address) {
  349.     /* Check if we can just write this directly to the compacted flash area */
  350.     uintptr_t directAddress = FEE_COMPACTED_BASE_ADDRESS + (Address & 0xFFFE);
  351.     if (*(uint16_t *)directAddress == FEE_EMPTY_WORD) {
  352.         /* Write the value directly to the compacted area without a log entry */
  353.         uint16_t value = ~*(uint16_t *)(&DataBuf[Address & 0xFFFE]);
  354.         /* Early exit if a write isn't needed */
  355.         if (value == FEE_EMPTY_WORD) return FLASH_COMPLETE;
  357.         FLASH_Unlock();
  359.         eeprom_printf("FLASH_ProgramHalfWord(0x%08lx, 0x%04x) [DIRECT]\n", (uint32_t)directAddress, value);
  360.         FLASH_Status status = FLASH_ProgramHalfWord(directAddress, value);
  362.         FLASH_Lock();
  363.         return status;
  364.     }
  365.     return 0;
  366. }
  368. static uint8_t eeprom_write_log_word_entry(uint16_t Address) {
  369.     FLASH_Status final_status = FLASH_COMPLETE;
  371.     uint16_t value = *(uint16_t *)(&DataBuf[Address]);
  372.     eeprom_printf("eeprom_write_log_word_entry(0x%04x): 0x%04x\n", Address, value);
  374.     /* MSB signifies the lowest 128-byte optimization is not in effect */
  375.     uint16_t encoding = FEE_WORD_ENCODING;
  376.     uint8_t  entry_size;
  377.     if (value <= 1) {
  378.         encoding |= value << 13;
  379.         entry_size = 2;
  380.     } else {
  381.         encoding |= FEE_VALUE_NEXT;
  382.         entry_size = 4;
  383.         /* Writes to addresses less than 128 are byte log entries */
  384.         Address -= FEE_BYTE_RANGE;
  385.     }
  387.     /* if we can't find an empty spot, we must compact emulated eeprom */
  388.     if (empty_slot > (uint16_t *)(FEE_WRITE_LOG_LAST_ADDRESS - entry_size)) {
  389.         /* compact the write log into the compacted flash area */
  390.         return eeprom_compact();
  391.     }
  393.     /* Word log writes should be word-aligned.  Take back a bit */
  394.     Address >>= 1;
  395.     Address |= encoding;
  397.     /* ok we found a place let's write our data */
  398.     FLASH_Unlock();
  400.     /* address */
  401.     eeprom_printf("FLASH_ProgramHalfWord(0x%08lx, 0x%04x)\n", (uint32_t)empty_slot, Address);
  402.     final_status = FLASH_ProgramHalfWord((uintptr_t)empty_slot++, Address);
  404.     /* value */
  405.     if (encoding == (FEE_WORD_ENCODING | FEE_VALUE_NEXT)) {
  406.         eeprom_printf("FLASH_ProgramHalfWord(0x%08lx, 0x%04x)\n", (uint32_t)empty_slot, ~value);
  407.         FLASH_Status status = FLASH_ProgramHalfWord((uintptr_t)empty_slot++, ~value);
  408.         if (status != FLASH_COMPLETE) final_status = status;
  409.     }
  411.     FLASH_Lock();
  413.     return final_status;
  414. }
  416. static uint8_t eeprom_write_log_byte_entry(uint16_t Address) {
  417.     eeprom_printf("eeprom_write_log_byte_entry(0x%04x): 0x%02x\n", Address, DataBuf[Address]);
  419.     /* if couldn't find an empty spot, we must compact emulated eeprom */
  420.     if (empty_slot >= (uint16_t *)FEE_WRITE_LOG_LAST_ADDRESS) {
  421.         /* compact the write log into the compacted flash area */
  422.         return eeprom_compact();
  423.     }
  425.     /* ok we found a place let's write our data */
  426.     FLASH_Unlock();
  428.     /* Pack address and value into the same word */
  429.     uint16_t value = (Address << 8) | DataBuf[Address];
  431.     /* write to flash */
  432.     eeprom_printf("FLASH_ProgramHalfWord(0x%08lx, 0x%04x)\n", (uint32_t)empty_slot, value);
  433.     FLASH_Status status = FLASH_ProgramHalfWord((uintptr_t)empty_slot++, value);
  435.     FLASH_Lock();
  437.     return status;
  438. }
  440. uint8_t EEPROM_WriteDataByte(uint16_t Address, uint8_t DataByte) {
  441.     /* if the address is out-of-bounds, do nothing */
  442.     if (Address >= FEE_DENSITY_BYTES) {
  443.         eeprom_printf("EEPROM_WriteDataByte(0x%04x, 0x%02x) [BAD ADDRESS]\n", Address, DataByte);
  444.         return FLASH_BAD_ADDRESS;
  445.     }
  447.     /* if the value is the same, don't bother writing it */
  448.     if (DataBuf[Address] == DataByte) {
  449.         eeprom_printf("EEPROM_WriteDataByte(0x%04x, 0x%02x) [SKIP SAME]\n", Address, DataByte);
  450.         return 0;
  451.     }
  453.     /* keep DataBuf cache in sync */
  454.     DataBuf[Address] = DataByte;
  455.     eeprom_printf("EEPROM_WriteDataByte DataBuf[0x%04x] = 0x%02x\n", Address, DataBuf[Address]);
  457.     /* perform the write into flash memory */
  458.     /* First, attempt to write directly into the compacted flash area */
  459.     FLASH_Status status = eeprom_write_direct_entry(Address);
  460.     if (!status) {
  461.         /* Otherwise append to the write log */
  462.         if (Address < FEE_BYTE_RANGE) {
  463.             status = eeprom_write_log_byte_entry(Address);
  464.         } else {
  465.             status = eeprom_write_log_word_entry(Address & 0xFFFE);
  466.         }
  467.     }
  468.     if (status != 0 && status != FLASH_COMPLETE) {
  469.         eeprom_printf("EEPROM_WriteDataByte [STATUS == %d]\n", status);
  470.     }
  471.     return status;
  472. }
  474. uint8_t EEPROM_WriteDataWord(uint16_t Address, uint16_t DataWord) {
  475.     /* if the address is out-of-bounds, do nothing */
  476.     if (Address >= FEE_DENSITY_BYTES) {
  477.         eeprom_printf("EEPROM_WriteDataWord(0x%04x, 0x%04x) [BAD ADDRESS]\n", Address, DataWord);
  478.         return FLASH_BAD_ADDRESS;
  479.     }
  481.     /* Check for word alignment */
  482.     FLASH_Status final_status = FLASH_COMPLETE;
  483.     if (Address % 2) {
  484.         final_status        = EEPROM_WriteDataByte(Address, DataWord);
  485.         FLASH_Status status = EEPROM_WriteDataByte(Address + 1, DataWord >> 8);
  486.         if (status != FLASH_COMPLETE) final_status = status;
  487.         if (final_status != 0 && final_status != FLASH_COMPLETE) {
  488.             eeprom_printf("EEPROM_WriteDataWord [STATUS == %d]\n", final_status);
  489.         }
  490.         return final_status;
  491.     }
  493.     /* if the value is the same, don't bother writing it */
  494.     uint16_t oldValue = *(uint16_t *)(&DataBuf[Address]);
  495.     if (oldValue == DataWord) {
  496.         eeprom_printf("EEPROM_WriteDataWord(0x%04x, 0x%04x) [SKIP SAME]\n", Address, DataWord);
  497.         return 0;
  498.     }
  500.     /* keep DataBuf cache in sync */
  501.     *(uint16_t *)(&DataBuf[Address]) = DataWord;
  502.     eeprom_printf("EEPROM_WriteDataWord DataBuf[0x%04x] = 0x%04x\n", Address, *(uint16_t *)(&DataBuf[Address]));
  504.     /* perform the write into flash memory */
  505.     /* First, attempt to write directly into the compacted flash area */
  506.     final_status = eeprom_write_direct_entry(Address);
  507.     if (!final_status) {
  508.         /* Otherwise append to the write log */
  509.         /* Check if we need to fall back to byte write */
  510.         if (Address < FEE_BYTE_RANGE) {
  511.             final_status = FLASH_COMPLETE;
  512.             /* Only write a byte if it has changed */
  513.             if ((uint8_t)oldValue != (uint8_t)DataWord) {
  514.                 final_status = eeprom_write_log_byte_entry(Address);
  515.             }
  516.             FLASH_Status status = FLASH_COMPLETE;
  517.             /* Only write a byte if it has changed */
  518.             if ((oldValue >> 8) != (DataWord >> 8)) {
  519.                 status = eeprom_write_log_byte_entry(Address + 1);
  520.             }
  521.             if (status != FLASH_COMPLETE) final_status = status;
  522.         } else {
  523.             final_status = eeprom_write_log_word_entry(Address);
  524.         }
  525.     }
  526.     if (final_status != 0 && final_status != FLASH_COMPLETE) {
  527.         eeprom_printf("EEPROM_WriteDataWord [STATUS == %d]\n", final_status);
  528.     }
  529.     return final_status;
  530. }
  532. uint8_t EEPROM_ReadDataByte(uint16_t Address) {
  533.     uint8_t DataByte = 0xFF;
  535.     if (Address < FEE_DENSITY_BYTES) {
  536.         DataByte = DataBuf[Address];
  537.     }
  539.     eeprom_printf("EEPROM_ReadDataByte(0x%04x): 0x%02x\n", Address, DataByte);
  541.     return DataByte;
  542. }
  544. uint16_t EEPROM_ReadDataWord(uint16_t Address) {
  545.     uint16_t DataWord = 0xFFFF;
  547.     if (Address < FEE_DENSITY_BYTES - 1) {
  548.         /* Check word alignment */
  549.         if (Address % 2) {
  550.             DataWord = DataBuf[Address] | (DataBuf[Address + 1] << 8);
  551.         } else {
  552.             DataWord = *(uint16_t *)(&DataBuf[Address]);
  553.         }
  554.     }
  556.     eeprom_printf("EEPROM_ReadDataWord(0x%04x): 0x%04x\n", Address, DataWord);
  558.     return DataWord;
  559. }
  561. /*****************************************************************************
  562.  *  Bind to eeprom_driver.c
  563.  *******************************************************************************/
  564. void eeprom_driver_init(void) {
  565.     EEPROM_Init();
  566. }
  568. void eeprom_driver_format(bool erase) {
  569.     /* emulated eepron requires the write log data structures to be erased before use. */
  570.     (void)erase;
  571.     eeprom_driver_erase();
  572. }
  574. void eeprom_driver_erase(void) {
  575.     EEPROM_Erase();
  576. }
  578. void eeprom_read_block(void *buf, const void *addr, size_t len) {
  579.     const uint8_t *src  = (const uint8_t *)addr;
  580.     uint8_t *      dest = (uint8_t *)buf;
  582.     /* Check word alignment */
  583.     if (len && (uintptr_t)src % 2) {
  584.         /* Read the unaligned first byte */
  585.         *dest++ = EEPROM_ReadDataByte((const uintptr_t)src++);
  586.         --len;
  587.     }
  589.     uint16_t value;
  590.     bool     aligned = ((uintptr_t)dest % 2 == 0);
  591.     while (len > 1) {
  592.         value = EEPROM_ReadDataWord((const uintptr_t)((uint16_t *)src));
  593.         if (aligned) {
  594.             *(uint16_t *)dest = value;
  595.             dest += 2;
  596.         } else {
  597.             *dest++ = value;
  598.             *dest++ = value >> 8;
  599.         }
  600.         src += 2;
  601.         len -= 2;
  602.     }
  603.     if (len) {
  604.         *dest = EEPROM_ReadDataByte((const uintptr_t)src);
  605.     }
  606. }
  608. void eeprom_write_block(const void *buf, void *addr, size_t len) {
  609.     uint8_t *      dest = (uint8_t *)addr;
  610.     const uint8_t *src  = (const uint8_t *)buf;
  612.     /* Check word alignment */
  613.     if (len && (uintptr_t)dest % 2) {
  614.         /* Write the unaligned first byte */
  615.         EEPROM_WriteDataByte((uintptr_t)dest++, *src++);
  616.         --len;
  617.     }
  619.     uint16_t value;
  620.     bool     aligned = ((uintptr_t)src % 2 == 0);
  621.     while (len > 1) {
  622.         if (aligned) {
  623.             value = *(uint16_t *)src;
  624.         } else {
  625.             value = *(uint8_t *)src | (*(uint8_t *)(src + 1) << 8);
  626.         }
  627.         EEPROM_WriteDataWord((uintptr_t)((uint16_t *)dest), value);
  628.         dest += 2;
  629.         src += 2;
  630.         len -= 2;
  631.     }
  633.     if (len) {
  634.         EEPROM_WriteDataByte((uintptr_t)dest, *src);
  635.     }
  636. }