eeprom.c 4.1 KB

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