xc_drv_fmc_spi.c

浏览该文件的文档.

 
/*-----------------------------------------------------------------------------------
                                       INCLUDE HEADE FILES
 ------------------------------------------------------------------------------------*/
#include "xc_drv_fmc_spi.h"
 
/*------------------------------------------------------------------------------------
                                            Functions
 -------------------------------------------------------------------------------------*/
__RAM_CODE static void *ram_memcpy_bytes(void *dst, const void *src, int size)
{
    if (dst == NULL || src == NULL || size <= 0)
        return NULL;
 
    char *pdst = (char *)dst;
    char *psrc = (char *)src;
 
    if (pdst > psrc && pdst < psrc + size) {
        pdst = pdst + size - 1;
        psrc = psrc + size - 1;
        while (size--)
            *pdst-- = *psrc--;
    } else {
        while (size--)
            *pdst++ = *psrc++;
    }
 
    return dst;
}
 
__RAM_CODE static void xc_fmc_status_wait_idle(void)
{
    uint32_t reg = 0;
    do {
        __READ_REG32(BLE_COMN_AGC_REG_OUT0, reg);
    } while (!(reg & FMC_IDLE_STATUS));
}
 
__RAM_CODE static void xc_fmc_spi_write_nbyte(uint8_t *txdata, uint16_t size)
{
    if (size == 0)
        return;
 
    uint16_t n;
    uint8_t remain            = size % 4;
    uint16_t cnt              = size / 4;
    uint32_t mid_data[64 + 1] = {0};
 
    if (cnt != 0) {
        for (n = 0; n < cnt; n++) {
            mid_data[n] = ((txdata[n * 4] << 24) | (txdata[n * 4 + 1] << 16) |
                           (txdata[n * 4 + 2] << 8) | txdata[n * 4 + 3]);
        }
    }
 
    if (remain != 0) {
        for (n = 0; n < remain; n++) {
            mid_data[cnt] |= (txdata[cnt * 4 + n] << (24 - 8 * n));
        }
    }
 
    if (cnt != 0) {
        if (remain != 0)
            cnt = cnt + 1;
        for (n = 0; n < cnt; n++)
            fmc_data__fmc_dr__setf(mid_data[n]);
    } else {
        fmc_data__fmc_dr__setf(mid_data[0]);
    }
 
    while (!(fmc_sts_get() & FMC_SSI_STS_TFE_SET) ||
           (fmc_sts_get() & FMC_SSI_STS_BUSY_SET))
        ;
}
 
__RAM_CODE static void xc_fmc_spi_read_nbyte(uint8_t *rxdata, uint16_t size)
{
    if (size == 0)
        return;
 
    uint16_t n;
    uint8_t remain    = size % 4;
    uint16_t cnt      = size / 4;
    uint32_t mid_data = 0;
 
    if (cnt != 0) {
        for (n = 0; n < cnt; n++) {
            mid_data          = fmc_data__fmc_dr__getf();
 
            rxdata[n * 4]     = mid_data >> 24;
            rxdata[n * 4 + 1] = mid_data >> 16;
            rxdata[n * 4 + 2] = mid_data >> 8;
            rxdata[n * 4 + 3] = mid_data;
        }
    }
 
    if (remain != 0) {
        mid_data = fmc_data__fmc_dr__getf();
 
        for (n = 0; n < remain; n++) {
            rxdata[cnt * 4 + n]     = mid_data >> 24;
            rxdata[cnt * 4 + 1 + n] = mid_data >> 16;
            rxdata[cnt * 4 + 2 + n] = mid_data >> 8;
            rxdata[cnt * 4 + 3 + n] = mid_data;
        }
    }
 
    while (fmc_sts_get() & FMC_SSI_STS_RFNE_SET) {
        mid_data = fmc_data__fmc_dr__getf();
    }
}
 
__RAM_CODE static void xc_fmc_spi_enable(uint8_t dfs)
{
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_DISABLE);
    if (dfs != FMC_SSI_CTRL0_DFS_LEN_32BIT) {
        fmc_ctrl0__dfs__setf(dfs);
    }
 
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_ENABLE);
}
 
__RAM_CODE static void xc_fmc_spi_disable(void)
{
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_DISABLE);
    fmc_ctrl0__dfs__setf(FMC_SSI_CTRL0_DFS_LEN_32BIT);
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_ENABLE);
}
 
__RAM_CODE void xc_fmc_spi_init_oprt(void)
{
    cpr_bt_clk_ctl__bt_clk_en__setf(ENABLE);
 
    cpr_bt_modem_clk_ctl__bt_modem_clk_en__setf(ENABLE);
 
    cpr_ctlapbclken_grctl__bt_pclk_en__setf(ENABLE);
    cpr_ssi0_mclk_ctl__ssi_mclk_en__setf(DISABLE);
    cpr_rstctl_subrst_sw__ssi0_rstn__setf(RSTCTL_ENABLE);
    cpr_rstctl_subrst_sw__ssi0_rstn__setf(RSTCTL_DISABLE);
 
    xc_fmc_status_wait_idle();
 
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_DISABLE);
 
    fmc_ctrl0__sste__setf(FMC_SSI_CTRL0_SSTE_DISABLE);
 
    fmc_ctrl0__dfs__setf(FMC_SSI_CTRL0_DFS_LEN_32BIT);
 
    fmc_ctrl0__slv_oe__setf(FMC_SSI_CTRL0_SLV_OE_ENABLE);
 
    fmc_se__ss0__setf(FMC_SSI_EN_SEN_ENABLE);
 
    fmc_ie_set(FMC_SSI_IE_TXEIE_DISABLE | FMC_SSI_IE_TXOIE_DISABLE |
               FMC_SSI_IE_RXUIE_DISABLE | FMC_SSI_IE_RXOIE_DISABLE |
               FMC_SSI_IE_RXFIE_DISABLE);
 
    fmc_baud__sckdv__setf(FMC_SSI_BAUD_DIV_2);
    fmc_txftl__tft__setf(FMC_SSI_TXFTL_FIFO_0);
    fmc_rxftl__rft__setf(FMC_SSI_RXFTL_FIFO_0);
    fmc_en__ssic_en__setf(FMC_SSI_EN_SEN_ENABLE);
}
 
__RAM_CODE void xc_fmc_spi_flash_power_down(void)
{
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[4];
 
    cmd[0] = 0;
    cmd[1] = 0;
    cmd[2] = 0;
    cmd[3] = CMD_PWRDWN;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_8BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
    xc_fmc_spi_disable();
}
 
__RAM_CODE void xc_fmc_spi_flash_wake_up(void)
{
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[4];
 
    cmd[0] = 0;
    cmd[1] = 0;
    cmd[2] = 0;
    cmd[3] = CMD_RELEASE_PWRDWN;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_8BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
 
    xc_fmc_spi_disable();
}
 
__RAM_CODE static uint8_t xc_fmc_spi_flash_status(void)
{
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[2] = {0};
    uint8_t sta[4] = {0xff, 0xff, 0xff, 0xff};
 
    cmd[0]         = CMD_READ_STATUS;
    cmd[1]         = 0xff;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
    xc_fmc_spi_read_nbyte(sta, sizeof(sta));
    xc_fmc_spi_disable();
 
    return sta[1];
}
 
__RAM_CODE static void xc_fmc_spi_flash_wait_busy(void)
{
    while ((xc_fmc_spi_flash_status() & PUYA_FLASH_STATUS_WIP_SET))
        ;
}
 
__RAM_CODE static void xc_fmc_spi_flash_write_enable(void)
{
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[4] = {0};
 
    cmd[0]         = 0;
    cmd[1]         = 0;
    cmd[2]         = 0;
    cmd[3]         = CMD_WRITE_ENABLE;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_8BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
    xc_fmc_spi_disable();
}
 
__RAM_CODE void xc_fmc_spi_flash_erase_sector(uint32_t addr)
{
    xc_fmc_status_wait_idle();
 
    xc_fmc_spi_flash_wait_busy();
    xc_fmc_spi_flash_write_enable();
    xc_fmc_spi_flash_wait_busy();
 
    uint8_t cmd[4] = {0};
 
    cmd[0]         = CMD_SECTOR_ERASE;
    cmd[1]         = addr >> 16;
    cmd[2]         = addr >> 8;
    cmd[3]         = addr;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
    xc_fmc_spi_disable();
 
    xc_fmc_spi_flash_wait_busy();
}
 
__RAM_CODE void xc_fmc_spi_flash_erase_page(uint32_t addr)
{
    uint32_t mid = 0;
    xc_fmc_spi_flash_rdid((uint8_t*)&mid);
    
    if(mid != GD_FlASH_RDID){       
        xc_fmc_status_wait_idle();
 
        xc_fmc_spi_flash_wait_busy();
        xc_fmc_spi_flash_write_enable();
        xc_fmc_spi_flash_wait_busy();
 
        uint8_t cmd[4] = {0};
 
        cmd[0]         = CMD_PAGE_ERASE;
        cmd[1]         = addr >> 16;
        cmd[2]         = addr >> 8;
        cmd[3]         = addr;
 
        xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
        xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
        xc_fmc_spi_disable();
 
        xc_fmc_spi_flash_wait_busy();    
    }
}
 
__RAM_CODE void xc_fmc_spi_flash_write_page(uint32_t addr, uint8_t *data,
                                         uint16_t size)
{
    if (size > FLASH_PAGE_SIZE)
        return;
 
    uint8_t cmd[16 + 4] = {0};
 
    for (uint8_t i = 0; i < 16; i++) {
        xc_fmc_spi_flash_wait_busy();
        xc_fmc_spi_flash_write_enable();
        xc_fmc_spi_flash_wait_busy();
 
        cmd[0] = CMD_PAGE_PROGRAM;
        cmd[1] = addr >> 16;
        cmd[2] = addr >> 8;
        cmd[3] = addr;
 
        ram_memcpy_bytes(&cmd[4], data + i * 16, 16);
 
        xc_fmc_status_wait_idle();
 
        xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
        xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
 
        addr += 16;
    }
 
    xc_fmc_spi_flash_wait_busy();
    xc_fmc_spi_disable();
}
 
 
__RAM_CODE void xc_fmc_spi_otp_read_page(uint32_t addr, uint8_t *data,
                                        uint16_t size)
{
      uint8_t temp_buff[FLASH_PAGE_SIZE] = {0};
    if (size > FLASH_PAGE_SIZE)
        return;
 
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[16 + 5] = {0};
    uint8_t mid[16 + 5] = {0};
    uint16_t rx_idx     = 0;
        
        uint8_t address_h = 0;
    uint8_t address_l = 0;
        uint32_t addr_offset=0;
 
    for (uint8_t i = 0; i < 3; i++) {
            
              address_h = ((addr_offset) & 0x100) >> 8;
        address_l = addr_offset & 0xff;   
            
        cmd[0] = CMD_READ_SECURITY_REG;
        cmd[1] = 0X00;
        cmd[2] = addr & 0xFE | address_h;
        cmd[3] = address_l;
              cmd[4] = 0xff;
 
        xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
        xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
        xc_fmc_spi_read_nbyte(mid, sizeof(cmd));
 
        ram_memcpy_bytes(&temp_buff[rx_idx], mid + 5, 16);
        addr_offset   += 16;
        rx_idx += 16;
    }
    xc_fmc_spi_disable();
        
        ram_memcpy_bytes(data,temp_buff,size);
}
 
 
 
 
 
__RAM_CODE void xc_fmc_spi_flash_read_page(uint32_t addr, uint8_t *data,
                                        uint16_t size)
{
    if (size > FLASH_PAGE_SIZE)
        return;
 
    xc_fmc_status_wait_idle();
 
    uint8_t cmd[16 + 4] = {0};
    uint8_t mid[16 + 4] = {0};
    uint16_t rx_idx     = 0;
 
    for (uint8_t i = 0; i < 16; i++) {
        cmd[0] = CMD_READ_DATA;
        cmd[1] = addr >> 16;
        cmd[2] = addr >> 8;
        cmd[3] = addr;
 
        xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
        xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
        xc_fmc_spi_read_nbyte(mid, sizeof(cmd));
 
        ram_memcpy_bytes(&data[rx_idx], mid + 4, 16);
        addr   += 16;
        rx_idx += 16;
    }
 
    xc_fmc_spi_disable();
}
 
__RAM_CODE uint8_t xc_fmc_spi_flash_write(uint32_t addr, uint8_t *buff,
                                       uint16_t size)
{
    uint32_t cur_addr = addr;
    uint32_t end_addr = addr + size;
    uint16_t wt_len   = 0;
    // The current page number occupied by this data storage
    uint16_t CurPageNum = 0; 
    uint16_t CurSectorNum = 0; 
    // The position occupied by this address on the current page
    uint32_t CurStartPsr = 0; 
    
 
    uint32_t mid = 0;
    xc_fmc_spi_flash_rdid((uint8_t*)&mid);  
    
    if(mid != GD_FlASH_RDID){
        uint8_t temp_buff[FLASH_PAGE_SIZE];
        while (cur_addr != end_addr) {
            /* code */
            CurPageNum  = CUR_PAGE_NUM(cur_addr);
            CurStartPsr = CUR_START_PSR(cur_addr);
 
            xc_fmc_spi_flash_read_page(CurPageNum * FLASH_PAGE_SIZE, temp_buff,
                                FLASH_PAGE_SIZE);
            xc_fmc_spi_flash_erase_page(CurPageNum * FLASH_PAGE_SIZE);
            
 
            if (CurStartPsr) {
                memcpy(&temp_buff[CurStartPsr], buff + wt_len,
                                 (FLASH_PAGE_SIZE  - CurStartPsr) > size - wt_len // 当前扇区剩余的空间是否满足写长度
                                     ? size - wt_len
                                     : (FLASH_PAGE_SIZE  - CurStartPsr));
                wt_len += wt_len + ((FLASH_PAGE_SIZE  - CurStartPsr) > size - wt_len
                                        ? size - wt_len
                                        : (FLASH_PAGE_SIZE  - CurStartPsr));
                cur_addr += wt_len;
            } else {
                memcpy(temp_buff, buff + wt_len,
                                 size - wt_len > FLASH_PAGE_SIZE  ? FLASH_PAGE_SIZE 
                                                                 : size - wt_len);
                cur_addr += (size - wt_len > FLASH_PAGE_SIZE  ? FLASH_PAGE_SIZE 
                                                             : size - wt_len);
                wt_len   += (size - wt_len > FLASH_PAGE_SIZE  ? FLASH_PAGE_SIZE 
                                                             : size - wt_len);
            }
            
            xc_fmc_spi_flash_write_page(CurPageNum * FLASH_PAGE_SIZE, temp_buff,
                                     FLASH_PAGE_SIZE);
        }
          
    }else if(mid == GD_FlASH_RDID){    
        uint8_t temp_buff[FLASH_SECTOR_SIZE] = {0};
        while (cur_addr != end_addr) {
            /* code */
            CurSectorNum  = CUR_SECTOR_NUM(cur_addr);
            CurStartPsr = CUR_START_PSR(cur_addr);
            
            for(int i=0;i<FLASH_SECTOR_SIZE/FLASH_PAGE_SIZE;i++){
                xc_fmc_spi_flash_read_page(CurSectorNum * FLASH_SECTOR_SIZE+ i* FLASH_PAGE_SIZE, temp_buff+i*FLASH_PAGE_SIZE,
                                    FLASH_PAGE_SIZE);
            }
            
            xc_fmc_spi_flash_erase_sector(CurSectorNum * FLASH_SECTOR_SIZE);
            
            if (CurStartPsr) {
                ram_memcpy_bytes(&temp_buff[CurStartPsr], buff + wt_len,
                                 (FLASH_SECTOR_SIZE - CurStartPsr) > size - wt_len
                                     ? size - wt_len
                                     : (FLASH_SECTOR_SIZE - CurStartPsr));
                wt_len += wt_len + ((FLASH_SECTOR_SIZE - CurStartPsr) > size - wt_len
                                        ? size - wt_len
                                        : (FLASH_SECTOR_SIZE - CurStartPsr));
                cur_addr += wt_len;
            } else {
                ram_memcpy_bytes(temp_buff, buff + wt_len,
                                 size - wt_len > FLASH_SECTOR_SIZE ? FLASH_SECTOR_SIZE
                                                                 : size - wt_len);
                cur_addr += (size - wt_len > FLASH_SECTOR_SIZE ? FLASH_SECTOR_SIZE
                                                             : size - wt_len);
                wt_len   += (size - wt_len > FLASH_SECTOR_SIZE ? FLASH_SECTOR_SIZE
                                                             : size - wt_len);
            }
            
            for(int i=0;i<FLASH_SECTOR_SIZE/FLASH_PAGE_SIZE;i++){
                xc_fmc_spi_flash_write_page(CurSectorNum * FLASH_SECTOR_SIZE+ i* FLASH_PAGE_SIZE, temp_buff+i*FLASH_PAGE_SIZE,
                                         FLASH_PAGE_SIZE);
            }
        }        
    }
 
 
    return 0;
}
 
__RAM_CODE uint8_t xc_fmc_spi_flash_read(uint32_t addr, uint8_t *buff,
                                      uint16_t size)
{
    uint32_t cur_addr    = addr;
    uint32_t end_addr    = addr + size;
    uint16_t rd_len      = 0;
    uint16_t CurPageNum  = 0;
    uint32_t CurStartPsr = 0;
    uint8_t temp_buff[FLASH_PAGE_SIZE] = {0};
 
    while (cur_addr != end_addr) {
        CurPageNum  = CUR_PAGE_NUM(cur_addr);
        CurStartPsr = CUR_START_PSR(cur_addr);
        xc_fmc_spi_flash_read_page(CurPageNum * FLASH_PAGE_SIZE, temp_buff,
                                FLASH_PAGE_SIZE);
        if (CurStartPsr) {
            ram_memcpy_bytes(buff + rd_len, &temp_buff[CurStartPsr],
                             (FLASH_PAGE_SIZE - CurStartPsr) > size - rd_len
                                 ? size - rd_len
                                 : (FLASH_PAGE_SIZE - CurStartPsr));
            rd_len += rd_len + ((FLASH_PAGE_SIZE - CurStartPsr) > size - rd_len
                                    ? size - rd_len
                                    : (FLASH_PAGE_SIZE - CurStartPsr));
            cur_addr += rd_len;
        } else {
            ram_memcpy_bytes(buff + rd_len, temp_buff,
                             size - rd_len > FLASH_PAGE_SIZE ? FLASH_PAGE_SIZE
                                                             : size - rd_len);
            cur_addr += (size - rd_len > FLASH_PAGE_SIZE ? FLASH_PAGE_SIZE
                                                         : size - rd_len);
            rd_len   += (size - rd_len > FLASH_PAGE_SIZE ? FLASH_PAGE_SIZE
                                                         : size - rd_len);
        }
    }
 
    return 0;
}
 
 
__RAM_CODE void xc_fmc_spi_flash_ruid(uint8_t *ruid)
{
    xc_fmc_status_wait_idle();
    xc_fmc_spi_flash_wait_busy();
 
    uint8_t cmd[21] = {0};
    uint8_t id[21]  = {0};
 
    cmd[0]          = CMD_RUID;
    cmd[1]          = 0x00;
    cmd[2]          = 0x00;
    cmd[3]          = 0x00;
    cmd[4]          = 0x00;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
 
    xc_fmc_spi_read_nbyte(id, sizeof(id));
    xc_fmc_spi_disable();
 
    ram_memcpy_bytes(ruid, &id[5], 16);
}
 
__RAM_CODE void xc_fmc_spi_flash_rdid(uint8_t *rdid)
{
    xc_fmc_status_wait_idle();
    xc_fmc_spi_flash_wait_busy();
 
    uint8_t cmd[4] = {0};
    uint8_t id[4]  = {0};
 
    cmd[0]         = CMD_RDID;
    cmd[1]         = 0x0;
    cmd[2]         = 0x0;
    cmd[3]         = 0x0;
 
    xc_fmc_spi_enable(FMC_SSI_CTRL0_DFS_LEN_32BIT);
    xc_fmc_spi_write_nbyte(cmd, sizeof(cmd));
 
    xc_fmc_spi_read_nbyte(id, sizeof(id));
 
    xc_fmc_spi_disable();
 
    ram_memcpy_bytes(rdid, &id[1], 3);
}
 
 
bool flash_size_and_type_get(uint32_t *flash_size, uint16_t *flash_type)
{
    uint32_t mid = 0;
      uint8_t flash_flag =0;
      xc_fmc_spi_init_oprt( );
    xc_fmc_spi_flash_wake_up( );
    xc_fmc_spi_flash_rdid((uint8_t*)&mid);
        
        flash_flag  = (mid >> 16) & 0xff;
        *flash_type = (mid & 0xffff);
        switch(flash_flag)
    {
        case FLASH_128K_FLAG:
           *flash_size = FLASH_128K_SIZE;
        break;
        case FLASH_256K_FLAG:
           *flash_size = FLASH_256K_SIZE;
        break;
        case FLASH_512K_FLAG:
           *flash_size = FLASH_512K_SIZE;
        break;
        case FLASH_1M_FLAG:
           *flash_size = FLASH_1M_SIZE;
        break;
        case FLASH_2M_FLAG:
           *flash_size = FLASH_2M_SIZE;
        break;
                default:
                    return false ;
    }
        return true;
}
 
uint16_t extract32_16(uint32_t val) {  
    return  ((val >> 8) & 0x0000FF00) |  
           (val >> 24);   
}
 
bool reverse_verif_is_true(uint32_t value, uint32_t value_reverse_verif)
{  
   if(value == ~value_reverse_verif) 
     {  
         return true;
     }
   else  
     {   
         return false;
     }
}   
bool xc_adc_2v4_calibrate_read(uint16_t * adc_calibrate)
{
    uint32_t flash_size;
    uint16_t flash_type;
    board_card_t board_card;
    GLOBAL_INT_DISABLE( );
    xc_fmc_spi_init_oprt( );
    xc_fmc_spi_flash_wake_up( );
    
    if(false == flash_size_and_type_get(&flash_size, &flash_type))
    {
        return false;
    }           
    
    if(flash_type == GD25WD40_512K_FLASH)
    {
        xc_fmc_spi_flash_read(flash_size - FLASH_SECTOR_SIZE, (uint8_t *)&board_card, sizeof(board_card));
    }
    else
    {
        xc_fmc_spi_flash_read(flash_size - FLASH_PAGE_SIZE, (uint8_t *)&board_card, sizeof(board_card));
    }           
        
    GLOBAL_INT_RESTORE( );
    
    if(reverse_verif_is_true(board_card.adc2v4_cail, board_card.adc2v4_reverse_verif))
    {
        *adc_calibrate = extract32_16(board_card.adc2v4_cail);
        return true ;
    }   
    else
    {
        GLOBAL_INT_DISABLE( );
        if(flash_type == GD25WD40_512K_FLASH)
        {
        xc_fmc_spi_otp_read_page(OTP_PROGRAM_PAGE_0,(uint8_t *)&board_card, sizeof(board_card));
        }
        else
        {
            xc_fmc_spi_otp_read_page(OTP_PROGRAM_PAGE_1,(uint8_t *)&board_card, sizeof(board_card));
        }
        GLOBAL_INT_RESTORE( );
                
        if(reverse_verif_is_true(board_card.adc2v4_cail, board_card.adc2v4_reverse_verif))
        {
            *adc_calibrate = extract32_16(board_card.adc2v4_cail)  ;
            return true ;
        }   
    }   
    return false;
}
 
 
bool xc_unique_identification_read(uint8_t *unique_id)
{
    uint32_t flash_size;
    uint16_t flash_type;
    board_card_t board_card;
    GLOBAL_INT_DISABLE( );
    xc_fmc_spi_init_oprt( );
    xc_fmc_spi_flash_wake_up( );
    
    if(false == flash_size_and_type_get(&flash_size, &flash_type))
    {
        return false;
    }           
    
    if(flash_type == GD25WD40_512K_FLASH)
    {
            xc_fmc_spi_flash_read(flash_size - FLASH_SECTOR_SIZE, (uint8_t *)&board_card, sizeof(board_card));
    }
    else
    {
        xc_fmc_spi_flash_read(flash_size - FLASH_PAGE_SIZE, (uint8_t *)&board_card, sizeof(board_card));
    }       
    GLOBAL_INT_RESTORE( );
        
    if((reverse_verif_is_true(board_card.flash_id, board_card.flash_id_reverse_verif))\
        &&(reverse_verif_is_true(board_card.ft_rest, board_card.ft_rest_reverse_verif))\
        &&(reverse_verif_is_true(board_card.chip_cnt, board_card.chip_cnt_reverse_verif)))
    {
        *(uint16_t *)&unique_id[0] = extract32_16(board_card.flash_id);
            *(uint16_t *)&unique_id[2] = extract32_16(board_card.ft_rest);
            *(uint16_t *)&unique_id[4] = extract32_16(board_card.chip_cnt);
            
        return true ;
    }   
    else
    {
        GLOBAL_INT_DISABLE( );
        if(flash_type == GD25WD40_512K_FLASH)
        {
            xc_fmc_spi_otp_read_page(OTP_PROGRAM_PAGE_0,(uint8_t *)&board_card, sizeof(board_card));
        }
        else
        {
            xc_fmc_spi_otp_read_page(OTP_PROGRAM_PAGE_1,(uint8_t *)&board_card, sizeof(board_card));
        }
        GLOBAL_INT_RESTORE( );
            
        if((reverse_verif_is_true(board_card.flash_id, board_card.flash_id_reverse_verif))\
            &&(reverse_verif_is_true(board_card.ft_rest, board_card.ft_rest_reverse_verif))\
            &&(reverse_verif_is_true(board_card.chip_cnt, board_card.chip_cnt_reverse_verif)))
        {
                    *(uint16_t *)&unique_id[0] = extract32_16(board_card.flash_id);
                    *(uint16_t *)&unique_id[2] = extract32_16(board_card.ft_rest);
                    *(uint16_t *)&unique_id[4] = extract32_16(board_card.chip_cnt);
                
            return true ;
        }           
    }
    return false;       
}