[openthread] update flash impl to use isolated nv

Author: tyler-potyondy

libopenthread/platform/flash.c

@@ -1,65 +1,63 @@
-#include <storage/nonvolatile_storage.h>
-#include <libtock-sync/storage/nonvolatile_storage.h>
+#include <storage/isolated_nonvolatile_storage.h>
+#include <libtock-sync/storage/isolated_nonvolatile_storage.h>
 
 #include <openthread/platform/flash.h>
 
 #include <stdio.h>
 
-const uint32_t SWAP_SIZE = 1024;
+// TODO: The kernel currently has a 512 byte buffer 
+// for isolated nonvolatile storage. This means that we can only
+// allow 512 bytes. 2x 512B swaps seems to be enough for openthread
+// but we may need to revist this in the future.
+const uint32_t SWAP_SIZE = 512;
 const uint8_t SWAP_NUM = 2;
 
-uint32_t otPlatFlashGetSwapSize(otInstance *aInstance){
+uint32_t otPlatFlashGetSwapSize(otInstance *aInstance) {
 	OT_UNUSED_VARIABLE(aInstance);
 	return SWAP_SIZE;
 }
 
-void otPlatFlashInit(otInstance *aInstance) {
+void otPlatFlashInit(otInstance *aInstance) { 
     OT_UNUSED_VARIABLE(aInstance);
-}
 
-void otPlatFlashErase(otInstance *aInstance, uint8_t aSwapIndex) {
-    OT_UNUSED_VARIABLE(aInstance);
+    // Confirm we have enough space for the 2 swaps.
+    uint64_t num_bytes;
+    libtocksync_isolated_nonvolatile_storage_get_number_bytes(&num_bytes);
 
-    uint32_t num_bytes;
-    libtock_nonvolatile_storage_get_number_bytes(&num_bytes);
+    assert(num_bytes >= SWAP_SIZE * SWAP_NUM);
+}
 
-    // Write all zeroes to flash
-    uint8_t zeroes[SWAP_SIZE];
+void otPlatFlashErase(otInstance *aInstance, uint8_t aSwapIndex) {
+    uint8_t overwrite[SWAP_SIZE];
 
-    otPlatFlashWrite(aInstance, aSwapIndex, 0, zeroes, num_bytes);
+    // Fill the swap area with 0xFF to erase it.
+    for (uint32_t i = 0; i < SWAP_SIZE; i++) {
+        overwrite[i] = 0xFF;
+    }
 
+    otPlatFlashWrite(aInstance, aSwapIndex, 0, overwrite, SWAP_SIZE);
 }
 
 void otPlatFlashWrite(otInstance *aInstance, uint8_t aSwapIndex, uint32_t aOffset,
                       const void *aData, uint32_t aSize) {
     OT_UNUSED_VARIABLE(aInstance);
-    OT_UNUSED_VARIABLE(aSwapIndex);
-    int ret;
 
     assert(aSwapIndex < SWAP_NUM);
+    assert(aOffset + aSize <= SWAP_SIZE);
     uint32_t offset = aSwapIndex ? SWAP_SIZE : 0;
     offset += aOffset;
 
-    int _written;
-    ret = libtocksync_nonvolatile_storage_write(offset, aSize, (uint8_t*)aData, aSize, &_written);
-    if (ret != RETURNCODE_SUCCESS) {
-        return;
-    }
+    libtocksync_isolated_nonvolatile_storage_write(offset, (uint8_t*)aData, aSize);
 }
 
 void otPlatFlashRead(otInstance *aInstance, uint8_t aSwapIndex, uint32_t aOffset, void *aData,
                      uint32_t aSize) {
     OT_UNUSED_VARIABLE(aInstance);
-    OT_UNUSED_VARIABLE(aSwapIndex);
-    int ret;
-
+    
     assert(aSwapIndex < SWAP_NUM);
+    assert(aOffset + aSize <= SWAP_SIZE);
     uint32_t offset = aSwapIndex ? SWAP_SIZE : 0;
     offset += aOffset;
-
-    int _read;
-    ret = libtocksync_nonvolatile_storage_read(offset, aSize, (uint8_t*)aData, aSize, &_read);
-    if (ret != RETURNCODE_SUCCESS) {
-        return;
-    }
+    
+    libtocksync_isolated_nonvolatile_storage_read(offset, (uint8_t*)aData, aSize);
 }