STM32F103ZET_JDASMBIC/Src/eeprom.c

/*
 * eeprom.c
 *
 *  Created on: 2020. 4. 22.
 *      Author: parkyj
 */
#include <stdio.h>
#include <string.h>
#include "main.h"
#include "eeprom.h"
#include "flash.h"
#include "stm32f1xx_hal.h"
#include "stm32f1xx_hal_gpio.h"

/* Includes ------------------------------------------------------------------*/   
HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
extern uint8_t MBIC_BankBooting_Flash_write(uint8_t* data,uint32_t StartBankAddress);


BLUESTATUS_st bluecell_Currdatastatus;


extern I2C_HandleTypeDef hi2c2;





void EEPROM_M24C08_Init(void){
    
    bool Download_Possible[2] = {false,false};
    EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );



    uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
    uint32_t i = 0;
    uint8_t ret = 0;
    CurrApiAddress = FLASH_MBICUSER_START_ADDR;
    Bank1Address = FLASH_USER_BANK1_START_ADDR;
    Bank2Address = FLASH_USER_BANK2_START_ADDR;

    uint8_t* Currdata = (uint8_t*)CurrApiAddress;
    uint8_t* Bank1data = (uint8_t*)Bank1Address;
    uint8_t* Bank2data = (uint8_t*)Bank2Address;

    uint32_t FileCrc = 0;
    int32_t CrcLength = 0;
    uint32_t crcret=0;


      





    printf("Flash Init \r\n");
   
    uint8_t* pdata;
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime1 = Bank1data[MBIC_BOOT_CREATION_TIME + 0];
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime2 = Bank1data[MBIC_BOOT_CREATION_TIME + 1];
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime3 = Bank1data[MBIC_BOOT_CREATION_TIME + 2];
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime4 = Bank1data[MBIC_BOOT_CREATION_TIME + 3];
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime5 = Bank1data[MBIC_BOOT_CREATION_TIME + 4];
    bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime6 = Bank1data[MBIC_BOOT_CREATION_TIME + 5];

    bluecell_Currdatastatus.CPU_Bank1_Image_Version1 = Bank1data[MBIC_BOOT_VERSION + 0];
    bluecell_Currdatastatus.CPU_Bank1_Image_Version2 = Bank1data[MBIC_BOOT_VERSION + 1];
    bluecell_Currdatastatus.CPU_Bank1_Image_Version3 = Bank1data[MBIC_BOOT_VERSION + 2];

//    pdata = &bluecell_Currdatastatus.CPU_Bank1_Image_Name;
//    printf("BANK1 IMAGE NAME : ");
//    for(int i = 0 ; i< 32; i++){
//       pdata[i] = Bank1data[MBIC_BOOT_FILENAME + i];
//       printf("%c",pdata[i]);
//    }
//    printf("\r\n");


    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime1 = Bank2data[MBIC_BOOT_CREATION_TIME + 0];
    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime2 = Bank2data[MBIC_BOOT_CREATION_TIME + 1];
    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime3 = Bank2data[MBIC_BOOT_CREATION_TIME + 2];
    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime4 = Bank2data[MBIC_BOOT_CREATION_TIME + 3];
    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime5 = Bank2data[MBIC_BOOT_CREATION_TIME + 4];
    bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime6 = Bank2data[MBIC_BOOT_CREATION_TIME + 5];

    bluecell_Currdatastatus.CPU_Bank2_Image_Version1 = Bank2data[MBIC_BOOT_VERSION + 0];
    bluecell_Currdatastatus.CPU_Bank2_Image_Version2 = Bank2data[MBIC_BOOT_VERSION + 1];
    bluecell_Currdatastatus.CPU_Bank2_Image_Version3 = Bank2data[MBIC_BOOT_VERSION + 2];

//    pdata = & bluecell_Currdatastatus.CPU_Bank2_Image_Name;
//    printf("BANK2 IMAGE NAME : ");
//    for(int i = 0 ; i< 32; i++){
//       pdata[i] = Bank2data[MBIC_BOOT_FILENAME + i];  
//       printf("%c",pdata[i]);
//    }
//    printf("\r\n");


   printf("20%d Y / %d M / %d D / %d H / %d M / %d S  \r\n",
   Currdata[MBIC_BOOT_CREATION_TIME + 0],
   Currdata[MBIC_BOOT_CREATION_TIME + 1],
   Currdata[MBIC_BOOT_CREATION_TIME + 2],
   Currdata[MBIC_BOOT_CREATION_TIME + 3],
   Currdata[MBIC_BOOT_CREATION_TIME + 4],
   Currdata[MBIC_BOOT_CREATION_TIME + 5]        
);

#if 0 // PYJ.2020.06.29_BEGIN -- 
    if(Currdata[MBIC_BOOT_VERSION + 0] == Bank1data[MBIC_BOOT_VERSION + 0]
     &&Currdata[MBIC_BOOT_VERSION + 1] == Bank1data[MBIC_BOOT_VERSION + 1]
     &&Currdata[MBIC_BOOT_VERSION + 2] == Bank1data[MBIC_BOOT_VERSION + 2]){
      ret = HFR_BANK1_SEL;
    }else if(
       Currdata[MBIC_BOOT_VERSION + 0] == Bank2data[MBIC_BOOT_VERSION + 0]
     &&Currdata[MBIC_BOOT_VERSION + 1] == Bank2data[MBIC_BOOT_VERSION + 1]
     &&Currdata[MBIC_BOOT_VERSION + 2] == Bank2data[MBIC_BOOT_VERSION + 2]){
      ret = HFR_BANK2_SEL;
    }else{
      ret = 0;
    }
#endif // PYJ.2020.06.29_END -- 

    bluecell_Currdatastatus.CPU_Current_Bank = ret;
    printf("MBIC BANK %d Booting \r\n",bluecell_Currdatastatus.CPU_Current_Bank);    
    printf("bluecell_Currdatastatus.CPU_Bank_Select : %d \r\n",bluecell_Currdatastatus.CPU_Bank_Select);
    
    if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK2_SEL)
    {
       ret = HFR_BANK2_SEL;
        FileCrc = 
        ((Bank2data[MBIC_BOOT_CRC] << 24 ) 
        | Bank2data[MBIC_BOOT_CRC + 1]<<16 
        | Bank2data[MBIC_BOOT_CRC + 2]<<8   
        | Bank2data[MBIC_BOOT_CRC + 3]);
        CrcLength=
        ((Bank2data[MBIC_BOOT_LENGTH] << 24 ) 
        | Bank2data[MBIC_BOOT_LENGTH + 1]<<16 
        | Bank2data[MBIC_BOOT_LENGTH + 2]<<8   
        | Bank2data[MBIC_BOOT_LENGTH + 3]);       
                    if(CrcLength > 0 && CrcLength <= 0x1FFFF )
        crcret = crc32(&Bank2data[MBIC_BOOT_DATA], CrcLength);
        if(FileCrc != crcret){
            printf("Bank1 CRC ERR : FILE CRC : %x  ///    CALC  CRC : %x \r\n",FileCrc,crcret);
            return;
        }
    }
    else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK1_SEL)
    {
       ret = HFR_BANK1_SEL;
        FileCrc = 
        ((Bank1data[MBIC_BOOT_CRC] << 24 ) 
        | Bank1data[MBIC_BOOT_CRC + 1]<<16 
        | Bank1data[MBIC_BOOT_CRC + 2]<<8   
        | Bank1data[MBIC_BOOT_CRC + 3]);
        CrcLength=
        ((Bank1data[MBIC_BOOT_LENGTH] << 24 ) 
        | Bank1data[MBIC_BOOT_LENGTH + 1]<<16 
        | Bank1data[MBIC_BOOT_LENGTH + 2]<<8   
        | Bank1data[MBIC_BOOT_LENGTH + 3]);
        if(CrcLength > 0 && CrcLength <= 0x1FFFF )
        crcret = crc32(&Bank1data[MBIC_BOOT_DATA], CrcLength);
        if(FileCrc != crcret){
            printf("Ban2 CRC ERR : FILE CRC : %x  ///    CALC  CRC : %x \r\n",FileCrc,crcret);
            return;
        }
        
    }
    else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL)
    {
        if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL)
        {
           ret = HFR_BANK1_SEL;
            FileCrc = 
            ((Bank1data[MBIC_BOOT_CRC] << 24 ) 
            | Bank1data[MBIC_BOOT_CRC + 1]<<16 
            | Bank1data[MBIC_BOOT_CRC + 2]<<8   
            | Bank1data[MBIC_BOOT_CRC + 3]);
            CrcLength=
            ((Bank1data[MBIC_BOOT_LENGTH] << 24 ) 
            | Bank1data[MBIC_BOOT_LENGTH + 1]<<16 
            | Bank1data[MBIC_BOOT_LENGTH + 2]<<8   
            | Bank1data[MBIC_BOOT_LENGTH + 3]);
            if(CrcLength > 0 && CrcLength <= 0x1FFFF )
             crcret = crc32(&Bank1data[MBIC_BOOT_DATA], CrcLength);
            if(FileCrc != crcret){
                printf("Bank1 CRC ERR : FILE CRC : %x  ///    CALC  CRC : %x \r\n",FileCrc,crcret);
                return;
            }
             
        }
        else    
        {
            ret = HFR_BANK2_SEL;
            FileCrc = 
            ((Bank2data[MBIC_BOOT_CRC] << 24 ) 
            | Bank2data[MBIC_BOOT_CRC + 1]<<16 
            | Bank2data[MBIC_BOOT_CRC + 2]<<8   
            | Bank2data[MBIC_BOOT_CRC + 3]);
            CrcLength=
            ((Bank2data[MBIC_BOOT_LENGTH] << 24 ) 
            | Bank2data[MBIC_BOOT_LENGTH + 1]<<16 
            | Bank2data[MBIC_BOOT_LENGTH + 2]<<8   
            | Bank2data[MBIC_BOOT_LENGTH + 3]);           
        }
        if(CrcLength > 0 && CrcLength <= 0x1FFFF )
        crcret = crc32(&Bank2data[MBIC_BOOT_DATA], CrcLength);
        if(FileCrc != crcret){
            printf("Bank2 CRC ERR : FILE CRC : %x  ///    CALC  CRC : %x \r\n",FileCrc,crcret);
            return;
        }
        
    }
#if 1 // PYJ.2020.06.29_BEGIN -- 
    printf("CRC LENGTH : %d,CRC LENGTH : %X \r\n",CrcLength,CrcLength);
    if(crcret != FileCrc){
        printf("CRC ERROR : %x , File CRC : %x \r\n",crcret,FileCrc);
        return;
    }
    else
        printf("CRC SUCCESS  : %x , File CRC : %x \r\n",crcret,FileCrc);      
#endif // PYJ.2020.06.29_END -- 
#if 0 // PYJ.2020.06.30_BEGIN -- 
        uint32_t  CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
        int32_t CrcLength = 0;
        CurrApiAddress = FLASH_MBICUSER_START_ADDR;
        Bank1Address = FLASH_USER_BANK1_START_ADDR;
        Bank2Address = FLASH_USER_BANK2_START_ADDR;

        uint8_t* Currdata = (uint8_t*)CurrApiAddress;
        uint8_t* Bank1data = (uint8_t*)Bank1Address;
        uint8_t* Bank2data = (uint8_t*)Bank2Address;

        uint16_t crcret = 0;

        CrcLength=
        ((Bank1data[MBIC_BOOT_LENGTH] << 24 ) 
        | Bank1data[MBIC_BOOT_LENGTH + 1]<<16 
        | Bank1data[MBIC_BOOT_LENGTH + 2]<<8   
        | Bank1data[MBIC_BOOT_LENGTH + 3]);    

        if(CrcLength > 0)
            crcret = CRC16_Generate(Bank1data, CrcLength + 128);
        CrcLength += 128;
        
        printf("Bank 1 Crc ret : %x  Length : %x :  %d \r\n",crcret ,CrcLength,CrcLength);

        if()
#endif // PYJ.2020.06.30_END -- 
    
    if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK1_SEL && bluecell_Currdatastatus.CPU_Current_Bank != HFR_BANK1_SEL){
        printf("Write Start BANK 1 Down Start\r\n");
        MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK1_START_ADDR,FLASH_MBICUSER_START_ADDR);
        bluecell_Currdatastatus.CPU_Bank_Select = 5;
    }else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK2_SEL && bluecell_Currdatastatus.CPU_Current_Bank != HFR_BANK2_SEL){
        printf("Write Start BANK 2 Down Start\r\n");
        MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK2_START_ADDR,FLASH_MBICUSER_START_ADDR);
        bluecell_Currdatastatus.CPU_Bank_Select = 6;
    }
    else if (bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL || bluecell_Currdatastatus.CPU_Bank_Select == 7){
        if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){
            printf("Write Start BANK BANK 1 Down Start\r\n");
            MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK2_START_ADDR,FLASH_MBICUSER_START_ADDR);
	    bluecell_Currdatastatus.CPU_Bank_Select = 5;
        }else{
            printf("Write Start BANK BANK 2 Down Start\r\n");
            MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK1_START_ADDR,FLASH_MBICUSER_START_ADDR);
            bluecell_Currdatastatus.CPU_Bank_Select = 6;
        }
    }
    EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));    
    printf("EEPROM INIT COMPLETE\r\n");
}


#define MAXEEPROM_LENG 32
HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
   HAL_StatusTypeDef ret = HAL_ERROR;
 //  uint16_t sizecnt = 0,
   //uint16_t sizeremain = 0;
  // uint16_t addrees_inc = 0;
//   ret = HAL_I2C_Mem_Read(&hi2c2, devid | ((Address & 0x0300) >> 7),((Address )),  I2C_MEMADD_SIZE_8BIT, &data[0], size, 1024);

   ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )),  I2C_MEMADD_SIZE_16BIT, &data[0], size, 1024);
//      EEPROM24XX_Load( Address,data, size);

      if(ret == HAL_ERROR)
            printf("Write ERR\r\n");
        else
            HAL_Delay(20);

    return ret;   
}
HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
    HAL_StatusTypeDef ret = HAL_ERROR;
    uint8_t sizecnt = 0,sizeremain = 0; 
    uint16_t addrees_inc = 0;
    sizecnt = size /MAXEEPROM_LENG;
    sizeremain = size % MAXEEPROM_LENG;
    addrees_inc = 0;
    if(sizecnt > 0){
        for(int i = 0 ; i < sizecnt; i++ ){
             addrees_inc = i * MAXEEPROM_LENG;
             ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);

             if(ret == HAL_ERROR)
                 printf("Write ERR\r\n");
             else
                 HAL_Delay(20);
        }
        addrees_inc += MAXEEPROM_LENG;
    }

//    printf("Remain Data Index : %d \r\n",sizeremain);
    
    if(sizeremain > 0){
//        printf("Remain Data Write Start ");
        for(int i = 0; i < sizeremain; i++){
            ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc + i)& 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[addrees_inc + i], 1, 1024);
         //       EEPROM24XX_Save( Address,data, size);
         if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         else
             HAL_Delay(20);
        }
    }

    return ret;
}

HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
    HAL_StatusTypeDef ret = HAL_ERROR;
   // uint8_t sizeremain = 0;
    uint16_t addrees_inc = 0;
    addrees_inc = 0;
    uint8_t data[4096] = {0,};


    for(int i = 0 ; i < 128; i++ ){
         addrees_inc = i * MAXEEPROM_LENG;
         ret = HAL_I2C_Mem_Write(&hi2c2, devid  ,((Address + addrees_inc) & 0xFFFF) ,  I2C_MEMADD_SIZE_16BIT, &data[0], MAXEEPROM_LENG, 1024);
         if(ret == HAL_ERROR)
             printf("Write ERR\r\n");
         else
             HAL_Delay(20);
    }


    return ret;
}