env_eeprom.c 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264
  1. /*
  2. * (C) Copyright 2000-2010
  3. * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  4. *
  5. * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
  6. * Andreas Heppel <aheppel@sysgo.de>
  7. *
  8. * SPDX-License-Identifier: GPL-2.0+
  9. */
  10. #include <common.h>
  11. #include <command.h>
  12. #include <environment.h>
  13. #include <linux/stddef.h>
  14. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  15. #include <i2c.h>
  16. #endif
  17. #include <search.h>
  18. #include <errno.h>
  19. #include <linux/compiler.h> /* for BUG_ON */
  20. DECLARE_GLOBAL_DATA_PTR;
  21. env_t *env_ptr;
  22. char *env_name_spec = "EEPROM";
  23. static int eeprom_bus_read(unsigned dev_addr, unsigned offset,
  24. uchar *buffer, unsigned cnt)
  25. {
  26. int rcode;
  27. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  28. int old_bus = i2c_get_bus_num();
  29. if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
  30. i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
  31. #endif
  32. rcode = eeprom_read(dev_addr, offset, buffer, cnt);
  33. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  34. i2c_set_bus_num(old_bus);
  35. #endif
  36. return rcode;
  37. }
  38. static int eeprom_bus_write(unsigned dev_addr, unsigned offset,
  39. uchar *buffer, unsigned cnt)
  40. {
  41. int rcode;
  42. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  43. int old_bus = i2c_get_bus_num();
  44. if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
  45. i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
  46. #endif
  47. rcode = eeprom_write(dev_addr, offset, buffer, cnt);
  48. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  49. i2c_set_bus_num(old_bus);
  50. #endif
  51. return rcode;
  52. }
  53. uchar env_get_char_spec(int index)
  54. {
  55. uchar c;
  56. unsigned int off = CONFIG_ENV_OFFSET;
  57. #ifdef CONFIG_ENV_OFFSET_REDUND
  58. if (gd->env_valid == 2)
  59. off = CONFIG_ENV_OFFSET_REDUND;
  60. #endif
  61. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  62. off + index + offsetof(env_t, data), &c, 1);
  63. return c;
  64. }
  65. void env_relocate_spec(void)
  66. {
  67. char buf[CONFIG_ENV_SIZE];
  68. unsigned int off = CONFIG_ENV_OFFSET;
  69. #ifdef CONFIG_ENV_OFFSET_REDUND
  70. if (gd->env_valid == 2)
  71. off = CONFIG_ENV_OFFSET_REDUND;
  72. #endif
  73. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  74. off, (uchar *)buf, CONFIG_ENV_SIZE);
  75. env_import(buf, 1);
  76. }
  77. int saveenv(void)
  78. {
  79. env_t env_new;
  80. int rc;
  81. unsigned int off = CONFIG_ENV_OFFSET;
  82. #ifdef CONFIG_ENV_OFFSET_REDUND
  83. unsigned int off_red = CONFIG_ENV_OFFSET_REDUND;
  84. char flag_obsolete = OBSOLETE_FLAG;
  85. #endif
  86. BUG_ON(env_ptr != NULL);
  87. rc = env_export(&env_new);
  88. if (rc)
  89. return rc;
  90. #ifdef CONFIG_ENV_OFFSET_REDUND
  91. if (gd->env_valid == 1) {
  92. off = CONFIG_ENV_OFFSET_REDUND;
  93. off_red = CONFIG_ENV_OFFSET;
  94. }
  95. env_new.flags = ACTIVE_FLAG;
  96. #endif
  97. rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
  98. off, (uchar *)&env_new, CONFIG_ENV_SIZE);
  99. #ifdef CONFIG_ENV_OFFSET_REDUND
  100. if (rc == 0) {
  101. eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
  102. off_red + offsetof(env_t, flags),
  103. (uchar *)&flag_obsolete, 1);
  104. if (gd->env_valid == 1)
  105. gd->env_valid = 2;
  106. else
  107. gd->env_valid = 1;
  108. }
  109. #endif
  110. return rc;
  111. }
  112. /*
  113. * Initialize Environment use
  114. *
  115. * We are still running from ROM, so data use is limited.
  116. * Use a (moderately small) buffer on the stack
  117. */
  118. #ifdef CONFIG_ENV_OFFSET_REDUND
  119. int env_init(void)
  120. {
  121. #ifdef ENV_IS_EMBEDDED
  122. ulong len, crc[2], crc_tmp;
  123. unsigned int off, off_env[2];
  124. uchar buf[64], flags[2];
  125. int i, crc_ok[2] = {0, 0};
  126. eeprom_init(); /* prepare for EEPROM read/write */
  127. off_env[0] = CONFIG_ENV_OFFSET;
  128. off_env[1] = CONFIG_ENV_OFFSET_REDUND;
  129. for (i = 0; i < 2; i++) {
  130. /* read CRC */
  131. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  132. off_env[i] + offsetof(env_t, crc),
  133. (uchar *)&crc[i], sizeof(ulong));
  134. /* read FLAGS */
  135. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  136. off_env[i] + offsetof(env_t, flags),
  137. (uchar *)&flags[i], sizeof(uchar));
  138. crc_tmp = 0;
  139. len = ENV_SIZE;
  140. off = off_env[i] + offsetof(env_t, data);
  141. while (len > 0) {
  142. int n = (len > sizeof(buf)) ? sizeof(buf) : len;
  143. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
  144. buf, n);
  145. crc_tmp = crc32(crc_tmp, buf, n);
  146. len -= n;
  147. off += n;
  148. }
  149. if (crc_tmp == crc[i])
  150. crc_ok[i] = 1;
  151. }
  152. if (!crc_ok[0] && !crc_ok[1]) {
  153. gd->env_addr = 0;
  154. gd->env_valid = 0;
  155. return 0;
  156. } else if (crc_ok[0] && !crc_ok[1]) {
  157. gd->env_valid = 1;
  158. } else if (!crc_ok[0] && crc_ok[1]) {
  159. gd->env_valid = 2;
  160. } else {
  161. /* both ok - check serial */
  162. if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
  163. gd->env_valid = 1;
  164. else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
  165. gd->env_valid = 2;
  166. else if (flags[0] == 0xFF && flags[1] == 0)
  167. gd->env_valid = 2;
  168. else if (flags[1] == 0xFF && flags[0] == 0)
  169. gd->env_valid = 1;
  170. else /* flags are equal - almost impossible */
  171. gd->env_valid = 1;
  172. }
  173. if (gd->env_valid == 2)
  174. gd->env_addr = off_env[1] + offsetof(env_t, data);
  175. else if (gd->env_valid == 1)
  176. gd->env_addr = off_env[0] + offsetof(env_t, data);
  177. #else
  178. gd->env_addr = (ulong)&default_environment[0];
  179. gd->env_valid = 1;
  180. #endif
  181. return 0;
  182. }
  183. #else
  184. int env_init(void)
  185. {
  186. #ifdef ENV_IS_EMBEDDED
  187. ulong crc, len, new;
  188. unsigned off;
  189. uchar buf[64];
  190. eeprom_init(); /* prepare for EEPROM read/write */
  191. /* read old CRC */
  192. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  193. CONFIG_ENV_OFFSET + offsetof(env_t, crc),
  194. (uchar *)&crc, sizeof(ulong));
  195. new = 0;
  196. len = ENV_SIZE;
  197. off = offsetof(env_t, data);
  198. while (len > 0) {
  199. int n = (len > sizeof(buf)) ? sizeof(buf) : len;
  200. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  201. CONFIG_ENV_OFFSET + off, buf, n);
  202. new = crc32(new, buf, n);
  203. len -= n;
  204. off += n;
  205. }
  206. if (crc == new) {
  207. gd->env_addr = offsetof(env_t, data);
  208. gd->env_valid = 1;
  209. } else {
  210. gd->env_addr = 0;
  211. gd->env_valid = 0;
  212. }
  213. #else
  214. gd->env_addr = (ulong)&default_environment[0];
  215. gd->env_valid = 1;
  216. #endif
  217. return 0;
  218. }
  219. #endif