增加所有文件

middleware/fee/fee.h

@@ -0,0 +1,161 @@
+/**
+ * @file fee.h
+ *
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ *
+ * Description:
+ *
+ * Revision History:
+ * -----------------
+ */
+
+#ifndef DISK_FEE_H_
+#define DISK_FEE_H_
+
+#define FEE_PAGE_NUMBER_TWO                     2 /* page number, two page schemes are considered to have the highest space utilization */
+#define FEE_PAGE_NUMBER                         FEE_PAGE_NUMBER_TWO
+
+#define FEE_CHAR_BIT                            8 /* char indicates the number of bits */
+
+#define FEE_RECORD_BUFF_SIZE                    0x1000
+
+#define DIVD_NUM(div, rem, coe) ((div) * (coe) + (rem)) /* compute the dividend */
+#define DIV_NUM(num, coe) ((num) / (coe))               /* calculate the divisor */
+#define REM_NUM(num, coe) ((num) % (coe))               /* calculate the remainder */
+
+/* page status type */
+typedef uint32_t fee_page_status_t;
+/* page status definitions */
+#define FEE_PAGE_ERASED                 ((fee_page_status_t)0xFFFFFFFF)     /* PAGE is empty */
+#define FEE_PAGE_RECEIVE                ((fee_page_status_t)0xFFFFFFA5)     /* PAGE is marked to receive data */
+#define FEE_PAGE_ACTIVE                 ((fee_page_status_t)0xFFFFA5A5)     /* PAGE is marked to store new data */
+#define FEE_PAGE_VALID                  ((fee_page_status_t)0xFFA5A5A5)     /* PAGE is full */
+#define FEE_PAGE_ERASING                ((fee_page_status_t)0xA5A5A5A5)     /* PAGE is marked to be erase */
+
+/* page mode type */
+typedef uint32_t fee_page_mode_t;
+#define FEE_PAGE_BLOCK                  ((fee_page_mode_t)0xFFFFA5A5)     /* PAGE mode is block */
+#define FEE_PAGE_EEPROM                 ((fee_page_mode_t)0xA5A5A5A5)     /* PAGE mode is eeprom */
+
+#define FEE_BLOCK_ADDR_BIT_SIZE         (0x10000 >> 0x3)
+
+/* page information */
+struct fee_page_info {
+    fee_page_status_t page_status;
+};
+
+typedef uint64_t disk_addr_t;
+typedef uint64_t disk_size_t;
+
+typedef uint32_t fee_record_status_t;
+typedef uint16_t fee_record_number_t; /* block number range is 64K */
+typedef uint16_t fee_record_length_t; /* block size range is 64K */
+
+/* block status definitions */
+#define FEE_RECORD_ERASED                ((fee_record_status_t)0xFFFFFFFF)     /* block is empty */
+#define FEE_RECORD_INVALID               ((fee_record_status_t)0xFFFFA5A5)     /* block is marked to invalid */
+#define FEE_RECORD_VALID                 ((fee_record_status_t)0xA5A5A5A5)     /* block is marked to valid */
+
+/* record information */
+struct fee_record_info {
+    fee_record_status_t record_status;
+    fee_record_number_t record_num;
+    fee_record_length_t record_len;
+};
+
+/* page information */
+struct fee_page {
+    disk_addr_t
+    page_addr;         /* page start address in the physical layer device, sector_size aligned */
+    disk_size_t page_size;         /* page size,sector_size aligned */
+    uint16_t    page_sector_num;   /* number of sectors in page */
+    uint16_t    page_buff_num;   /* number of sectors in page */
+    fee_page_status_t page_status __ALIGNED(CONFIG_ARCH_CACHE_LINE);
+};
+
+/* address mask index */
+typedef enum {
+    FEE_INFO_BUFF = 0,
+    FEE_DATA_BUFF,
+    FEE_DATA_OFFSET_BUFF,
+    FEE_BUFF_MAX,
+} fee_buff_index;
+
+/* address mask index */
+typedef enum {
+    FEE_ADDR_MASK_BLOCK = 0,
+    FEE_ADDR_MASK_RECORD,
+    FEE_ADDR_MASK_RECORD_CURRENT,
+    FEE_ADDR_MASK_RECORD_TMP,
+    FEE_ADDR_MASK_MAX,
+} fee_addr_mask_index;
+
+#define FEE_ADDR_MASK_PRT(addr, addr_index, addr_size) ((addr) + ((addr_index) * (addr_size)))
+
+struct disk_dev_info {
+    /* disk_dev */
+    void* disk_dev;                 /* disk device */
+    disk_addr_t addr;          /* disk start address */
+    disk_size_t size;          /* disk size */
+    uint16_t mem_align_size;
+    uint16_t access_size;
+    uint32_t sector_size;
+    uint16_t pe_cycles;         /* flash sector erase the life,Unit ten thousand */
+
+    /* disk_ops */
+    int (*disk_read)(void *disk_dev, uint8_t *dst, disk_addr_t addr, disk_size_t size);
+    int (*disk_write)(void *disk_dev, const uint8_t *src, disk_addr_t addr, disk_size_t size);
+    int (*disk_erase)(void *disk_dev, disk_addr_t addr, disk_size_t size);
+};
+
+/* fee device */
+struct fee_dev {
+    struct disk_dev_info *disk_dev;
+
+    /* page info */
+    uint16_t page_number;           /* PAGE_NUMBER */
+    struct fee_page page_info[FEE_PAGE_NUMBER];
+    fee_page_mode_t page_mode;
+
+    /* record info */
+    uint16_t block_number;                  /* block number range, 1 ~ block_number */
+    uint16_t block_length;                  /* single block size range, 1 ~ block_length */
+
+    /* record buff */
+    uint8_t *record_info_buff;              /* used for record information cache, the length is sector_size */
+    uint8_t *record_data_buff;              /* used for record data cache, length sector_size */
+    uint8_t *record_data_offset_buff;       /* used for calculate record data offset, length sector_size */
+    uint16_t record_info_num;               /* number of record info in record_info_buff */
+    uint16_t record_buff_size;              /* record buff size */
+
+    /* fee dev information at run time */
+    uint16_t current_page;                  /* current page page */
+    disk_size_t record_info_offset;         /* current record_info index offset */
+    disk_size_t record_data_offset;         /* current record_data addr offset*/
+
+    /* block addr buff */
+    uint8_t *block_addr_mask;               /* used to store address mask information */
+    uint16_t block_addr_size;               /* number of block addr mask size,block_addr_mask size */
+
+    /* fee record info */
+    struct fee_record_info record_info __ALIGNED(CONFIG_ARCH_CACHE_LINE);
+};
+
+/* fee APIs */
+int fee_init(struct fee_dev *fee_dev);
+int fee_exit(struct fee_dev *fee_dev);
+
+/* fee multiple block operations, length block_length aligned */
+int fee_write_record_multiple(struct fee_dev *fee_dev, uint16_t block_number,
+                              uint8_t *data_buffer, uint16_t length);
+int fee_read_record_multiple(struct fee_dev *fee_dev, uint16_t block_number,
+                             uint8_t *data_buffer, uint16_t length);
+/* fee single block operations,length <= block_length */
+int fee_write_record_single(struct fee_dev *fee_dev, uint16_t block_number,
+                            uint8_t *data_buffer, uint16_t length);
+int fee_read_record_single(struct fee_dev *fee_dev, uint16_t block_number,
+                           uint16_t block_offset, uint8_t *data_buffer, uint16_t length);
+
+#endif /* DISK_MMC_H_ */
+

middleware/fee/fee_block.c

@@ -0,0 +1,85 @@
+/**
+ * @file fee_block.c
+ *
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ *
+ * Description:
+ *
+ * Revision History:
+ * -----------------
+ */
+
+
+#include <debug.h>
+#include <stdlib.h>
+#include <string.h>
+#include <param.h>
+#include <types.h>
+#include <cmsis_os2.h>
+#include <arch/atomic.h>
+#include <stdarg.h>
+
+#include <lib/list.h>
+#include <lib/fee/fee_block.h>
+
+static struct list_node g_fee_list;
+
+static struct fee_block *fee_get_dev(const char *fee_name)
+{
+    struct fee_block *fee_block;
+
+    /* matches nodes based on name */
+    list_for_every_entry(&g_fee_list, fee_block,
+                         struct fee_block, node) {
+        if (!strcmp(fee_name, fee_block->fee_name)) {
+            return fee_block;
+        }
+    }
+    return NULL;
+}
+
+int fee_register_block(struct fee_block *fee)
+{
+    int ret = 0;
+    return ret;
+}
+int fee_unregister_block(struct fee_block *fee)
+{
+    int ret = 0;
+    return ret;
+}
+
+int fee_read_block(const char *fee_name, uint16_t block_number,
+                   uint16_t block_offset, uint8_t *data_buffer, uint16_t length)
+{
+    int ret = 0;
+
+    return ret;
+
+}
+
+int fee_write_block(const char *fee_name, uint16_t block_number,
+                    const uint8_t *data_buffer, uint16_t length)
+{
+    int ret = 0;
+    return ret;
+
+}
+
+int fee_init_block(void)
+{
+    ssdk_printf(SSDK_INFO, "fee block init\n");
+    /* disk list node init */
+    list_initialize(&g_fee_list);
+    return 0;
+}
+
+int fee_exit_block(void)
+{
+    ssdk_printf(SSDK_INFO, "fee block exit\n");
+    /* disk list node init */
+    return 0;
+}
+
+

middleware/fee/fee_block.h

@@ -0,0 +1,59 @@
+/**
+ * @file fee_block.h
+ *
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ *
+ * Description:
+ *
+ * Revision History:
+ * -----------------
+ */
+
+#ifndef DISK_FEE_BLCOK_H_
+#define DISK_FEE_BLCOK_H_
+
+#include "fee.h"
+
+#define FEE_BLOCK_NAME(n) "fee_block"#n
+
+struct fee_config_block {
+    /* nor flash info */
+    const char *disk_name;
+    disk_addr_t addr;           /* nor flash sector_size aligned */
+    disk_size_t size;           /* sector_size * page_number aligned */
+    uint16_t mem_align_size;    /* nor flash read/write memory alignment size */
+    uint16_t access_align_size; /* nor flash access alignment size */
+    uint32_t sector_size;       /* erasing is based on sector_size */
+    uint16_t pe_cycles;         /* flash sector erase the life,Unit ten thousand */
+
+    /* block info */
+    const char *fee_name;
+    uint16_t block_number;      /* number of target virtual blocks */
+    uint16_t block_length;      /* maximum size of the target virtual block, align size access_ALIGN_size */
+    uint32_t block_data_size;   /* target virtual block data size */
+};
+
+struct fee_block {
+    const char *fee_name;
+    struct list_node node;              /* list node */
+    osMutexId_t fee_mutex;
+    struct fee_dev fee_dev;             /* fee device */
+    struct fee_config_block fee_con;    /* fee block config */
+};
+
+/* fee block APIs */
+int fee_init_block(void);
+int fee_init_block(void);
+
+int fee_register_block(struct fee_block *fee);
+int fee_unregister_block(struct fee_block *fee);
+
+/* single block can be accessed */
+int fee_read_block(const char *fee_name, uint16_t block_number,
+                   uint16_t block_offset, uint8_t *data_buffer, uint16_t length);
+int fee_write_block(const char *fee_name, uint16_t block_number,
+                    const uint8_t *data_buffer, uint16_t length);
+
+#endif /* DISK_FEE_BLCOK_H_ */
+

middleware/fee/fee_eeprom.c

@@ -0,0 +1,241 @@
+/**
+ * @file fee_eeprom.c
+ *
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ *
+ * Description:
+ *
+ * Revision History:
+ * -----------------
+ */
+
+
+#include <debug.h>
+#include <stdlib.h>
+#include <string.h>
+#include <param.h>
+#include <types.h>
+#include <stdarg.h>
+
+#include <lib/list.h>
+#include <fee/fee_eeprom.h>
+
+static struct list_node g_fee_list;
+
+static struct fee_eeprom *fee_get_dev(const char *fee_name)
+{
+    struct fee_eeprom *fee_eeprom;
+
+    /* matches nodes based on name */
+    list_for_every_entry(&g_fee_list, fee_eeprom,
+                         struct fee_eeprom, node) {
+        if (!strcmp(fee_name, fee_eeprom->fee_name)) {
+            return fee_eeprom;
+        }
+    }
+    return NULL;
+}
+
+static int fee_eeprom_check(struct fee_config_eeprom *fee_con)
+{
+    struct disk_dev_info *disk_dev = fee_con->disk_dev;
+
+    /* check whether the Flash capacity is supported */
+    uint16_t pe_ratio = ROUNDUP(fee_con->eeprom_pe_cycles,
+                                disk_dev->pe_cycles) / disk_dev->pe_cycles;
+    uint16_t size_avg = fee_con->eeprom_align_size * FEE_EEPROM_SIZE_AVG;
+    disk_size_t target_size = fee_con->eeprom_size * pe_ratio +
+                              (fee_con->eeprom_size / size_avg) * pe_ratio * sizeof(struct fee_record_info);
+
+    if (target_size > disk_dev->size) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee eeprom target_size %llx actual size %llx,space size does not meet the requirements\n",
+                    target_size, disk_dev->size);
+        return -1;
+    }
+
+    ssdk_printf(SSDK_INFO, "fee eeprom target_size %llx actual size %llx\n",
+                target_size, disk_dev->size);
+    return 0;
+}
+
+int fee_register_eeprom(struct fee_eeprom *fee)
+{
+    int ret = 0;
+    struct fee_dev *fee_dev = &fee->fee_dev;
+    struct fee_config_eeprom *fee_con = &fee->fee_con;
+    fee->fee_name = fee_con->fee_name;
+    ssdk_printf(SSDK_INFO, "register fee eeprom device %s\n", fee->fee_name);
+
+    if (NULL != fee_get_dev(fee->fee_name)) {
+        ssdk_printf(SSDK_CRIT, "fee devicve %s already registered\n", fee->fee_name);
+        return -1;
+    }
+
+    /* check the configuration */
+    ret = fee_eeprom_check(fee_con);
+
+    if (ret) {
+        ssdk_printf(SSDK_CRIT, "register fee eeprom device %s\n error", fee->fee_name);
+        return -1;
+    }
+
+    /* insert node */
+    list_add_tail(&g_fee_list, &fee->node);
+
+    fee_dev->disk_dev = fee_con->disk_dev;
+
+    fee_dev->block_length = fee_con->eeprom_align_size;
+    fee_dev->block_number = fee_con->eeprom_size / fee_dev->block_length;
+
+    fee_dev->page_mode = FEE_PAGE_EEPROM;
+
+    fee_dev->block_addr_mask = fee_con->block_addr_mask;
+    fee_dev->block_addr_size = fee_con->block_addr_size;
+
+    ret = fee_init(fee_dev);
+
+    if (ret) {
+        ssdk_printf(SSDK_CRIT, "fee eeprom %s init faild\n", fee->fee_name);
+        goto error;
+    }
+
+    return ret;
+
+error:
+    if (list_in_list(&fee->node))
+        list_delete(&fee->node);
+    return ret;
+}
+int fee_unregister_eeprom(struct fee_eeprom *fee)
+{
+    int ret = 0;
+    struct fee_dev *fee_dev = &fee->fee_dev;
+    ssdk_printf(SSDK_INFO, "unregiste fee eeprom device %s\n", fee->fee_name);
+    fee->fee_name = NULL;
+
+    /* remove nodes */
+    if (list_in_list(&fee->node))
+        list_delete(&fee->node);
+
+    fee_exit(fee_dev);
+    return ret;
+}
+
+int fee_read_eeprom(const char *fee_name, uint32_t addr, uint8_t *data_buffer,
+                    uint16_t length)
+{
+    int ret = 0;
+    struct fee_eeprom *fee = fee_get_dev(fee_name);
+
+    if (NULL == fee) {
+        ssdk_printf(SSDK_CRIT, "no fee devicve %s\n", fee_name);
+        return -1;
+    }
+
+    ssdk_printf(SSDK_INFO, "read fee eeprom device %s addr:%x length:%x\n", fee->fee_name, addr, length);
+    struct fee_dev *fee_dev = &fee->fee_dev;
+    struct fee_config_eeprom *fee_con = &fee->fee_con;
+
+    if (!IS_ALIGNED(addr, fee_dev->block_length)) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_read eeprom addr %d not aligned to record_length %d\n",
+                    addr, fee_dev->block_length);
+        return -1;
+    }
+
+    uint16_t block_number = addr / fee_dev->block_length;
+
+    if (!IS_ALIGNED(length, fee_dev->block_length)) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_read eeprom length %d not aligned to record_length %d\n",
+                    length, fee_dev->block_length);
+        return -1;
+    }
+
+    if ((addr + length) > fee_con->eeprom_size) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_read eeprom addr %d length %d more than eeprom capacity %d\n",
+                    addr, length, fee_con->eeprom_size);
+        return -1;
+    }
+
+    ret = fee_read_record_multiple(fee_dev, block_number, data_buffer, length);
+
+    if (ret) {
+        ssdk_printf(SSDK_CRIT, "fee_read_record_multiple fee_name %s addr %d error\n",
+                    fee_name, addr);
+        return -1;
+    }
+
+    return ret;
+
+}
+
+int fee_write_eeprom(const char *fee_name, uint32_t addr,
+                     const uint8_t *data_buffer, uint16_t length)
+{
+    int ret = 0;
+    struct fee_eeprom *fee = fee_get_dev(fee_name);
+
+    if (NULL == fee) {
+        ssdk_printf(SSDK_CRIT, "no fee devicve %s\n", fee_name);
+        return -1;
+    }
+
+    struct fee_dev *fee_dev = &fee->fee_dev;
+
+    struct fee_config_eeprom *fee_con = &fee->fee_con;
+
+    ssdk_printf(SSDK_INFO, "write fee eeprom device %s addr:%x length:%x\n", fee->fee_name, addr, length);
+
+    if (!IS_ALIGNED(addr, fee_dev->block_length)) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_write eeprom addr %d not aligned to record_length %d\n",
+                    addr, fee_dev->block_length);
+        return -1;
+    }
+
+    uint16_t block_number = addr / fee_dev->block_length;
+
+    if (!IS_ALIGNED(length, fee_dev->block_length)) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_write eeprom length %d not aligned to record_length %d\n",
+                    length, fee_dev->block_length);
+        return -1;
+    }
+
+    if ((addr + length) > fee_con->eeprom_size) {
+        ssdk_printf(SSDK_CRIT,
+                    "fee_write eeprom addr %d length %d more than eeprom capacity %d\n",
+                    addr, length, fee_con->eeprom_size);
+        return -1;
+    }
+
+    ret = fee_write_record_multiple(fee_dev, block_number, (uint8_t *)data_buffer,
+                                    length);
+
+    if (ret) {
+        ssdk_printf(SSDK_CRIT, "fee_write_record_multiple fee_name %s addr %d error\n",
+                    fee_name, addr);
+        return -1;
+    }
+
+    return ret;
+}
+
+int fee_init_eeprom(void)
+{
+    ssdk_printf(SSDK_INFO, "fee eeprom init\n");
+    /* disk list node init */
+    list_initialize(&g_fee_list);
+    return 0;
+}
+
+int fee_exit_eeprom(void)
+{
+    ssdk_printf(SSDK_INFO, "fee eeprom exit\n");
+    /* disk list node init */
+    return 0;
+}

middleware/fee/fee_eeprom.h

@@ -0,0 +1,60 @@
+/**
+ * @file fee_eeprom.h
+ *
+ * Copyright (c) 2022 Semidrive Semiconductor.
+ * All rights reserved.
+ *
+ * Description:
+ *
+ * Revision History:
+ * -----------------
+ */
+
+#ifndef DISK_FEE_EEPROM_H_
+#define DISK_FEE_EEPROM_H_
+
+#include "fee.h"
+#include <lib/list.h>
+
+#define FEE_EEPROM_NAME(n) "fee_eeprom"#n
+
+#define FEE_EEPROM_SIZE_AVG 2   /* average access size,unit is eeprom_align_size */
+
+struct fee_config_eeprom {
+    /* nor flash info */
+    struct disk_dev_info *disk_dev;
+
+    /* eeprom info */
+    const char *fee_name;
+    uint16_t eeprom_size;      /* The capacity of the virtual EEPROM */
+    uint16_t eeprom_align_size;/* virtual EEPROM access alignment size, alignment access_align_size */
+    uint16_t eeprom_pe_cycles; /* virtual EEPROM lifetime */
+
+    /* block addr buff */
+    uint8_t *block_addr_mask;               /* used to store block_addr mask */
+    uint16_t block_addr_size;               /* block_addr buff size */
+    uint16_t block_addr_num;                /* block_addr buff number */
+};
+
+struct fee_eeprom {
+    const char *fee_name;
+    struct list_node node;              /* list node */
+    struct fee_dev fee_dev;             /* fee device */
+    struct fee_config_eeprom fee_con;   /* fee eeprom config */
+};
+
+/* fee eeprom APIs */
+int fee_init_eeprom(void);
+int fee_exit_eeprom(void);
+
+int fee_register_eeprom(struct fee_eeprom *fee);
+int fee_unregister_eeprom(struct fee_eeprom *fee);
+
+/* access to multiple blocks, address and length must be aligned eeprom_align_size */
+int fee_read_eeprom(const char *fee_name, uint32_t addr, uint8_t *data_buffer,
+                    uint16_t length);
+int fee_write_eeprom(const char *fee_name, uint32_t addr,
+                     const uint8_t *data_buffer, uint16_t length);
+
+#endif /* DISK_FEE_EEPROM_H_ */
+