eeprom.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344
  1. /*
  2. * eeprom.c
  3. *
  4. * Created on: 2020. 4. 22.
  5. * Author: parkyj
  6. */
  7. #include <stdio.h>
  8. #include <string.h>
  9. #include "main.h"
  10. #include "eeprom.h"
  11. #include "flash.h"
  12. #include "stm32f1xx_hal.h"
  13. #include "stm32f1xx_hal_gpio.h"
  14. /* Includes ------------------------------------------------------------------*/
  15. HAL_StatusTypeDef EEPROM_M24C08_ByteRead(uint16_t devid,uint16_t Address,uint8_t* data,uint8_t size);
  16. extern uint8_t MBIC_BankBooting_Flash_write(uint8_t* data,uint32_t StartBankAddress);
  17. BLUESTATUS_st bluecell_Currdatastatus;
  18. extern I2C_HandleTypeDef hi2c2;
  19. void EEPROM_M24C08_Init(void){
  20. bool Download_Possible[2] = {false,false};
  21. EEPROM_M24C08_Read(EEPROM_M24C08_ID,EEPROM_WINDOW_STATUS_ADDRESDS,&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st) );
  22. uint32_t CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
  23. uint32_t i = 0;
  24. uint8_t ret = 0;
  25. CurrApiAddress = FLASH_MBICUSER_START_ADDR;
  26. Bank1Address = FLASH_USER_BANK1_START_ADDR;
  27. Bank2Address = FLASH_USER_BANK2_START_ADDR;
  28. uint8_t* Currdata = (uint8_t*)CurrApiAddress;
  29. uint8_t* Bank1data = (uint8_t*)Bank1Address;
  30. uint8_t* Bank2data = (uint8_t*)Bank2Address;
  31. uint32_t FileCrc = 0;
  32. uint32_t CrcLength = 0;
  33. uint32_t crcret=0;
  34. printf("Flash Init \r\n");
  35. uint8_t* pdata;
  36. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime1 = Bank1data[MBIC_BOOT_CREATION_TIME + 0];
  37. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime2 = Bank1data[MBIC_BOOT_CREATION_TIME + 1];
  38. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime3 = Bank1data[MBIC_BOOT_CREATION_TIME + 2];
  39. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime4 = Bank1data[MBIC_BOOT_CREATION_TIME + 3];
  40. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime5 = Bank1data[MBIC_BOOT_CREATION_TIME + 4];
  41. bluecell_Currdatastatus.CPU_Bank1_Image_BuildTime6 = Bank1data[MBIC_BOOT_CREATION_TIME + 5];
  42. bluecell_Currdatastatus.CPU_Bank1_Image_Version1 = Bank1data[MBIC_BOOT_VERSION + 0];
  43. bluecell_Currdatastatus.CPU_Bank1_Image_Version2 = Bank1data[MBIC_BOOT_VERSION + 1];
  44. bluecell_Currdatastatus.CPU_Bank1_Image_Version3 = Bank1data[MBIC_BOOT_VERSION + 2];
  45. // pdata = &bluecell_Currdatastatus.CPU_Bank1_Image_Name;
  46. // printf("BANK1 IMAGE NAME : ");
  47. // for(int i = 0 ; i< 32; i++){
  48. // pdata[i] = Bank1data[MBIC_BOOT_FILENAME + i];
  49. // printf("%c",pdata[i]);
  50. // }
  51. // printf("\r\n");
  52. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime1 = Bank2data[MBIC_BOOT_CREATION_TIME + 0];
  53. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime2 = Bank2data[MBIC_BOOT_CREATION_TIME + 1];
  54. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime3 = Bank2data[MBIC_BOOT_CREATION_TIME + 2];
  55. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime4 = Bank2data[MBIC_BOOT_CREATION_TIME + 3];
  56. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime5 = Bank2data[MBIC_BOOT_CREATION_TIME + 4];
  57. bluecell_Currdatastatus.CPU_Bank2_Image_BuildTime6 = Bank2data[MBIC_BOOT_CREATION_TIME + 5];
  58. bluecell_Currdatastatus.CPU_Bank2_Image_Version1 = Bank2data[MBIC_BOOT_VERSION + 0];
  59. bluecell_Currdatastatus.CPU_Bank2_Image_Version2 = Bank2data[MBIC_BOOT_VERSION + 1];
  60. bluecell_Currdatastatus.CPU_Bank2_Image_Version3 = Bank2data[MBIC_BOOT_VERSION + 2];
  61. // pdata = & bluecell_Currdatastatus.CPU_Bank2_Image_Name;
  62. // printf("BANK2 IMAGE NAME : ");
  63. // for(int i = 0 ; i< 32; i++){
  64. // pdata[i] = Bank2data[MBIC_BOOT_FILENAME + i];
  65. // printf("%c",pdata[i]);
  66. // }
  67. // printf("\r\n");
  68. printf("20%d Y / %d M / %d D / %d H / %d M / %d S \r\n",
  69. Currdata[MBIC_BOOT_CREATION_TIME + 0],
  70. Currdata[MBIC_BOOT_CREATION_TIME + 1],
  71. Currdata[MBIC_BOOT_CREATION_TIME + 2],
  72. Currdata[MBIC_BOOT_CREATION_TIME + 3],
  73. Currdata[MBIC_BOOT_CREATION_TIME + 4],
  74. Currdata[MBIC_BOOT_CREATION_TIME + 5]
  75. );
  76. #if 0 // PYJ.2020.06.29_BEGIN --
  77. if(Currdata[MBIC_BOOT_VERSION + 0] == Bank1data[MBIC_BOOT_VERSION + 0]
  78. &&Currdata[MBIC_BOOT_VERSION + 1] == Bank1data[MBIC_BOOT_VERSION + 1]
  79. &&Currdata[MBIC_BOOT_VERSION + 2] == Bank1data[MBIC_BOOT_VERSION + 2]){
  80. ret = HFR_BANK1_SEL;
  81. }else if(
  82. Currdata[MBIC_BOOT_VERSION + 0] == Bank2data[MBIC_BOOT_VERSION + 0]
  83. &&Currdata[MBIC_BOOT_VERSION + 1] == Bank2data[MBIC_BOOT_VERSION + 1]
  84. &&Currdata[MBIC_BOOT_VERSION + 2] == Bank2data[MBIC_BOOT_VERSION + 2]){
  85. ret = HFR_BANK2_SEL;
  86. }else{
  87. ret = 0;
  88. }
  89. #endif // PYJ.2020.06.29_END --
  90. bluecell_Currdatastatus.CPU_Current_Bank = ret;
  91. printf("MBIC BANK %d Booting \r\n",bluecell_Currdatastatus.CPU_Current_Bank);
  92. printf("bluecell_Currdatastatus.CPU_Bank_Select : %d \r\n",bluecell_Currdatastatus.CPU_Bank_Select);
  93. if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK2_SEL)
  94. {
  95. ret = HFR_BANK2_SEL;
  96. FileCrc =
  97. ((Bank2data[MBIC_BOOT_CRC] << 24 )
  98. | Bank2data[MBIC_BOOT_CRC + 1]<<16
  99. | Bank2data[MBIC_BOOT_CRC + 2]<<8
  100. | Bank2data[MBIC_BOOT_CRC + 3]);
  101. CrcLength=
  102. ((Bank2data[MBIC_BOOT_LENGTH] << 24 )
  103. | Bank2data[MBIC_BOOT_LENGTH + 1]<<16
  104. | Bank2data[MBIC_BOOT_LENGTH + 2]<<8
  105. | Bank2data[MBIC_BOOT_LENGTH + 3]);
  106. crcret = crc32(&Bank2data[MBIC_BOOT_DATA], CrcLength);
  107. }
  108. else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK1_SEL)
  109. {
  110. ret = HFR_BANK1_SEL;
  111. FileCrc =
  112. ((Bank1data[MBIC_BOOT_CRC] << 24 )
  113. | Bank1data[MBIC_BOOT_CRC + 1]<<16
  114. | Bank1data[MBIC_BOOT_CRC + 2]<<8
  115. | Bank1data[MBIC_BOOT_CRC + 3]);
  116. CrcLength=
  117. ((Bank1data[MBIC_BOOT_LENGTH] << 24 )
  118. | Bank1data[MBIC_BOOT_LENGTH + 1]<<16
  119. | Bank1data[MBIC_BOOT_LENGTH + 2]<<8
  120. | Bank1data[MBIC_BOOT_LENGTH + 3]);
  121. crcret = crc32(&Bank1data[MBIC_BOOT_DATA], CrcLength);
  122. }
  123. else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL)
  124. {
  125. if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL)
  126. {
  127. ret = HFR_BANK1_SEL;
  128. FileCrc =
  129. ((Bank1data[MBIC_BOOT_CRC] << 24 )
  130. | Bank1data[MBIC_BOOT_CRC + 1]<<16
  131. | Bank1data[MBIC_BOOT_CRC + 2]<<8
  132. | Bank1data[MBIC_BOOT_CRC + 3]);
  133. CrcLength=
  134. ((Bank1data[MBIC_BOOT_LENGTH] << 24 )
  135. | Bank1data[MBIC_BOOT_LENGTH + 1]<<16
  136. | Bank1data[MBIC_BOOT_LENGTH + 2]<<8
  137. | Bank1data[MBIC_BOOT_LENGTH + 3]);
  138. crcret = crc32(&Bank1data[MBIC_BOOT_DATA], CrcLength);
  139. }
  140. else
  141. {
  142. ret = HFR_BANK2_SEL;
  143. FileCrc =
  144. ((Bank2data[MBIC_BOOT_CRC] << 24 )
  145. | Bank2data[MBIC_BOOT_CRC + 1]<<16
  146. | Bank2data[MBIC_BOOT_CRC + 2]<<8
  147. | Bank2data[MBIC_BOOT_CRC + 3]);
  148. CrcLength=
  149. ((Bank2data[MBIC_BOOT_LENGTH] << 24 )
  150. | Bank2data[MBIC_BOOT_LENGTH + 1]<<16
  151. | Bank2data[MBIC_BOOT_LENGTH + 2]<<8
  152. | Bank2data[MBIC_BOOT_LENGTH + 3]);
  153. }
  154. crcret = crc32(&Bank2data[MBIC_BOOT_DATA], CrcLength);
  155. }
  156. #if 1 // PYJ.2020.06.29_BEGIN --
  157. printf("CRC LENGTH : %d,CRC LENGTH : %X \r\n",CrcLength,CrcLength);
  158. if(crcret != FileCrc){
  159. printf("CRC ERROR : %x , File CRC : %x \r\n",crcret,FileCrc);
  160. return;
  161. }
  162. else
  163. printf("CRC SUCCESS : %x , File CRC : %x \r\n",crcret,FileCrc);
  164. #endif // PYJ.2020.06.29_END --
  165. #if 0 // PYJ.2020.06.30_BEGIN --
  166. uint32_t CurrApiAddress = 0,Bank1Address=0,Bank2Address = 0;
  167. int32_t CrcLength = 0;
  168. CurrApiAddress = FLASH_MBICUSER_START_ADDR;
  169. Bank1Address = FLASH_USER_BANK1_START_ADDR;
  170. Bank2Address = FLASH_USER_BANK2_START_ADDR;
  171. uint8_t* Currdata = (uint8_t*)CurrApiAddress;
  172. uint8_t* Bank1data = (uint8_t*)Bank1Address;
  173. uint8_t* Bank2data = (uint8_t*)Bank2Address;
  174. uint16_t crcret = 0;
  175. CrcLength=
  176. ((Bank1data[MBIC_BOOT_LENGTH] << 24 )
  177. | Bank1data[MBIC_BOOT_LENGTH + 1]<<16
  178. | Bank1data[MBIC_BOOT_LENGTH + 2]<<8
  179. | Bank1data[MBIC_BOOT_LENGTH + 3]);
  180. if(CrcLength > 0)
  181. crcret = CRC16_Generate(Bank1data, CrcLength + 128);
  182. CrcLength += 128;
  183. printf("Bank 1 Crc ret : %x Length : %x : %d \r\n",crcret ,CrcLength,CrcLength);
  184. if()
  185. #endif // PYJ.2020.06.30_END --
  186. if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK1_SEL && bluecell_Currdatastatus.CPU_Current_Bank != HFR_BANK1_SEL){
  187. printf("Write Start BANK 1 Down Start\r\n");
  188. MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK1_START_ADDR,FLASH_MBICUSER_START_ADDR);
  189. bluecell_Currdatastatus.CPU_Bank_Select = 5;
  190. }else if(bluecell_Currdatastatus.CPU_Bank_Select == HFR_BANK2_SEL && bluecell_Currdatastatus.CPU_Current_Bank != HFR_BANK2_SEL){
  191. printf("Write Start BANK 2 Down Start\r\n");
  192. MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK2_START_ADDR,FLASH_MBICUSER_START_ADDR);
  193. bluecell_Currdatastatus.CPU_Bank_Select = 6;
  194. }
  195. else if (bluecell_Currdatastatus.CPU_Bank_Select == HFR_AUTO_SEL || bluecell_Currdatastatus.CPU_Bank_Select == 7){
  196. if(bluecell_Currdatastatus.CPU_Current_Bank == HFR_BANK1_SEL){
  197. printf("Write Start BANK BANK 1 Down Start\r\n");
  198. MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK2_START_ADDR,FLASH_MBICUSER_START_ADDR);
  199. }else{
  200. printf("Write Start BANK BANK 2 Down Start\r\n");
  201. MBIC_BankBooting_Flash_write((uint32_t*)FLASH_USER_BANK1_START_ADDR,FLASH_MBICUSER_START_ADDR);
  202. }
  203. bluecell_Currdatastatus.CPU_Bank_Select = 3;
  204. }
  205. EEPROM_M24C08_write(EEPROM_M24C08_ID ,(EEPROM_WINDOW_STATUS_ADDRESDS),&bluecell_Currdatastatus.bluecell_header,sizeof(BLUESTATUS_st));
  206. printf("EEPROM INIT COMPLETE\r\n");
  207. }
  208. #define MAXEEPROM_LENG 32
  209. HAL_StatusTypeDef EEPROM_M24C08_Read(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
  210. HAL_StatusTypeDef ret = HAL_ERROR;
  211. // uint16_t sizecnt = 0,
  212. //uint16_t sizeremain = 0;
  213. // uint16_t addrees_inc = 0;
  214. // ret = HAL_I2C_Mem_Read(&hi2c2, devid | ((Address & 0x0300) >> 7),((Address )), I2C_MEMADD_SIZE_8BIT, &data[0], size, 1024);
  215. ret = HAL_I2C_Mem_Read(&hi2c2, devid ,((Address )), I2C_MEMADD_SIZE_16BIT, &data[0], size, 1024);
  216. // EEPROM24XX_Load( Address,data, size);
  217. if(ret == HAL_ERROR)
  218. printf("Write ERR\r\n");
  219. else
  220. HAL_Delay(20);
  221. return ret;
  222. }
  223. HAL_StatusTypeDef EEPROM_M24C08_write(uint8_t devid,uint16_t Address,uint8_t* data,uint16_t size){
  224. HAL_StatusTypeDef ret = HAL_ERROR;
  225. uint8_t sizecnt = 0,sizeremain = 0;
  226. uint16_t addrees_inc = 0;
  227. sizecnt = size /MAXEEPROM_LENG;
  228. sizeremain = size % MAXEEPROM_LENG;
  229. addrees_inc = 0;
  230. if(sizecnt > 0){
  231. for(int i = 0 ; i < sizecnt; i++ ){
  232. addrees_inc = i * MAXEEPROM_LENG;
  233. ret = HAL_I2C_Mem_Write(&hi2c2, devid ,((Address + addrees_inc) & 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[addrees_inc], MAXEEPROM_LENG, 1024);
  234. if(ret == HAL_ERROR)
  235. printf("Write ERR\r\n");
  236. else
  237. HAL_Delay(20);
  238. }
  239. addrees_inc += MAXEEPROM_LENG;
  240. }
  241. // printf("Remain Data Index : %d \r\n",sizeremain);
  242. if(sizeremain > 0){
  243. // printf("Remain Data Write Start ");
  244. for(int i = 0; i < sizeremain; i++){
  245. ret = HAL_I2C_Mem_Write(&hi2c2, devid ,((Address + addrees_inc + i)& 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[addrees_inc + i], 1, 1024);
  246. // EEPROM24XX_Save( Address,data, size);
  247. if(ret == HAL_ERROR)
  248. printf("Write ERR\r\n");
  249. else
  250. HAL_Delay(20);
  251. }
  252. }
  253. return ret;
  254. }
  255. HAL_StatusTypeDef EEPROM_M24C08_Zerowrite(uint8_t devid,uint16_t Address){
  256. HAL_StatusTypeDef ret = HAL_ERROR;
  257. // uint8_t sizeremain = 0;
  258. uint16_t addrees_inc = 0;
  259. addrees_inc = 0;
  260. uint8_t data[4096] = {0,};
  261. for(int i = 0 ; i < 128; i++ ){
  262. addrees_inc = i * MAXEEPROM_LENG;
  263. ret = HAL_I2C_Mem_Write(&hi2c2, devid ,((Address + addrees_inc) & 0xFFFF) , I2C_MEMADD_SIZE_16BIT, &data[0], MAXEEPROM_LENG, 1024);
  264. if(ret == HAL_ERROR)
  265. printf("Write ERR\r\n");
  266. else
  267. HAL_Delay(20);
  268. }
  269. return ret;
  270. }