1.将A27新UI文件夹重命名为CANUI 2.A272O新版本发布

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/inc/easyflash.h

@@ -0,0 +1,107 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2014-2019, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: It is an head file for this library. You can see all be called functions.
+ * Created on: 2014-09-10
+ */
+
+
+#ifndef EASYFLASH_H_
+#define EASYFLASH_H_
+
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <ef_cfg.h>
+#include <ef_def.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* easyflash.c */
+EfErrCode easyflash_init(void);
+
+#ifdef EF_USING_ENV
+/* only supported on ef_env.c */
+size_t ef_get_env_blob(const char *key, void *value_buf, size_t buf_len, size_t *saved_value_len);
+bool ef_get_env_obj(const char *key, env_node_obj_t env);
+size_t ef_read_env_value(env_node_obj_t env, uint8_t *value_buf, size_t buf_len);
+EfErrCode ef_set_env_blob(const char *key, const void *value_buf, size_t buf_len);
+
+/* ef_env.c, ef_env_legacy_wl.c and ef_env_legacy.c */
+EfErrCode ef_load_env(void);
+void ef_print_env(void);
+char *ef_get_env(const char *key);
+EfErrCode ef_set_env(const char *key, const char *value);
+EfErrCode ef_del_env(const char *key);
+EfErrCode ef_save_env(void);
+EfErrCode ef_env_set_default(void);
+size_t ef_get_env_write_bytes(void);
+EfErrCode ef_set_and_save_env(const char *key, const char *value);
+EfErrCode ef_del_and_save_env(const char *key);
+#endif
+
+#ifdef EF_USING_IAP
+/* ef_iap.c */
+EfErrCode ef_erase_bak_app(size_t app_size);
+EfErrCode ef_erase_user_app(uint32_t user_app_addr, size_t user_app_size);
+EfErrCode ef_erase_spec_user_app(uint32_t user_app_addr, size_t app_size,
+                                 EfErrCode (*app_erase)(uint32_t addr, size_t size));
+EfErrCode ef_erase_bl(uint32_t bl_addr, size_t bl_size);
+EfErrCode ef_write_data_to_bak(uint8_t *data, size_t size, size_t *cur_size,
+                               size_t total_size);
+EfErrCode ef_copy_app_from_bak(uint32_t user_app_addr, size_t app_size);
+EfErrCode ef_copy_spec_app_from_bak(uint32_t user_app_addr, size_t app_size,
+                                    EfErrCode (*app_write)(uint32_t addr, const uint32_t *buf, size_t size));
+EfErrCode ef_copy_bl_from_bak(uint32_t bl_addr, size_t bl_size);
+uint32_t ef_get_bak_app_start_addr(void);
+#endif
+
+#ifdef EF_USING_LOG
+/* ef_log.c */
+EfErrCode ef_log_read(size_t index, uint32_t *log, size_t size);
+EfErrCode ef_log_write(const uint32_t *log, size_t size);
+EfErrCode ef_log_clean(void);
+size_t ef_log_get_used_size(void);
+#endif
+
+/* ef_utils.c */
+uint32_t ef_calc_crc32(uint32_t crc, const void *buf, size_t size);
+
+/* ef_port.c */
+EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size);
+EfErrCode ef_port_erase(uint32_t addr, size_t size);
+EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size);
+void ef_port_env_lock(void);
+void ef_port_env_unlock(void);
+void ef_log_debug(const char *file, const long line, const char *format, ...);
+void ef_log_info(const char *format, ...);
+void ef_print(const char *format, ...);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EASYFLASH_H_ */

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/inc/ef_cfg.h

@@ -0,0 +1,102 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2015-2019, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: It is the configure head file for this library.
+ * Created on: 2015-07-14
+ */
+
+
+#ifndef EF_CFG_H_
+#define EF_CFG_H_
+
+#include <board.h>
+
+/* using ENV function */
+#ifdef EASYFLASH_ENV
+#define EF_USING_ENV
+
+#ifdef EASYFLASH_ENV_AUTO_UPDATE
+/* Auto update ENV to latest default when current ENV version number is changed. */
+#define EF_ENV_AUTO_UPDATE
+/**
+ * ENV version number defined by user.
+ * Please change it when your firmware add a new ENV to default_env_set.
+ */
+#define EF_ENV_VER_NUM            EASYFLASH_ENV_VER_NUM
+#endif
+
+#endif /* EASYFLASH_ENV */
+
+/* using IAP function */
+#ifdef EASYFLASH_IAP
+#define EF_USING_IAP
+#endif
+
+/* using save log function */
+#ifdef EASYFLASH_LOG
+#define EF_USING_LOG
+/* saved log area size */
+#define LOG_AREA_SIZE             (EASYFLASH_LOG_AREA_SIZE)
+#endif
+
+/* the minimum size of flash erasure */
+#define EF_ERASE_MIN_SIZE         EASYFLASH_ERASE_GRAN
+
+/* the flash write granularity, unit: bit
+ * only support 1(nor flash)/ 8(stm32f4)/ 32(stm32f1)/ 64(stm32l4) */
+#define EF_WRITE_GRAN             (EASYFLASH_WRITE_GRAN)
+
+/*
+ *
+ * This all Backup Area Flash storage index. All used flash area configure is under here.
+ * |----------------------------|   Storage Size
+ * | Environment variables area |   ENV area size @see ENV_AREA_SIZE
+ * |----------------------------|
+ * |      Saved log area        |   Log area size @see LOG_AREA_SIZE
+ * |----------------------------|
+ * |(IAP)Downloaded application |   IAP already downloaded application, unfixed size
+ * |----------------------------|
+ *
+ * @note all area sizes must be aligned with EF_ERASE_MIN_SIZE
+ *
+ * The EasyFlash add the NG (Next Generation) mode start from V4.0. All old mode before V4.0, called LEGACY mode.
+ *
+ * - NG (Next Generation) mode is default mode from V4.0. It's easy to settings, only defined the ENV_AREA_SIZE.
+ * - The LEGACY mode has been DEPRECATED. It is NOT RECOMMENDED to continue using.
+ *   Beacuse it will use ram to buffer the ENV and spend more flash erase times.
+ *   If you want use it please using the V3.X version.
+ */
+
+/* backup area start address */
+#define EF_START_ADDR             EASYFLASH_START_ADDR
+
+/* ENV area size. It's at least one empty sector for GC. So it's definition must more then or equal 2 flash sector size. */
+#define ENV_AREA_SIZE             (EF_ERASE_MIN_SIZE * 2) /* default is the double erase min size */
+
+/* print debug information of flash */
+#ifdef EASYFLASH_DEBUG
+#define PRINT_DEBUG
+#endif
+
+#endif /* EF_CFG_H_ */

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/inc/ef_def.h

@@ -0,0 +1,124 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2019-2020, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: It is the definitions head file for this library.
+ * Created on: 2019-11-20
+ */
+
+#ifndef EF_DEF_H_
+#define EF_DEF_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* EasyFlash software version number */
+#define EF_SW_VERSION                  "4.1.0"
+#define EF_SW_VERSION_NUM              0x40100
+
+/*
+ * ENV version number defined by user.
+ * Please change it when your firmware add a new ENV to default_env_set.
+ */
+#ifndef EF_ENV_VER_NUM
+#define EF_ENV_VER_NUM                 0
+#endif
+
+/* the ENV max name length must less then it */
+#ifndef EF_ENV_NAME_MAX
+#define EF_ENV_NAME_MAX                          32
+#endif
+
+/* EasyFlash debug print function. Must be implement by user. */
+#ifdef PRINT_DEBUG
+#define EF_DEBUG(...) ef_log_debug(__FILE__, __LINE__, __VA_ARGS__)
+#else
+#define EF_DEBUG(...)
+#endif
+/* EasyFlash routine print function. Must be implement by user. */
+#define EF_INFO(...)  ef_log_info(__VA_ARGS__)
+/* EasyFlash assert for developer. */
+#define EF_ASSERT(EXPR)                                                       \
+if (!(EXPR))                                                                  \
+{                                                                             \
+    EF_DEBUG("(%s) has assert failed at %s.\n", #EXPR, __FUNCTION__);         \
+    while (1);                                                                \
+}
+
+typedef struct _ef_env {
+    char *key;
+    void *value;
+    size_t value_len;
+} ef_env, *ef_env_t;
+
+/* EasyFlash error code */
+typedef enum {
+    EF_NO_ERR,
+    EF_ERASE_ERR,
+    EF_READ_ERR,
+    EF_WRITE_ERR,
+    EF_ENV_NAME_ERR,
+    EF_ENV_NAME_EXIST,
+    EF_ENV_FULL,
+    EF_ENV_INIT_FAILED,
+} EfErrCode;
+
+/* the flash sector current status */
+typedef enum {
+    EF_SECTOR_EMPTY,
+    EF_SECTOR_USING,
+    EF_SECTOR_FULL,
+} EfSecrorStatus;
+
+enum env_status {
+    ENV_UNUSED,
+    ENV_PRE_WRITE,
+    ENV_WRITE,
+    ENV_PRE_DELETE,
+    ENV_DELETED,
+    ENV_ERR_HDR,
+    ENV_STATUS_NUM,
+};
+typedef enum env_status env_status_t;
+
+struct env_node_obj {
+    env_status_t status;                         /**< ENV node status, @see node_status_t */
+    bool crc_is_ok;                              /**< ENV node CRC32 check is OK */
+    uint8_t name_len;                            /**< name length */
+    uint32_t magic;                              /**< magic word(`K`, `V`, `4`, `0`) */
+    uint32_t len;                                /**< ENV node total length (header + name + value), must align by EF_WRITE_GRAN */
+    uint32_t value_len;                          /**< value length */
+    char name[EF_ENV_NAME_MAX];                  /**< name */
+    struct {
+        uint32_t start;                          /**< ENV node start address */
+        uint32_t value;                          /**< value start address */
+    } addr;
+};
+typedef struct env_node_obj *env_node_obj_t;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* EF_DEF_H_ */

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/ports/ef_port.c

@@ -0,0 +1,239 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2015, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Portable interface for SFUD flash driver.
+ * Created on: 2015-01-16
+ */
+
+#include <easyflash.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <sfud.h>
+#include <FreeRTOS.h>
+#include "semphr.h"
+#include "board.h"
+#include "mmcsd_core.h"
+
+#ifdef ULOG_EASYFLASH_BACKEND_ENABLE
+
+/* default ENV set for user */
+static const ef_env default_env_set[] = {
+        {"iap_need_copy_app", "0"},
+        {"iap_need_crc32_check", "0"},
+        {"iap_copy_app_size", "0"},
+        {"stop_in_bootloader", "0"},
+};
+
+#define CONSOLEBUF_SIZE	256
+static char log_buf[CONSOLEBUF_SIZE];
+static SemaphoreHandle_t env_cache_lock;
+
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH
+static const sfud_flash *flash;
+#endif
+
+/**
+ * Flash port for hardware initialize.
+ *
+ * @param default_env default ENV set for user
+ * @param default_env_size default ENV size
+ *
+ * @return result
+ */
+EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size) {
+    EfErrCode result = EF_NO_ERR;
+
+    *default_env = default_env_set;
+    *default_env_size = sizeof(default_env_set) / sizeof(default_env_set[0]);
+
+	env_cache_lock = xSemaphoreCreateMutex();
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH	
+    flash = sfud_get_device(0);
+#endif
+
+    return result;
+}
+
+/**
+ * Read data from flash.
+ * @note This operation's units is word.
+ *
+ * @param addr flash address
+ * @param buf buffer to store read data
+ * @param size read bytes size
+ *
+ * @return result
+ */
+EfErrCode ef_port_read(uint32_t addr, uint32_t *buf, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH
+    sfud_read(flash, addr, size, (uint8_t *)buf);
+#else
+	if (emmc_read(addr, size, (uint8_t*)buf))
+		result = EF_READ_ERR;
+#endif
+
+    return result;
+}
+
+/**
+ * Erase data on flash.
+ * @note This operation is irreversible.
+ * @note This operation's units is different which on many chips.
+ *
+ * @param addr flash address
+ * @param size erase bytes size
+ *
+ * @return result
+ */
+EfErrCode ef_port_erase(uint32_t addr, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH	
+    sfud_err sfud_result = SFUD_SUCCESS;
+#endif
+
+    /* make sure the start address is a multiple of FLASH_ERASE_MIN_SIZE */
+    EF_ASSERT(addr % EF_ERASE_MIN_SIZE == 0);
+
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH
+    sfud_result = sfud_erase(flash, addr, size);
+
+    if(sfud_result != SFUD_SUCCESS) {
+        result = EF_ERASE_ERR;
+    }
+#else
+	if (emmc_write(addr, size, NULL))
+		result = EF_ERASE_ERR;
+#endif
+
+    return result;
+}
+/**
+ * Write data to flash.
+ * @note This operation's units is word.
+ * @note This operation must after erase. @see flash_erase.
+ *
+ * @param addr flash address
+ * @param buf the write data buffer
+ * @param size write bytes size
+ *
+ * @return result
+ */
+EfErrCode ef_port_write(uint32_t addr, const uint32_t *buf, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+
+#if DEVICE_TYPE_SELECT	!= EMMC_FLASH	
+    sfud_err sfud_result = SFUD_SUCCESS;
+
+    sfud_result = sfud_write(flash, addr, size, (const uint8_t *)buf);
+
+    if(sfud_result != SFUD_SUCCESS) {
+        result = EF_WRITE_ERR;
+    }
+#else
+	if (emmc_write(addr, size, (uint8_t*)buf))
+		result = EF_WRITE_ERR;
+#endif
+
+    return result;
+}
+
+/**
+ * lock the ENV ram cache
+ */
+void ef_port_env_lock(void) {
+    xSemaphoreTake(env_cache_lock, portMAX_DELAY);
+}
+
+/**
+ * unlock the ENV ram cache
+ */
+void ef_port_env_unlock(void) {
+    xSemaphoreGive(env_cache_lock);
+}
+
+/**
+ * This function is print flash debug info.
+ *
+ * @param file the file which has call this function
+ * @param line the line number which has call this function
+ * @param format output format
+ * @param ... args
+ *
+ */
+void ef_log_debug(const char *file, const long line, const char *format, ...) {
+
+#ifdef PRINT_DEBUG
+
+    va_list args;
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    ef_print("[Flash] (%s:%ld) ", file, line);
+    /* must use vprintf to print */
+    vsprintf(log_buf, format, args);
+    ef_print("%s", log_buf);
+    va_end(args);
+
+#endif
+
+}
+
+/**
+ * This function is print flash routine info.
+ *
+ * @param format output format
+ * @param ... args
+ */
+void ef_log_info(const char *format, ...) {
+    va_list args;
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    ef_print("[Flash] ");
+    /* must use vprintf to print */
+    vsprintf(log_buf, format, args);
+    ef_print("%s", log_buf);
+    va_end(args);
+}
+/**
+ * This function is print flash non-package info.
+ *
+ * @param format output format
+ * @param ... args
+ */
+void ef_print(const char *format, ...) {
+    va_list args;
+
+    /* args point to the first variable parameter */
+    va_start(args, format);
+    /* must use vprintf to print */
+    vsprintf(log_buf, format, args);
+    printf("%s", log_buf);
+    va_end(args);
+}
+
+#endif /* ULOG_EASYFLASH_BACKEND_ENABLE */

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/src/easyflash.c

@@ -0,0 +1,103 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2014-2019, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Initialize interface for this library.
+ * Created on: 2014-09-09
+ */
+
+/*
+ *
+ * This all Backup Area Flash storage index. All used flash area configure is under here.
+ * |----------------------------|   Storage Size
+ * | Environment variables area |   ENV area size @see ENV_AREA_SIZE
+ * |----------------------------|
+ * |      Saved log area        |   Log area size @see LOG_AREA_SIZE
+ * |----------------------------|
+ * |(IAP)Downloaded application |   IAP already downloaded application, unfixed size
+ * |----------------------------|
+ *
+ * @note all area sizes must be aligned with EF_ERASE_MIN_SIZE
+ *
+ * The EasyFlash add the NG (Next Generation) mode start from V4.0. All old mode before V4.0, called LEGACY mode.
+ *
+ * - NG (Next Generation) mode is default mode from V4.0. It's easy to settings, only defined the ENV_AREA_SIZE.
+ * - The LEGACY mode has been DEPRECATED. It is NOT RECOMMENDED to continue using.
+ *   Beacuse it will use ram to buffer the ENV and spend more flash erase times.
+ *   If you want use it please using the V3.X version.
+ */
+
+#include <easyflash.h>
+
+#if !defined(EF_START_ADDR)
+#error "Please configure backup area start address (in ef_cfg.h)"
+#endif
+
+#if !defined(EF_ERASE_MIN_SIZE)
+#error "Please configure minimum size of flash erasure (in ef_cfg.h)"
+#endif
+
+/**
+ * EasyFlash system initialize.
+ *
+ * @return result
+ */
+EfErrCode easyflash_init(void) {
+    extern EfErrCode ef_port_init(ef_env const **default_env, size_t *default_env_size);
+    extern EfErrCode ef_env_init(ef_env const *default_env, size_t default_env_size);
+    extern EfErrCode ef_iap_init(void);
+    extern EfErrCode ef_log_init(void);
+
+    size_t default_env_set_size = 0;
+    const ef_env *default_env_set;
+    EfErrCode result = EF_NO_ERR;
+
+    result = ef_port_init(&default_env_set, &default_env_set_size);
+
+#ifdef EF_USING_ENV
+    if (result == EF_NO_ERR) {
+        result = ef_env_init(default_env_set, default_env_set_size);
+    }
+#endif
+
+#ifdef EF_USING_IAP
+    if (result == EF_NO_ERR) {
+        result = ef_iap_init();
+    }
+#endif
+
+#ifdef EF_USING_LOG
+    if (result == EF_NO_ERR) {
+        result = ef_log_init();
+    }
+#endif
+
+    if (result == EF_NO_ERR) {
+        EF_INFO("EasyFlash V%s is initialize success.\n", EF_SW_VERSION);
+    } else {
+        EF_INFO("EasyFlash V%s is initialize fail.\n", EF_SW_VERSION);
+    }
+    EF_INFO("You can get the latest version on https://github.com/armink/EasyFlash .\n");
+
+    return result;
+}

MXC_A27-PCB4.5-CANUI/lib/EasyFlash/src/ef_log.c

@@ -0,0 +1,731 @@
+/*
+ * This file is part of the EasyFlash Library.
+ *
+ * Copyright (c) 2015-2019, Armink, <armink.ztl@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the
+ * 'Software'), to deal in the Software without restriction, including
+ * without limitation the rights to use, copy, modify, merge, publish,
+ * distribute, sublicense, and/or sell copies of the Software, and to
+ * permit persons to whom the Software is furnished to do so, subject to
+ * the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+ * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+ * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ * Function: Save logs to flash.
+ * Created on: 2015-06-04
+ */
+
+#include <easyflash.h>
+
+#ifdef EF_USING_LOG
+
+#if defined(EF_USING_LOG) && !defined(LOG_AREA_SIZE)
+#error "Please configure log area size (in ef_cfg.h)"
+#endif
+
+/* magic code on every sector header. 'EF' is 0xEF30EF30 */
+#define LOG_SECTOR_MAGIC               0xEF30EF30
+/* sector header size, includes the sector magic code and status magic code */
+#define LOG_SECTOR_HEADER_SIZE         12
+/* sector header word size,what is equivalent to the total number of sectors header index */
+#define LOG_SECTOR_HEADER_WORD_SIZE    3
+
+/**
+ * Sector status magic code
+ * The sector status is 8B after LOG_SECTOR_MAGIC at every sector header.
+ * ==============================================
+ * |           header(12B)            | status |
+ * ----------------------------------------------
+ * | 0xEF30EF30 0xFFFFFFFF 0xFFFFFFFF |  empty |
+ * | 0xEF30EF30 0xFEFEFEFE 0xFFFFFFFF |  using |
+ * | 0xEF30EF30 0xFEFEFEFE 0xFCFCFCFC |  full  |
+ * ==============================================
+ *
+ * State transition relationship: empty->using->full
+ * The FULL status will change to EMPTY after sector clean.
+ */
+#define SECTOR_STATUS_MAGIC_EMPUT     0xFFFFFFFF
+#define SECTOR_STATUS_MAGIC_USING     0xFEFEFEFE
+#define SECTOR_STATUS_MAGIC_FULL      0xFCFCFCFC
+
+typedef enum {
+    SECTOR_STATUS_EMPUT,
+    SECTOR_STATUS_USING,
+    SECTOR_STATUS_FULL,
+    SECTOR_STATUS_HEADER_ERROR,
+} SectorStatus;
+
+typedef enum {
+    SECTOR_HEADER_MAGIC_INDEX,
+    SECTOR_HEADER_USING_INDEX,
+    SECTOR_HEADER_FULL_INDEX,
+} SectorHeaderIndex;
+
+/* the stored logs start address and end address. It's like a ring buffer implemented on flash. */
+static uint32_t log_start_addr = 0, log_end_addr = 0;
+/* saved log area address for flash */
+static uint32_t log_area_start_addr = 0;
+/* initialize OK flag */
+static bool init_ok = false;
+
+static void find_start_and_end_addr(void);
+static uint32_t get_next_flash_sec_addr(uint32_t cur_addr);
+
+/**
+ * The flash save log function initialize.
+ *
+ * @return result
+ */
+EfErrCode ef_log_init(void) {
+    EfErrCode result = EF_NO_ERR;
+
+    EF_ASSERT(LOG_AREA_SIZE);
+    EF_ASSERT(EF_ERASE_MIN_SIZE);
+    /* the log area size must be an integral multiple of erase minimum size. */
+    EF_ASSERT(LOG_AREA_SIZE % EF_ERASE_MIN_SIZE == 0);
+    /* the log area size must be more than twice of EF_ERASE_MIN_SIZE */
+    EF_ASSERT(LOG_AREA_SIZE / EF_ERASE_MIN_SIZE >= 2);
+
+#ifdef EF_USING_ENV
+    log_area_start_addr = EF_START_ADDR + ENV_AREA_SIZE;
+#else
+    log_area_start_addr = EF_START_ADDR;
+#endif
+
+    /* find the log store start address and end address */
+    find_start_and_end_addr();
+    /* initialize OK */
+    init_ok = true;
+
+    return result;
+}
+
+/**
+ * Get flash sector current status.
+ *
+ * @param addr sector address, this function will auto calculate the sector header address by this address.
+ *
+ * @return the flash sector current status
+ */
+static SectorStatus get_sector_status(uint32_t addr) {
+    uint32_t header_buf[LOG_SECTOR_HEADER_WORD_SIZE] = {0}, header_addr = 0;
+    uint32_t sector_header_magic = 0;
+    uint32_t status_full_magic = 0, status_use_magic = 0;
+
+    /* calculate the sector header address */
+    header_addr = addr & (~(EF_ERASE_MIN_SIZE - 1));
+
+    if (ef_port_read(header_addr, header_buf, sizeof(header_buf)) == EF_NO_ERR) {
+        sector_header_magic = header_buf[SECTOR_HEADER_MAGIC_INDEX];
+        status_use_magic = header_buf[SECTOR_HEADER_USING_INDEX];
+        status_full_magic = header_buf[SECTOR_HEADER_FULL_INDEX];
+    } else {
+        EF_DEBUG("Error: Read sector header data error.\n");
+        return SECTOR_STATUS_HEADER_ERROR;
+    }
+
+    /* compare header magic code */
+    if(sector_header_magic == LOG_SECTOR_MAGIC){
+        if((status_use_magic == SECTOR_STATUS_MAGIC_EMPUT) && (status_full_magic == SECTOR_STATUS_MAGIC_EMPUT)) {
+            return SECTOR_STATUS_EMPUT;
+        } else if((status_use_magic == SECTOR_STATUS_MAGIC_USING) && (status_full_magic == SECTOR_STATUS_MAGIC_EMPUT)) {
+             return SECTOR_STATUS_USING;
+        } else if((status_use_magic == SECTOR_STATUS_MAGIC_USING) && (status_full_magic == SECTOR_STATUS_MAGIC_FULL)) {
+             return SECTOR_STATUS_FULL;
+        } else {
+            return SECTOR_STATUS_HEADER_ERROR;
+        }
+    } else {
+        return SECTOR_STATUS_HEADER_ERROR;
+    }
+
+}
+
+/**
+ * Write flash sector current status.
+ *
+ * @param addr sector address, this function will auto calculate the sector header address by this address.
+ * @param status sector cur status
+ *
+ * @return result
+ */
+static EfErrCode write_sector_status(uint32_t addr, SectorStatus status) {
+    uint32_t header, header_addr = 0;
+
+    /* calculate the sector header address */
+    header_addr = addr & (~(EF_ERASE_MIN_SIZE - 1));
+
+    /* calculate the sector staus magic */
+    switch (status) {
+    case SECTOR_STATUS_EMPUT: {
+        header = LOG_SECTOR_MAGIC;
+        return ef_port_write(header_addr, &header, sizeof(header));
+    }
+    case SECTOR_STATUS_USING: {
+        header = SECTOR_STATUS_MAGIC_USING;
+        return ef_port_write(header_addr + sizeof(header), &header, sizeof(header));
+    }
+    case SECTOR_STATUS_FULL: {
+        header = SECTOR_STATUS_MAGIC_FULL;
+        return ef_port_write(header_addr + sizeof(header) * 2, &header, sizeof(header));
+    }
+    default:
+        return EF_WRITE_ERR;
+    }
+}
+
+/**
+ * Find the current flash sector using end address by continuous 0xFF.
+ *
+ * @param addr sector address
+ *
+ * @return current flash sector using end address
+ */
+static uint32_t find_sec_using_end_addr(uint32_t addr) {
+/* read section data buffer size */
+#define READ_BUF_SIZE                512
+
+    uint32_t sector_start = addr, data_start = addr, continue_ff = 0, read_buf_size = 0, i;
+    uint8_t buf[READ_BUF_SIZE];
+
+    EF_ASSERT(READ_BUF_SIZE % 4 == 0);
+    /* calculate the sector start and data start address */
+    sector_start = addr & (~(EF_ERASE_MIN_SIZE - 1));
+    data_start = sector_start + LOG_SECTOR_HEADER_SIZE;
+
+    /* counts continuous 0xFF which is end of sector */
+    while (data_start < sector_start + EF_ERASE_MIN_SIZE) {
+        if (data_start + READ_BUF_SIZE < sector_start + EF_ERASE_MIN_SIZE) {
+            read_buf_size = READ_BUF_SIZE;
+        } else {
+            read_buf_size = sector_start + EF_ERASE_MIN_SIZE - data_start;
+        }
+        ef_port_read(data_start, (uint32_t *)buf, read_buf_size);
+        for (i = 0; i < read_buf_size; i++) {
+            if (buf[i] == 0xFF) {
+                continue_ff++;
+            } else {
+                continue_ff = 0;
+            }
+        }
+        data_start += read_buf_size;
+    }
+    /* calculate current flash sector using end address */
+    if (continue_ff >= EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE) {
+        /* from 0 to sec_size all sector is 0xFF, so the sector is empty */
+        return sector_start + LOG_SECTOR_HEADER_SIZE;
+    } else if (continue_ff >= 4) {
+        /* form end_addr - 4 to sec_size length all area is 0xFF, so it's used part of the sector.
+         * the address must be word alignment. */
+        if (continue_ff % 4 != 0) {
+            continue_ff = (continue_ff / 4 + 1) * 4;
+        }
+        return sector_start + EF_ERASE_MIN_SIZE - continue_ff;
+    } else {
+        /* all sector not has continuous 0xFF, so the sector is full */
+        return sector_start + EF_ERASE_MIN_SIZE;
+    }
+}
+
+/**
+ * Find the log store start address and end address.
+ * It's like a ring buffer implemented on flash.
+ * The flash log area can be in two states depending on start address and end address:
+ *                       state 1                                state 2
+ *                   |============|                         |============|
+ * log area start--> |############| <-- start address       |############| <-- end address
+ *                   |############|                         |   empty    |
+ *                   |------------|                         |------------|
+ *                   |############|                         |############| <-- start address
+ *                   |############|                         |############|
+ *                   |------------|                         |------------|
+ *                   |     .      |                         |     .      |
+ *                   |     .      |                         |     .      |
+ *                   |     .      |                         |     .      |
+ *                   |------------|                         |------------|
+ *                   |############| <-- end address         |############|
+ *                   |   empty    |                         |############|
+ *  log area end --> |============|                         |============|
+ *
+ *  LOG_AREA_SIZE = log area end - log area star
+ *
+ */
+static void find_start_and_end_addr(void) {
+    size_t cur_size = 0;
+    SectorStatus cur_sec_status, last_sec_status;
+    uint32_t cur_using_sec_addr = 0;
+    /* all status sector counts */
+    size_t empty_sec_counts = 0, using_sec_counts = 0, full_sector_counts = 0;
+    /* total sector number */
+    size_t total_sec_num = LOG_AREA_SIZE / EF_ERASE_MIN_SIZE;
+    /* see comment of find_start_and_end_addr function */
+    uint8_t cur_log_sec_state = 0;
+
+    /* get the first sector status */
+    cur_sec_status = get_sector_status(log_area_start_addr);
+    last_sec_status = cur_sec_status;
+
+    for (cur_size = EF_ERASE_MIN_SIZE; cur_size < LOG_AREA_SIZE; cur_size += EF_ERASE_MIN_SIZE) {
+        /* get current sector status */
+        cur_sec_status = get_sector_status(log_area_start_addr + cur_size);
+        /* compare last and current status */
+        switch (last_sec_status) {
+        case SECTOR_STATUS_EMPUT: {
+            switch (cur_sec_status) {
+            case SECTOR_STATUS_EMPUT:
+                break;
+            case SECTOR_STATUS_USING:
+                EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
+                ef_log_clean();
+                return;
+            case SECTOR_STATUS_FULL:
+                EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
+                ef_log_clean();
+                return;
+            }
+            empty_sec_counts++;
+            break;
+        }
+        case SECTOR_STATUS_USING: {
+            switch (cur_sec_status) {
+            case SECTOR_STATUS_EMPUT:
+                /* like state 1 */
+                cur_log_sec_state = 1;
+                log_start_addr = log_area_start_addr;
+                cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
+                break;
+            case SECTOR_STATUS_USING:
+                EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
+                ef_log_clean();
+                return;
+            case SECTOR_STATUS_FULL:
+                /* like state 2 */
+                cur_log_sec_state = 2;
+                log_start_addr = log_area_start_addr + cur_size;
+                cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
+                break;
+            }
+            using_sec_counts++;
+            break;
+        }
+        case SECTOR_STATUS_FULL: {
+            switch (cur_sec_status) {
+            case SECTOR_STATUS_EMPUT:
+                /* like state 1 */
+                if (cur_log_sec_state == 2) {
+                    EF_DEBUG("Error: Log area error! Now will clean all log area.\n");
+                    ef_log_clean();
+                    return;
+                } else {
+                    cur_log_sec_state = 1;
+                    log_start_addr = log_area_start_addr;
+                    log_end_addr = log_area_start_addr + cur_size;
+                    cur_using_sec_addr = log_area_start_addr + cur_size - EF_ERASE_MIN_SIZE;
+                }
+                break;
+            case SECTOR_STATUS_USING:
+                if(total_sec_num <= 2) {
+                    /* like state 1 */
+                    cur_log_sec_state = 1;
+                    log_start_addr = log_area_start_addr;
+                    cur_using_sec_addr = log_area_start_addr + cur_size;
+                } else {
+                    /* like state 2 when the sector is the last one */
+                    if (cur_size + EF_ERASE_MIN_SIZE >= LOG_AREA_SIZE) {
+                        cur_log_sec_state = 2;
+                        log_start_addr = get_next_flash_sec_addr(log_area_start_addr + cur_size);
+                        cur_using_sec_addr = log_area_start_addr + cur_size;
+                    }
+                }
+                break;
+            case SECTOR_STATUS_FULL:
+                break;
+            }
+            full_sector_counts++;
+            break;
+        }
+        case SECTOR_STATUS_HEADER_ERROR:
+            EF_DEBUG("Error: Log sector header error! Now will clean all log area.\n");
+            ef_log_clean();
+            return;
+        }
+        last_sec_status = cur_sec_status;
+    }
+
+    /* the last sector status counts */
+    if (cur_sec_status == SECTOR_STATUS_EMPUT) {
+        empty_sec_counts++;
+    } else if (cur_sec_status == SECTOR_STATUS_USING) {
+        using_sec_counts++;
+    } else if (cur_sec_status == SECTOR_STATUS_FULL) {
+        full_sector_counts++;
+    } else if (cur_sec_status == SECTOR_STATUS_HEADER_ERROR) {
+        EF_DEBUG("Error: Log sector header error! Now will clean all log area.\n");
+        ef_log_clean();
+        return;
+    }
+
+    if (using_sec_counts != 1) {
+        /* this state is almost impossible */
+        EF_DEBUG("Error: There must be only one sector status is USING! Now will clean all log area.\n");
+        ef_log_clean();
+    } else {
+        /* find the end address */
+        log_end_addr = find_sec_using_end_addr(cur_using_sec_addr);
+    }
+
+}
+
+/**
+ * Get log used flash total size.
+ *
+ * @return log used flash total size. @note NOT contain sector headers
+ */
+size_t ef_log_get_used_size(void) {
+    size_t header_total_num = 0, physical_size = 0;
+    /* must be call this function after initialize OK */
+    if (!init_ok) {
+        return 0;
+    }
+
+    if (log_start_addr < log_end_addr) {
+        physical_size = log_end_addr - log_start_addr;
+    } else {
+        physical_size = LOG_AREA_SIZE - (log_start_addr - log_end_addr);
+    }
+
+    header_total_num = physical_size / EF_ERASE_MIN_SIZE + 1;
+
+    return physical_size - header_total_num * LOG_SECTOR_HEADER_SIZE;
+}
+
+/**
+ * Sequential reading log data. It will ignore sector headers.
+ *
+ * @param addr address
+ * @param log log buffer
+ * @param size log size, not contain sector headers.
+ *
+ * @return result
+ */
+static EfErrCode log_seq_read(uint32_t addr, uint32_t *log, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+    size_t read_size = 0, read_size_temp = 0;
+
+    while (size) {
+        /* move to sector data address */
+        if ((addr + read_size) % EF_ERASE_MIN_SIZE == 0) {
+            addr += LOG_SECTOR_HEADER_SIZE;
+        }
+        /* calculate current sector last data size */
+        read_size_temp = EF_ERASE_MIN_SIZE - (addr % EF_ERASE_MIN_SIZE);
+        if (size < read_size_temp) {
+            read_size_temp = size;
+        }
+        result = ef_port_read(addr + read_size, log + read_size / 4, read_size_temp);
+        if (result != EF_NO_ERR) {
+            return result;
+        }
+        read_size += read_size_temp;
+        size -= read_size_temp;
+    }
+
+    return result;
+}
+
+/**
+ * Calculate flash physical address by log index.
+ *
+ * @param index log index
+ *
+ * @return flash physical address
+ */
+static uint32_t log_index2addr(size_t index) {
+    size_t header_total_offset = 0;
+    /* total include sector number */
+    size_t sector_num = index / (EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE) + 1;
+
+    header_total_offset = sector_num * LOG_SECTOR_HEADER_SIZE;
+    if (log_start_addr < log_end_addr) {
+        return log_start_addr + index + header_total_offset;
+    } else {
+        if (log_start_addr + index + header_total_offset < log_area_start_addr + LOG_AREA_SIZE) {
+            return log_start_addr + index + header_total_offset;
+        } else {
+            return log_start_addr + index + header_total_offset - LOG_AREA_SIZE;
+
+        }
+    }
+}
+
+/**
+ * Read log from flash.
+ *
+ * @param index index for saved log.
+ *        Minimum index is 0.
+ *        Maximum index is ef_log_get_used_size() - 1.
+ * @param log the log which will read from flash
+ * @param size read bytes size
+ *
+ * @return result
+ */
+EfErrCode ef_log_read(size_t index, uint32_t *log, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+    size_t cur_using_size = ef_log_get_used_size();
+    size_t read_size_temp = 0;
+    size_t header_total_num = 0;
+
+    if (!size) {
+        return result;
+    }
+
+    EF_ASSERT(size % 4 == 0);
+    EF_ASSERT(index < cur_using_size);
+
+    if (index + size > cur_using_size) {
+        EF_DEBUG("Warning: Log read size out of bound. Cut read size.\n");
+        size = cur_using_size - index;
+    }
+    /* must be call this function after initialize OK */
+    if (!init_ok) {
+        return EF_ENV_INIT_FAILED;
+    }
+
+    if (log_start_addr < log_end_addr) {
+        log_seq_read(log_index2addr(index), log, size);
+    } else {
+        if (log_index2addr(index) + size <= log_area_start_addr + LOG_AREA_SIZE) {
+            /*                          Flash log area
+             *                         |--------------|
+             * log_area_start_addr --> |##############|
+             *                         |##############|
+             *                         |##############|
+             *                         |--------------|
+             *                         |##############|
+             *                         |##############|
+             *                         |##############| <-- log_end_addr
+             *                         |--------------|
+             *      log_start_addr --> |##############|
+             *          read start --> |**************| <-- read end
+             *                         |##############|
+             *                         |--------------|
+             *
+             * read from (log_start_addr + log_index2addr(index)) to (log_start_addr + index + log_index2addr(index))
+             */
+            result = log_seq_read(log_index2addr(index), log, size);
+        } else if (log_index2addr(index) < log_area_start_addr + LOG_AREA_SIZE) {
+            /*                          Flash log area
+             *                         |--------------|
+             * log_area_start_addr --> |**************| <-- read end
+             *                         |##############|
+             *                         |##############|
+             *                         |--------------|
+             *                         |##############|
+             *                         |##############|
+             *                         |##############| <-- log_end_addr
+             *                         |--------------|
+             *      log_start_addr --> |##############|
+             *          read start --> |**************|
+             *                         |**************|
+             *                         |--------------|
+             * read will by 2 steps
+             * step1: read from (log_start_addr + log_index2addr(index)) to flash log area end address
+             * step2: read from flash log area start address to read size's end address
+             */
+            read_size_temp = (log_area_start_addr + LOG_AREA_SIZE) - log_index2addr(index);
+            header_total_num = read_size_temp / EF_ERASE_MIN_SIZE;
+            /* Minus some ignored bytes */
+            read_size_temp -= header_total_num * LOG_SECTOR_HEADER_SIZE;
+            result = log_seq_read(log_index2addr(index), log, read_size_temp);
+            if (result == EF_NO_ERR) {
+                result = log_seq_read(log_area_start_addr, log + read_size_temp / 4, size - read_size_temp);
+            }
+        } else {
+            /*                          Flash log area
+             *                         |--------------|
+             * log_area_start_addr --> |##############|
+             *          read start --> |**************|
+             *                         |**************| <-- read end
+             *                         |--------------|
+             *                         |##############|
+             *                         |##############|
+             *                         |##############| <-- log_end_addr
+             *                         |--------------|
+             *      log_start_addr --> |##############|
+             *                         |##############|
+             *                         |##############|
+             *                         |--------------|
+             * read from (log_start_addr + log_index2addr(index) - LOG_AREA_SIZE) to read size's end address
+             */
+            result = log_seq_read(log_index2addr(index) - LOG_AREA_SIZE, log, size);
+        }
+    }
+
+    return result;
+}
+
+/**
+ * Write log to flash.
+ *
+ * @param log the log which will be write to flash
+ * @param size write bytes size
+ *
+ * @return result
+ */
+EfErrCode ef_log_write(const uint32_t *log, size_t size) {
+    EfErrCode result = EF_NO_ERR;
+    size_t write_size = 0, writable_size = 0;
+    uint32_t write_addr = log_end_addr, erase_addr;
+    SectorStatus sector_status;
+
+    EF_ASSERT(size % 4 == 0);
+    /* must be call this function after initialize OK */
+    if (!init_ok) {
+        return EF_ENV_INIT_FAILED;
+    }
+
+    if ((sector_status = get_sector_status(write_addr)) == SECTOR_STATUS_HEADER_ERROR) {
+        return EF_WRITE_ERR;
+    }
+    /* write some log when current sector status is USING and EMPTY */
+    if ((sector_status == SECTOR_STATUS_USING) || (sector_status == SECTOR_STATUS_EMPUT)) {
+        /* write the already erased but not used area */
+        writable_size = EF_ERASE_MIN_SIZE - ((write_addr - log_area_start_addr) % EF_ERASE_MIN_SIZE);
+        if (size >= writable_size) {
+            result = ef_port_write(write_addr, log, writable_size);
+            if (result != EF_NO_ERR) {
+                goto exit;
+            }
+            /* change the current sector status to FULL */
+            result = write_sector_status(write_addr, SECTOR_STATUS_FULL);
+            if (result != EF_NO_ERR) {
+                goto exit;
+            }
+            write_size += writable_size;
+        } else {
+            result = ef_port_write(write_addr, log, size);
+            log_end_addr = write_addr + size;
+            goto exit;
+        }
+    }
+    /* erase and write remain log */
+    while (true) {
+        /* calculate next available sector address */
+        erase_addr = write_addr = get_next_flash_sec_addr(write_addr - 4);
+        /* move the flash log start address to next available sector address */
+        if (log_start_addr == erase_addr) {
+            log_start_addr = get_next_flash_sec_addr(log_start_addr);
+        }
+        /* erase sector */
+        result = ef_port_erase(erase_addr, EF_ERASE_MIN_SIZE);
+        if (result != EF_NO_ERR) {
+            goto exit;
+        }
+        /* change the sector status to EMPTY and USING when write begin sector start address */
+        result = write_sector_status(write_addr, SECTOR_STATUS_EMPUT);
+        result = write_sector_status(write_addr, SECTOR_STATUS_USING);
+        if (result == EF_NO_ERR) {
+            write_addr += LOG_SECTOR_HEADER_SIZE;
+        } else {
+            goto exit;
+        }
+        /* calculate current sector writable data size */
+        writable_size = EF_ERASE_MIN_SIZE - LOG_SECTOR_HEADER_SIZE;
+        if (size - write_size >= writable_size) {
+            result = ef_port_write(write_addr, log + write_size / 4, writable_size);
+            if (result != EF_NO_ERR) {
+                goto exit;
+            }
+            /* change the current sector status to FULL */
+            result = write_sector_status(write_addr, SECTOR_STATUS_FULL);
+            if (result != EF_NO_ERR) {
+                goto exit;
+            }
+            log_end_addr = write_addr + writable_size;
+            write_size += writable_size;
+            write_addr += writable_size;
+        } else {
+            result = ef_port_write(write_addr, log + write_size / 4, size - write_size);
+            if (result != EF_NO_ERR) {
+                goto exit;
+            }
+            log_end_addr = write_addr + (size - write_size);
+            break;
+        }
+    }
+
+exit:
+    return result;
+}
+
+/**
+ * Get next flash sector address.The log total sector like ring buffer which implement by flash.
+ *
+ * @param cur_addr cur flash address
+ *
+ * @return next flash sector address
+ */
+static uint32_t get_next_flash_sec_addr(uint32_t cur_addr) {
+    size_t cur_sec_id = (cur_addr - log_area_start_addr) / EF_ERASE_MIN_SIZE;
+    size_t sec_total_num = LOG_AREA_SIZE / EF_ERASE_MIN_SIZE;
+
+    if (cur_sec_id + 1 >= sec_total_num) {
+        /* return to ring head */
+        return log_area_start_addr;
+    } else {
+        return log_area_start_addr + (cur_sec_id + 1) * EF_ERASE_MIN_SIZE;
+    }
+}
+
+/**
+ * Clean all log which in flash.
+ *
+ * @return result
+ */
+EfErrCode ef_log_clean(void) {
+    EfErrCode result = EF_NO_ERR;
+    uint32_t write_addr = log_area_start_addr;
+
+    /* clean address */
+    log_start_addr = log_area_start_addr;
+    log_end_addr = log_start_addr + LOG_SECTOR_HEADER_SIZE;
+    /* erase log flash area */
+    result = ef_port_erase(log_area_start_addr, LOG_AREA_SIZE);
+    if (result != EF_NO_ERR) {
+        goto exit;
+    }
+    /* setting first sector is EMPTY to USING */
+    write_sector_status(write_addr, SECTOR_STATUS_EMPUT);
+    write_sector_status(write_addr, SECTOR_STATUS_USING);
+    if (result != EF_NO_ERR) {
+        goto exit;
+    }
+    write_addr += EF_ERASE_MIN_SIZE;
+    /* add sector header */
+    while (true) {
+        write_sector_status(write_addr, SECTOR_STATUS_EMPUT);
+        if (result != EF_NO_ERR) {
+            goto exit;
+        }
+        write_addr += EF_ERASE_MIN_SIZE;
+        if (write_addr >= log_area_start_addr + LOG_AREA_SIZE) {
+            break;
+        }
+    }
+
+exit:
+    return result;
+}
+
+#endif /* EF_USING_LOG */