sf.c 8.7 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2000-2010
  4. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  5. *
  6. * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  7. * Andreas Heppel <aheppel@sysgo.de>
  8. *
  9. * (C) Copyright 2008 Atmel Corporation
  10. */
  11. #include <common.h>
  12. #include <dm.h>
  13. #include <env.h>
  14. #include <env_internal.h>
  15. #include <flash.h>
  16. #include <malloc.h>
  17. #include <spi.h>
  18. #include <spi_flash.h>
  19. #include <search.h>
  20. #include <errno.h>
  21. #include <uuid.h>
  22. #include <asm/cache.h>
  23. #include <asm/global_data.h>
  24. #include <dm/device-internal.h>
  25. #include <u-boot/crc.h>
  26. #ifndef CONFIG_SPL_BUILD
  27. #define INITENV
  28. #endif
  29. #ifdef CONFIG_ENV_OFFSET_REDUND
  30. static ulong env_offset = CONFIG_ENV_OFFSET;
  31. static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  32. #endif /* CONFIG_ENV_OFFSET_REDUND */
  33. DECLARE_GLOBAL_DATA_PTR;
  34. static struct spi_flash *env_flash;
  35. static int setup_flash_device(void)
  36. {
  37. #if CONFIG_IS_ENABLED(DM_SPI_FLASH)
  38. struct udevice *new;
  39. int ret;
  40. /* speed and mode will be read from DT */
  41. ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  42. CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
  43. &new);
  44. if (ret) {
  45. env_set_default("spi_flash_probe_bus_cs() failed", 0);
  46. return ret;
  47. }
  48. env_flash = dev_get_uclass_priv(new);
  49. #else
  50. if (env_flash)
  51. spi_flash_free(env_flash);
  52. env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
  53. CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
  54. if (!env_flash) {
  55. env_set_default("spi_flash_probe() failed", 0);
  56. return -EIO;
  57. }
  58. #endif
  59. return 0;
  60. }
  61. #if defined(CONFIG_ENV_OFFSET_REDUND)
  62. static int env_sf_save(void)
  63. {
  64. env_t env_new;
  65. char *saved_buffer = NULL, flag = ENV_REDUND_OBSOLETE;
  66. u32 saved_size, saved_offset, sector;
  67. int ret;
  68. ret = setup_flash_device();
  69. if (ret)
  70. return ret;
  71. ret = env_export(&env_new);
  72. if (ret)
  73. return -EIO;
  74. env_new.flags = ENV_REDUND_ACTIVE;
  75. if (gd->env_valid == ENV_VALID) {
  76. env_new_offset = CONFIG_ENV_OFFSET_REDUND;
  77. env_offset = CONFIG_ENV_OFFSET;
  78. } else {
  79. env_new_offset = CONFIG_ENV_OFFSET;
  80. env_offset = CONFIG_ENV_OFFSET_REDUND;
  81. }
  82. /* Is the sector larger than the env (i.e. embedded) */
  83. if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  84. saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
  85. saved_offset = env_new_offset + CONFIG_ENV_SIZE;
  86. saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
  87. if (!saved_buffer) {
  88. ret = -ENOMEM;
  89. goto done;
  90. }
  91. ret = spi_flash_read(env_flash, saved_offset,
  92. saved_size, saved_buffer);
  93. if (ret)
  94. goto done;
  95. }
  96. sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
  97. puts("Erasing SPI flash...");
  98. ret = spi_flash_erase(env_flash, env_new_offset,
  99. sector * CONFIG_ENV_SECT_SIZE);
  100. if (ret)
  101. goto done;
  102. puts("Writing to SPI flash...");
  103. ret = spi_flash_write(env_flash, env_new_offset,
  104. CONFIG_ENV_SIZE, &env_new);
  105. if (ret)
  106. goto done;
  107. if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  108. ret = spi_flash_write(env_flash, saved_offset,
  109. saved_size, saved_buffer);
  110. if (ret)
  111. goto done;
  112. }
  113. ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
  114. sizeof(env_new.flags), &flag);
  115. if (ret)
  116. goto done;
  117. puts("done\n");
  118. gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
  119. printf("Valid environment: %d\n", (int)gd->env_valid);
  120. done:
  121. if (saved_buffer)
  122. free(saved_buffer);
  123. return ret;
  124. }
  125. static int env_sf_load(void)
  126. {
  127. int ret;
  128. int read1_fail, read2_fail;
  129. env_t *tmp_env1, *tmp_env2;
  130. tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
  131. CONFIG_ENV_SIZE);
  132. tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
  133. CONFIG_ENV_SIZE);
  134. if (!tmp_env1 || !tmp_env2) {
  135. env_set_default("malloc() failed", 0);
  136. ret = -EIO;
  137. goto out;
  138. }
  139. ret = setup_flash_device();
  140. if (ret)
  141. goto out;
  142. read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
  143. CONFIG_ENV_SIZE, tmp_env1);
  144. read2_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET_REDUND,
  145. CONFIG_ENV_SIZE, tmp_env2);
  146. ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
  147. read2_fail, H_EXTERNAL);
  148. spi_flash_free(env_flash);
  149. env_flash = NULL;
  150. out:
  151. free(tmp_env1);
  152. free(tmp_env2);
  153. return ret;
  154. }
  155. #else
  156. static int env_sf_save(void)
  157. {
  158. u32 saved_size, saved_offset, sector;
  159. char *saved_buffer = NULL;
  160. int ret = 1;
  161. env_t env_new;
  162. ret = setup_flash_device();
  163. if (ret)
  164. return ret;
  165. /* Is the sector larger than the env (i.e. embedded) */
  166. if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  167. saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
  168. saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
  169. saved_buffer = malloc(saved_size);
  170. if (!saved_buffer)
  171. goto done;
  172. ret = spi_flash_read(env_flash, saved_offset,
  173. saved_size, saved_buffer);
  174. if (ret)
  175. goto done;
  176. }
  177. ret = env_export(&env_new);
  178. if (ret)
  179. goto done;
  180. sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
  181. puts("Erasing SPI flash...");
  182. ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
  183. sector * CONFIG_ENV_SECT_SIZE);
  184. if (ret)
  185. goto done;
  186. puts("Writing to SPI flash...");
  187. ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
  188. CONFIG_ENV_SIZE, &env_new);
  189. if (ret)
  190. goto done;
  191. if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
  192. ret = spi_flash_write(env_flash, saved_offset,
  193. saved_size, saved_buffer);
  194. if (ret)
  195. goto done;
  196. }
  197. ret = 0;
  198. puts("done\n");
  199. done:
  200. if (saved_buffer)
  201. free(saved_buffer);
  202. return ret;
  203. }
  204. static int env_sf_load(void)
  205. {
  206. int ret;
  207. char *buf = NULL;
  208. buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
  209. if (!buf) {
  210. env_set_default("malloc() failed", 0);
  211. return -EIO;
  212. }
  213. ret = setup_flash_device();
  214. if (ret)
  215. goto out;
  216. ret = spi_flash_read(env_flash,
  217. CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
  218. if (ret) {
  219. env_set_default("spi_flash_read() failed", 0);
  220. goto err_read;
  221. }
  222. ret = env_import(buf, 1, H_EXTERNAL);
  223. if (!ret)
  224. gd->env_valid = ENV_VALID;
  225. err_read:
  226. spi_flash_free(env_flash);
  227. env_flash = NULL;
  228. out:
  229. free(buf);
  230. return ret;
  231. }
  232. #endif
  233. #if CONFIG_ENV_ADDR != 0x0
  234. __weak void *env_sf_get_env_addr(void)
  235. {
  236. return (void *)CONFIG_ENV_ADDR;
  237. }
  238. #endif
  239. #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
  240. /*
  241. * check if Environment on CONFIG_ENV_ADDR is valid.
  242. */
  243. static int env_sf_init_addr(void)
  244. {
  245. env_t *env_ptr = (env_t *)env_sf_get_env_addr();
  246. if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
  247. gd->env_addr = (ulong)&(env_ptr->data);
  248. gd->env_valid = 1;
  249. } else {
  250. gd->env_addr = (ulong)&default_environment[0];
  251. gd->env_valid = 1;
  252. }
  253. return 0;
  254. }
  255. #endif
  256. #if defined(CONFIG_ENV_SPI_EARLY)
  257. /*
  258. * early load environment from SPI flash (before relocation)
  259. * and check if it is valid.
  260. */
  261. static int env_sf_init_early(void)
  262. {
  263. int ret;
  264. int read1_fail;
  265. int read2_fail;
  266. int crc1_ok;
  267. env_t *tmp_env2 = NULL;
  268. env_t *tmp_env1;
  269. /*
  270. * if malloc is not ready yet, we cannot use
  271. * this part yet.
  272. */
  273. if (!gd->malloc_limit)
  274. return -ENOENT;
  275. tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
  276. CONFIG_ENV_SIZE);
  277. if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
  278. tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
  279. CONFIG_ENV_SIZE);
  280. if (!tmp_env1 || !tmp_env2)
  281. goto out;
  282. ret = setup_flash_device();
  283. if (ret)
  284. goto out;
  285. read1_fail = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
  286. CONFIG_ENV_SIZE, tmp_env1);
  287. if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT)) {
  288. read2_fail = spi_flash_read(env_flash,
  289. CONFIG_ENV_OFFSET_REDUND,
  290. CONFIG_ENV_SIZE, tmp_env2);
  291. ret = env_check_redund((char *)tmp_env1, read1_fail,
  292. (char *)tmp_env2, read2_fail);
  293. if (ret == -EIO || ret == -ENOMSG)
  294. goto err_read;
  295. if (gd->env_valid == ENV_VALID)
  296. gd->env_addr = (unsigned long)&tmp_env1->data;
  297. else
  298. gd->env_addr = (unsigned long)&tmp_env2->data;
  299. } else {
  300. if (read1_fail)
  301. goto err_read;
  302. crc1_ok = crc32(0, tmp_env1->data, ENV_SIZE) ==
  303. tmp_env1->crc;
  304. if (!crc1_ok)
  305. goto err_read;
  306. /* if valid -> this is our env */
  307. gd->env_valid = ENV_VALID;
  308. gd->env_addr = (unsigned long)&tmp_env1->data;
  309. }
  310. return 0;
  311. err_read:
  312. spi_flash_free(env_flash);
  313. env_flash = NULL;
  314. free(tmp_env1);
  315. if (IS_ENABLED(CONFIG_SYS_REDUNDAND_ENVIRONMENT))
  316. free(tmp_env2);
  317. out:
  318. /* env is not valid. always return 0 */
  319. gd->env_valid = ENV_INVALID;
  320. return 0;
  321. }
  322. #endif
  323. static int env_sf_init(void)
  324. {
  325. #if defined(INITENV) && (CONFIG_ENV_ADDR != 0x0)
  326. return env_sf_init_addr();
  327. #elif defined(CONFIG_ENV_SPI_EARLY)
  328. return env_sf_init_early();
  329. #endif
  330. /*
  331. * return here -ENOENT, so env_init()
  332. * can set the init bit and later if no
  333. * other Environment storage is defined
  334. * can set the default environment
  335. */
  336. return -ENOENT;
  337. }
  338. U_BOOT_ENV_LOCATION(sf) = {
  339. .location = ENVL_SPI_FLASH,
  340. ENV_NAME("SPIFlash")
  341. .load = env_sf_load,
  342. .save = CONFIG_IS_ENABLED(SAVEENV) ? ENV_SAVE_PTR(env_sf_save) : NULL,
  343. .init = env_sf_init,
  344. };