Crc checksum

obc/app/drivers/rm46/obc_crc.c

@@ -0,0 +1,116 @@
+#include "obc_crc.h"
+#include "obc_errors.h"
+
+#include "crc.h"
+#include "reg_crc.h"
+#include "sys_dma.h"
+
+#include "FreeRTOS.h"
+#include "os_semphr.h"
+
+#include <stdint.h>
+
+#define CRC_MAX_TIMEOUT 0x00U  // Setting it to 0, disables the timeout.
+#define CRC_SECTOR_COUNT 0x01U
+#define CRC_CHANNEL CRC_CH1
+#define CRC_MODE CRC_SEMI_CPU
+#define CRC_BASE crcREG
+
+// DMA associated signals
+#define CRC_DMA_PORT 0x04  // Only PORT B seems to be valid
+#define CRC_DMA_FRAME_COUNT 0x01U
+#define CRC_DMA_CHANNEL DMA_CH26
+#define CRC_DMA_REQLINE 26U
+
+#define CRC_QUEUE_LENGTH 1U
+
+typedef enum { CRC_COMPLETE, CRC_FAILURE } crc_result_t;
+
+static SemaphoreHandle_t crcMutex = NULL;
+static StaticSemaphore_t crcMutexBuffer = {0};
+static QueueHandle_t crcCompleteQueue = NULL;
+
+static crcConfig_t crcConfig = {0};
+static obc_error_code_t requestCrcDmaTransfer(uint32_t startAddress, uint32_t patternCount);
+
+obc_error_code_t obcCrcInit() {
+  crcInit();
+  crcEnableNotification(CRC_BASE, CRC_CH1_CC | CRC_CH1_TO);
+
+  crcMutex = xSemaphoreCreateMutexStatic(&crcMutexBuffer);
+  ASSERT(crcMutex != NULL);
+
+  crcCompleteQueue = xQueueCreate(CRC_QUEUE_LENGTH, sizeof(crc_result_t));
+  ASSERT(crcCompleteQueue != NULL);
+
+  crcConfig.mode = CRC_MODE;
+  crcConfig.crc_channel = CRC_CHANNEL;
+  crcConfig.scount = CRC_SECTOR_COUNT;
+  crcConfig.wdg_preload = CRC_MAX_TIMEOUT;
+  return OBC_ERR_CODE_SUCCESS;
+}
+
+obc_error_code_t performCrcVerification(crc_dma_request_t* request, TickType_t mutexTimeout, TickType_t dmaTimeout) {
+  if (request == NULL) {
+    return OBC_ERR_CODE_INVALID_ARG;
+  }
+
+  if (xSemaphoreTake(crcMutex, mutexTimeout) != pdPASS) {
+    return OBC_ERR_CODE_MUTEX_TIMEOUT;
+  }
+
+  crcConfig.pcount = request->crcElementCount;
+  crcConfig.block_preload = request->crcSeedValue;
+  crcSetConfig(CRC_BASE, &crcConfig);
+  RETURN_IF_ERROR_CODE(requestCrcDmaTransfer((uint32_t)request->crcStartAddress, request->crcElementCount));
+
+  crc_result_t result = 0;
+  obc_error_code_t errCode = OBC_ERR_CODE_SUCCESS;
+  if (xQueueReceive(crcCompleteQueue, &result, dmaTimeout) != pdPASS) {
+    errCode = OBC_ERR_CODE_CRC_DMA_TIMEOUT;
+  }
+
+  if (result != CRC_COMPLETE) {
+    errCode = OBC_ERR_CODE_CRC_INTERRUPT_FAILURE;
+  }
+
+  uint64_t crcResult = crcGetSectorSig(CRC_BASE, CRC_CHANNEL);
+  if (crcResult != request->crcExpectedValue) {
+    errCode = OBC_ERR_CODE_CRC_FAILURE;
+  }
+
+  xSemaphoreGive(crcMutex);
+  return errCode;
+}
+
+void crcNotification(crcBASE_t* crc, uint32 flags) {
+  BaseType_t higherPriorityTaskWoken = pdFALSE;
+
+  crc_result_t crcResult = CRC_FAILURE;
+
+  if (flags & CRC_CH1_CC) {
+    result = CRC_COMPLETE;
+  }
+
+  xQueueSendToBackFromISR(crcCompleteQueue, &crcResult, &higherPriorityTaskWoken);
+  portYIELD_FROM_ISR(higherPriorityTaskWoken);
+}
+
+static obc_error_code_t requestCrcDmaTransfer(uint32_t startAddress, uint32_t patternCount) {
+  g_dmaCTRL dmaCtrlPkt = {0};
+  dmaCtrlPkt.SADD = startAddress;
+  dmaCtrlPkt.DADD = (uint32_t)(&CRC_BASE->PSA_SIGREGH1);
+  dmaCtrlPkt.FRCNT = CRC_DMA_FRAME_COUNT;
+  dmaCtrlPkt.ELCNT = patternCount;
+  dmaCtrlPkt.ADDMODERD = ADDR_INC1;
+  dmaCtrlPkt.ADDMODEWR = ADDR_FIXED;
+  dmaCtrlPkt.PORTASGN = CRC_DMA_PORT;
+  dmaCtrlPkt.RDSIZE = ACCESS_8_BIT;
+  dmaCtrlPkt.WRSIZE = ACCESS_64_BIT;
+  dmaCtrlPkt.TTYPE = FRAME_TRANSFER;
+
+  dmaSetCtrlPacket(CRC_DMA_CHANNEL, dmaCtrlPkt);
+  dmaReqAssign(CRC_DMA_CHANNEL, CRC_DMA_REQLINE);
+  dmaSetChEnable(CRC_CHANNEL, DMA_SW);
+  return OBC_ERR_CODE_SUCCESS;
+}

obc/app/drivers/rm46/obc_crc.h

@@ -0,0 +1,23 @@
+#ifndef __OBC_CRC_H__
+#define __OBC_CRC_H__
+
+#include "obc_errors.h"
+#include <os_portmacro.h>
+#include <stdint.h>
+
+// Default suggested timeout.
+#define OBC_CRC_MUTEX_TIMEOUT pdMS_TO_TICKS(10)
+#define OBC_CRC_DMA_TIMEOUT pdMS_TO_TICKS(15)
+
+typedef struct obc_dma_request {
+  uint32_t crcStartAddress;
+  uint32_t crcElementCount;
+  uint64_t crcSeedValue;
+  uint64_t crcExpectedValue;
+} obc_dma_request_t;
+
+obc_error_code_t obcCrcInit();
+
+obc_error_code_t performCrcVerification(crc_dma_request_t* request, TickType_t mutexTimeout, TickType_t dmaTimeout);
+
+#endif

obc/app/sys/obc_errors.h

@@ -188,4 +188,8 @@ typedef enum {
   /** Operation is not supported. */
   OBC_ERR_CODE_RED_ENOTSUPP = 1524,
 
+  OBC_ERR_CODE_CRC_DMA_TIMEOUT = 1100,
+  OBC_ERR_CODE_CRC_FAILURE,
+  OBC_ERR_CODE_CRC_INTERRUPT_FAILURE
+
 } obc_error_code_t;

obc/bl/CMakeLists.txt

@@ -4,6 +4,8 @@ set(BL_SOURCES
     ${CMAKE_CURRENT_SOURCE_DIR}/bl_main.c
     ${CMAKE_CURRENT_SOURCE_DIR}/source/bl_flash.c
     ${CMAKE_CURRENT_SOURCE_DIR}/source/bl_uart.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/bl_common.c
+    ${CMAKE_CURRENT_SOURCE_DIR}/source/bl_crc.c
     ${CMAKE_CURRENT_SOURCE_DIR}/F021_Flash_API/source/Fapi_UserDefinedFunctions.c
 )
 

obc/bl/bl_main.c

@@ -1,5 +1,6 @@
 #include "bl_config.h"
 #include "bl_flash.h"
+#include "bl_common.h"
 #include "bl_uart.h"
 
 #include <stdio.h>
@@ -21,12 +22,6 @@ extern uint32_t __ramFuncsRunEnd__;
 /* TYPEDEFS */
 typedef void (*appStartFunc_t)(void);
 
-// If this header changes, update the host utility
-typedef struct {
-  uint32_t version;
-  uint32_t size;
-} app_header_t;
-
 typedef enum {
   BL_STATE_IDLE,
   BL_STATE_DOWNLOAD_IMAGE,

obc/bl/include/bl_common.h

@@ -0,0 +1,21 @@
+#ifndef __BL_COMMON__
+#define __BL_COMMON__
+
+#include "bl_errors.h"
+#include <stdint.h>
+
+typedef struct {
+  uint32_t crc32Checksum;
+  uint32_t seed;
+} bl_checksum_t;
+
+// If this header changes, update the host utility
+typedef struct {
+  uint32_t version;
+  uint32_t size;
+  bl_checksum_t blChecksum;
+} app_header_t;
+
+bl_error_code_t verifyBinaryChecksum(app_header_t* header);
+
+#endif

obc/bl/include/bl_crc.h

@@ -0,0 +1,18 @@
+#ifndef __BL_CRC_H__
+#define __BL_CRC_H__
+
+#include "bl_errors.h"
+#include <stdint.h>
+
+typedef struct crc_dma_request {
+  uint32_t crcStartAddress;
+  uint32_t crcElementCount;
+  uint64_t crcSeedValue;
+  uint64_t crcExpectedValue;
+} crc_dma_request_t;
+
+bl_error_code_t blCrcInit();
+
+bl_error_code_t performCrcVerification(crc_dma_request_t* request);
+
+#endif

obc/bl/include/bl_errors.h

@@ -12,4 +12,14 @@ typedef enum {
   BL_ERR_CODE_FAPI_ERASE = 101,
   BL_ERR_CODE_FAPI_PROGRAM = 102,
 
+  BL_ERR_CODE_CRC_FAILURE = 200,
+  BL_ERR_CODE_CRC_TIMEOUT = 201,
 } bl_error_code_t;
+
+#define RETURN_IF_ERROR_CODE(err)      \
+  {                                    \
+    bl_error_code_t _err = err;        \
+    if (_err != BL_ERR_CODE_SUCCESS) { \
+      return err;                      \
+    }                                  \
+  }

obc/bl/source/bl_common.c

@@ -0,0 +1,17 @@
+#include "bl_common.h"
+#include "bl_config.h"
+#include "bl_errors.h"
+#include "bl_crc.h"
+
+#include <stdint.h>
+
+bl_error_code_t verifyBinaryChecksum(app_header_t* header) {
+  crc_dma_request_t request = {0};
+  request.crcStartAddress = (uint32_t)APP_START_ADDRESS;
+  request.crcElementCount = header->size;
+  request.crcSeedValue = header->blChecksum.seed;
+  request.crcExpectedValue = header->blChecksum.crc32Checksum;
+
+  RETURN_IF_ERROR_CODE(performCrcVerification(&request));
+  return BL_ERR_CODE_SUCCESS;
+}

obc/bl/source/bl_crc.c

@@ -0,0 +1,89 @@
+#include "bl_crc.h"
+#include "bl_errors.h"
+
+#include "crc.h"
+#include "reg_crc.h"
+#include "sys_dma.h"
+
+#include <stdint.h>
+
+#define CRC_MAX_TIMEOUT 0x00U  // Setting it to 0, disables the timeout.
+#define CRC_SECTOR_COUNT 0x01U
+#define CRC_CHANNEL CRC_CH1
+#define CRC_MODE CRC_SEMI_CPU
+#define CRC_BASE crcREG
+
+// DMA associated signals
+#define CRC_DMA_PORT 0x04  // Only PORT B seems to be valid
+#define CRC_DMA_FRAME_COUNT 0x01U
+#define CRC_DMA_CHANNEL DMA_CH26
+#define CRC_DMA_REQLINE 26U
+
+static enum { CRC_FLAG_CLEAR, CRC_FLAG_SET } crcCompleteFlag = CRC_FLAG_CLEAR;
+static enum { CRC_TIMED_OUT, CRC_NO_TIMEOUT } crcTimeoutFlag = CRC_NO_TIMEOUT;
+static crcConfig_t crcConfig = {0};
+
+static bl_error_code_t requestCrcDmaTransfer(uint32_t startAddress, uint32_t patternCount);
+
+bl_error_code_t blCrcInit() {
+  crcInit();
+  crcEnableNotification(CRC_BASE, CRC_CH1_CC | CRC_CH1_TO);
+
+  crcCompleteFlag = CRC_FLAG_CLEAR;
+  crcTimeoutFlag = CRC_NO_TIMEOUT;
+
+  crcConfig.mode = CRC_MODE;
+  crcConfig.crc_channel = CRC_CHANNEL;
+  crcConfig.scount = CRC_SECTOR_COUNT;
+  crcConfig.wdg_preload = CRC_MAX_TIMEOUT;
+  return BL_ERR_CODE_SUCCESS;
+}
+
+bl_error_code_t performCrcVerification(crc_dma_request_t* request) {
+  crcConfig.pcount = request->crcElementCount;
+  crcConfig.block_preload = request->crcSeedValue;
+
+  crcSetConfig(CRC_BASE, &crcConfig);
+  RETURN_IF_ERROR_CODE(requestCrcDmaTransfer((uint32_t)request->crcStartAddress, request->crcElementCount));
+
+  while (crcCompleteFlag != CRC_FLAG_SET || crcTimeoutFlag != CRC_TIMED_OUT) continue;
+  if (crcTimeoutFlag == CRC_TIMED_OUT) {
+    return BL_ERR_CODE_CRC_TIMEOUT;
+  }
+
+  uint64_t crcResult = crcGetSectorSig(CRC_BASE, CRC_CHANNEL);
+  if (crcResult != request->crcExpectedValue) {
+    return BL_ERR_CODE_CRC_FAILURE;
+  }
+
+  crcCompleteFlag = CRC_FLAG_CLEAR;
+  crcTimeoutFlag = CRC_NO_TIMEOUT;
+  return BL_ERR_CODE_SUCCESS;
+}
+
+void crcNotification(crcBASE_t* crc, uint32 flags) {
+  if (flags == CRC_CH1_CC) {
+    crcCompleteFlag = CRC_FLAG_SET;
+    return;
+  }
+  crcTimeoutFlag = CRC_TIMED_OUT;
+}
+
+static bl_error_code_t requestCrcDmaTransfer(uint32_t startAddress, uint32_t patternCount) {
+  g_dmaCTRL dmaCtrlPkt = {0};
+  dmaCtrlPkt.SADD = startAddress;
+  dmaCtrlPkt.DADD = (uint32_t)(&CRC_BASE->PSA_SIGREGH1);
+  dmaCtrlPkt.FRCNT = CRC_DMA_FRAME_COUNT;
+  dmaCtrlPkt.ELCNT = patternCount;
+  dmaCtrlPkt.ADDMODERD = ADDR_INC1;
+  dmaCtrlPkt.ADDMODEWR = ADDR_FIXED;
+  dmaCtrlPkt.PORTASGN = CRC_DMA_PORT;
+  dmaCtrlPkt.RDSIZE = ACCESS_8_BIT;
+  dmaCtrlPkt.WRSIZE = ACCESS_64_BIT;
+  dmaCtrlPkt.TTYPE = FRAME_TRANSFER;
+
+  dmaSetCtrlPacket(CRC_DMA_CHANNEL, dmaCtrlPkt);
+  dmaReqAssign(CRC_DMA_CHANNEL, CRC_DMA_REQLINE);
+  dmaSetChEnable(CRC_CHANNEL, DMA_SW);
+  return BL_ERR_CODE_SUCCESS;
+}