memory.h

Go to the documentation of this file.

 
#ifndef _MEMORY_H
#define _MEMORY_H
 
// Dependencies
#include "boot_config.h"
#include "core/flash.h"
#include "os_port.h"
 
#include <stdint.h>
#include <stdlib.h>
 
#include "core/cboot_error.h"
#include "error.h"
 
/*
 *
 * Memory is the abstraction layer between hardware and the library.
 * Inside a memory, there could be one or more slots. Depending on the
 * type of the slot and the way it is implemented within a "memory", it
 * shall expose different APIs and structs.
 *
 */
 
// Number of memories used
#ifndef NB_MEMORIES
#define NB_MEMORIES 1
#elif (NB_MEMORIES < 1)
#error NB_MEMORIES parameter is not valid
#endif
 
// Maximum number of slots per memoriess
#ifndef NB_MAX_MEMORY_SLOTS
#define NB_MAX_MEMORY_SLOTS 2
#elif (NB_MAX_MEMORY_SLOTS < 1)
#error NB_MEMORIES parameter is not valid
#endif
 
// File system layer memory support
#ifndef MEMORIES_FS_SUPPORT
#define MEMORIES_FS_SUPPORT DISABLED
#elif ((MEMORIES_FS_SUPPORT != DISABLED) && (MEMORIES_FS_SUPPORT != ENABLED))
#error MEMORIES_FS_SUPPORT parameter is not valid
#endif
 
// External memory support
#ifndef EXTERNAL_MEMORY_SUPPORT
#define EXTERNAL_MEMORY_SUPPORT DISABLED
#elif ((EXTERNAL_MEMORY_SUPPORT != DISABLED) && (EXTERNAL_MEMORY_SUPPORT != ENABLED))
#error EXTERNAL_MEMORY_SUPPORT parameter is not valid
#endif
 
#if (MEMORIES_FS_SUPPORT == ENABLED)
#include "core/fs.h"
#endif
 
// C++ guard
#ifdef __cplusplus
extern "C"
{
#endif
 
typedef enum
{
   MEMORY_TYPE_FLASH,      // FLASH
#if (MEMORIES_FS_SUPPORT == ENABLED)
   MEMORY_TYPE_FS,      // File system type abstraction
#endif
   MEMORY_TYPE_EEPROM      // EEPROM
} MemoryType;
 
typedef enum
{
   MEMORY_ROLE_PRIMARY,       // Primary memory, most likely internal Flash
   MEMORY_ROLE_SECONDARY      // Secondary memory, most likely an external memory
} MemoryRole;
 
typedef enum
{
   MEMORY_STATUS_BUSY,
   MEMORY_STATUS_ERROR,
   MEMORY_STATUS_OK
} MemoryStatus;
 
typedef enum
{
   MEMORY_WRITE_DEFAULT_FLAG,
   MEMORY_WRITE_FORCE_FLAG,
   MEMORY_WRITE_RESET_FLAG
} MemoryWriteFlag;
 
typedef enum
{
   SLOT_TYPE_DIRECT = 1,      // FLASH
#if (MEMORIES_FS_SUPPORT == ENABLED)
   SLOT_TYPE_FILE,      // File system type abstraction
#endif
} SlotType;
 
typedef enum
{
   SLOT_STATUS_BUSY,
   SLOT_STATUS_ERROR,
   SLOT_STATUS_OK
} SlotStatus;
 
typedef enum
{
   SLOT_CONTENT_NONE = 0x00,               // Each value has its own bit
   SLOT_CONTENT_APP = 0x01,                //
   SLOT_CONTENT_UPDATE = 0x02,             //
   SLOT_CONTENT_BACKUP = 0x04,             //
   SLOT_CONTENT_BINARY = 0x08,             //
   SLOT_CONTENT_DATA = 0x10,               //
   SLOT_CONTENT_CONFIGURATION = 0x20,      //
   SLOT_CONTENT_BOOT = 0x40,               //
   SLOT_CONTENT_FACTORY = 0x80             // Standalone only for now; never an update target
} SlotContentType;
 
typedef struct
{
   SlotType type;
   uint8_t cType;
   const void *memParent;
 
   __packed_union
   {
      __packed_struct
      {
         uint32_t addr;
         size_t size;
      } /*flash*/;
#if (MEMORIES_FS_SUPPORT == ENABLED)
      __packed_struct
      {
         const char *path;
         const char *mode;
         FsFileHandler *file;
      } /*filesystem*/;
#endif
   } /*memory*/;
 
} Slot;
 
typedef struct
{
   uint32_t addr;
   size_t size;
   uint32_t bank1Addr;
   uint32_t bank2Addr;
   size_t bankSize;
   size_t writeSize;
   uint32_t flags;
} MemoryInfo;
 
typedef struct
{
   MemoryType memoryType;
   void *memoryInfo;
   Slot slots[NB_MAX_MEMORY_SLOTS];
   uint8_t nbSlots;
   const void *driver;
   MemoryRole memoryRole;
} Memory;
 
cboot_error_t memoryInit(Memory *memories, size_t nbMemories);
 
cboot_error_t memoryDeInit(Memory *memories, size_t nbMemories);
 
cboot_error_t memoryGetInfo(Memory *memory, MemoryInfo *info);
 
cboot_error_t memoryGetSlotStatus(Slot *slot, SlotStatus *status);
 
cboot_error_t memoryWriteSlot(Slot *slot, uint32_t offset, uint8_t *buffer, size_t length,
   size_t *written, uint8_t flag);
 
cboot_error_t memoryReadSlot(Slot *slot, uint32_t offset, uint8_t *buffer, size_t length);
 
cboot_error_t memoryEraseSlot(Slot *slot, uint32_t offset, size_t length);
 
cboot_error_t memoryCopySlot(Slot *src, Slot *dst, size_t bytesNumber);
 
void memoryCompareSlot(Slot *src, Slot *dst, uint8_t *result);
 
cboot_error_t memoryCompareSlotContent(Slot *src, Slot *dst, uint8_t *result);
 
cboot_error_t memoryCleanup(Memory *memories, size_t nbMemories);
 
cboot_error_t memoryGetSlotByCType(Memory *memory, uint8_t slotCType, Slot **slot);
cboot_error_t memoryGetMemoryByRole(Memory *memories, size_t nb_memories, MemoryRole role,
   Memory **memory);
 
void memoryInitWriteBuffer(void);
void memoryResetWriteBuffer(void);
 
// Include Extended Memory routines
#include "memory_ex.h"
 
// C++ guard
#ifdef __cplusplus
}
#endif
#endif //_MEMORY_H