tricorder-eeprom.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2013
  4. * Corscience GmbH & Co. KG, <www.corscience.de>
  5. * Andreas Bießmann <andreas.biessmann@corscience.de>
  6. */
  7. #include <common.h>
  8. #include <i2c.h>
  9. #include <u-boot/crc.h>
  10. #include "tricorder-eeprom.h"
  11. static inline void warn_wrong_value(const char *msg, unsigned int a,
  12. unsigned int b)
  13. {
  14. printf("Expected EEPROM %s %08x, got %08x\n", msg, a, b);
  15. }
  16. static int handle_eeprom_v0(struct tricorder_eeprom *eeprom)
  17. {
  18. struct tricorder_eeprom_v0 {
  19. uint32_t magic;
  20. uint16_t length;
  21. uint16_t version;
  22. char board_name[TRICORDER_BOARD_NAME_LENGTH];
  23. char board_version[TRICORDER_BOARD_VERSION_LENGTH];
  24. char board_serial[TRICORDER_BOARD_SERIAL_LENGTH];
  25. uint32_t crc32;
  26. } __packed eepromv0;
  27. uint32_t crc;
  28. printf("Old EEPROM (v0), consider rewrite!\n");
  29. if (be16_to_cpu(eeprom->length) != sizeof(eepromv0)) {
  30. warn_wrong_value("length", sizeof(eepromv0),
  31. be16_to_cpu(eeprom->length));
  32. return 1;
  33. }
  34. memcpy(&eepromv0, eeprom, sizeof(eepromv0));
  35. crc = crc32(0L, (unsigned char *)&eepromv0,
  36. sizeof(eepromv0) - sizeof(eepromv0.crc32));
  37. if (be32_to_cpu(eepromv0.crc32) != crc) {
  38. warn_wrong_value("CRC", be32_to_cpu(eepromv0.crc32),
  39. crc);
  40. return 1;
  41. }
  42. /* Ok the content is correct, do the conversion */
  43. memset(eeprom->interface_version, 0x0,
  44. TRICORDER_INTERFACE_VERSION_LENGTH);
  45. crc = crc32(0L, (unsigned char *)eeprom, TRICORDER_EEPROM_CRC_SIZE);
  46. eeprom->crc32 = cpu_to_be32(crc);
  47. return 0;
  48. }
  49. static int handle_eeprom_v1(struct tricorder_eeprom *eeprom)
  50. {
  51. uint32_t crc;
  52. if (be16_to_cpu(eeprom->length) != TRICORDER_EEPROM_SIZE) {
  53. warn_wrong_value("length", TRICORDER_EEPROM_SIZE,
  54. be16_to_cpu(eeprom->length));
  55. return 1;
  56. }
  57. crc = crc32(0L, (unsigned char *)eeprom, TRICORDER_EEPROM_CRC_SIZE);
  58. if (be32_to_cpu(eeprom->crc32) != crc) {
  59. warn_wrong_value("CRC", be32_to_cpu(eeprom->crc32), crc);
  60. return 1;
  61. }
  62. return 0;
  63. }
  64. int tricorder_get_eeprom(int addr, struct tricorder_eeprom *eeprom)
  65. {
  66. unsigned int bus = i2c_get_bus_num();
  67. i2c_set_bus_num(CONFIG_SYS_EEPROM_BUS_NUM);
  68. memset(eeprom, 0, TRICORDER_EEPROM_SIZE);
  69. i2c_read(addr, 0, 2, (unsigned char *)eeprom, TRICORDER_EEPROM_SIZE);
  70. i2c_set_bus_num(bus);
  71. if (be32_to_cpu(eeprom->magic) != TRICORDER_EEPROM_MAGIC) {
  72. warn_wrong_value("magic", TRICORDER_EEPROM_MAGIC,
  73. be32_to_cpu(eeprom->magic));
  74. return 1;
  75. }
  76. switch (be16_to_cpu(eeprom->version)) {
  77. case 0:
  78. return handle_eeprom_v0(eeprom);
  79. case 1:
  80. return handle_eeprom_v1(eeprom);
  81. default:
  82. warn_wrong_value("version", TRICORDER_EEPROM_VERSION,
  83. be16_to_cpu(eeprom->version));
  84. return 1;
  85. }
  86. }
  87. #if !defined(CONFIG_SPL)
  88. int tricorder_eeprom_read(unsigned devaddr)
  89. {
  90. struct tricorder_eeprom eeprom;
  91. int ret = tricorder_get_eeprom(devaddr, &eeprom);
  92. if (ret)
  93. return ret;
  94. printf("Board type: %.*s\n",
  95. sizeof(eeprom.board_name), eeprom.board_name);
  96. printf("Board version: %.*s\n",
  97. sizeof(eeprom.board_version), eeprom.board_version);
  98. printf("Board serial: %.*s\n",
  99. sizeof(eeprom.board_serial), eeprom.board_serial);
  100. printf("Board interface version: %.*s\n",
  101. sizeof(eeprom.interface_version),
  102. eeprom.interface_version);
  103. return ret;
  104. }
  105. int tricorder_eeprom_write(unsigned devaddr, const char *name,
  106. const char *version, const char *serial, const char *interface)
  107. {
  108. struct tricorder_eeprom eeprom, eeprom_verify;
  109. size_t length;
  110. uint32_t crc;
  111. int ret;
  112. unsigned char *p;
  113. int i;
  114. memset(eeprom, 0, TRICORDER_EEPROM_SIZE);
  115. memset(eeprom_verify, 0, TRICORDER_EEPROM_SIZE);
  116. eeprom.magic = cpu_to_be32(TRICORDER_EEPROM_MAGIC);
  117. eeprom.length = cpu_to_be16(TRICORDER_EEPROM_SIZE);
  118. eeprom.version = cpu_to_be16(TRICORDER_EEPROM_VERSION);
  119. length = min(sizeof(eeprom.board_name), strlen(name));
  120. strncpy(eeprom.board_name, name, length);
  121. length = min(sizeof(eeprom.board_version), strlen(version));
  122. strncpy(eeprom.board_version, version, length);
  123. length = min(sizeof(eeprom.board_serial), strlen(serial));
  124. strncpy(eeprom.board_serial, serial, length);
  125. if (interface) {
  126. length = min(sizeof(eeprom.interface_version),
  127. strlen(interface));
  128. strncpy(eeprom.interface_version, interface, length);
  129. }
  130. crc = crc32(0L, (unsigned char *)&eeprom, TRICORDER_EEPROM_CRC_SIZE);
  131. eeprom.crc32 = cpu_to_be32(crc);
  132. #if defined(DEBUG)
  133. puts("Tricorder EEPROM content:\n");
  134. print_buffer(0, &eeprom, 1, sizeof(eeprom), 16);
  135. #endif
  136. eeprom_init(CONFIG_SYS_EEPROM_BUS_NUM);
  137. ret = eeprom_write(devaddr, 0, (unsigned char *)&eeprom,
  138. TRICORDER_EEPROM_SIZE);
  139. if (ret)
  140. printf("Tricorder: Could not write EEPROM content!\n");
  141. ret = eeprom_read(devaddr, 0, (unsigned char *)&eeprom_verify,
  142. TRICORDER_EEPROM_SIZE);
  143. if (ret)
  144. printf("Tricorder: Could not read EEPROM content!\n");
  145. if (memcmp(&eeprom, &eeprom_verify, sizeof(eeprom)) != 0) {
  146. printf("Tricorder: Could not verify EEPROM content!\n");
  147. ret = 1;
  148. }
  149. return ret;
  150. }
  151. int do_tricorder_eeprom(cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
  152. {
  153. if (argc == 3) {
  154. ulong dev_addr = simple_strtoul(argv[2], NULL, 16);
  155. if (strcmp(argv[1], "read") == 0)
  156. return tricorder_eeprom_read(dev_addr);
  157. } else if (argc == 6 || argc == 7) {
  158. ulong dev_addr = simple_strtoul(argv[2], NULL, 16);
  159. char *name = argv[3];
  160. char *version = argv[4];
  161. char *serial = argv[5];
  162. char *interface = NULL;
  163. if (argc == 7)
  164. interface = argv[6];
  165. if (strcmp(argv[1], "write") == 0)
  166. return tricorder_eeprom_write(dev_addr, name, version,
  167. serial, interface);
  168. }
  169. return CMD_RET_USAGE;
  170. }
  171. U_BOOT_CMD(
  172. tricordereeprom, 7, 1, do_tricorder_eeprom,
  173. "Tricorder EEPROM",
  174. "read devaddr\n"
  175. " - read Tricorder EEPROM at devaddr and print content\n"
  176. "tricordereeprom write devaddr name version serial [interface]\n"
  177. " - write Tricorder EEPROM at devaddr with 'name', 'version'"
  178. "and 'serial'\n"
  179. " optional add an HW interface parameter"
  180. );
  181. #endif /* CONFIG_SPL */