eeprom.c 5.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240
  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. #include <common.h>
  10. #include <command.h>
  11. #include <eeprom.h>
  12. #include <env.h>
  13. #include <env_internal.h>
  14. #include <linux/stddef.h>
  15. #include <u-boot/crc.h>
  16. #if defined(CONFIG_I2C_ENV_EEPROM_BUS)
  17. #include <i2c.h>
  18. #endif
  19. #include <search.h>
  20. #include <errno.h>
  21. #include <linux/compiler.h> /* for BUG_ON */
  22. DECLARE_GLOBAL_DATA_PTR;
  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. /** Call this function from overridden env_get_char_spec() if you need
  54. * this functionality.
  55. */
  56. int env_eeprom_get_char(int index)
  57. {
  58. uchar c;
  59. unsigned int off = CONFIG_ENV_OFFSET;
  60. #ifdef CONFIG_ENV_OFFSET_REDUND
  61. if (gd->env_valid == ENV_REDUND)
  62. off = CONFIG_ENV_OFFSET_REDUND;
  63. #endif
  64. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  65. off + index + offsetof(env_t, data), &c, 1);
  66. return c;
  67. }
  68. static int env_eeprom_load(void)
  69. {
  70. char buf_env[CONFIG_ENV_SIZE];
  71. unsigned int off = CONFIG_ENV_OFFSET;
  72. #ifdef CONFIG_ENV_OFFSET_REDUND
  73. ulong len, crc[2], crc_tmp;
  74. unsigned int off_env[2];
  75. uchar rdbuf[64], flags[2];
  76. int i, crc_ok[2] = {0, 0};
  77. eeprom_init(-1); /* prepare for EEPROM read/write */
  78. off_env[0] = CONFIG_ENV_OFFSET;
  79. off_env[1] = CONFIG_ENV_OFFSET_REDUND;
  80. for (i = 0; i < 2; i++) {
  81. /* read CRC */
  82. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  83. off_env[i] + offsetof(env_t, crc),
  84. (uchar *)&crc[i], sizeof(ulong));
  85. /* read FLAGS */
  86. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  87. off_env[i] + offsetof(env_t, flags),
  88. (uchar *)&flags[i], sizeof(uchar));
  89. crc_tmp = 0;
  90. len = ENV_SIZE;
  91. off = off_env[i] + offsetof(env_t, data);
  92. while (len > 0) {
  93. int n = (len > sizeof(rdbuf)) ? sizeof(rdbuf) : len;
  94. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
  95. rdbuf, n);
  96. crc_tmp = crc32(crc_tmp, rdbuf, n);
  97. len -= n;
  98. off += n;
  99. }
  100. if (crc_tmp == crc[i])
  101. crc_ok[i] = 1;
  102. }
  103. if (!crc_ok[0] && !crc_ok[1]) {
  104. gd->env_addr = 0;
  105. gd->env_valid = ENV_INVALID;
  106. } else if (crc_ok[0] && !crc_ok[1]) {
  107. gd->env_valid = ENV_VALID;
  108. } else if (!crc_ok[0] && crc_ok[1]) {
  109. gd->env_valid = ENV_REDUND;
  110. } else {
  111. /* both ok - check serial */
  112. if (flags[0] == ENV_REDUND_ACTIVE &&
  113. flags[1] == ENV_REDUND_OBSOLETE)
  114. gd->env_valid = ENV_VALID;
  115. else if (flags[0] == ENV_REDUND_OBSOLETE &&
  116. flags[1] == ENV_REDUND_ACTIVE)
  117. gd->env_valid = ENV_REDUND;
  118. else if (flags[0] == 0xFF && flags[1] == 0)
  119. gd->env_valid = ENV_REDUND;
  120. else if (flags[1] == 0xFF && flags[0] == 0)
  121. gd->env_valid = ENV_VALID;
  122. else /* flags are equal - almost impossible */
  123. gd->env_valid = ENV_VALID;
  124. }
  125. #else /* CONFIG_ENV_OFFSET_REDUND */
  126. ulong crc, len, new;
  127. uchar rdbuf[64];
  128. eeprom_init(-1); /* prepare for EEPROM read/write */
  129. /* read old CRC */
  130. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  131. CONFIG_ENV_OFFSET + offsetof(env_t, crc),
  132. (uchar *)&crc, sizeof(ulong));
  133. new = 0;
  134. len = ENV_SIZE;
  135. off = offsetof(env_t, data);
  136. while (len > 0) {
  137. int n = (len > sizeof(rdbuf)) ? sizeof(rdbuf) : len;
  138. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  139. CONFIG_ENV_OFFSET + off, rdbuf, n);
  140. new = crc32(new, rdbuf, n);
  141. len -= n;
  142. off += n;
  143. }
  144. if (crc == new) {
  145. gd->env_valid = ENV_VALID;
  146. } else {
  147. gd->env_valid = ENV_INVALID;
  148. }
  149. #endif /* CONFIG_ENV_OFFSET_REDUND */
  150. off = CONFIG_ENV_OFFSET;
  151. #ifdef CONFIG_ENV_OFFSET_REDUND
  152. if (gd->env_valid == ENV_REDUND)
  153. off = CONFIG_ENV_OFFSET_REDUND;
  154. #endif
  155. eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
  156. off, (uchar *)buf_env, CONFIG_ENV_SIZE);
  157. return env_import(buf_env, 1);
  158. }
  159. static int env_eeprom_save(void)
  160. {
  161. env_t env_new;
  162. int rc;
  163. unsigned int off = CONFIG_ENV_OFFSET;
  164. #ifdef CONFIG_ENV_OFFSET_REDUND
  165. unsigned int off_red = CONFIG_ENV_OFFSET_REDUND;
  166. char flag_obsolete = ENV_REDUND_OBSOLETE;
  167. #endif
  168. rc = env_export(&env_new);
  169. if (rc)
  170. return rc;
  171. #ifdef CONFIG_ENV_OFFSET_REDUND
  172. if (gd->env_valid == ENV_VALID) {
  173. off = CONFIG_ENV_OFFSET_REDUND;
  174. off_red = CONFIG_ENV_OFFSET;
  175. }
  176. env_new.flags = ENV_REDUND_ACTIVE;
  177. #endif
  178. rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
  179. off, (uchar *)&env_new, CONFIG_ENV_SIZE);
  180. #ifdef CONFIG_ENV_OFFSET_REDUND
  181. if (rc == 0) {
  182. eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
  183. off_red + offsetof(env_t, flags),
  184. (uchar *)&flag_obsolete, 1);
  185. if (gd->env_valid == ENV_VALID)
  186. gd->env_valid = ENV_REDUND;
  187. else
  188. gd->env_valid = ENV_VALID;
  189. }
  190. #endif
  191. return rc;
  192. }
  193. U_BOOT_ENV_LOCATION(eeprom) = {
  194. .location = ENVL_EEPROM,
  195. ENV_NAME("EEPROM")
  196. .load = env_eeprom_load,
  197. .save = env_save_ptr(env_eeprom_save),
  198. };