flash_api.c 9.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362
  1. /******************************************************************************
  2. * Flash api for NodeMCU
  3. * NodeMCU Team
  4. * 2014-12-31
  5. *******************************************************************************/
  6. #include "user_config.h"
  7. #include "flash_api.h"
  8. #include "spi_flash.h"
  9. #include <stdio.h>
  10. #include <string.h>
  11. #include <stdlib.h>
  12. uint32_t flash_detect_size_byte(void)
  13. {
  14. #define FLASH_BUFFER_SIZE_DETECT 32
  15. uint32_t dummy_size = FLASH_SIZE_256KBYTE;
  16. uint8_t data_orig[FLASH_BUFFER_SIZE_DETECT] ICACHE_STORE_ATTR = {0};
  17. uint8_t data_new[FLASH_BUFFER_SIZE_DETECT] ICACHE_STORE_ATTR = {0};
  18. if (SPI_FLASH_RESULT_OK == flash_safe_read(0, (uint32 *)data_orig, FLASH_BUFFER_SIZE_DETECT))
  19. {
  20. dummy_size = FLASH_SIZE_256KBYTE;
  21. while ((dummy_size < FLASH_SIZE_16MBYTE) &&
  22. (SPI_FLASH_RESULT_OK == flash_safe_read(dummy_size, (uint32 *)data_new, FLASH_BUFFER_SIZE_DETECT)) &&
  23. (0 != memcmp(data_orig, data_new, FLASH_BUFFER_SIZE_DETECT))
  24. )
  25. {
  26. dummy_size *= 2;
  27. }
  28. };
  29. return dummy_size;
  30. #undef FLASH_BUFFER_SIZE_DETECT
  31. }
  32. uint32_t flash_safe_get_size_byte(void)
  33. {
  34. static uint32_t flash_size = 0;
  35. if (flash_size == 0)
  36. {
  37. flash_size = flash_detect_size_byte();
  38. }
  39. return flash_size;
  40. }
  41. uint16_t flash_safe_get_sec_num(void)
  42. {
  43. return (flash_safe_get_size_byte() / (SPI_FLASH_SEC_SIZE));
  44. }
  45. SpiFlashOpResult flash_safe_read(uint32 src_addr, uint32 *des_addr, uint32 size)
  46. {
  47. SpiFlashOpResult result = SPI_FLASH_RESULT_ERR;
  48. FLASH_SAFEMODE_ENTER();
  49. result = spi_flash_read(src_addr, (uint32 *) des_addr, size);
  50. FLASH_SAFEMODE_LEAVE();
  51. return result;
  52. }
  53. SpiFlashOpResult flash_safe_write(uint32 des_addr, uint32 *src_addr, uint32 size)
  54. {
  55. SpiFlashOpResult result = SPI_FLASH_RESULT_ERR;
  56. FLASH_SAFEMODE_ENTER();
  57. result = spi_flash_write(des_addr, src_addr, size);
  58. FLASH_SAFEMODE_LEAVE();
  59. return result;
  60. }
  61. SpiFlashOpResult flash_safe_erase_sector(uint16 sec)
  62. {
  63. SpiFlashOpResult result = SPI_FLASH_RESULT_ERR;
  64. FLASH_SAFEMODE_ENTER();
  65. result = spi_flash_erase_sector(sec);
  66. FLASH_SAFEMODE_LEAVE();
  67. return result;
  68. }
  69. SPIFlashInfo flash_rom_getinfo(void)
  70. {
  71. volatile SPIFlashInfo spi_flash_info ICACHE_STORE_ATTR;
  72. spi_flash_read(0, (uint32 *)(& spi_flash_info), sizeof(spi_flash_info));
  73. return spi_flash_info;
  74. }
  75. uint8_t flash_rom_get_size_type(void)
  76. {
  77. return flash_rom_getinfo().size;
  78. }
  79. uint32_t flash_rom_get_size_byte(void)
  80. {
  81. static uint32_t flash_size = 0;
  82. if (flash_size == 0)
  83. {
  84. switch (flash_rom_getinfo().size)
  85. {
  86. case SIZE_2MBIT:
  87. // 2Mbit, 256kByte
  88. flash_size = 256 * 1024;
  89. break;
  90. case SIZE_4MBIT:
  91. // 4Mbit, 512kByte
  92. flash_size = 512 * 1024;
  93. break;
  94. case SIZE_8MBIT:
  95. // 8Mbit, 1MByte
  96. flash_size = 1 * 1024 * 1024;
  97. break;
  98. case SIZE_16MBIT:
  99. // 16Mbit, 2MByte
  100. flash_size = 2 * 1024 * 1024;
  101. break;
  102. case SIZE_32MBIT:
  103. // 32Mbit, 4MByte
  104. flash_size = 4 * 1024 * 1024;
  105. break;
  106. case SIZE_16MBIT_8M_8M:
  107. // 16Mbit, 2MByte
  108. flash_size = 2 * 1024 * 1024;
  109. break;
  110. case SIZE_32MBIT_8M_8M:
  111. // 32Mbit, 4MByte
  112. flash_size = 4 * 1024 * 1024;
  113. break;
  114. default:
  115. // Unknown flash size, fall back mode.
  116. flash_size = 512 * 1024;
  117. break;
  118. }
  119. }
  120. return flash_size;
  121. }
  122. bool flash_rom_set_size_type(uint8_t size)
  123. {
  124. // Dangerous, here are dinosaur infested!!!!!
  125. // Reboot required!!!
  126. // If you don't know what you're doing, your nodemcu may turn into stone ...
  127. NODE_DBG("\nBEGIN SET FLASH HEADER\n");
  128. uint8_t *data = malloc (SPI_FLASH_SEC_SIZE);
  129. if (!data)
  130. return false;
  131. if (SPI_FLASH_RESULT_OK == spi_flash_read(0, (uint32 *)data, SPI_FLASH_SEC_SIZE))
  132. {
  133. ((SPIFlashInfo *)(&data[0]))->size = size;
  134. if (SPI_FLASH_RESULT_OK == spi_flash_erase_sector(0 * SPI_FLASH_SEC_SIZE))
  135. {
  136. NODE_DBG("\nERASE SUCCESS\n");
  137. }
  138. if (SPI_FLASH_RESULT_OK == spi_flash_write(0, (uint32 *)data, SPI_FLASH_SEC_SIZE))
  139. {
  140. NODE_DBG("\nWRITE SUCCESS, %u\n", size);
  141. }
  142. }
  143. free (data);
  144. NODE_DBG("\nEND SET FLASH HEADER\n");
  145. return true;
  146. }
  147. bool flash_rom_set_size_byte(uint32_t size)
  148. {
  149. // Dangerous, here are dinosaur infested!!!!!
  150. // Reboot required!!!
  151. // If you don't know what you're doing, your nodemcu may turn into stone ...
  152. bool result = true;
  153. uint32_t flash_size = 0;
  154. switch (size)
  155. {
  156. case 256 * 1024:
  157. // 2Mbit, 256kByte
  158. flash_size = SIZE_2MBIT;
  159. flash_rom_set_size_type(flash_size);
  160. break;
  161. case 512 * 1024:
  162. // 4Mbit, 512kByte
  163. flash_size = SIZE_4MBIT;
  164. flash_rom_set_size_type(flash_size);
  165. break;
  166. case 1 * 1024 * 1024:
  167. // 8Mbit, 1MByte
  168. flash_size = SIZE_8MBIT;
  169. flash_rom_set_size_type(flash_size);
  170. break;
  171. case 2 * 1024 * 1024:
  172. // 16Mbit, 2MByte
  173. flash_size = SIZE_16MBIT;
  174. flash_rom_set_size_type(flash_size);
  175. break;
  176. case 4 * 1024 * 1024:
  177. // 32Mbit, 4MByte
  178. flash_size = SIZE_32MBIT;
  179. flash_rom_set_size_type(flash_size);
  180. break;
  181. /*
  182. case 8 * 1024 * 1024:
  183. // 64Mbit, 8MByte
  184. flash_size = SIZE_16MBIT_8M_8M;
  185. flash_rom_set_size_type(flash_size);
  186. break;
  187. case 16 * 1024 * 1024:
  188. // 128Mbit, 16MByte
  189. flash_size = SIZE_32MBIT_8M_8M;
  190. flash_rom_set_size_type(flash_size);
  191. break;
  192. */
  193. default:
  194. // Unknown flash size.
  195. result = false;
  196. break;
  197. }
  198. return result;
  199. }
  200. uint16_t flash_rom_get_sec_num(void)
  201. {
  202. //static uint16_t sec_num = 0;
  203. // return flash_rom_get_size_byte() / (SPI_FLASH_SEC_SIZE);
  204. // printf("\nflash_rom_get_size_byte()=%d\n", ( flash_rom_get_size_byte() / (SPI_FLASH_SEC_SIZE) ));
  205. // if( sec_num == 0 )
  206. //{
  207. // sec_num = 4 * 1024 * 1024 / (SPI_FLASH_SEC_SIZE);
  208. //}
  209. //return sec_num;
  210. return ( flash_rom_get_size_byte() / (SPI_FLASH_SEC_SIZE) );
  211. }
  212. uint8_t flash_rom_get_mode(void)
  213. {
  214. SPIFlashInfo spi_flash_info = flash_rom_getinfo();
  215. switch (spi_flash_info.mode)
  216. {
  217. // Reserved for future use
  218. case MODE_QIO:
  219. break;
  220. case MODE_QOUT:
  221. break;
  222. case MODE_DIO:
  223. break;
  224. case MODE_DOUT:
  225. break;
  226. }
  227. return spi_flash_info.mode;
  228. }
  229. uint32_t flash_rom_get_speed(void)
  230. {
  231. uint32_t speed = 0;
  232. SPIFlashInfo spi_flash_info = flash_rom_getinfo();
  233. switch (spi_flash_info.speed)
  234. {
  235. case SPEED_40MHZ:
  236. // 40MHz
  237. speed = 40000000;
  238. break;
  239. case SPEED_26MHZ:
  240. //26.7MHz
  241. speed = 26700000;
  242. break;
  243. case SPEED_20MHZ:
  244. // 20MHz
  245. speed = 20000000;
  246. break;
  247. case SPEED_80MHZ:
  248. //80MHz
  249. speed = 80000000;
  250. break;
  251. }
  252. return speed;
  253. }
  254. bool flash_rom_set_speed(uint32_t speed)
  255. {
  256. // Dangerous, here are dinosaur infested!!!!!
  257. // Reboot required!!!
  258. // If you don't know what you're doing, your nodemcu may turn into stone ...
  259. NODE_DBG("\nBEGIN SET FLASH HEADER\n");
  260. uint8_t *data = malloc (SPI_FLASH_SEC_SIZE);
  261. if (!data)
  262. return false;
  263. uint8_t speed_type = SPEED_40MHZ;
  264. if (speed < 26700000)
  265. {
  266. speed_type = SPEED_20MHZ;
  267. }
  268. else if (speed < 40000000)
  269. {
  270. speed_type = SPEED_26MHZ;
  271. }
  272. else if (speed < 80000000)
  273. {
  274. speed_type = SPEED_40MHZ;
  275. }
  276. else if (speed >= 80000000)
  277. {
  278. speed_type = SPEED_80MHZ;
  279. }
  280. if (SPI_FLASH_RESULT_OK == spi_flash_read(0, (uint32 *)data, SPI_FLASH_SEC_SIZE))
  281. {
  282. ((SPIFlashInfo *)(&data[0]))->speed = speed_type;
  283. if (SPI_FLASH_RESULT_OK == spi_flash_erase_sector(0 * SPI_FLASH_SEC_SIZE))
  284. {
  285. NODE_DBG("\nERASE SUCCESS\n");
  286. }
  287. if (SPI_FLASH_RESULT_OK == spi_flash_write(0, (uint32 *)data, SPI_FLASH_SEC_SIZE))
  288. {
  289. NODE_DBG("\nWRITE SUCCESS, %u\n", speed_type);
  290. }
  291. }
  292. free (data);
  293. NODE_DBG("\nEND SET FLASH HEADER\n");
  294. return true;
  295. }
  296. uint8_t byte_of_aligned_array(const uint8_t *aligned_array, uint32_t index)
  297. {
  298. if ( (((uint32_t)aligned_array) % 4) != 0 )
  299. {
  300. NODE_DBG("aligned_array is not 4-byte aligned.\n");
  301. return 0;
  302. }
  303. volatile uint32_t v = ((uint32_t *)aligned_array)[ index / 4 ];
  304. uint8_t *p = (uint8_t *) (&v);
  305. return p[ (index % 4) ];
  306. }
  307. uint16_t word_of_aligned_array(const uint16_t *aligned_array, uint32_t index)
  308. {
  309. if ( (((uint32_t)aligned_array) % 4) != 0 )
  310. {
  311. NODE_DBG("aligned_array is not 4-byte aligned.\n");
  312. return 0;
  313. }
  314. volatile uint32_t v = ((uint32_t *)aligned_array)[ index / 2 ];
  315. uint16_t *p = (uint16_t *) (&v);
  316. return (index % 2 == 0) ? p[ 0 ] : p[ 1 ];
  317. // return p[ (index % 2) ]; // -- why error???
  318. // (byte_of_aligned_array((uint8_t *)aligned_array, index * 2 + 1) << 8) | byte_of_aligned_array((uint8_t *)aligned_array, index * 2);
  319. }
  320. // uint8_t flash_rom_get_checksum(void)
  321. // {
  322. // // SPIFlashInfo spi_flash_info ICACHE_STORE_ATTR = flash_rom_getinfo();
  323. // // uint32_t address = sizeof(spi_flash_info) + spi_flash_info.segment_size;
  324. // // uint32_t address_aligned_4bytes = (address + 3) & 0xFFFFFFFC;
  325. // // uint8_t buffer[64] = {0};
  326. // // spi_flash_read(address, (uint32 *) buffer, 64);
  327. // // uint8_t i = 0;
  328. // // printf("\nBEGIN DUMP\n");
  329. // // for (i = 0; i < 64; i++)
  330. // // {
  331. // // printf("%02x," , buffer[i]);
  332. // // }
  333. // // i = (address + 0x10) & 0x10 - 1;
  334. // // printf("\nSIZE:%d CHECK SUM:%02x\n", spi_flash_info.segment_size, buffer[i]);
  335. // // printf("\nEND DUMP\n");
  336. // // return buffer[0];
  337. // return 0;
  338. // }
  339. // uint8_t flash_rom_calc_checksum(void)
  340. // {
  341. // return 0;
  342. // }