eeprom.c 5.1 KB

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