eeprom.c 5.3 KB

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