STM32F103ZET_JDASMBIC/Src/flash.c

/*
 * flash.c
 *
 *  Created on: 2019. 7. 15.
 *      Author: parkyj
 */
#include "flash.h"
#include "MBIC_Bootloader.h"
uint8_t flashinit = 0;
uint32_t Address = FLASH_USER_START_ADDR;
volatile uint32_t UserAddress;
uint8_t MBIC_BankBooting_Flash_write(uint8_t* data,uint32_t StartBankAddress);


typedef void (*fptr)(void);
fptr jump_to_app;
uint32_t jump_addr;
void Jump_App(void){
    __HAL_RCC_TIM6_CLK_DISABLE(); // 留ㅼ씤???占쏙옙癒몌옙?? ?占쏙옙占�??占쏙옙?占쏙옙?占쏙옙
    printf("boot loader start\n");               //硫붿꽭占�? 異쒕젰
    jump_addr = *(__IO uint32_t*) (APPLICATION_ADDRESS + 4);
    jump_to_app = (fptr) jump_addr;
    
    /* init user app's sp */
    printf("jump!\n");
    __set_MSP(*(__IO uint32_t*) APPLICATION_ADDRESS);
    jump_to_app();
}


void FLASH_If_Init(void)
{
  /* Unlock the Program memory */
  HAL_FLASH_Unlock();

  /* Clear all FLASH flags */
  __HAL_FLASH_CLEAR_FLAG(FLASH_FLAG_EOP | FLASH_FLAG_PGERR | FLASH_FLAG_WRPERR);
  /* Unlock the Program memory */
  HAL_FLASH_Lock();
}

void Flash_InitRead(void) // ?占쏙옙湲고븿?占쏙옙
{
    uint32_t  Address = 0;
    Address = FLASH_USER_START_ADDR - 128;
    for(uint32_t i = 0; i < 300; i++ ){
        printf("%08x : %02X \n",Address ,*(uint8_t*)Address);
        Address++;
    }
#if 0 // PYJ.2019.03.27_BEGIN -- 
    for(uint32_t i = 0; i < 13848; i++ ){
        printf("%08x : %02X \n",Address ,*(uint8_t*)Address);
        Address++;
    }
    Address = StartAddr;
    for(uint32_t i = 0; i < 13848; i++ ){
        printf("%02X ",*(uint8_t*)Address);
        Address++;
    }
#endif // PYJ.2019.03.27_END -- 

}

#if 1 // PYJ.2020.05.20_BEGIN -- 
uint8_t Flash_RGB_Data_Write(uint8_t* data){
    uint16_t Firmdata = 0;

    uint8_t ret = 0;
    for(int i = 0; i < data[bluecell_length] - 2; i+=2){
        Firmdata  = ((data[(bluecell_length + 1) + i]) & 0x00FF);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 1)] << 8) & 0xFF00);
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,Address ,   (uint16_t)Firmdata) != HAL_OK){
            printf("HAL NOT OK \n");
            ret = 1;
        }
        Address += 2;
        //if(!(i%FirmwareUpdateDelay))
      //  HAL_Delay(1);
    }
    return ret;
}
uint8_t Flash_Data_Write(uint8_t* data){
    uint16_t Firmdata = 0;
    uint8_t ret = 0;
    int i = 0;
    static uint32_t Curr_Download_DataIndex = 0;
    static uint32_t Prev_Download_DataIndex = 0;  
    
    Curr_Download_DataIndex = data[MBIC_PAYLOADSTART  + 4] << 24;
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 5] << 16;
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 6] << 8;            
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 7];      

//    data[MBIC_PAYLOADSTART + 12 +i];
   
    for(i= 0; i <= Curr_Download_DataIndex - Prev_Download_DataIndex; i+=2){
        Firmdata  = ((data[MBIC_PAYLOADSTART + 12 +i]) & 0x00FF);
        Firmdata  += ((data[MBIC_PAYLOADSTART + 12 +i + 1] << 8) & 0xFF00);
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,UserAddress ,   (uint16_t)Firmdata) != HAL_OK){
            printf("HAL NOT OK \n");
            ret = 1;
            HAL_Delay(1000);
        }else{
            UserAddress += 2;
        }
    }
    Prev_Download_DataIndex = Curr_Download_DataIndex + 1;
    return ret;
}


uint8_t MBIC_Flash_Data_Write(uint8_t* data){
#if 1 // PYJ.2020.06.24_BEGIN -- 
    int i = 0;
    uint32_t a = 0;
    uint8_t flashdata[1024]  = {0,};
    uint32_t cnt = 0;
    uint32_t remind = 0;
    uint32_t WriteDataLength = data[61] << 24 | data[62] << 16 | data[63] << 8 | data[64] << 0;
    
#if 0 // PYJ.2020.06.24_BEGIN -- 
    uint32_t Curr_Download_Data = 0;
#else
    uint16_t Curr_Download_Data = 0;

#endif // PYJ.2020.06.24_END -- 
//        printf("=====================Data Recv2================\r\n");
//    for(a  = 0; a  < 128; a++ ){
//        printf("%08x : %02X  Index : %d \n",data ,*(uint8_t*)data,a );
//        data++;
//    }  
//    data -= a;
//        printf("=====================Data Recv2================\r\n");    
//    printf("Download Data Length :%d \r\n",WriteDataLength);

   
//    printf("Curr_Download_Data %x   : i  : %d\r\n",Curr_Download_Data,i);
#if 0 // PYJ.2020.06.24_BEGIN -- 
    for(i= 0; i < 128; i+=4){
        Curr_Download_Data = 0;
        /*Curr_Download_Data =  *(uint8_t*)(data+((i * 4)+ 0));
        Curr_Download_Data |= *(uint8_t*)(data+((i * 4)+ 1)) << 8;
        Curr_Download_Data |= *(uint8_t*)(data+((i * 4)+ 2)) << 16;            
        Curr_Download_Data |= *(uint8_t*)(data+((i * 4)+ 3)) << 24; */
        printf("%02X ",data[i + 0]);
        printf("%02X ",data[i + 1]);
        printf("%02X ",data[i + 2]);
        printf("%02X ",data[i + 3]);        
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,UserAddress , Curr_Download_Data) != HAL_OK){
            printf("HAL NOT OK \n");
            HAL_Delay(1000);
        }else{
            UserAddress += 4;
        }
    }
    //            printf("%02X ",flashdata[i*2 + 0]);
    //            printf("%02X ",flashdata[i*2 + 1]);
        //        HAL_Delay(1);
#else
    cnt = (((WriteDataLength + 128)/1024));
    remind =(((WriteDataLength + 128)%1024));
    

#if 0 // PYJ.2020.06.24_BEGIN -- 

    for(int b = 0; b < cnt; b++){
        for(i = 0; i < 1024; i+=2){
            flashdata[i*2] = data[(cnt*1024)+i*2];
            flashdata[i*2+1] = data[(cnt*1024)+i*2+1];            
            Curr_Download_Data = (flashdata[i*2]) & 0x00FF;//*(uint8_t*)(data+((i * 2)+ 0));
            Curr_Download_Data |= flashdata[i*2+1] << 8;//(*(uint8_t*)(data+((i * 2)+ 1)) << 8);
            if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,UserAddress , Curr_Download_Data) != HAL_OK){
                printf("HAL NOT OK \n");
                HAL_Delay(1000);
                return;
            }
            UserAddress += 2;
            HAL_Delay(1);
        }
    }
    for(i = 0; i < remind; i+=2){
        flashdata[i*2] = data[(cnt*1024)+i*2];
        flashdata[i*2+1] = data[(cnt*1024)+i*2+1];            
        Curr_Download_Data = (flashdata[i*2]) & 0x00FF;//*(uint8_t*)(data+((i * 2)+ 0));
        Curr_Download_Data |= flashdata[i*2+1] << 8;//(*(uint8_t*)(data+((i * 2)+ 1)) << 8);
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,UserAddress , Curr_Download_Data) != HAL_OK){
            printf("HAL NOT OK \n");
            HAL_Delay(1000);
            return;
        }
        UserAddress += 2;
        HAL_Delay(1);
    }      
#else
    for(i= 0; i <WriteDataLength + 128; i+=2){
        Curr_Download_Data = 0;
//        Curr_Download_Data =  ;                  (*(uint8_t*)(data+((i * 4)+ 1)) << 8)
//        Curr_Download_Data |= ;        
        uint16_t writedata = (*(uint8_t*)(data+((i)+ 1))) << 8 | (*(uint8_t*)(data+((i)+ 0)));
        printf("%02X ",writedata & 0xFF00 >> 8);
        printf("%02X ",writedata & 0x00FF);        
//        printf("%02X ",(*(uint8_t*)(data+((i )+ 1))));
        
//        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,UserAddress , *(uint8_t*)(data+(i * 2))  | *(uint8_t*)data+((i * 2)+1) << 8) != HAL_OK){
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,UserAddress ,writedata /*(*(uint8_t*)(data+((i * 2)+ 0))) | (*(uint8_t*)(data+((i * 2)+ 1))) << 8*/) != HAL_OK){
            printf("HAL NOT OK \n");
            HAL_Delay(1000);
        }else{
            UserAddress += 2;
        }
//        HAL_Delay(5);
    }

#endif // PYJ.2020.06.24_END -- 

#endif // PYJ.2020.06.24_END -- 
    return 0;
#else
    uint16_t Firmdata = 0;
    uint8_t ret = 0;
    int i = 0;
    uint32_t dataindex = 0;
    static uint32_t Curr_Download_DataIndex = 0;
    static uint32_t Prev_Download_DataIndex = 0;  
    Curr_Download_DataIndex = data[dataindex  + 0];
    Curr_Download_DataIndex += data[dataindex + 1] << 8;
    Curr_Download_DataIndex += data[dataindex + 2] << 16;            
    Curr_Download_DataIndex += data[dataindex + 3] << 24;      
    printf("Download Data Length :%d \r\n",Curr_Download_DataIndex);
    Firmdata = 0x12345678;
    if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,UserAddress ,   (uint32_t)Firmdata) != HAL_OK){
        printf("HAL NOT OK \n");
        ret = 1;
        HAL_Delay(1000);
    }else{
        UserAddress += 4;
    }

   
#if 0 // PYJ.2020.06.24_BEGIN -- 
    for(i= 0; i <= Curr_Download_DataIndex; i+=4){
        Firmdata  = ((data[MBIC_PAYLOADSTART + 12 +i]) & 0x00FF);
        Firmdata  += ((data[MBIC_PAYLOADSTART + 12 +i + 1] << 8) & 0xFF00);

    }
#endif // PYJ.2020.06.24_END -- 
    Prev_Download_DataIndex = Curr_Download_DataIndex + 1;


#endif // PYJ.2020.06.24_END -- 
}
uint8_t Flash_Data_WriteTest(uint8_t* data){
    uint32_t Firmdata = 0;
    uint8_t ret = 0;
    static uint32_t Curr_Download_DataIndex = 0;
    static uint32_t Prev_Download_DataIndex = 0;  
    
    Curr_Download_DataIndex = data[MBIC_PAYLOADSTART  + 4] << 24;
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 5] << 16;
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 6] << 8;            
    Curr_Download_DataIndex += data[MBIC_PAYLOADSTART + 7];      

    for(int i= 0; i <= Curr_Download_DataIndex - Prev_Download_DataIndex; i+=2){
        Firmdata  = ((data[MBIC_PAYLOADSTART + 12 +i  + 0])       & 0x000000FF);
        Firmdata  += ((data[MBIC_PAYLOADSTART + 12 +i + 1] << 8)  & 0x0000FF00);
        Firmdata  += ((data[MBIC_PAYLOADSTART + 12 +i + 2] << 16) & 0x00FF0000);
        Firmdata  += ((data[MBIC_PAYLOADSTART + 12 +i + 3] << 24) & 0xFF000000);
        if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,UserAddress ,   (uint32_t)Firmdata) != HAL_OK){
            printf("HAL NOT OK \n");
            ret = 1;
        }
        UserAddress += 4;
    }
    Prev_Download_DataIndex = Curr_Download_DataIndex + 1;
    return ret;
}
#if 0 // PYJ.2020.06.17_BEGIN -- 
uint8_t Flash_Data_Write(uint8_t* data){
    uint64_t Firmdata = 0;
    uint8_t ret = 0;
    uint8_t Length = data[bluecell_length] - 2;
    uint8_t Length_remainder =  Length % 8;    
    uint8_t Length_ans =  Length / 8;    

    for(int i = 0; i < Length; i+=8){
        Firmdata  =  ((data[(bluecell_length + 1) + i])             & 0x00000000000000FF);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 1)] << 8)  & 0x000000000000FF00);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 2)] << 16) & 0x0000000000FF0000);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 3)] << 24) & 0x00000000FF000000);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 4)] << 32) & 0x000000FF00000000);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 5)] << 40) & 0x0000FF0000000000);
        Firmdata  += ((data[(bluecell_length + 1) + (i + 6)] << 48) & 0x00FF000000000000);        
        Firmdata  += ((data[(bluecell_length + 1) + (i + 7)] << 56) & 0xFF00000000000000);                
        if(Length_remainder > 0 && Length_ans > i){
            for(int a = 0; a < Length_remainder; a += 2){
                if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,Address ,   (uint16_t)Firmdata) != HAL_OK){
                    printf("HAL NOT OK \n");
                    ret = 1;
                }
                Address += 2;            
            }
        }
        else{        
            if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_DOUBLEWORD,Address ,   (uint64_t)Firmdata) != HAL_OK){
                printf("HAL NOT OK \n");
                ret = 1;
            }
            Address += 8;
        }
        //if(!(i%FirmwareUpdateDelay))
      //  HAL_Delay(1);
    }
    return ret;
}
#endif // PYJ.2020.06.17_END -- 
#endif // PYJ.2020.06.10_END -- 
uint8_t Flash_DataTest_Write(uint8_t* data){
    uint32_t Firmdata = 0;
    uint8_t ret = 0;
    uint8_t Length = data[bluecell_length] - 2;
    uint8_t Length_remainder =  Length % 4;    
    uint8_t Length_ans =  Length / 4;        
    for(int i = 0; i < data[bluecell_length] - 2; i+=4){

        if(Length_remainder > 0 && Length_ans > i){
            for(int a = 0; a < Length_remainder; a += 2){
                Firmdata  = ((data[(bluecell_length + 1) + i]) & 0x00FF);
                Firmdata  += ((data[(bluecell_length + 1) + (i + 1)] << 8) & 0xFF00);                
                if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_HALFWORD,Address ,   (uint16_t)Firmdata) != HAL_OK){
                    printf("HAL NOT OK \n");
                    ret = 1;
                }
                Address += 2;            
            }
        }
        else{
            Firmdata  = ((data[(bluecell_length + 1) + i]) 	          & 0x000000FF);
            Firmdata  += ((data[(bluecell_length + 1) + (i + 1)] << 8) & 0x0000FF00);
            Firmdata  += ((data[(bluecell_length + 1) + (i + 2)] << 16) & 0x00FF0000);
            Firmdata  += ((data[(bluecell_length + 1) + (i + 3)] << 24) & 0xFF000000);            
            if(HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD,Address ,   (uint32_t)Firmdata) != HAL_OK){
                printf("HAL NOT OK \n");
                ret = 1;
            }
            Address += 4;
        }
        //if(!(i%FirmwareUpdateDelay))
      //  HAL_Delay(1);
    }
    return ret;
}


uint8_t Flash_write(uint8_t* data) // ?占쏙옙湲고븿?占쏙옙
{

    /*Variable used for Erase procedure*/
    static FLASH_EraseInitTypeDef EraseInitStruct;
    static uint32_t PAGEError = 0;
    uint8_t ret = 0;
    /* Fill EraseInit structure*/
    EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
    EraseInitStruct.PageAddress = FLASH_USER_START_ADDR;
    
    EraseInitStruct.NbPages     = (FLASH_USER_START_ADDR - ((uint32_t)0xFFFF)) / FLASH_PAGE_SIZE;

//    __HAL_RCC_TIM6_CLK_DISABLE(); // 留ㅼ씤???占쏙옙癒몌옙?? ?占쏙옙占�??占쏙옙?占쏙옙?占쏙옙
    HAL_FLASH_Unlock(); // lock ??占�?
    if(flashinit == 0){
        flashinit= 1;
        //FLASH_PageErase(StartAddr);
        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK){
            printf("Erase Failed \r\n");
        }
    }
//    FLASH_If_Erase();
    ret = Flash_RGB_Data_Write(&data[bluecell_stx]);
//    ret = Flash_DataTest_Write(&data[bluecell_stx]);

    HAL_FLASH_Lock(); // lock ?占쏙옙洹멸린
//    __HAL_RCC_TIM6_CLK_ENABLE(); // 留ㅼ씤???占쏙옙癒몌옙?? ?占쏙옙?占쏙옙?占쏙옙?占쏙옙?占쏙옙?占쏙옙

    return ret;
}


uint8_t Bank_Flash_write(uint8_t* data,uint32_t StartBankAddress) // ?占쏙옙湲고븿?占쏙옙
{

#if 1 // PYJ.2020.06.24_BEGIN -- 
#if 0 // PYJ.2020.06.24_BEGIN -- 
#endif // PYJ.2020.06.24_END -- 
    /*Variable used for Erase procedure*/
    static FLASH_EraseInitTypeDef EraseInitStruct;
    static uint32_t PAGEError = 0;
    uint8_t ret = 0;


    HAL_FLASH_Unlock(); // lock ??占�?
    if(flashinit == 0){
        
        flashinit= 1;
        /* Fill EraseInit structure*/
        switch(StartBankAddress){
            case FLASH_USER_START_ADDR:
                EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
                EraseInitStruct.PageAddress = FLASH_USER_START_ADDR - 128;
                EraseInitStruct.NbPages     = (FLASH_USER_END_ADDR - FLASH_USER_START_ADDR) / FLASH_PAGE_SIZE;
            break;
            case FLASH_USER_BANK1_START_ADDR:
                EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
                EraseInitStruct.PageAddress = FLASH_USER_BANK1_START_ADDR - 128;
                EraseInitStruct.NbPages     = (FLASH_USER_END_ADDR - FLASH_USER_BANK1_START_ADDR) / FLASH_PAGE_SIZE;

            break;
            case FLASH_USER_BANK2_START_ADDR:
                EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
                EraseInitStruct.PageAddress = FLASH_USER_BANK2_START_ADDR - 128;
                EraseInitStruct.NbPages     = (FLASH_USER_END_ADDR - FLASH_USER_BANK2_START_ADDR) / FLASH_PAGE_SIZE;

            break;

        }        
        
        UserAddress = EraseInitStruct.PageAddress;
        //FLASH_PageErase(StartAddr);
        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK){
            printf("Erase Failed \r\n");
        }
    }
    ret = Flash_Data_Write(&data[0]);
    HAL_FLASH_Lock(); // lock ?占쏙옙洹멸린
    return ret;
#else
    uint32_t  Address = 0;
    Address = FLASH_USER_START_ADDR - 128;
    for(uint32_t i = 0; i < 128; i++ ){
        printf("%08x : %02X \n",data ,*(uint8_t*)data);
        data++;
    }

#endif // PYJ.2020.06.24_END -- 

}
#if 0 // PYJ.2020.06.24_BEGIN -- 
void MBIC_FlashErase()
{
    static FLASH_EraseInitTypeDef EraseInitStruct;
    static uint32_t PAGEError = 0;

    if(EraseInit == false){
        EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
        EraseInitStruct.PageAddress = FLASH_USER_START_ADDR;
        EraseInitStruct.NbPages     = ((FLASH_USER_START_ADDR + ((uint32_t)0xFFFF)) - FLASH_USER_START_ADDR) / FLASH_PAGE_SIZE;
        printf("Erase Start\r\n");
        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
        {
          /*
            Error occurred while page erase.
            User can add here some code to deal with this error.
            PAGEError will contain the faulty page and then to know the code error on this page,
            user can call function 'HAL_FLASH_GetError()'
          */
          /* Infinite loop */
          while (1)
          {
            /* Make LED2 blink (100ms on, 2s off) to indicate error in Erase operation */
            printf("HAL_FLASHEx_Erase Error\r\n");
            HAL_Delay(2000);
          }
        }
        EraseInit = true;
        printf("Erase End\r\n");
    }

}
#endif // PYJ.2020.06.24_END -- 


uint8_t MBIC_BankBooting_Flash_write(uint8_t* data,uint32_t StartBankAddress) // ?占쏙옙湲고븿?占쏙옙
{

#if 1 // PYJ.2020.06.24_BEGIN -- 
#if 0 // PYJ.2020.06.24_BEGIN -- 
#endif // PYJ.2020.06.24_END -- 
    /*Variable used for Erase procedure*/
    static FLASH_EraseInitTypeDef EraseInitStruct;
    static uint32_t PAGEError = 0;
    uint8_t ret = 0;
    uint32_t tmpdata = 0;
    uint32_t i = 0;
    printf("=====================Data Recv================\r\n");
    uint8_t datacnt = 0;
    if(data[0]!= 0x4A){
        printf("File ERRor\r\n");
        return;
    }
    for( i = 0; i < 128; i++ ){
        if(*(uint8_t*)data == 0xFF)
            datacnt++;
        
        printf("%08x : %02X  Index : %d \n",data ,*(uint8_t*)data,i);
        data++;
    }    
    if(datacnt > 100)
        return;
    data -=i;
    printf("=====================Data Recv================\r\n");    
//    tmpdata = data[61] <<24 |data[62] <<16 |data[63] <<8 |data[64] <<0 ;
//    printf("data[01] : %x \r\n",data[01]);
//    printf("data[61] : %x \r\n",data[61]);
//    printf("data[62] : %x \r\n",data[62]);
//    printf("data[63] : %x \r\n",data[63]);
//    printf("data[64] : %x \r\n",data[64]);    
//    printf("data Length %x   / D %d ",tmpdata,tmpdata);
//    return;
    HAL_FLASH_Unlock(); // lock ??占�?
    if(flashinit == 0){
        
        flashinit= 1;
        /* Fill EraseInit structure*/
        printf("Download Erase Conifiguaration Start\r\n");
        switch(StartBankAddress){
            case FLASH_MBICUSER_START_ADDR:
                printf("User API Erase %x\r\n",StartBankAddress);
#if 1 // PYJ.2020.06.24_BEGIN -- 
                /* Fill EraseInit structure*/
                EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
                EraseInitStruct.PageAddress = FLASH_MBICUSER_START_ADDR;
                EraseInitStruct.NbPages     = ((FLASH_MBICUSER_END_ADDR - FLASH_MBICUSER_START_ADDR) / FLASH_PAGE_SIZE )+ 1;
#else
                EraseInitStruct.TypeErase   = FLASH_TYPEERASE_PAGES;
                EraseInitStruct.PageAddress = FLASH_MBICUSER_START_ADDR;
                printf("PageAddress : %x \r\n",FLASH_MBICUSER_START_ADDR);
                EraseInitStruct.NbPages     = (FLASH_MBICUSER_START_ADDR - ((uint32_t)0xFFFF + 128))) / FLASH_PAGE_SIZE;

#endif // PYJ.2020.06.24_END -- 
                UserAddress = FLASH_MBICUSER_START_ADDR;
            break;
        }        
        printf("Download Erase Conifiguaration END\r\n");        
        //FLASH_PageErase(StartAddr);
        printf("Download Erase  start\r\n");                
        if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK){
            printf("Erase Failed \r\n");
        }
        printf("Download Erase  END\r\n");                        
    }
        printf("Download Start  \r\n");       
    
        ret = MBIC_Flash_Data_Write((uint32_t*)data);
        printf("Download END  \r\n");
        HAL_FLASH_Lock(); // lock ?占쏙옙洹멸린
    return ret;
#else
    uint32_t  Address = 0;
    Address = FLASH_USER_START_ADDR - 128;
    for(uint32_t i = 0; i < 128; i++ ){
        printf("%08x : %02X \n",data ,*(uint8_t*)data);
        data++;
    }

#endif // PYJ.2020.06.24_END -- 

}