IOT-OS之RT-Thread（十一）--- FAL分区管理与easyflash变量管理

最新推荐文章于 2024-08-08 07:06:01 发布

流云IoT

最新推荐文章于 2024-08-08 07:06:01 发布

阅读量1.3w

点赞数 28

分类专栏：操作系统 STM32 流云的博客文章标签： FAL partition easyflash DFS RT-Thread

本文链接：https://blog.csdn.net/m0_37621078/article/details/102689903

版权

本文详细介绍了如何在RT-Thread物联网操作系统中使用FAL（Flash Abstraction Layer）进行分区管理和Easyflash进行环境变量管理。首先，文章阐述了FAL的管理与示例，包括FAL软件包的获取、管理、移植和使用。接着，展示了如何将DFS文件系统挂载到FAL分区。然后，讲解了Easyflash的移植，包括源码获取、环境变量管理和移植步骤。最后，给出了Easyflash的使用示例，演示了如何初始化、设置和保存环境变量。

摘要由CSDN通过智能技术生成

一、FAL管理与示例

FAL (Flash Abstraction Layer) Flash 抽象层，是对 Flash 及基于 Flash 的分区进行管理、操作的抽象层，对上层统一了 Flash 及分区操作的 API ，FAL 框架图如下：
FAL框架图
从上图可以看出FAL抽象层位于SFUD框架的上层，可以将多个Flash硬件（包括片内Flash和片外Flash）统一进行管理，并向上层比如DFS文件系统层提供对底层多个Flash硬件的统一访问接口，方便上层应用对底层硬件的访问操作。

1.1 FAL软件包源码获取

从Github下载的RT-Thread源码中并没有FAL软件包的源码，我们可以通过git工具获取，menuconfig中也配置了FAL软件包的配置项，在配置项内有FAL软件包的下载地址等信息，我们配置启用FAL软件包后即可通过git工具（前提是需要安装并配置后Git工具）自动下载FAL软件包源码到工程目录。

在前篇博客的工程目录stm32l475_dfs_sample中打开env环境，运行menuconfig命令，启用FAL配置界面如下：
启用FAL软件包的配置界面
启用FAL软件包后出现更多选项，我们想使用FAL管理STM32L475片内Flash和W25Q128 Flash，其中W25Q128使用SFUD框架驱动，在启用FAL软件包后，我们可以选择使用SFUD驱动，SFUD设备名默认为norflash0，可以更改设备名为W25Q128，使用SFUD驱动的配置界面如下：
FAL使用SFUD的配置界面
保存配置退出后，在env环境执行pkgs --update命令，会自动从FAL的github仓库获取FAL软件包源码到本地工程目录，如下图所示：

获取到的FAL软件包目录结构如下：
FAL目录结构

1.2 FAL管理

FAL既然是对多个Flash设备进行分区管理的，自然会对Flash设备和分区有相应的数据结构描述。

FAL设备与分区控制块

FAL设备与FAL分区的描述结构体如下：

// projects\stm32l475_dfs_sample\packages\fal-latest\inc\fal_def.h

/* FAL flash and partition device name max length */
#ifndef FAL_DEV_NAME_MAX
#define FAL_DEV_NAME_MAX 24
#endif

struct fal_flash_dev
{
   
    char name[FAL_DEV_NAME_MAX];

    /* flash device start address and len  */
    uint32_t addr;
    size_t len;
    /* the block size in the flash for erase minimum granularity */
    size_t blk_size;

    struct
    {
   
        int (*init)(void);
        int (*read)(long offset, uint8_t *buf, size_t size);
        int (*write)(long offset, const uint8_t *buf, size_t size);
        int (*erase)(long offset, size_t size);
    } ops;
};
typedef struct fal_flash_dev *fal_flash_dev_t;

/**
 * FAL partition
 */
struct fal_partition
{
   
    uint32_t magic_word;

    /* partition name */
    char name[FAL_DEV_NAME_MAX];
    /* flash device name for partition */
    char flash_name[FAL_DEV_NAME_MAX];

    /* partition offset address on flash device */
    long offset;
    size_t len;

    uint32_t reserved;
};
typedef struct fal_partition *fal_partition_t;

fal_flash_dev结构体除了包含设备名、起始地址、长度、块大小等对flash设备的描述参数，还包括对flash设备的操作函数指针，这些操作函数需要在移植FAL时由下层的驱动实现。

fal_partition结构体则包含分区名、设备名、分区在设备上的偏移地址和长度等，从该结构体定义也可以看出，一个fal_partition分区不能跨flash设备分配。

FAL初始化过程

了解FAL原理，先从FAL组件初始化过程开始：

// projects\stm32l475_dfs_sample\packages\fal-latest\src\fal.c

/**
 * FAL (Flash Abstraction Layer) initialization.
 * It will initialize all flash device and all flash partition.
 *
 * @return >= 0: partitions total number
 */
int fal_init(void)
{
   
    extern int fal_flash_init(void);
    extern int fal_partition_init(void);

    int result;

    /* initialize all flash device on FAL flash table */
    result = fal_flash_init();

    if (result < 0) {
   
        goto __exit;
    }

    /* initialize all flash partition on FAL partition table */
    result = fal_partition_init();

__exit:

    if ((result > 0) && (!init_ok))
    {
   
        init_ok = 1;
        log_i("RT-Thread Flash Abstraction Layer (V%s) initialize success.", FAL_SW_VERSION);
    }
    else if(result <= 0)
    {
   
        init_ok = 0;
        log_e("RT-Thread Flash Abstraction Layer (V%s) initialize failed.", FAL_SW_VERSION);
    }

    return result;
}


// projects\stm32l475_dfs_sample\packages\fal-latest\src\fal_flash.c

static const struct fal_flash_dev * const device_table[] = FAL_FLASH_DEV_TABLE;
static const size_t device_table_len = sizeof(device_table) / sizeof(device_table[0]);
static uint8_t init_ok = 0;

/**
 * Initialize all flash device on FAL flash table
 *
 * @return result
 */
int fal_flash_init(void)
{
   
    size_t i;

    if (init_ok)
    {
   
        return 0;
    }

    for (i = 0; i < device_table_len; i++)
    {
   
        assert(device_table[i]->ops.read);
        assert(device_table[i]->ops.write);
        assert(device_table[i]->ops.erase);
        /* init flash device on flash table */
        if (device_table[i]->ops.init)
        {
   
            device_table[i]->ops.init();
        }
        ......
    }
    init_ok = 1;
    return 0;
}


// projects\stm32l475_dfs_sample\packages\fal-latest\src\fal_partition.c

USED static const struct fal_partition partition_table_def[] SECTION("FalPartTable") = FAL_PART_TABLE;
static const struct fal_partition *partition_table = NULL;

/**
 * Initialize all flash partition on FAL partition table
 *
 * @return partitions total number
 */
int fal_partition_init(void)
{
   
    size_t i;
    const struct fal_flash_dev *flash_dev = NULL;

    if (init_ok)
    {
   
        return partition_table_len;
    }

#ifdef FAL_PART_HAS_TABLE_CFG
    partition_table = &partition_table_def[0];
    partition_table_len = sizeof(partition_table_def) / sizeof(partition_table_def[0]);
#else
    /* load partition table from the end address FAL_PART_TABLE_END_OFFSET, error return 0 */
    long part_table_offset = FAL_PART_TABLE_END_OFFSET;
    size_t table_num = 0, table_item_size = 0;
    uint8_t part_table_find_ok = 0;
    uint32_t read_magic_word;
    fal_partition_t new_part = NULL;

    flash_dev = fal_flash_device_find(FAL_PART_TABLE_FLASH_DEV_NAME);
    if (flash_dev == NULL)
    {
   
        log_e("Initialize failed! Flash device (%s) NOT found.", FAL_PART_TABLE_FLASH_DEV_NAME);
        goto _exit;
    }

    /* check partition table offset address */
    if (part_table_offset < 0 || part_table_offset >= (long) flash_dev->len)
    {
   
        log_e("Setting partition table end offset address(%ld) out of flash bound(<%d).", part_table_offset, flash_dev->len);
        goto _exit;
    }

    table_item_size = sizeof(struct fal_partition);
    new_part = (fal_partition_t)FAL_MALLOC(table_item_size);
    if (new_part == NULL)
    {
   
        log_e("Initialize failed! No memory for table buffer.");
        goto _exit;
    }

    /* find partition table location */
    {
   
        uint8_t read_buf[64];

        part_table_offset -= sizeof(read_buf);
        while (part_table_offset >= 0)
        {
   
            if (flash_dev->ops.read(part_table_offset, read_buf, sizeof(read_buf)) > 0)
            {
   
                /* find magic word in read buf */
                for (i = 0; i < sizeof(read_buf) - sizeof(read_magic_word) + 1; i++)
                {
   
                    read_magic_word = read_buf[0 + i] + (read_buf[1 + i] << 8) + (read_buf[2 + i] << 16) + (read_buf[3 + i] << 24);
                    if (read_magic_word == ((FAL_PART_MAGIC_WORD_H << 16) + FAL_PART_MAGIC_WORD_L))
                    {
   
                        part_table_find_ok = 1;
                        part_table_offset += i;
                        log_d("Find the partition table on '%s' offset @0x%08lx.", FAL_PART_TABLE_FLASH_DEV_NAME,
                                part_table_offset);
                        break;
                    }
                }
            }
            else
            {
   
                /* read failed */
                break;
            }

            if (part_table_find_ok)
            {
   
                break;
            }
            else
            {
   
                /* calculate next read buf position */
                if (part_table_offset >= (long)sizeof(read_buf))
                {
   
                    part_table_offset -= sizeof(read_buf);
                    part_table_offset += (sizeof(read_magic_word) - 1);
                }
                else if (part_table_offset != 0)
                {
   
                    part_table_offset = 0;
                }
                else
                {
   
                    /* find failed */
                    break;
                }
            }
        }
    }

    /* load partition table */
    while (part_table_find_ok)
    {
   
        memset(new_part, 0x00, table_num);
        if (flash_dev->ops.read(part_table_offset - table_item_size * (table_num), (uint8_t *) new_part,
                table_item_size) < 0)
        {
   
            log_e("Initialize failed! Flash device (%s) read error!", flash_dev->name);
            table_num = 0;
            break;
        }

        if (new_part->magic_word != ((FAL_PART_MAGIC_WORD_H << 16) + FAL_PART_MAGIC_WORD_L))
        {
   
            break;
        }

        partition_table = (fal_partition_t) FAL_REALLOC(partition_table, table_item_size * (table_num + 1));
        if (partition_table == NULL)
        {