Обновление

Inc/InternalFlashPage.h

@@ -9,43 +9,95 @@
 #include "fc7xxx_driver_flash.h"
 #include "stddef.h"
 
-bool bInternalFlashPage_Clear(
+bool D_bInternalFlashPage_Clear(
         uint32_t pageAddress
 );
 
-size_t sInternalFlashPage_Write(
+size_t D_sInternalFlashPage_Write(
         uint32_t pageAddress,
         size_t offset,
         uint8_t *data,
         size_t size
 );
 
-size_t bInternalFlashPage_DumpFromRam(
+size_t D_bInternalFlashPage_DumpFromRam(
         uint32_t beginPageAddr,
         void *sourceRamAddr,
         uint32_t size
 );
 
-size_t sInternalFlashPage_Read(
+size_t D_sInternalFlashPage_Read(
         uint32_t pageAddress,
         size_t offset,
         uint8_t *data,
         size_t size
 );
 
-bool bInternalFlashPage_ClearRange(
+bool D_bInternalFlashPage_ClearRange(
         uint32_t firstPageAddr,
         uint32_t totalSize
 );
 
-bool bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size);
+bool D_bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size);
 
-bool bInternalFlashPage_CopyRange(
+bool D_bInternalFlashPage_CopyRange(
         uint32_t targetPageAddr,
         uint32_t sourcePageAddr,
         uint32_t totalCopySize
 );
 
-uint32_t iInternalFlashPage_ReadWord(uint32_t addressOnFlash);
+uint32_t D_iInternalFlashPage_ReadWord(uint32_t addressOnFlash);
+
+
+
+
+
+
+
+
+
+
+
+
+
+bool P_bInternalFlashPage_Clear(
+        uint32_t pageAddress
+);
+
+size_t P_sInternalFlashPage_Write(
+        uint32_t pageAddress,
+        size_t offset,
+        uint8_t *data,
+        size_t size
+);
+
+size_t P_bInternalFlashPage_DumpFromRam(
+        uint32_t beginPageAddr,
+        void *sourceRamAddr,
+        uint32_t size
+);
+
+size_t P_sInternalFlashPage_Read(
+        uint32_t pageAddress,
+        size_t offset,
+        uint8_t *data,
+        size_t size
+);
+
+bool P_bInternalFlashPage_ClearRange(
+        uint32_t firstPageAddr,
+        uint32_t totalSize
+);
+
+bool P_bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size);
+
+bool P_bInternalFlashPage_CopyRange(
+        uint32_t targetPageAddr,
+        uint32_t sourcePageAddr,
+        uint32_t totalCopySize
+);
+
+uint32_t P_iInternalFlashPage_ReadWord(uint32_t addressOnFlash);
+
 
 #endif //HVAC_INTERNAL_FLASH_PAGE_H

Src/InternalFlashPage_DFlash.c

@@ -4,11 +4,11 @@
 #include "SystemDelayInterface.h"
 #include "InternalFlashPage.h"
 
-uint32_t iInternalFlashPage_ReadWord(uint32_t addressOnFlash) {
+uint32_t D_iInternalFlashPage_ReadWord(uint32_t addressOnFlash) {
     return (*(__IO uint32_t *) (addressOnFlash));
 }
 
-size_t sInternalFlashPage_Read(
+size_t D_sInternalFlashPage_Read(
         uint32_t pageAddress,
         size_t offset,
         uint8_t *data,
@@ -23,12 +23,12 @@ size_t sInternalFlashPage_Read(
 
     while (left) {
         if (left >= 4) {
-            *((uint32_t *) data) = iInternalFlashPage_ReadWord(pageAddress + offset);
+            *((uint32_t *) data) = D_iInternalFlashPage_ReadWord(pageAddress + offset);
             data += 4;
             offset += 4;
             left -= 4;
         } else {
-            uint32_t word = iInternalFlashPage_ReadWord(pageAddress + offset);
+            uint32_t word = D_iInternalFlashPage_ReadWord(pageAddress + offset);
             for (uint8_t sub_byte = 0; sub_byte < left; ++sub_byte) {
                 *data = ((uint8_t *) &word)[sub_byte];
                 ++data;
@@ -41,7 +41,7 @@ size_t sInternalFlashPage_Read(
     return size;
 }
 
-bool bInternalFlashPage_Clear(
+bool D_bInternalFlashPage_Clear(
         uint32_t pageAddress
 ) {
     FLASHDRIVER_Init();
@@ -73,7 +73,7 @@ bool bInternalFlashPage_Clear(
     return true;
 }
 
-bool bInternalFlashPage_ClearRange(
+bool D_bInternalFlashPage_ClearRange(
         uint32_t firstPageAddr,
         uint32_t totalSize
 ) {
@@ -83,7 +83,7 @@ bool bInternalFlashPage_ClearRange(
 
     uint32_t endAddr = firstPageAddr + totalSize;
     for (; firstPageAddr < endAddr; firstPageAddr += FLASH_PAGE_SIZE) {
-        if (!bInternalFlashPage_Clear(firstPageAddr)) {
+        if (!D_bInternalFlashPage_Clear(firstPageAddr)) {
             return false;
         }
     }
@@ -91,12 +91,12 @@ bool bInternalFlashPage_ClearRange(
     return true;
 }
 
-bool bInternalFlashPage_CopyRange(
+bool D_bInternalFlashPage_CopyRange(
         uint32_t targetPageAddr,
         uint32_t sourcePageAddr,
         uint32_t size
 ) {
-    if (!bInternalFlashPage_ClearRange(targetPageAddr, size)) {
+    if (!D_bInternalFlashPage_ClearRange(targetPageAddr, size)) {
         return false;
     }
 
@@ -148,7 +148,7 @@ bool bInternalFlashPage_CopyRange(
    */
 }
 
-bool bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size) {
+bool D_bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size) {
     FLASHDRIVER_Init();
 
     FLASH_DRIVER_ParamType tFlashParam = {.pData = (uint8_t *) sourceRamAddr,
@@ -165,14 +165,14 @@ bool bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr
     return true;
 }
 
-size_t bInternalFlashPage_DumpFromRam(
+size_t D_bInternalFlashPage_DumpFromRam(
         uint32_t beginPageAddr,
         void *sourceRamAddr,
         uint32_t size
 ) {
     size_t alignedSize = ((size / FLASH_PAGE_SIZE) + (size % FLASH_PAGE_SIZE ? 1 : 0)) * FLASH_PAGE_SIZE;
 
-    if (!bInternalFlashPage_ClearRange(beginPageAddr, alignedSize)) {
+    if (!D_bInternalFlashPage_ClearRange(beginPageAddr, alignedSize)) {
         return 0;
     }
 
@@ -229,7 +229,7 @@ size_t bInternalFlashPage_DumpFromRam(
 */
 }
 
-size_t sInternalFlashPage_Write(
+size_t D_sInternalFlashPage_Write(
         uint32_t pageAddress,
         size_t offset,
         uint8_t *data,

Src/InternalFlashPage_PFlash.c

@@ -0,0 +1,305 @@
+//
+// Created by cfif on 07.10.22.
+//
+#include "SystemDelayInterface.h"
+#include "InternalFlashPage.h"
+
+uint32_t P_iInternalFlashPage_ReadWord(uint32_t addressOnFlash) {
+    return (*(__IO uint32_t *) (addressOnFlash));
+}
+
+size_t P_sInternalFlashPage_Read(
+        uint32_t pageAddress,
+        size_t offset,
+        uint8_t *data,
+        size_t size
+) {
+    if ((offset & (uint32_t) 0x3) != 0) {
+        // The offset is not a multiple of 4
+        return 0;
+    }
+
+    size_t left = size;
+
+    while (left) {
+        if (left >= 4) {
+            *((uint32_t *) data) = P_iInternalFlashPage_ReadWord(pageAddress + offset);
+            data += 4;
+            offset += 4;
+            left -= 4;
+        } else {
+            uint32_t word = P_iInternalFlashPage_ReadWord(pageAddress + offset);
+            for (uint8_t sub_byte = 0; sub_byte < left; ++sub_byte) {
+                *data = ((uint8_t *) &word)[sub_byte];
+                ++data;
+            }
+            offset += 4;
+            left = 0;
+        }
+    }
+
+    return size;
+}
+
+bool P_bInternalFlashPage_Clear(
+        uint32_t pageAddress
+) {
+    FLASHDRIVER_Init();
+
+    FLASH_DRIVER_ParamType tFlashParam = {.pData = NULL,
+            .wdTriggerFct = (void *) 0
+    };
+
+    tFlashParam.u32Address = pageAddress;
+    tFlashParam.u32Length = FLASH_PAGE_SIZE;
+    if (FLASH_ERROR_OK != FLASHDRIVER_PFlashEraseSector(&tFlashParam)) {
+        return false;
+    }
+
+
+/*
+    flash_unlock();
+
+//    if (FLASH_OPERATE_DONE != flash_block_erase(pageAddress)) {
+//        return false;
+//    }
+    if (FLASH_OPERATE_DONE != flash_sector_erase(pageAddress)) {
+        flash_lock();
+        return false;
+    }
+
+    flash_lock();
+*/
+    return true;
+}
+
+bool P_bInternalFlashPage_ClearRange(
+        uint32_t firstPageAddr,
+        uint32_t totalSize
+) {
+    if (totalSize % FLASH_PAGE_SIZE) {
+        return false;
+    }
+
+    uint32_t endAddr = firstPageAddr + totalSize;
+    for (; firstPageAddr < endAddr; firstPageAddr += FLASH_PAGE_SIZE) {
+        if (!P_bInternalFlashPage_Clear(firstPageAddr)) {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+bool P_bInternalFlashPage_CopyRange(
+        uint32_t targetPageAddr,
+        uint32_t sourcePageAddr,
+        uint32_t size
+) {
+    if (!P_bInternalFlashPage_ClearRange(targetPageAddr, size)) {
+        return false;
+    }
+
+    FLASHDRIVER_Init();
+
+    FLASH_DRIVER_ParamType tFlashParam = {.pData = (uint8_t *) sourcePageAddr,
+            .wdTriggerFct = (void *) 0
+    };
+
+    tFlashParam.u32Address = targetPageAddr;
+    tFlashParam.u32Length = size;
+    FLASHDRIVER_PFlashWrite(&tFlashParam);
+
+    return size;
+
+    /*
+    flash_unlock();
+
+    for (size_t i = 0; i < size; ++i) {
+
+        if (FLASH_OPERATE_DONE != flash_byte_program(targetPageAddr + i, (*(__IO uint8_t *) (sourcePageAddr + i)))) {
+            flash_lock();
+            return i;
+        }
+    }
+
+    flash_lock();
+
+    return size;
+    */
+    /*
+   flash_unlock();
+   uint32_t offset = 0;
+
+   uint32_t word;
+   while (offset < size) {
+       word = iInternalFlashPage_ReadWord(sourcePageAddr + offset);
+
+       if (FLASH_OPERATE_DONE != flash_word_program(targetPageAddr + offset, word)) {
+           flash_lock();
+           // whole isn't written
+           return offset;
+       }
+       offset += 4;
+   }
+
+   flash_lock();
+   return size;
+   */
+}
+
+bool P_bInternalFlashPage_WriteFromRam(uint32_t beginPageAddr, void *sourceRamAddr, uint32_t size) {
+    FLASHDRIVER_Init();
+
+    FLASH_DRIVER_ParamType tFlashParam = {.pData = (uint8_t *) sourceRamAddr,
+            .wdTriggerFct = (void *) 0
+    };
+
+    tFlashParam.u32Address = beginPageAddr;
+    tFlashParam.u32Length = size;
+
+    if (FLASH_ERROR_OK != FLASHDRIVER_PFlashWrite(&tFlashParam)) {
+        return false;
+    }
+
+    return true;
+}
+
+size_t P_bInternalFlashPage_DumpFromRam(
+        uint32_t beginPageAddr,
+        void *sourceRamAddr,
+        uint32_t size
+) {
+    size_t alignedSize = ((size / FLASH_PAGE_SIZE) + (size % FLASH_PAGE_SIZE ? 1 : 0)) * FLASH_PAGE_SIZE;
+
+    if (!P_bInternalFlashPage_ClearRange(beginPageAddr, alignedSize)) {
+        return 0;
+    }
+
+    FLASHDRIVER_Init();
+
+    FLASH_DRIVER_ParamType tFlashParam = {.pData = (uint8_t *) sourceRamAddr,
+            .wdTriggerFct = (void *) 0
+    };
+
+    tFlashParam.u32Address = beginPageAddr;
+    tFlashParam.u32Length = size;
+    if (FLASH_ERROR_OK != FLASHDRIVER_PFlashWrite(&tFlashParam)) {
+        return 0;
+    }
+
+    return size;
+/*
+    flash_unlock();
+
+    for (size_t i = 0; i < size; ++i) {
+        if (FLASH_OPERATE_DONE != flash_byte_program(beginPageAddr + i, ((uint8_t*)sourceRamAddr)[i])) {
+            flash_lock();
+            return i;
+        }
+    }
+
+    flash_lock();
+
+    return size;
+    */
+/*
+    flash_unlock();
+
+    uint32_t offset = 0;
+
+    uint32_t word;
+    while (offset < size) {
+        word = *(uint32_t *) (sourceRamAddr + offset);
+
+        if (size < 4) {
+            word = word & (0xFFFFFFFF >> (8 * (4 - size)));
+        }
+
+        if (FLASH_OPERATE_DONE != flash_word_program(beginPageAddr + offset, word)) {
+            flash_lock();
+            // whole isn't written
+            return offset;
+        }
+        offset += 4;
+    }
+
+    flash_lock();
+    return offset;
+*/
+}
+
+size_t P_sInternalFlashPage_Write(
+        uint32_t pageAddress,
+        size_t offset,
+        uint8_t *data,
+        size_t size
+) {
+
+    FLASHDRIVER_Init();
+
+    FLASH_DRIVER_ParamType tFlashParam = {.pData = (uint8_t *) data,
+            .wdTriggerFct = (void *) 0
+    };
+
+    tFlashParam.u32Address = pageAddress + offset;
+    tFlashParam.u32Length = size;
+    FLASH_StatusType ret = FLASHDRIVER_PFlashWrite(&tFlashParam);
+
+    return size;
+
+    /*
+    flash_unlock();
+
+    for (size_t i = 0; i < size; ++i) {
+        if (FLASH_OPERATE_DONE != flash_byte_program(pageAddress + i + offset, data[i])) {
+            flash_lock();
+            return i;
+        }
+    }
+
+    flash_lock();
+
+    return size;
+*/
+
+/*
+    flash_unlock();
+    size_t left = size;
+
+    while (left) {
+        if (left >= 4) {
+            if (FLASH_OPERATE_DONE != flash_word_program(pageAddress + offset, *((uint32_t *) data))) {
+                // whole isn't written
+                return size - left;
+            }
+            data += 4;
+            offset += 4;
+            left -= 4;
+        } else {
+            uint32_t word;
+            for (uint8_t sub_byte = 0; sub_byte < 4; ++sub_byte) {
+                if (sub_byte < left) {
+                    ((uint8_t *) &word)[sub_byte] = *data;
+                    ++data;
+                } else {
+                    ++size;
+                    ((uint8_t *) &word)[sub_byte] = 0;
+                }
+            }
+
+            if (FLASH_OPERATE_DONE != flash_word_program(pageAddress + offset, word)) {
+                // whole isn't written
+                return size - left;
+            }
+            offset += 4;
+            left = 0;
+
+        }
+
+    }
+    flash_lock();
+
+    return size;
+*/
+}