hal_nv.h

Go to the documentation of this file.

#ifndef HAL_NV_H_
#define HAL_NV_H_

#include <stdbool.h>
#include "hal_config.h"
#include "hal_os.h"
#include "hal_bp.h"

#if !defined(HAL_ENABLE_OS) || (HAL_ENABLE_OS == 0)
#error "OS support has to be enabled to be able to use NVMEM!"
#endif

#if !defined(HAL_ENABLE_BP) || (HAL_ENABLE_BP == 0)
#error "Buffer pool support has to be enabled to be able to use NVMEM!"
#endif


#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)
#if defined(HAL_NV_USE_SEM_TO_PROCESS_IDLE) && (HAL_NV_USE_SEM_TO_PROCESS_IDLE != 0)
/*
 * Counting semaphores (up to number of entries in requests queue)
 * initially semaphore should have counter set to 0 (no entries available)
 */
#define HAL_NV_WAIT_SEM_PTR_DECLARE(name)   OSCntSem name
#endif /* defined(HAL_NV_USE_SEM_TO_PROCESS_IDLE) && (HAL_NV_USE_SEM_TO_PROCESS_IDLE != 0) */
#endif /* defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0) */


#if defined(HAL_NV_USE_SEM_TO_PROCESS_IDLE) && (HAL_NV_USE_SEM_TO_PROCESS_IDLE != 0)
#if !defined(HAL_NV_USE_WORKER_TASK) || (HAL_NV_USE_WORKER_TASK == 0)
#warning "The HAL_NV_USE_SEM_TO_PROCESS_IDLE macro definition has no effect!"
#undef HAL_NV_USE_SEM_TO_PROCESS_IDLE
#endif
#endif

typedef enum {
    NVOP_OK,
    NVOP_IN_PROGRESS,
    NVOP_BAD_REQUEST,
    NVOP_NO_SEM_AVAIL,
    NVOP_NO_BUF_AVAIL,
    NVOP_TOO_MANY_REQ,
    NVOP_DEVOP_RD_ERR,
    NVOP_DEVOP_WR_ERR,
    NVOP_DEVOP_ER_ERR,
    NVOP_LOCKED
} NV_OpResult;

typedef uint32_t NV_Addressable;

typedef uint32_t NV_DevId;

struct NV_Memory_Tag;
typedef struct NV_Memory_Tag* NV_Memory;


#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)

struct NV_SemaphorePool_Tag;
typedef struct NV_SemaphorePool_Tag* NV_SemaphorePool;

struct NV_RequestQueue_Tag;
typedef struct NV_RequestQueue_Tag* NV_RequestQueue;

#endif /* defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0) */

typedef struct NV_AddressMap_Tag
{
    NV_Addressable start_addr;
    NV_Addressable end_addr;
    NV_Addressable write_len_unit;
} NV_AddressMap_T;

typedef NV_AddressMap_T* NV_AddressMap;


typedef struct NV_MemPeripheral_Tag
{
    void (*init)(NV_Memory dev);
    void (*deinit)(NV_Memory dev);
    NV_OpResult (*read)(NV_Memory dev, NV_Addressable addr, NV_Addressable size, void* dst);
    NV_OpResult (*write)(NV_Memory dev, NV_Addressable addr, const void* src);
    NV_OpResult (*erase)(NV_Memory dev);
} NV_MemPeripheral_T;

typedef NV_MemPeripheral_T* NV_MemPeripheral;

typedef struct NV_MemDevice_Tag
{
    NV_Memory* devices;
    uint32_t no_devices;
#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)
    NV_RequestQueue dev_requests;
    NV_SemaphorePool dev_semaphores;
    BP_BufferPool buf_pool;
#endif
    uint8_t* page_buffer;
    volatile bool op_in_progress;
    bool was_init;
    volatile bool lock;
#if defined(HAL_NV_USE_SEM_TO_PROCESS_IDLE) && (HAL_NV_USE_SEM_TO_PROCESS_IDLE != 0)
    HAL_NV_WAIT_SEM_PTR_DECLARE(req_queue_sem);
#endif
} NV_MemDevice_T;

typedef NV_MemDevice_T* NV_MemDevice;

typedef struct NV_Memory_Tag
{
    NV_MemDevice parent_dev;
    NV_AddressMap mem_map;
    void* phy_data;
    NV_MemPeripheral ops;
} NV_Memory_T;



#define NV_INIT_MEMORY(mem_map, phy_data, dev_ops)  { NULL, &(mem_map), (void*)(phy_data), &(dev_ops) }

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)
#if defined(HAL_NV_USE_SEM_TO_PROCESS_IDLE) && (HAL_NV_USE_SEM_TO_PROCESS_IDLE != 0)
#define NV_INIT_MEMDEVICE(devs, no_devs)                { (devs), (no_devs), NULL, NULL, NULL, NULL, false, false, false, NULL }
#else
#define NV_INIT_MEMDEVICE(devs, no_devs)                { (devs), (no_devs), NULL, NULL, NULL, NULL, false, false, false }
#endif
#else
#define NV_INIT_MEMDEVICE(devs, no_devs)                { (devs), (no_devs), NULL, false, false, false }
#endif

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)
void NV_MemDeviceInit(NV_MemDevice mdev, uint8_t* buffer, uint32_t req_queue_len, uint32_t sem_pool_len, BP_BufferPool bpool);
#else
void NV_MemDeviceInit(NV_MemDevice mdev, uint8_t* buffer);
#endif

void NV_MemDeviceDeInit(NV_MemDevice mdev);

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)
NV_OpResult NV_MemDeviceLock(NV_MemDevice mdev, bool flush);
#else
NV_OpResult NV_MemDeviceLock(NV_MemDevice mdev);
#endif

void NV_MemDeviceUnlock(NV_MemDevice mdev);

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)

void NV_ProcessRequests(NV_MemDevice mdev);
#endif

NV_OpResult NV_ReadSync(NV_Memory nv_mem, NV_Addressable addr, NV_Addressable size, void* dst);

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)

NV_OpResult NV_WriteAsync(NV_Memory nv_mem, NV_Addressable addr, NV_Addressable size, const void* src, volatile NV_OpResult* result);
#endif

NV_OpResult NV_WriteSync(NV_Memory nv_mem, NV_Addressable addr, NV_Addressable size, const void* src);

#if defined(HAL_NV_USE_WORKER_TASK) && (HAL_NV_USE_WORKER_TASK != 0)

NV_OpResult NV_Flush(NV_Memory nv_mem);
#endif

NV_OpResult NV_Erase(NV_Memory nv_mem);

#endif /* HAL_NV_H_ */