flash_api.c 4.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186
  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. uint32_t flash_detect_size_byte(void)
  12. {
  13. // enable operations on whole physical flash, SDK might have restricted
  14. // the flash size already
  15. extern SpiFlashChip * flashchip;
  16. uint32 orig_chip_size = flashchip->chip_size;
  17. flashchip->chip_size = FLASH_SIZE_16MBYTE;
  18. #define FLASH_BUFFER_SIZE_DETECT 32
  19. uint32_t dummy_size = FLASH_SIZE_256KBYTE;
  20. uint8_t data_orig[FLASH_BUFFER_SIZE_DETECT] ICACHE_STORE_ATTR = {0};
  21. uint8_t data_new[FLASH_BUFFER_SIZE_DETECT] ICACHE_STORE_ATTR = {0};
  22. if (SPI_FLASH_RESULT_OK == flash_read(0, (uint32 *)data_orig, FLASH_BUFFER_SIZE_DETECT))
  23. {
  24. dummy_size = FLASH_SIZE_256KBYTE;
  25. while ((dummy_size < FLASH_SIZE_16MBYTE) &&
  26. (SPI_FLASH_RESULT_OK == flash_read(dummy_size, (uint32 *)data_new, FLASH_BUFFER_SIZE_DETECT)) &&
  27. (0 != memcmp(data_orig, data_new, FLASH_BUFFER_SIZE_DETECT))
  28. )
  29. {
  30. dummy_size *= 2;
  31. }
  32. };
  33. // revert temporary setting
  34. flashchip->chip_size = orig_chip_size;
  35. return dummy_size;
  36. #undef FLASH_BUFFER_SIZE_DETECT
  37. }
  38. static SPIFlashInfo spi_flash_info = {0};
  39. SPIFlashInfo *flash_rom_getinfo(void)
  40. {
  41. if (spi_flash_info.entry_point == 0) {
  42. spi_flash_read(0, (uint32 *)(& spi_flash_info), sizeof(spi_flash_info));
  43. }
  44. return &spi_flash_info;
  45. }
  46. uint8_t flash_rom_get_size_type(void)
  47. {
  48. return flash_rom_getinfo()->size;
  49. }
  50. uint32_t flash_rom_get_size_byte(void)
  51. {
  52. static uint32_t flash_size = 0;
  53. if (flash_size == 0)
  54. {
  55. switch (flash_rom_getinfo()->size)
  56. {
  57. case SIZE_2MBIT:
  58. // 2Mbit, 256kByte
  59. flash_size = 256 * 1024;
  60. break;
  61. case SIZE_4MBIT:
  62. // 4Mbit, 512kByte
  63. flash_size = 512 * 1024;
  64. break;
  65. case SIZE_8MBIT:
  66. // 8Mbit, 1MByte
  67. flash_size = 1 * 1024 * 1024;
  68. break;
  69. case SIZE_16MBIT:
  70. // 16Mbit, 2MByte
  71. flash_size = 2 * 1024 * 1024;
  72. break;
  73. case SIZE_32MBIT:
  74. // 32Mbit, 4MByte
  75. flash_size = 4 * 1024 * 1024;
  76. break;
  77. case SIZE_16MBIT_8M_8M:
  78. // 16Mbit, 2MByte
  79. flash_size = 2 * 1024 * 1024;
  80. break;
  81. case SIZE_32MBIT_8M_8M:
  82. // 32Mbit, 4MByte
  83. flash_size = 4 * 1024 * 1024;
  84. break;
  85. case SIZE_32MBIT_16M_16M:
  86. // 32Mbit, 4MByte
  87. flash_size = 4 * 1024 * 1024;
  88. break;
  89. case SIZE_64MBIT:
  90. // 64Mbit, 8MByte
  91. flash_size = 8 * 1024 * 1024;
  92. break;
  93. case SIZE_128MBIT:
  94. // 128Mbit, 16MByte
  95. flash_size = 16 * 1024 * 1024;
  96. break;
  97. default:
  98. // Unknown flash size, fall back mode.
  99. flash_size = 512 * 1024;
  100. break;
  101. }
  102. }
  103. return flash_size;
  104. }
  105. uint16_t flash_rom_get_sec_num(void)
  106. {
  107. return ( flash_rom_get_size_byte() / (SPI_FLASH_SEC_SIZE) );
  108. }
  109. uint8_t flash_rom_get_mode(void)
  110. {
  111. uint8_t mode = flash_rom_getinfo()->mode;
  112. switch (mode)
  113. {
  114. // Reserved for future use
  115. case MODE_QIO:
  116. break;
  117. case MODE_QOUT:
  118. break;
  119. case MODE_DIO:
  120. break;
  121. case MODE_DOUT:
  122. break;
  123. }
  124. return mode;
  125. }
  126. uint32_t flash_rom_get_speed(void)
  127. {
  128. uint32_t speed = 0;
  129. uint8_t spi_speed = flash_rom_getinfo()->speed;
  130. switch (spi_speed)
  131. {
  132. case SPEED_40MHZ:
  133. // 40MHz
  134. speed = 40000000;
  135. break;
  136. case SPEED_26MHZ:
  137. //26.7MHz
  138. speed = 26700000;
  139. break;
  140. case SPEED_20MHZ:
  141. // 20MHz
  142. speed = 20000000;
  143. break;
  144. case SPEED_80MHZ:
  145. //80MHz
  146. speed = 80000000;
  147. break;
  148. }
  149. return speed;
  150. }
  151. uint8_t byte_of_aligned_array(const uint8_t *aligned_array, uint32_t index)
  152. {
  153. if ( (((uint32_t)aligned_array) % 4) != 0 )
  154. {
  155. NODE_DBG("aligned_array is not 4-byte aligned.\n");
  156. return 0;
  157. }
  158. volatile uint32_t v = ((uint32_t *)aligned_array)[ index / 4 ];
  159. uint8_t *p = (uint8_t *) (&v);
  160. return p[ (index % 4) ];
  161. }
  162. uint16_t word_of_aligned_array(const uint16_t *aligned_array, uint32_t index)
  163. {
  164. if ( (((uint32_t)aligned_array) % 4) != 0 )
  165. {
  166. NODE_DBG("aligned_array is not 4-byte aligned.\n");
  167. return 0;
  168. }
  169. volatile uint32_t v = ((uint32_t *)aligned_array)[ index / 2 ];
  170. uint16_t *p = (uint16_t *) (&v);
  171. return (index % 2 == 0) ? p[ 0 ] : p[ 1 ];
  172. }