flash_api.c 9.6 KB

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