drv_flash_f1.c 6.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278
  1. /*
  2. * Copyright (c) 2006-2018, RT-Thread Development Team
  3. *
  4. * SPDX-License-Identifier: Apache-2.0
  5. *
  6. * Change Logs:
  7. * Date Author Notes
  8. * 2018-12-5 SummerGift first version
  9. * 2020-03-05 redoc support stm32f103vg
  10. *
  11. */
  12. #include "board.h"
  13. #ifdef BSP_USING_ON_CHIP_FLASH
  14. #include "drv_config.h"
  15. #include "drv_flash.h"
  16. #if defined(PKG_USING_FAL)
  17. #include "fal.h"
  18. #endif
  19. #define DRV_DEBUG
  20. #define LOG_TAG "drv.flash"
  21. #include <drv_log.h>
  22. /**
  23. * @brief Gets the page of a given address
  24. * @param Addr: Address of the FLASH Memory
  25. * @retval The page of a given address
  26. */
  27. static uint32_t GetPage(uint32_t addr)
  28. {
  29. uint32_t page = 0;
  30. page = RT_ALIGN_DOWN(addr, FLASH_PAGE_SIZE);
  31. return page;
  32. }
  33. /**
  34. * Read data from flash.
  35. * @note This operation's units is word.
  36. *
  37. * @param addr flash address
  38. * @param buf buffer to store read data
  39. * @param size read bytes size
  40. *
  41. * @return result
  42. */
  43. int stm32_flash_read(rt_uint32_t addr, rt_uint8_t *buf, size_t size)
  44. {
  45. size_t i;
  46. if ((addr + size) > STM32_FLASH_END_ADDRESS)
  47. {
  48. LOG_E("read outrange flash size! addr is (0x%p)", (void *)(addr + size));
  49. return -RT_EINVAL;
  50. }
  51. for (i = 0; i < size; i++, buf++, addr++)
  52. {
  53. *buf = *(rt_uint8_t *) addr;
  54. }
  55. return size;
  56. }
  57. /**
  58. * Write data to flash.
  59. * @note This operation's units is word.
  60. * @note This operation must after erase. @see flash_erase.
  61. *
  62. * @param addr flash address
  63. * @param buf the write data buffer
  64. * @param size write bytes size
  65. *
  66. * @return result
  67. */
  68. int stm32_flash_write(rt_uint32_t addr, const rt_uint8_t *buf, size_t size)
  69. {
  70. rt_err_t result = RT_EOK;
  71. rt_uint32_t end_addr = addr + size;
  72. if (addr % 4 != 0)
  73. {
  74. LOG_E("write addr must be 4-byte alignment");
  75. return -RT_EINVAL;
  76. }
  77. if ((end_addr) > STM32_FLASH_END_ADDRESS)
  78. {
  79. LOG_E("write outrange flash size! addr is (0x%p)", (void *)(addr + size));
  80. return -RT_EINVAL;
  81. }
  82. //LOG_D("stm32_flash_write:(0x%p)",addr);
  83. //APM32此处关闭中断
  84. __disable_irq();
  85. HAL_FLASH_Unlock();
  86. while (addr < end_addr)
  87. {
  88. if (HAL_FLASH_Program(FLASH_TYPEPROGRAM_WORD, addr, *((rt_uint32_t *)buf)) == HAL_OK)
  89. {
  90. if (*(rt_uint32_t *)addr != *(rt_uint32_t *)buf)
  91. {
  92. result = -RT_ERROR;
  93. LOG_D("addr ERROR!");
  94. break;
  95. }
  96. addr += 4;
  97. buf += 4;
  98. }
  99. else
  100. {
  101. LOG_E("HAL_FLASH_Program ERROR at:(0x%p)!",addr);
  102. result = -RT_ERROR;
  103. break;
  104. }
  105. }
  106. HAL_FLASH_Lock();
  107. //打开中断
  108. __enable_irq();
  109. if (result != RT_EOK)
  110. {
  111. return result;
  112. }
  113. return size;
  114. }
  115. /**
  116. * Erase data on flash with bank.
  117. * @note This operation is irreversible.
  118. * @note This operation's units is different which on many chips.
  119. *
  120. * @param bank flash bank
  121. * @param addr flash address
  122. * @param size erase bytes size
  123. *
  124. * @return result
  125. */
  126. int stm32_flash_erase_bank(uint32_t bank, rt_uint32_t addr, size_t size)
  127. {
  128. rt_err_t result = RT_EOK;
  129. uint32_t PAGEError = 0;
  130. /*Variable used for Erase procedure*/
  131. FLASH_EraseInitTypeDef EraseInitStruct;
  132. if ((addr + size) > STM32_FLASH_END_ADDRESS)
  133. {
  134. LOG_E("ERROR: erase outrange flash size! addr is (0x%p)\n", (void *)(addr + size));
  135. return -RT_EINVAL;
  136. }
  137. HAL_FLASH_Unlock();
  138. /* Fill EraseInit structure*/
  139. EraseInitStruct.TypeErase = FLASH_TYPEERASE_PAGES;
  140. EraseInitStruct.PageAddress = GetPage(addr);
  141. EraseInitStruct.NbPages = (size + FLASH_PAGE_SIZE - 1) / FLASH_PAGE_SIZE;
  142. EraseInitStruct.Banks = bank;
  143. if (HAL_FLASHEx_Erase(&EraseInitStruct, &PAGEError) != HAL_OK)
  144. {
  145. result = -RT_ERROR;
  146. goto __exit;
  147. }
  148. __exit:
  149. HAL_FLASH_Lock();
  150. if (result != RT_EOK)
  151. {
  152. return result;
  153. }
  154. LOG_D("erase done: addr (0x%p), size %d", (void *)addr, size);
  155. return size;
  156. }
  157. /**
  158. * Erase data on flash .
  159. * @note This operation is irreversible.
  160. * @note This operation's units is different which on many chips.
  161. *
  162. * @param addr flash address
  163. * @param size erase bytes size
  164. *
  165. * @return result
  166. */
  167. int stm32_flash_erase(rt_uint32_t addr, size_t size)
  168. {
  169. #if defined(FLASH_BANK2_END)
  170. rt_err_t result = RT_EOK;
  171. rt_uint32_t addr_bank1 = 0;
  172. rt_uint32_t size_bank1 = 0;
  173. rt_uint32_t addr_bank2 = 0;
  174. rt_uint32_t size_bank2 = 0;
  175. if((addr + size) <= FLASH_BANK1_END)
  176. {
  177. addr_bank1 = addr;
  178. size_bank1 = size;
  179. size_bank2 = 0;
  180. }
  181. else if(addr > FLASH_BANK1_END)
  182. {
  183. size_bank1 = 0;
  184. addr_bank2 = addr;
  185. size_bank2 = size;
  186. }
  187. else
  188. {
  189. addr_bank1 = addr;
  190. size_bank1 = FLASH_BANK1_END + 1 - addr_bank1;
  191. addr_bank2 = FLASH_BANK1_END + 1;
  192. size_bank2 = addr + size - (FLASH_BANK1_END + 1);
  193. }
  194. if(size_bank1)
  195. {
  196. LOG_D("bank1: addr (0x%p), size %d", (void *)addr_bank1, size_bank1);
  197. if(size_bank1 != stm32_flash_erase_bank(FLASH_BANK_1, addr_bank1, size_bank1))
  198. {
  199. result = -RT_ERROR;
  200. goto __exit;
  201. }
  202. }
  203. if(size_bank2)
  204. {
  205. LOG_D("bank2: addr (0x%p), size %d", (void *)addr_bank2, size_bank2);
  206. if(size_bank2 != stm32_flash_erase_bank(FLASH_BANK_2, addr_bank2, size_bank2))
  207. {
  208. result = -RT_ERROR;
  209. goto __exit;
  210. }
  211. }
  212. __exit:
  213. if(result != RT_EOK)
  214. {
  215. return result;
  216. }
  217. return size_bank1 + size_bank2;
  218. #else
  219. return stm32_flash_erase_bank(FLASH_BANK_1, addr, size);
  220. #endif
  221. }
  222. #if defined(PKG_USING_FAL)
  223. static int fal_flash_read(long offset, rt_uint8_t *buf, size_t size);
  224. static int fal_flash_write(long offset, const rt_uint8_t *buf, size_t size);
  225. static int fal_flash_erase(long offset, size_t size);
  226. const struct fal_flash_dev stm32_onchip_flash = { "onchip_flash", STM32_FLASH_START_ADRESS, STM32_FLASH_SIZE, FLASH_PAGE_SIZE, {NULL, fal_flash_read, fal_flash_write, fal_flash_erase} };
  227. static int fal_flash_read(long offset, rt_uint8_t *buf, size_t size)
  228. {
  229. return stm32_flash_read(stm32_onchip_flash.addr + offset, buf, size);
  230. }
  231. static int fal_flash_write(long offset, const rt_uint8_t *buf, size_t size)
  232. {
  233. return stm32_flash_write(stm32_onchip_flash.addr + offset, buf, size);
  234. }
  235. static int fal_flash_erase(long offset, size_t size)
  236. {
  237. return stm32_flash_erase(stm32_onchip_flash.addr + offset, size);
  238. }
  239. #endif
  240. #endif /* BSP_USING_ON_CHIP_FLASH */