fru_ops.c 8.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * (C) Copyright 2019 - 2020 Xilinx, Inc.
  4. */
  5. #include <common.h>
  6. #include <cpu_func.h>
  7. #include <env.h>
  8. #include <fdtdec.h>
  9. #include <log.h>
  10. #include <malloc.h>
  11. #include <asm/io.h>
  12. #include <asm/arch/hardware.h>
  13. #include "fru.h"
  14. struct fru_table fru_data __section(".data");
  15. static u16 fru_cal_area_len(u8 len)
  16. {
  17. return len * FRU_COMMON_HDR_LEN_MULTIPLIER;
  18. }
  19. static u8 fru_version(u8 ver)
  20. {
  21. return ver & FRU_COMMON_HDR_VER_MASK;
  22. }
  23. static int fru_check_language(u8 code)
  24. {
  25. if (code != FRU_LANG_CODE_ENGLISH && code != FRU_LANG_CODE_ENGLISH_1) {
  26. printf("FRU_ERROR: Only English Language is supported\n");
  27. return -EINVAL;
  28. }
  29. return 0;
  30. }
  31. u8 fru_checksum(u8 *addr, u8 len)
  32. {
  33. u8 checksum = 0;
  34. while (len--) {
  35. checksum += *addr;
  36. addr++;
  37. }
  38. return checksum;
  39. }
  40. static int fru_check_type_len(u8 type_len, u8 language, u8 *type)
  41. {
  42. int len;
  43. if (type_len == FRU_TYPELEN_EOF)
  44. return -EINVAL;
  45. *type = (type_len & FRU_TYPELEN_CODE_MASK) >> FRU_TYPELEN_TYPE_SHIFT;
  46. len = type_len & FRU_TYPELEN_LEN_MASK;
  47. return len;
  48. }
  49. /* Return len */
  50. static u8 fru_gen_type_len(u8 *addr, char *name)
  51. {
  52. int len = strlen(name);
  53. struct fru_board_info_member *member;
  54. member = (struct fru_board_info_member *)addr;
  55. member->type_len = FRU_TYPELEN_TYPE_ASCII8 << FRU_TYPELEN_TYPE_SHIFT;
  56. member->type_len |= len;
  57. debug("%lx/%lx: Add %s to 0x%lx (len 0x%x)\n", (ulong)addr,
  58. (ulong)&member->type_len, name, (ulong)&member->name, len);
  59. memcpy(&member->name, name, len);
  60. /* Add +1 for type_len parameter */
  61. return 1 + len;
  62. }
  63. int fru_generate(unsigned long addr, char *manufacturer, char *board_name,
  64. char *serial_no, char *part_no, char *revision)
  65. {
  66. struct fru_common_hdr *header = (struct fru_common_hdr *)addr;
  67. struct fru_board_info_header *board_info;
  68. u8 *member;
  69. u8 len, pad, modulo;
  70. header->version = 1; /* Only version 1.0 is supported now */
  71. header->off_internal = 0; /* not present */
  72. header->off_chassis = 0; /* not present */
  73. header->off_board = (sizeof(*header)) / 8; /* Starting offset 8 */
  74. header->off_product = 0; /* not present */
  75. header->off_multirec = 0; /* not present */
  76. header->pad = 0;
  77. /*
  78. * This unsigned byte can be used to calculate a zero checksum
  79. * for the data area following the header. I.e. the modulo 256 sum of
  80. * the record data bytes plus the checksum byte equals zero.
  81. */
  82. header->crc = 0; /* Clear before calculation */
  83. header->crc = 0 - fru_checksum((u8 *)header, sizeof(*header));
  84. /* board info is just right after header */
  85. board_info = (void *)((u8 *)header + sizeof(*header));
  86. debug("header %lx, board_info %lx\n", (ulong)header, (ulong)board_info);
  87. board_info->ver = 1; /* 1.0 spec */
  88. board_info->lang_code = 0; /* English */
  89. board_info->time[0] = 0; /* unspecified */
  90. board_info->time[1] = 0; /* unspecified */
  91. board_info->time[2] = 0; /* unspecified */
  92. /* Member fields are just after board_info header */
  93. member = (u8 *)board_info + sizeof(*board_info);
  94. len = fru_gen_type_len(member, manufacturer); /* Board Manufacturer */
  95. member += len;
  96. len = fru_gen_type_len(member, board_name); /* Board Product name */
  97. member += len;
  98. len = fru_gen_type_len(member, serial_no); /* Board Serial number */
  99. member += len;
  100. len = fru_gen_type_len(member, part_no); /* Board part number */
  101. member += len;
  102. len = fru_gen_type_len(member, "U-Boot generator"); /* File ID */
  103. member += len;
  104. len = fru_gen_type_len(member, revision); /* Revision */
  105. member += len;
  106. *member++ = 0xc1; /* Indication of no more fields */
  107. len = member - (u8 *)board_info; /* Find current length */
  108. len += 1; /* Add checksum there too for calculation */
  109. modulo = len % 8;
  110. if (modulo) {
  111. /* Do not fill last item which is checksum */
  112. for (pad = 0; pad < 8 - modulo; pad++)
  113. *member++ = 0;
  114. /* Increase structure size */
  115. len += 8 - modulo;
  116. }
  117. board_info->len = len / 8; /* Size in multiples of 8 bytes */
  118. *member = 0; /* Clear before calculation */
  119. *member = 0 - fru_checksum((u8 *)board_info, len);
  120. debug("checksum %x(addr %x)\n", *member, len);
  121. env_set_hex("fru_addr", addr);
  122. env_set_hex("filesize", (unsigned long)member - addr + 1);
  123. return 0;
  124. }
  125. static int fru_parse_board(unsigned long addr)
  126. {
  127. u8 i, type;
  128. int len;
  129. u8 *data, *term, *limit;
  130. memcpy(&fru_data.brd.ver, (void *)addr, 6);
  131. addr += 6;
  132. data = (u8 *)&fru_data.brd.manufacturer_type_len;
  133. /* Record max structure limit not to write data over allocated space */
  134. limit = (u8 *)&fru_data.brd + sizeof(struct fru_board_data);
  135. for (i = 0; ; i++, data += FRU_BOARD_MAX_LEN) {
  136. len = fru_check_type_len(*(u8 *)addr, fru_data.brd.lang_code,
  137. &type);
  138. /*
  139. * Stop cature if it end of fields
  140. */
  141. if (len == -EINVAL)
  142. break;
  143. /* Stop when amount of chars is more then fields to record */
  144. if (data + len > limit)
  145. break;
  146. /* This record type/len field */
  147. *data++ = *(u8 *)addr;
  148. /* Add offset to match data */
  149. addr += 1;
  150. /* If len is 0 it means empty field that's why skip writing */
  151. if (!len)
  152. continue;
  153. /* Record data field */
  154. memcpy(data, (u8 *)addr, len);
  155. term = data + (u8)len;
  156. *term = 0;
  157. addr += len;
  158. }
  159. if (i < FRU_BOARD_AREA_TOTAL_FIELDS) {
  160. printf("Board area require minimum %d fields\n",
  161. FRU_BOARD_AREA_TOTAL_FIELDS);
  162. return -EINVAL;
  163. }
  164. return 0;
  165. }
  166. int fru_capture(unsigned long addr)
  167. {
  168. struct fru_common_hdr *hdr;
  169. u8 checksum = 0;
  170. checksum = fru_checksum((u8 *)addr, sizeof(struct fru_common_hdr));
  171. if (checksum) {
  172. printf("%s Common header CRC error\n", __func__);
  173. return -EINVAL;
  174. }
  175. hdr = (struct fru_common_hdr *)addr;
  176. memcpy((void *)&fru_data, (void *)hdr,
  177. sizeof(struct fru_common_hdr));
  178. fru_data.captured = true;
  179. if (hdr->off_board) {
  180. addr += fru_cal_area_len(hdr->off_board);
  181. fru_parse_board(addr);
  182. }
  183. env_set_hex("fru_addr", addr);
  184. return 0;
  185. }
  186. static int fru_display_board(struct fru_board_data *brd, int verbose)
  187. {
  188. u32 time = 0;
  189. u8 type;
  190. int len;
  191. u8 *data;
  192. static const char * const typecode[] = {
  193. "Binary/Unspecified",
  194. "BCD plus",
  195. "6-bit ASCII",
  196. "8-bit ASCII",
  197. "2-byte UNICODE"
  198. };
  199. static const char * const boardinfo[] = {
  200. "Manufacturer Name",
  201. "Product Name",
  202. "Serial No",
  203. "Part Number",
  204. "File ID",
  205. /* Xilinx spec */
  206. "Revision Number",
  207. };
  208. if (verbose) {
  209. printf("*****BOARD INFO*****\n");
  210. printf("Version:%d\n", fru_version(brd->ver));
  211. printf("Board Area Length:%d\n", fru_cal_area_len(brd->len));
  212. }
  213. if (fru_check_language(brd->lang_code))
  214. return -EINVAL;
  215. time = brd->time[2] << 16 | brd->time[1] << 8 |
  216. brd->time[0];
  217. if (verbose)
  218. printf("Time in Minutes from 0:00hrs 1/1/96: %d\n", time);
  219. data = (u8 *)&brd->manufacturer_type_len;
  220. for (u8 i = 0; i < (sizeof(boardinfo) / sizeof(*boardinfo)); i++) {
  221. len = fru_check_type_len(*data++, brd->lang_code,
  222. &type);
  223. if (len == -EINVAL) {
  224. printf("**** EOF for Board Area ****\n");
  225. break;
  226. }
  227. if (type <= FRU_TYPELEN_TYPE_ASCII8 &&
  228. (brd->lang_code == FRU_LANG_CODE_ENGLISH ||
  229. brd->lang_code == FRU_LANG_CODE_ENGLISH_1))
  230. debug("Type code: %s\n", typecode[type]);
  231. else
  232. debug("Type code: %s\n", typecode[type + 1]);
  233. if (!len) {
  234. debug("%s not found\n", boardinfo[i]);
  235. continue;
  236. }
  237. switch (type) {
  238. case FRU_TYPELEN_TYPE_BINARY:
  239. debug("Length: %d\n", len);
  240. printf(" %s: 0x%x\n", boardinfo[i], *data);
  241. break;
  242. case FRU_TYPELEN_TYPE_ASCII8:
  243. debug("Length: %d\n", len);
  244. printf(" %s: %s\n", boardinfo[i], data);
  245. break;
  246. default:
  247. debug("Unsupported type %x\n", type);
  248. }
  249. data += FRU_BOARD_MAX_LEN;
  250. }
  251. return 0;
  252. }
  253. static void fru_display_common_hdr(struct fru_common_hdr *hdr, int verbose)
  254. {
  255. if (!verbose)
  256. return;
  257. printf("*****COMMON HEADER*****\n");
  258. printf("Version:%d\n", fru_version(hdr->version));
  259. if (hdr->off_internal)
  260. printf("Internal Use Area Offset:%d\n",
  261. fru_cal_area_len(hdr->off_internal));
  262. else
  263. printf("*** No Internal Area ***\n");
  264. if (hdr->off_chassis)
  265. printf("Chassis Info Area Offset:%d\n",
  266. fru_cal_area_len(hdr->off_chassis));
  267. else
  268. printf("*** No Chassis Info Area ***\n");
  269. if (hdr->off_board)
  270. printf("Board Area Offset:%d\n",
  271. fru_cal_area_len(hdr->off_board));
  272. else
  273. printf("*** No Board Area ***\n");
  274. if (hdr->off_product)
  275. printf("Product Info Area Offset:%d\n",
  276. fru_cal_area_len(hdr->off_product));
  277. else
  278. printf("*** No Product Info Area ***\n");
  279. if (hdr->off_multirec)
  280. printf("MultiRecord Area Offset:%d\n",
  281. fru_cal_area_len(hdr->off_multirec));
  282. else
  283. printf("*** No MultiRecord Area ***\n");
  284. }
  285. int fru_display(int verbose)
  286. {
  287. if (!fru_data.captured) {
  288. printf("FRU data not available please run fru parse\n");
  289. return -EINVAL;
  290. }
  291. fru_display_common_hdr(&fru_data.hdr, verbose);
  292. return fru_display_board(&fru_data.brd, verbose);
  293. }