/*
 * @copyright Copyright (c) 2016-2020 TOYOTA MOTOR CORPORATION.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*******************************************************************************
* $Header::                                                                   $
* $Revision::                                                                 $
*******************************************************************************/

/*******************************************************************************
@file        mtd_backup.c
@system
@process
@detail
 ******************************************************************************/
#include "system_service/nor_backup.h"
#include <stdio.h>
#include <string.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <pthread.h>
#include <asm/unistd.h>
#include <mtd/mtd-user.h>

#define BACKUP_RETRY_CNT    3

/* Invalid Value */
#define FLSBACKUP_SEMAPHORE_INVALID    (0)


#define BACKUP_SECTOR_SIZ        1024                    // Secter Size

#define BACKUP_CHECK_OFFSET    16
#define BACKUP_CHECK_SIZE        12
#define BACKUP_CHECK_TEXT        "MTD_BACKUPDT"
#define BACKUP_CHECK_DAT1        1    // Lower 8bit
#define BACKUP_CHECK_DAT2        2    // Upper 8bit

#define NOR_ERRLOG(fmt, args...) \
  fprintf(stderr, "[ERR]%ld/%s/%d/= "fmt"\n", syscall(__NR_gettid), __func__, __LINE__, ##args)

static pthread_mutex_t    g_semid_flash = PTHREAD_MUTEX_INITIALIZER;       /* Semaphore ID of dram area access    */
static int    g_backup_init = FLSBACKUP_SEMAPHORE_INVALID;

typedef enum {
  RET_WT_CHK_OK = 0,
  RET_WT_ERR_OTHER,
  RET_WT_DEV_ERR,
} NOR_WRITE_BLK_CHK;

typedef enum {
  RET_RD_CHK_OK = 0,
  RET_RD_ERR_OTHER,
  RET_RD_DEV_ERR,
  RET_RD_ERR_1 = -1,
  RET_RD_ERR_2 = -2,
  RET_RD_ERR_3 = -3,
  RET_RD_ERR_4 = -4,
} NOR_READ_BLK_CHK;

typedef enum {
  RET_CHK_OK = 0,
  RET_CHK_TEXT_ERR,
  RET_CHK_BCC_ERR,
} NOR_BLK_CHK;

typedef enum {
  NOR_IDLE = 0,        // 0:Read-out of block data
  NOR_ORG_TEXT,        // 1:OrgText Error
  NOR_ORG_BCC,        // 2:OrgBcc error
  NOR_READ_OK,        // 3:Normal read-out
  NOR_READ_END        // 4:end state
} NOR_R_STATE;

typedef enum {
  NOR_IDEL = 0,            // 0:IDEL
  NOR_READ_ERR,            // 1:Read Error
  NOR_ORG_READ,            // 2:Org Read OK
  NOR_BAK_WRT,            // 3:Bak Write OK
  NOR_BACK_READ,            // 4:Bak Read OK
  NOR_ORG_WRITE,            // 5:Org Write OK
  NOR_WRITE_END            // 6:end state
} NOR_W_STATE;

NOR_READ_BLK_CHK MtdnBackupReadSub(
    const char * path_name, int i_id, int i_offset, int i_size,
    void *p_buff, mtd_info_t * mtd_info, int * get_state);
NOR_WRITE_BLK_CHK MtdnBackupWriteSub(
    const char * path_name, int i_id, int i_offset, int i_size,
    void *p_buff, mtd_info_t * mtd_info);

int MtdnBackupWriteBase(
    const char * path_name, int i_id, int i_offset, int i_size,
    void *p_buff, mtd_info_t * mtd_info);
int MtdnBackupReadBase(
    const char * path_name, int i_id, int i_offset, int i_size,
    void *p_buff, mtd_info_t * mtd_info);

int MtdBackupInfo(const char * path_name, mtd_info_t * mtd_info);        // INFO Get

NOR_BLK_CHK    MtdBackupCheksumRead(char * p_buff, int erase_size, int * ret_sum);            // check SUM
int    MtdBackupCheksumWrite(char * p_buff, int erase_size);            // check SUM

/***************************************************************************
@brief        mtdn_backup_Read
@outline        Read-out of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@return     int
@retval        0        : No error
@retval        Except    : Error
@usage        It is Backup API of data read.
*****************************************************************************/
int    mtdn_backup_Read(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff ) {
    int    ret_status = RET_DEV_NORMAL;

    if (path_name == NULL) {
        NOR_ERRLOG("invalid path:%p", path_name);
        return  RET_DEV_ERR_PARAM;
    }
    if (p_buff == NULL) {
        NOR_ERRLOG("invalid buf:%p", p_buff);
        return  RET_DEV_ERR_PARAM;
    }
    if (i_id < 0) {
        NOR_ERRLOG("invalid id:%d", i_id);
        return  RET_DEV_ERR_PARAM;
    }
    if ((i_offset < 0) || (i_size <= 0)) {
        NOR_ERRLOG("invalid size:%d offset:%d", i_size, i_offset);
        return  RET_DEV_ERR_PARAM;
    }
    if (g_backup_init == FLSBACKUP_SEMAPHORE_INVALID) {  // LCOV_EXCL_BR_LINE 200: g_backup_init is static variable
        pthread_mutex_init(&g_semid_flash, NULL);
        g_backup_init = ~FLSBACKUP_SEMAPHORE_INVALID;
    }
    mtd_info_t mtd_info;
    memset(&mtd_info, 0, sizeof(mtd_info_t));
    ret_status = MtdBackupInfo((const char *)path_name, &mtd_info);
    if (ret_status == RET_DEV_NORMAL) {
        if (mtd_info.type != MTD_NORFLASH) {
            NOR_ERRLOG("invalid type:%d", mtd_info.type);
            ret_status = RET_DEV_ERR_PARAM;
        } else {
            if ((i_offset + i_size) > (int)(mtd_info.erasesize - BACKUP_CHECK_OFFSET)) {
                NOR_ERRLOG("invalid size:%d offset:%d erasesize:%d", i_size, i_offset, mtd_info.erasesize);
                ret_status = RET_DEV_ERR_PARAM;
            }
        }
        if (ret_status == RET_DEV_NORMAL) {
            /* Start Semaphore(flash)    */
            pthread_mutex_lock(&g_semid_flash);
            int get_state;    // Read status
            ret_status = (int)MtdnBackupReadSub(path_name, i_id, i_offset, i_size,
                                                             p_buff, &mtd_info, &get_state);

            /* End Semaphore(flash)    */
            pthread_mutex_unlock(&g_semid_flash);
        }
    }
    if (ret_status != RET_DEV_NORMAL) {
        NOR_ERRLOG("error return:%d", ret_status);
    }
    return    ret_status;
}

/***************************************************************************
@brief        mtdn_backup_Write
@outline        Writing of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@return     int
@retval        0    : No error
@retval        Except: Error
@usage        It is Backup API of data read.
*****************************************************************************/
int    mtdn_backup_Write(const char * path_name, int i_id, int i_offset, int i_size, void *p_buff) {
    int    ret_status = RET_DEV_NORMAL;

    if (path_name == NULL) {
        NOR_ERRLOG("invalid path:%p", path_name);
        return  RET_DEV_ERR_PARAM;
    }
    if (p_buff == NULL) {
        NOR_ERRLOG("invalid buf:%p", p_buff);
        return RET_DEV_ERR_PARAM;
    }
    if (i_id < 0) {
        NOR_ERRLOG("invalid id:%d", i_id);
        return RET_DEV_ERR_PARAM;
    }
    if ((i_offset < 0) || (i_size <= 0)) {
        NOR_ERRLOG("invalid size:%d offset:%d", i_size, i_offset);
        return RET_DEV_ERR_PARAM;
    }
    if (g_backup_init == FLSBACKUP_SEMAPHORE_INVALID) {
        pthread_mutex_init(&g_semid_flash, NULL);
        g_backup_init = ~FLSBACKUP_SEMAPHORE_INVALID;
    }
    mtd_info_t mtd_info;
    memset(&mtd_info, 0, sizeof(mtd_info_t));
    ret_status = MtdBackupInfo((const char *)path_name, &mtd_info);
    if (ret_status == RET_DEV_NORMAL) {
        if (mtd_info.type != MTD_NORFLASH) {
            NOR_ERRLOG("invalid type:%d", mtd_info.type);
            ret_status = RET_DEV_ERR_PARAM;
        } else if (mtd_info.erasesize == 0) {
            NOR_ERRLOG("invalid erasesize:%d", mtd_info.erasesize);
            ret_status = RET_DEV_ERR_PARAM;
        } else {
            if ((i_offset + i_size) > (int)(mtd_info.erasesize - BACKUP_CHECK_OFFSET)) {
                NOR_ERRLOG("invalid size:%d offset:%d erasesize:%d", i_size, i_offset, mtd_info.erasesize);
                ret_status = RET_DEV_ERR_PARAM;
            }
        }
        if (ret_status == RET_DEV_NORMAL) {
            /* Start Semaphore(flash)    */
            pthread_mutex_lock(&g_semid_flash);
            ret_status = (int)MtdnBackupWriteSub(path_name, i_id, i_offset, i_size, p_buff, &mtd_info);

            /* End Semaphore(flash)    */
            pthread_mutex_unlock(&g_semid_flash);
        }
    }
    if (ret_status != RET_DEV_NORMAL) {
        NOR_ERRLOG("error return:%d", ret_status);
    }
    return    ret_status;
}

/***************************************************************************
@brief        MtdnBackupReadSub
@outline        Read-out of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@param[in]    mtd_info_t * mtd_info    : info
@param[in]    int * get_state    : 0:Rrg Normal 1:Bak Normal
@return     NOR_READ_BLK_CHK
@retval        RET_RD_CHK_OK    : No error
@retval        Except        : Error
@usage        It is Backup API of data read.
*****************************************************************************/
NOR_READ_BLK_CHK    MtdnBackupReadSub(const char * path_name, int i_id, int i_offset, int i_size,
                                      void *p_buff, mtd_info_t * mtd_info, int * get_state) {
    NOR_READ_BLK_CHK ret_status = RET_RD_CHK_OK;
    char *    lp_buffer;

    if (mtd_info->erasesize != 0) {  // LCOV_EXCL_BR_LINE 6: double check
        lp_buffer = (char *)malloc(mtd_info->erasesize);
        if (lp_buffer == NULL) {
            NOR_ERRLOG("malloc:%p", lp_buffer);
            ret_status = RET_RD_DEV_ERR;        // error
        }
    } else {
        // LCOV_EXCL_START 8: dead code
        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        NOR_ERRLOG("invalid erasesize:%d", mtd_info->erasesize);
        ret_status = RET_RD_DEV_ERR;        // error
        // LCOV_EXCL_STOP
    }
    if (ret_status == RET_RD_CHK_OK) {
        memset(lp_buffer, 0x00, mtd_info->erasesize);
        NOR_R_STATE        cycle_state = NOR_IDLE;
        int        block_check_mode = 0;
        int ret_sum = 0;
        while ((cycle_state < NOR_READ_END)
              &&(ret_status == RET_RD_CHK_OK)) {
            switch (cycle_state) {
            case NOR_IDLE:
                // Read-out of block data
                if (0 != MtdnBackupReadBase((const char *)path_name, i_id, 0,
                                            (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                    ret_status = RET_RD_ERR_OTHER;        // Other abnormalities
                } else {
                    NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize, (int *)&ret_sum);
                    if (ret == RET_CHK_TEXT_ERR) {            // Text character sequence   Abnormalities
                        cycle_state = NOR_ORG_TEXT;
                    } else if (ret == RET_CHK_BCC_ERR) {    // (BCC)error
                        cycle_state = NOR_ORG_BCC;
                    } else {
                        block_check_mode = 0;        // Org Normal
                        cycle_state = NOR_READ_OK;
                    }
                }
                break;
            case NOR_ORG_TEXT:    // OrgText Error
                // Read-out of block data
                if (0 != MtdnBackupReadBase((const char *)path_name, (i_id+1), 0,
                                            (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                    // other error
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = RET_RD_ERR_OTHER;    // LCOV_EXCL_LINE 5: c API error case.
                } else {
                    NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize,
                                                           (int *)&ret_sum);      // check SUM
                    if (ret == RET_CHK_TEXT_ERR) {            // Text character sequence   Abnormalities
                        ret_status = RET_RD_ERR_1;        // Uninitialized.
                    } else if (ret == RET_CHK_BCC_ERR) {    // BCC error
                        ret_status = RET_RD_ERR_2;        // write error
                    }
                    block_check_mode = 1;        // Bak Normal
                    cycle_state = NOR_READ_OK;
                }
                break;
            case NOR_ORG_BCC:    // OrgBcc error
                // Read-out of block data
                if (0 != MtdnBackupReadBase((const char *)path_name, (i_id+1), 0,
                                            (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                    // other error
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = RET_RD_ERR_OTHER;    // LCOV_EXCL_LINE 5: c API error case.
                } else {
                    NOR_BLK_CHK ret = MtdBackupCheksumRead(lp_buffer, (int)mtd_info->erasesize,
                                                           (int *)&ret_sum);      // check SUM
                    if (ret == RET_CHK_TEXT_ERR) {            // Text character sequence   Abnormalities
                        ret_status = RET_RD_ERR_3;        // write error
                    } else if (ret == RET_CHK_BCC_ERR) {    // BCC error
                        ret_status = RET_RD_ERR_4;        // write error
                    }
                    block_check_mode = 1;        // Bak Normal
                    cycle_state = NOR_READ_OK;
                }
                break;
            case NOR_READ_OK:    // Normal read-out
                // The pickup of the read data
                memcpy(p_buff, &lp_buffer[i_offset], (size_t)i_size);
                cycle_state = NOR_READ_END;
                break;
            default:
                // LCOV_EXCL_START 8: dead code
                AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                NOR_ERRLOG("invalid state:%d", cycle_state);
                // other error
                ret_status = RET_RD_ERR_OTHER;
                break;
                // LCOV_EXCL_STOP
            }
        }
        *get_state = block_check_mode;    // 0:OrgNormal 1:BakNormal
        free(lp_buffer);
    }
    return    ret_status;        // Normal
}

static inline NOR_WRITE_BLK_CHK MtdnBackupWriteRetryCount(int *count, NOR_WRITE_BLK_CHK cur_state) {
    NOR_WRITE_BLK_CHK ret_state = cur_state;
    (*count)++;
    if (*count > BACKUP_RETRY_CNT) {
        NOR_ERRLOG("retry over!! state:%d count:%d", ret_state, *count);
        ret_state = RET_WT_DEV_ERR;
    }
    return ret_state;
}

/***************************************************************************
@brief        MtdnBackupWriteSub
@outline        Writing of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@param[in]    mtd_info_t * mtd_info    : info
@return     NOR_WRITE_BLK_CHK
@retval        RET_WT_CHK_OK    : No error
@retval        Except    : Error
@usage        It is Backup API of data read.
*****************************************************************************/
NOR_WRITE_BLK_CHK    MtdnBackupWriteSub(const char * path_name, int i_id, int i_offset,
                                        int i_size, void *p_buff, mtd_info_t * mtd_info) {
    NOR_WRITE_BLK_CHK ret_status = RET_WT_CHK_OK;
    char*    lp_buffer;

    lp_buffer = (char *)malloc(mtd_info->erasesize);
    if (lp_buffer == NULL) {
        NOR_ERRLOG("malloc:%p", lp_buffer);
        ret_status = RET_WT_DEV_ERR;        // error
    } else {
        memset(lp_buffer, 0x00, mtd_info->erasesize);
        NOR_W_STATE    cycle_state = NOR_IDEL;
        int    retry_cnt = 0;
        int get_state = 0;    // Read status

        while ((cycle_state < NOR_WRITE_END)
              &&(ret_status == RET_WT_CHK_OK)) {
            switch (cycle_state) {
            case NOR_IDEL:    // IDLE
                if (RET_RD_CHK_OK != MtdnBackupReadSub((const char *)path_name, i_id, 0,
                                                       (int)mtd_info->erasesize, lp_buffer, mtd_info, &get_state)) {
                    cycle_state = NOR_READ_ERR;    // read error
                } else {
                    // write data set
                    memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size);
                    if (get_state == 0) {
                        cycle_state = NOR_ORG_READ;    // Org read Normal
                    } else {
                        // Bakread Normal
                        cycle_state = NOR_BACK_READ;
                    }
                    // Embedding of write-in data
                    memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size);
                }
                break;
            case NOR_READ_ERR:    // read error
                memset((char *)lp_buffer, 0x00, mtd_info->erasesize);
                // Embedding of write-in data
                memcpy(&lp_buffer[i_offset], p_buff, (size_t)i_size);
                cycle_state = NOR_ORG_READ;    // Org read Normal
                break;
            case NOR_ORG_READ:    // Orgread Normal
                // LCOV_EXCL_BR_START 6: double check
                if (0 != MtdBackupCheksumWrite(lp_buffer, (int)mtd_info->erasesize )) {            // check SUM
                // LCOV_EXCL_BR_STOP
                    // error(It does not generate.)
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = RET_WT_DEV_ERR;    // LCOV_EXCL_LINE 8: dead code
                } else {
                    // data write
                    if (0 == MtdnBackupWriteBase((const char *)path_name, (i_id+1), 0,
                                                 (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                        cycle_state = NOR_BAK_WRT;    // Bakwrite Success
                        retry_cnt = 0;
                    } else {
                        ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status);
                    }
                }
                break;
            case NOR_BAK_WRT:    // BakWriteSuccess
                // Data write
                // LCOV_EXCL_BR_START 11:unexpected branch
                if (0 == MtdnBackupWriteBase((const char *)path_name, i_id, 0,
                                             (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                // LCOV_EXCL_BR_STOP
                    cycle_state = NOR_WRITE_END;    // Normal end
                } else {
                    // LCOV_EXCL_START 5: c API error case.
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status);
                    // LCOV_EXCL_STOP
                }
                break;
            case NOR_BACK_READ:    // Bak read normal
                // LCOV_EXCL_BR_START 6: double check
                if (0 != MtdBackupCheksumWrite(lp_buffer, (int)mtd_info->erasesize )) {            // check SUM
                // LCOV_EXCL_BR_STOP
                    // Retry over
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = RET_WT_DEV_ERR;    // LCOV_EXCL_LINE 8: dead code
                } else {
                    // data write
                    if (0 == MtdnBackupWriteBase((const char *)path_name, i_id, 0,
                                                 (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                        // Org write Succses
                        cycle_state = NOR_ORG_WRITE;
                        retry_cnt = 0;
                    } else {
                        // LCOV_EXCL_START 5: c API error case.
                        AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                        ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status);
                        // LCOV_EXCL_STOP
                    }
                }
                break;
            case NOR_ORG_WRITE:    // Org write Succses
                // data write
                if (0 == MtdnBackupWriteBase((const char *)path_name, (i_id+1), 0,
                                             (int)mtd_info->erasesize, lp_buffer, mtd_info)) {
                    // Normal end
                    cycle_state = NOR_WRITE_END;
                } else {
                    // LCOV_EXCL_START 5: c API error case.
                    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    ret_status = MtdnBackupWriteRetryCount(&retry_cnt, ret_status);
                    // LCOV_EXCL_STOP
                }
                break;
            default:
                // LCOV_EXCL_START 8: dead code
                AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                NOR_ERRLOG("invalid state:%d", cycle_state);
                // other error
                ret_status = RET_WT_ERR_OTHER;
                break;
                // LCOV_EXCL_STOP
            }
        }
        free(lp_buffer);
    }
    return    ret_status;        // Normal
}

/***************************************************************************
@brief        MtdnBackupReadBase
@outline        Read-out of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@param[in]    mtd_info_t * mtd_info    :
@return     int
@retval        0    : No error
@retval        Except    : Error
@usage        It is Backup API of data read.
*****************************************************************************/
int    MtdnBackupReadBase(const char * path_name, int i_id, int i_offset,
                          int i_size, void *p_buff, mtd_info_t * mtd_info) {
    int ret_status = RET_DEV_NORMAL;

    int mtd_fd = open(path_name, O_RDONLY|O_CLOEXEC);
    // LCOV_EXCL_BR_START 5:It's impossible to mock open() function,so this line can not be passed.
    if (mtd_fd == -1) {
    // LCOV_EXCL_BR_STOP
    // LCOV_EXCL_START 5:It's impossible to mock open() function,so this line can not be passed.
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        NOR_ERRLOG("open(%s):%s", path_name, strerror(errno));
        ret_status = RET_DEV_ERROR;
    // LCOV_EXCL_STOP
    } else {
        int seek_top = i_id * (int)mtd_info->erasesize + i_offset;
        int sector_size = BACKUP_SECTOR_SIZ;
        int block_size = (int)mtd_info->erasesize / sector_size;    // Division number
        int llpi;
        int    buff_top = 0;
        int    get_size = i_size;
        char * work_buff = (char *)p_buff;
        ssize_t        read_size;

        // It reads several sector minutes.
        for (llpi=0; llpi < block_size; llpi++) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
            // It moves to a head.
            if (-1 == (off_t)lseek(mtd_fd, seek_top, SEEK_SET)) {
                NOR_ERRLOG("lseek():%s", strerror(errno));
                ret_status = RET_DEV_ERROR;
                break;
            }
            if (get_size >= sector_size) {  // LCOV_EXCL_BR_LINE 6:double check
                read_size = read(mtd_fd, &work_buff[buff_top], (size_t)sector_size);
                if (read_size < 0) {
                    NOR_ERRLOG("read():%zd %s", read_size, strerror(errno));
                    ret_status = RET_DEV_ERROR;
                    break;
                }

                get_size -= sector_size;
                if (get_size <= 0) {
                    break;
                }
            } else {
            // LCOV_EXCL_START 8: dead code
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                read_size = read(mtd_fd, &work_buff[buff_top], (size_t)get_size);
                if (read_size < 0) {
                    NOR_ERRLOG("read():%zd %s", read_size, strerror(errno));
                    ret_status = RET_DEV_ERROR;
                    break;
                }
                break;
            // LCOV_EXCL_STOP
            }
            seek_top += (int)read_size;
            buff_top += (int)read_size;
        }
        // LCOV_EXCL_BR_START 5:It's impossible to mock close() function,so this line can not be passed.
        if (0 != close(mtd_fd)) {
        // LCOV_EXCL_BR_STOP
            // LCOV_EXCL_START 5:It's impossible to mock close() function,so this line can not be passed.
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
            NOR_ERRLOG("close():%s", strerror(errno));
            ret_status = RET_DEV_ERROR;
            // LCOV_EXCL_STOP
        }
    }
    return    ret_status;
}

/***************************************************************************
@brief        MtdnBackupWriteBase
@outline        Writing of specified block ID
@type        Completion return type
@param[in]    const char * path_name    : (/dev/mtd  Device)
@param[in]    int    i_id        : ID...0~
@param[in]    int    i_offset    :  ( i_offset >= 0)
@param[in]    int    i_size    :  ( i_size > 0)
@param[in]    void *p_buff    : (p_buff != NULL)
@param[in]    mtd_info_t * mtd_info    :
@return     int
@retval        0    : No error
@retval        Except    : Error
@usage        It is Backup API of data read.
*****************************************************************************/
int    MtdnBackupWriteBase(const char * path_name, int i_id, int i_offset,
                           int i_size, void *p_buff, mtd_info_t * mtd_info) {
    int ret_status = RET_DEV_NORMAL;

    int mtd_fd = open(path_name, O_RDWR|O_CLOEXEC);
    if (mtd_fd == -1) {
        NOR_ERRLOG("open(%s):%s", path_name, strerror(errno));
        ret_status = RET_DEV_ERROR;
    } else {
        erase_info_t s_mtd_erase;
        s_mtd_erase.start = (__u32)i_id * mtd_info->erasesize;
        s_mtd_erase.length = mtd_info->erasesize;
        // erase
        if (ioctl(mtd_fd, MEMERASE, &s_mtd_erase) < 0) {
            NOR_ERRLOG("ioctl(MEMERASE):%s", strerror(errno));
            ret_status = RET_DEV_ERROR;
        } else {
            // write
            int seek_top = i_id * (int)mtd_info->erasesize + i_offset;
            int sector_size = BACKUP_SECTOR_SIZ;        //
            int block_size = (int)mtd_info->erasesize/sector_size;
            int llpi;
            int    buff_top = 0;
            int    put_size = i_size;
            char * work_buff = (char *)p_buff;
            ssize_t    write_size;

            for (llpi=0; llpi < block_size; llpi++) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
                if (-1 == (off_t)lseek(mtd_fd, seek_top, SEEK_SET)) {
                    NOR_ERRLOG("lseek():%s", strerror(errno));
                    ret_status = RET_DEV_ERROR;
                    break;
                }
                if (put_size >= sector_size) {  // LCOV_EXCL_BR_LINE 6:double check
                    write_size = write(mtd_fd, &work_buff[buff_top], (size_t)sector_size);
                    if (write_size < 0) {
                        NOR_ERRLOG("write():%zd %s", write_size, strerror(errno));
                        ret_status = RET_DEV_ERROR;
                        break;
                    }
                    put_size -= sector_size;
                    if (put_size <= 0) {
                        break;
                    }
                } else {
                // LCOV_EXCL_START 8: dead code
                AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
                    write_size = write(mtd_fd, &work_buff[buff_top], (size_t)put_size);
                    if (write_size < 0) {
                        NOR_ERRLOG("write():%zd %s", write_size, strerror(errno));
                        ret_status = RET_DEV_ERROR;
                        break;
                    }
                    break;
                // LCOV_EXCL_STOP
                }
                seek_top += (int)write_size;
                buff_top += (int)write_size;
            }
        }
        // LCOV_EXCL_BR_START 5:It's impossible to mock close() function,so this line can not be passed.
        if (0 != close(mtd_fd)) {
        // LCOV_EXCL_BR_STOP
            // LCOV_EXCL_START 5:It's impossible to mock close() function,so this line can not be passed.
            AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
            NOR_ERRLOG("close():%s", strerror(errno));
            ret_status = RET_DEV_ERROR;
            // LCOV_EXCL_STOP
        }
    }
    return    ret_status;
}

/***************************************************************************
int    backup_cheksum_read(char * p_buff, int erase_size ,int * ret_sum)
 * A text character sequence and a sum value are checked.
 IN:     char * p_buff        ...top address
        int erase_size    ...erase size
        int * ret_sum    ...return sum

 OUT: NOR_BLK_CHK    RET_CHK_OK:Normal
                    RET_CHK_TEXT_ERR:test error
                    RET_CHK_BCC_ERR:sum error Except:other error
 Remarks:
*****************************************************************************/
NOR_BLK_CHK    MtdBackupCheksumRead(char * p_buff, int erase_size, int * ret_sum) {
    if (erase_size > BACKUP_CHECK_OFFSET) {  // LCOV_EXCL_BR_LINE 6: double check
        // The check of the compatibility of block data
        if (0 != memcmp(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE)) {
            char tmp[BACKUP_CHECK_SIZE + 1];
            memcpy(tmp, &p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_SIZE);
            tmp[BACKUP_CHECK_SIZE] = '\0';
            NOR_ERRLOG("invalid check_text:%s", tmp);
            return    RET_CHK_TEXT_ERR;
        }
        // The check of the compatibility of block data
        int llpi;
        int get_sum;
        int    work_sum = 0;
        get_sum = ((int)p_buff[(erase_size-BACKUP_CHECK_DAT2)] & 0xff) +
                    (((int)p_buff[(erase_size-BACKUP_CHECK_DAT1)]) << 8 & 0xff00);

        for (llpi=0; llpi < (erase_size-BACKUP_CHECK_OFFSET); llpi++) {
            work_sum += p_buff[llpi];
        }
        work_sum = (work_sum & 0xffff);
        if (work_sum != get_sum) {
            NOR_ERRLOG("invalid checksum: work:%d get:%d", work_sum, get_sum);
            return    RET_CHK_BCC_ERR;        // checksum error
        }
        if (ret_sum != NULL) {  // LCOV_EXCL_BR_LINE 6: double check
            *ret_sum = work_sum;    // chesum Storing
        }
    } else {
    // LCOV_EXCL_START 8: dead code
    AGL_ASSERT_NOT_TESTED();  // LCOV_EXCL_LINE 200: test assert
        NOR_ERRLOG("invalid erase_size:%d", erase_size);
        // checksum error
        return    RET_CHK_BCC_ERR;
    // LCOV_EXCL_STOP
    }
    return    RET_CHK_OK;
}

/***************************************************************************
int    backup_cheksum_write(char * p_buff, int erase_size )
 * A text character sequence and a sum value are written in a buffer.
 IN:     char * p_buff        ...top address
        int erase_size    ...erase size

 OUT: int    0:normal Except:error
 Remarks:
*****************************************************************************/
int    MtdBackupCheksumWrite(char * p_buff, int erase_size ) {
    int    sum_add = 0;

    if (erase_size > BACKUP_CHECK_OFFSET) {  // LCOV_EXCL_BR_LINE 11:unexpected branch
        int ret_status;
        // The check of the compatibility of block data
        ret_status = memcmp(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE);
        if (ret_status != 0) {
            memcpy(&p_buff[(erase_size-BACKUP_CHECK_OFFSET)], BACKUP_CHECK_TEXT, BACKUP_CHECK_SIZE);
        }
        int llpi;
        for (llpi=0; llpi < (erase_size-BACKUP_CHECK_OFFSET); llpi++) {
            sum_add += p_buff[llpi];
        }
    }
    p_buff[(erase_size-BACKUP_CHECK_DAT2)] = (char)(sum_add     & 0xff);
    p_buff[(erase_size-BACKUP_CHECK_DAT1)] = (char)((sum_add>>8) & 0xff);
    return    RET_DEV_NORMAL;
}

/***************************************************************************
@brief        MtdBackupInfo( mtd_info_t * mtd_info)
@outline        The information to obtain is obtained.
@type        Completion return type
@param[in]    mtd_info_t * mtd_info
@return     int
@retval        0        : No error
@retval        Except    : Error
@usage        It is Backup API of data read.
*****************************************************************************/
int    MtdBackupInfo(const char * path_name, mtd_info_t * mtd_info) {
    int         ret_status = RET_DEV_NORMAL;

    int mtd_fd = open(path_name, O_RDONLY|O_CLOEXEC);
    if (mtd_fd == -1) {
        NOR_ERRLOG("open(%s):%s", path_name, strerror(errno));
        ret_status = RET_DEV_ERROR;
    } else {
        // device control  mtdchar_ioctl of mtdchar.c
        if (ioctl(mtd_fd, MEMGETINFO, mtd_info) < 0) {
            NOR_ERRLOG("ioctl(MEMGETINFO):%s", strerror(errno));
            ret_status = RET_DEV_ERROR;
        }
        if (0 != close(mtd_fd)) {
            NOR_ERRLOG("close():%s", strerror(errno));
            ret_status = RET_DEV_ERROR;
        }
    }
    return    ret_status;
}

/**************************************************************
  End Of Files
**************************************************************/