1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * See file CREDITS for list of people who contributed to this
4 * project.
5 *
6 * Copyright (C) 2013 Curt Brune <curt@cumulusnetworks.com>
7 * Copyright (C) 2014 Srideep <srideep_devireddy@dell.com>
8 * Copyright (C) 2013 Miles Tseng <miles_tseng@accton.com>
9 * Copyright (C) 2014,2016 david_yang <david_yang@accton.com>
10 */
11
12 #include <common.h>
13 #include <command.h>
14 #include <dm.h>
15 #include <i2c.h>
16 #include <i2c_eeprom.h>
17 #include <env.h>
18 #include <init.h>
19 #include <net.h>
20 #include <asm/global_data.h>
21 #include <linux/ctype.h>
22 #include <u-boot/crc.h>
23
24 #include "tlv_eeprom.h"
25
26 DECLARE_GLOBAL_DATA_PTR;
27
28 #define MAX_TLV_DEVICES 2
29
30 /* File scope function prototypes */
31 static bool is_checksum_valid(u8 *eeprom);
32 static int read_eeprom(u8 *eeprom);
33 static void show_eeprom(u8 *eeprom);
34 static void decode_tlv(struct tlvinfo_tlv *tlv);
35 static void update_crc(u8 *eeprom);
36 static int prog_eeprom(u8 *eeprom);
37 static bool tlvinfo_find_tlv(u8 *eeprom, u8 tcode, int *eeprom_index);
38 static bool tlvinfo_delete_tlv(u8 *eeprom, u8 code);
39 static bool tlvinfo_add_tlv(u8 *eeprom, int tcode, char *strval);
40 static int set_mac(char *buf, const char *string);
41 static int set_date(char *buf, const char *string);
42 static int set_bytes(char *buf, const char *string, int *converted_accum);
43 static void show_tlv_devices(void);
44
45 /* Set to 1 if we've read EEPROM into memory */
46 static int has_been_read;
47 /* The EERPOM contents after being read into memory */
48 static u8 eeprom[TLV_INFO_MAX_LEN];
49
50 static struct udevice *tlv_devices[MAX_TLV_DEVICES];
51 static unsigned int current_dev;
52
53 #define to_header(p) ((struct tlvinfo_header *)p)
54 #define to_entry(p) ((struct tlvinfo_tlv *)p)
55
56 #define HDR_SIZE sizeof(struct tlvinfo_header)
57 #define ENT_SIZE sizeof(struct tlvinfo_tlv)
58
is_digit(char c)59 static inline bool is_digit(char c)
60 {
61 return (c >= '0' && c <= '9');
62 }
63
64 /**
65 * is_valid_tlv
66 *
67 * Perform basic sanity checks on a TLV field. The TLV is pointed to
68 * by the parameter provided.
69 * 1. The type code is not reserved (0x00 or 0xFF)
70 */
is_valid_tlv(struct tlvinfo_tlv * tlv)71 static inline bool is_valid_tlv(struct tlvinfo_tlv *tlv)
72 {
73 return((tlv->type != 0x00) && (tlv->type != 0xFF));
74 }
75
76 /**
77 * is_hex
78 *
79 * Tests if character is an ASCII hex digit
80 */
is_hex(char p)81 static inline u8 is_hex(char p)
82 {
83 return (((p >= '0') && (p <= '9')) ||
84 ((p >= 'A') && (p <= 'F')) ||
85 ((p >= 'a') && (p <= 'f')));
86 }
87
88 /**
89 * is_checksum_valid
90 *
91 * Validate the checksum in the provided TlvInfo EEPROM data. First,
92 * verify that the TlvInfo header is valid, then make sure the last
93 * TLV is a CRC-32 TLV. Then calculate the CRC over the EEPROM data
94 * and compare it to the value stored in the EEPROM CRC-32 TLV.
95 */
is_checksum_valid(u8 * eeprom)96 static bool is_checksum_valid(u8 *eeprom)
97 {
98 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
99 struct tlvinfo_tlv *eeprom_crc;
100 unsigned int calc_crc;
101 unsigned int stored_crc;
102
103 // Is the eeprom header valid?
104 if (!is_valid_tlvinfo_header(eeprom_hdr))
105 return false;
106
107 // Is the last TLV a CRC?
108 eeprom_crc = to_entry(&eeprom[HDR_SIZE +
109 be16_to_cpu(eeprom_hdr->totallen) - (ENT_SIZE + 4)]);
110 if (eeprom_crc->type != TLV_CODE_CRC_32 || eeprom_crc->length != 4)
111 return false;
112
113 // Calculate the checksum
114 calc_crc = crc32(0, (void *)eeprom,
115 HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen) - 4);
116 stored_crc = (eeprom_crc->value[0] << 24) |
117 (eeprom_crc->value[1] << 16) |
118 (eeprom_crc->value[2] << 8) |
119 eeprom_crc->value[3];
120 return calc_crc == stored_crc;
121 }
122
123 /**
124 * read_eeprom
125 *
126 * Read the EEPROM into memory, if it hasn't already been read.
127 */
read_eeprom(u8 * eeprom)128 static int read_eeprom(u8 *eeprom)
129 {
130 int ret;
131 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
132 struct tlvinfo_tlv *eeprom_tlv = to_entry(&eeprom[HDR_SIZE]);
133
134 if (has_been_read)
135 return 0;
136
137 /* Read the header */
138 ret = read_tlv_eeprom((void *)eeprom_hdr, 0, HDR_SIZE, current_dev);
139 /* If the header was successfully read, read the TLVs */
140 if (ret == 0 && is_valid_tlvinfo_header(eeprom_hdr))
141 ret = read_tlv_eeprom((void *)eeprom_tlv, HDR_SIZE,
142 be16_to_cpu(eeprom_hdr->totallen),
143 current_dev);
144
145 // If the contents are invalid, start over with default contents
146 if (!is_valid_tlvinfo_header(eeprom_hdr) ||
147 !is_checksum_valid(eeprom)) {
148 strcpy(eeprom_hdr->signature, TLV_INFO_ID_STRING);
149 eeprom_hdr->version = TLV_INFO_VERSION;
150 eeprom_hdr->totallen = cpu_to_be16(0);
151 update_crc(eeprom);
152 }
153
154 has_been_read = 1;
155
156 #ifdef DEBUG
157 show_eeprom(eeprom);
158 #endif
159
160 return ret;
161 }
162
163 /**
164 * show_eeprom
165 *
166 * Display the contents of the EEPROM
167 */
show_eeprom(u8 * eeprom)168 static void show_eeprom(u8 *eeprom)
169 {
170 int tlv_end;
171 int curr_tlv;
172 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
173 struct tlvinfo_tlv *eeprom_tlv;
174
175 if (!is_valid_tlvinfo_header(eeprom_hdr)) {
176 printf("EEPROM does not contain data in a valid TlvInfo format.\n");
177 return;
178 }
179
180 printf("TLV: %u\n", current_dev);
181 printf("TlvInfo Header:\n");
182 printf(" Id String: %s\n", eeprom_hdr->signature);
183 printf(" Version: %d\n", eeprom_hdr->version);
184 printf(" Total Length: %d\n", be16_to_cpu(eeprom_hdr->totallen));
185
186 printf("TLV Name Code Len Value\n");
187 printf("-------------------- ---- --- -----\n");
188 curr_tlv = HDR_SIZE;
189 tlv_end = HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen);
190 while (curr_tlv < tlv_end) {
191 eeprom_tlv = to_entry(&eeprom[curr_tlv]);
192 if (!is_valid_tlv(eeprom_tlv)) {
193 printf("Invalid TLV field starting at EEPROM offset %d\n",
194 curr_tlv);
195 return;
196 }
197 decode_tlv(eeprom_tlv);
198 curr_tlv += ENT_SIZE + eeprom_tlv->length;
199 }
200
201 printf("Checksum is %s.\n",
202 is_checksum_valid(eeprom) ? "valid" : "invalid");
203
204 #ifdef DEBUG
205 printf("EEPROM dump: (0x%x bytes)", TLV_INFO_MAX_LEN);
206 for (i = 0; i < TLV_INFO_MAX_LEN; i++) {
207 if ((i % 16) == 0)
208 printf("\n%02X: ", i);
209 printf("%02X ", eeprom[i]);
210 }
211 printf("\n");
212 #endif
213 }
214
215 /**
216 * Struct for displaying the TLV codes and names.
217 */
218 struct tlv_code_desc {
219 u8 m_code;
220 char *m_name;
221 };
222
223 /**
224 * List of TLV codes and names.
225 */
226 static struct tlv_code_desc tlv_code_list[] = {
227 { TLV_CODE_PRODUCT_NAME, "Product Name"},
228 { TLV_CODE_PART_NUMBER, "Part Number"},
229 { TLV_CODE_SERIAL_NUMBER, "Serial Number"},
230 { TLV_CODE_MAC_BASE, "Base MAC Address"},
231 { TLV_CODE_MANUF_DATE, "Manufacture Date"},
232 { TLV_CODE_DEVICE_VERSION, "Device Version"},
233 { TLV_CODE_LABEL_REVISION, "Label Revision"},
234 { TLV_CODE_PLATFORM_NAME, "Platform Name"},
235 { TLV_CODE_ONIE_VERSION, "ONIE Version"},
236 { TLV_CODE_MAC_SIZE, "MAC Addresses"},
237 { TLV_CODE_MANUF_NAME, "Manufacturer"},
238 { TLV_CODE_MANUF_COUNTRY, "Country Code"},
239 { TLV_CODE_VENDOR_NAME, "Vendor Name"},
240 { TLV_CODE_DIAG_VERSION, "Diag Version"},
241 { TLV_CODE_SERVICE_TAG, "Service Tag"},
242 { TLV_CODE_VENDOR_EXT, "Vendor Extension"},
243 { TLV_CODE_CRC_32, "CRC-32"},
244 };
245
246 /**
247 * Look up a TLV name by its type.
248 */
tlv_type2name(u8 type)249 static inline const char *tlv_type2name(u8 type)
250 {
251 char *name = "Unknown";
252 int i;
253
254 for (i = 0; i < ARRAY_SIZE(tlv_code_list); i++) {
255 if (tlv_code_list[i].m_code == type) {
256 name = tlv_code_list[i].m_name;
257 break;
258 }
259 }
260
261 return name;
262 }
263
264 /*
265 * decode_tlv
266 *
267 * Print a string representing the contents of the TLV field. The format of
268 * the string is:
269 * 1. The name of the field left justified in 20 characters
270 * 2. The type code in hex right justified in 5 characters
271 * 3. The length in decimal right justified in 4 characters
272 * 4. The value, left justified in however many characters it takes
273 * The validity of EEPROM contents and the TLV field have been verified
274 * prior to calling this function.
275 */
276 #define DECODE_NAME_MAX 20
277
278 /*
279 * The max decode value is currently for the 'raw' type or the 'vendor
280 * extension' type, both of which have the same decode format. The
281 * max decode string size is computed as follows:
282 *
283 * strlen(" 0xFF") * TLV_VALUE_MAX_LEN + 1
284 *
285 */
286 #define DECODE_VALUE_MAX ((5 * TLV_VALUE_MAX_LEN) + 1)
287
decode_tlv(struct tlvinfo_tlv * tlv)288 static void decode_tlv(struct tlvinfo_tlv *tlv)
289 {
290 char name[DECODE_NAME_MAX];
291 char value[DECODE_VALUE_MAX];
292 int i;
293
294 strncpy(name, tlv_type2name(tlv->type), DECODE_NAME_MAX);
295
296 switch (tlv->type) {
297 case TLV_CODE_PRODUCT_NAME:
298 case TLV_CODE_PART_NUMBER:
299 case TLV_CODE_SERIAL_NUMBER:
300 case TLV_CODE_MANUF_DATE:
301 case TLV_CODE_LABEL_REVISION:
302 case TLV_CODE_PLATFORM_NAME:
303 case TLV_CODE_ONIE_VERSION:
304 case TLV_CODE_MANUF_NAME:
305 case TLV_CODE_MANUF_COUNTRY:
306 case TLV_CODE_VENDOR_NAME:
307 case TLV_CODE_DIAG_VERSION:
308 case TLV_CODE_SERVICE_TAG:
309 memcpy(value, tlv->value, tlv->length);
310 value[tlv->length] = 0;
311 break;
312 case TLV_CODE_MAC_BASE:
313 sprintf(value, "%02X:%02X:%02X:%02X:%02X:%02X",
314 tlv->value[0], tlv->value[1], tlv->value[2],
315 tlv->value[3], tlv->value[4], tlv->value[5]);
316 break;
317 case TLV_CODE_DEVICE_VERSION:
318 sprintf(value, "%u", tlv->value[0]);
319 break;
320 case TLV_CODE_MAC_SIZE:
321 sprintf(value, "%u", (tlv->value[0] << 8) | tlv->value[1]);
322 break;
323 case TLV_CODE_VENDOR_EXT:
324 value[0] = 0;
325 for (i = 0; (i < (DECODE_VALUE_MAX / 5)) && (i < tlv->length);
326 i++) {
327 sprintf(value, "%s 0x%02X", value, tlv->value[i]);
328 }
329 break;
330 case TLV_CODE_CRC_32:
331 sprintf(value, "0x%02X%02X%02X%02X",
332 tlv->value[0], tlv->value[1],
333 tlv->value[2], tlv->value[3]);
334 break;
335 default:
336 value[0] = 0;
337 for (i = 0; (i < (DECODE_VALUE_MAX / 5)) && (i < tlv->length);
338 i++) {
339 sprintf(value, "%s 0x%02X", value, tlv->value[i]);
340 }
341 break;
342 }
343
344 name[DECODE_NAME_MAX - 1] = 0;
345 printf("%-20s 0x%02X %3d %s\n", name, tlv->type, tlv->length, value);
346 }
347
348 /**
349 * update_crc
350 *
351 * This function updates the CRC-32 TLV. If there is no CRC-32 TLV, then
352 * one is added. This function should be called after each update to the
353 * EEPROM structure, to make sure the CRC is always correct.
354 */
update_crc(u8 * eeprom)355 static void update_crc(u8 *eeprom)
356 {
357 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
358 struct tlvinfo_tlv *eeprom_crc;
359 unsigned int calc_crc;
360 int eeprom_index;
361
362 // Discover the CRC TLV
363 if (!tlvinfo_find_tlv(eeprom, TLV_CODE_CRC_32, &eeprom_index)) {
364 unsigned int totallen = be16_to_cpu(eeprom_hdr->totallen);
365
366 if ((totallen + ENT_SIZE + 4) > TLV_TOTAL_LEN_MAX)
367 return;
368 eeprom_index = HDR_SIZE + totallen;
369 eeprom_hdr->totallen = cpu_to_be16(totallen + ENT_SIZE + 4);
370 }
371 eeprom_crc = to_entry(&eeprom[eeprom_index]);
372 eeprom_crc->type = TLV_CODE_CRC_32;
373 eeprom_crc->length = 4;
374
375 // Calculate the checksum
376 calc_crc = crc32(0, (void *)eeprom,
377 HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen) - 4);
378 eeprom_crc->value[0] = (calc_crc >> 24) & 0xFF;
379 eeprom_crc->value[1] = (calc_crc >> 16) & 0xFF;
380 eeprom_crc->value[2] = (calc_crc >> 8) & 0xFF;
381 eeprom_crc->value[3] = (calc_crc >> 0) & 0xFF;
382 }
383
384 /**
385 * prog_eeprom
386 *
387 * Write the EEPROM data from CPU memory to the hardware.
388 */
prog_eeprom(u8 * eeprom)389 static int prog_eeprom(u8 *eeprom)
390 {
391 int ret = 0;
392 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
393 int eeprom_len;
394
395 update_crc(eeprom);
396
397 eeprom_len = HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen);
398 ret = write_tlv_eeprom(eeprom, eeprom_len);
399 if (ret) {
400 printf("Programming failed.\n");
401 return -1;
402 }
403
404 printf("Programming passed.\n");
405 return 0;
406 }
407
408 /**
409 * show_tlv_code_list - Display the list of TLV codes and names
410 */
show_tlv_code_list(void)411 void show_tlv_code_list(void)
412 {
413 int i;
414
415 printf("TLV Code TLV Name\n");
416 printf("======== =================\n");
417 for (i = 0; i < ARRAY_SIZE(tlv_code_list); i++) {
418 printf("0x%02X %s\n",
419 tlv_code_list[i].m_code,
420 tlv_code_list[i].m_name);
421 }
422 }
423
424 /**
425 * do_tlv_eeprom
426 *
427 * This function implements the tlv_eeprom command.
428 */
do_tlv_eeprom(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])429 int do_tlv_eeprom(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
430 {
431 char cmd;
432 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
433
434 // If no arguments, read the EERPOM and display its contents
435 if (argc == 1) {
436 read_eeprom(eeprom);
437 show_eeprom(eeprom);
438 return 0;
439 }
440
441 // We only look at the first character to the command, so "read" and
442 // "reset" will both be treated as "read".
443 cmd = argv[1][0];
444
445 // Read the EEPROM contents
446 if (cmd == 'r') {
447 has_been_read = 0;
448 if (!read_eeprom(eeprom))
449 printf("EEPROM data loaded from device to memory.\n");
450 return 0;
451 }
452
453 // Subsequent commands require that the EEPROM has already been read.
454 if (!has_been_read) {
455 printf("Please read the EEPROM data first, using the 'tlv_eeprom read' command.\n");
456 return 0;
457 }
458
459 // Handle the commands that don't take parameters
460 if (argc == 2) {
461 switch (cmd) {
462 case 'w': /* write */
463 prog_eeprom(eeprom);
464 break;
465 case 'e': /* erase */
466 strcpy(eeprom_hdr->signature, TLV_INFO_ID_STRING);
467 eeprom_hdr->version = TLV_INFO_VERSION;
468 eeprom_hdr->totallen = cpu_to_be16(0);
469 update_crc(eeprom);
470 printf("EEPROM data in memory reset.\n");
471 break;
472 case 'l': /* list */
473 show_tlv_code_list();
474 break;
475 case 'd': /* dev */
476 show_tlv_devices();
477 break;
478 default:
479 cmd_usage(cmdtp);
480 break;
481 }
482 return 0;
483 }
484
485 // The set command takes one or two args.
486 if (argc > 4) {
487 cmd_usage(cmdtp);
488 return 0;
489 }
490
491 // Set command. If the TLV exists in the EEPROM, delete it. Then if
492 // data was supplied for this TLV add the TLV with the new contents at
493 // the end.
494 if (cmd == 's') {
495 int tcode;
496
497 tcode = simple_strtoul(argv[2], NULL, 0);
498 tlvinfo_delete_tlv(eeprom, tcode);
499 if (argc == 4)
500 tlvinfo_add_tlv(eeprom, tcode, argv[3]);
501 } else if (cmd == 'd') { /* 'dev' command */
502 unsigned int devnum;
503
504 devnum = simple_strtoul(argv[2], NULL, 0);
505 if (devnum > MAX_TLV_DEVICES || !tlv_devices[devnum]) {
506 printf("Invalid device number\n");
507 return 0;
508 }
509 current_dev = devnum;
510 has_been_read = 0;
511 } else {
512 cmd_usage(cmdtp);
513 }
514
515 return 0;
516 }
517
518 /**
519 * This macro defines the tlv_eeprom command line command.
520 */
521 U_BOOT_CMD(tlv_eeprom, 4, 1, do_tlv_eeprom,
522 "Display and program the system EEPROM data block.",
523 "[read|write|set <type_code> <string_value>|erase|list]\n"
524 "tlv_eeprom\n"
525 " - With no arguments display the current contents.\n"
526 "tlv_eeprom dev [dev]\n"
527 " - List devices or set current EEPROM device.\n"
528 "tlv_eeprom read\n"
529 " - Load EEPROM data from device to memory.\n"
530 "tlv_eeprom write\n"
531 " - Write the EEPROM data to persistent storage.\n"
532 "tlv_eeprom set <type_code> <string_value>\n"
533 " - Set a field to a value.\n"
534 " - If no string_value, field is deleted.\n"
535 " - Use 'tlv_eeprom write' to make changes permanent.\n"
536 "tlv_eeprom erase\n"
537 " - Reset the in memory EEPROM data.\n"
538 " - Use 'tlv_eeprom read' to refresh the in memory EEPROM data.\n"
539 " - Use 'tlv_eeprom write' to make changes permanent.\n"
540 "tlv_eeprom list\n"
541 " - List the understood TLV codes and names.\n"
542 );
543
544 /**
545 * tlvinfo_find_tlv
546 *
547 * This function finds the TLV with the supplied code in the EERPOM.
548 * An offset from the beginning of the EEPROM is returned in the
549 * eeprom_index parameter if the TLV is found.
550 */
tlvinfo_find_tlv(u8 * eeprom,u8 tcode,int * eeprom_index)551 static bool tlvinfo_find_tlv(u8 *eeprom, u8 tcode, int *eeprom_index)
552 {
553 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
554 struct tlvinfo_tlv *eeprom_tlv;
555 int eeprom_end;
556
557 // Search through the TLVs, looking for the first one which matches the
558 // supplied type code.
559 *eeprom_index = HDR_SIZE;
560 eeprom_end = HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen);
561 while (*eeprom_index < eeprom_end) {
562 eeprom_tlv = to_entry(&eeprom[*eeprom_index]);
563 if (!is_valid_tlv(eeprom_tlv))
564 return false;
565 if (eeprom_tlv->type == tcode)
566 return true;
567 *eeprom_index += ENT_SIZE + eeprom_tlv->length;
568 }
569 return(false);
570 }
571
572 /**
573 * tlvinfo_delete_tlv
574 *
575 * This function deletes the TLV with the specified type code from the
576 * EEPROM.
577 */
tlvinfo_delete_tlv(u8 * eeprom,u8 code)578 static bool tlvinfo_delete_tlv(u8 *eeprom, u8 code)
579 {
580 int eeprom_index;
581 int tlength;
582 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
583 struct tlvinfo_tlv *eeprom_tlv;
584
585 // Find the TLV and then move all following TLVs "forward"
586 if (tlvinfo_find_tlv(eeprom, code, &eeprom_index)) {
587 eeprom_tlv = to_entry(&eeprom[eeprom_index]);
588 tlength = ENT_SIZE + eeprom_tlv->length;
589 memcpy(&eeprom[eeprom_index], &eeprom[eeprom_index + tlength],
590 HDR_SIZE +
591 be16_to_cpu(eeprom_hdr->totallen) - eeprom_index -
592 tlength);
593 eeprom_hdr->totallen =
594 cpu_to_be16(be16_to_cpu(eeprom_hdr->totallen) -
595 tlength);
596 update_crc(eeprom);
597 return true;
598 }
599 return false;
600 }
601
602 /**
603 * tlvinfo_add_tlv
604 *
605 * This function adds a TLV to the EEPROM, converting the value (a string) to
606 * the format in which it will be stored in the EEPROM.
607 */
608 #define MAX_TLV_VALUE_LEN 256
tlvinfo_add_tlv(u8 * eeprom,int tcode,char * strval)609 static bool tlvinfo_add_tlv(u8 *eeprom, int tcode, char *strval)
610 {
611 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
612 struct tlvinfo_tlv *eeprom_tlv;
613 int new_tlv_len = 0;
614 u32 value;
615 char data[MAX_TLV_VALUE_LEN];
616 int eeprom_index;
617
618 // Encode each TLV type into the format to be stored in the EERPOM
619 switch (tcode) {
620 case TLV_CODE_PRODUCT_NAME:
621 case TLV_CODE_PART_NUMBER:
622 case TLV_CODE_SERIAL_NUMBER:
623 case TLV_CODE_LABEL_REVISION:
624 case TLV_CODE_PLATFORM_NAME:
625 case TLV_CODE_ONIE_VERSION:
626 case TLV_CODE_MANUF_NAME:
627 case TLV_CODE_MANUF_COUNTRY:
628 case TLV_CODE_VENDOR_NAME:
629 case TLV_CODE_DIAG_VERSION:
630 case TLV_CODE_SERVICE_TAG:
631 strncpy(data, strval, MAX_TLV_VALUE_LEN);
632 new_tlv_len = min_t(size_t, MAX_TLV_VALUE_LEN, strlen(strval));
633 break;
634 case TLV_CODE_DEVICE_VERSION:
635 value = simple_strtoul(strval, NULL, 0);
636 if (value >= 256) {
637 printf("ERROR: Device version must be 255 or less. Value supplied: %u",
638 value);
639 return false;
640 }
641 data[0] = value & 0xFF;
642 new_tlv_len = 1;
643 break;
644 case TLV_CODE_MAC_SIZE:
645 value = simple_strtoul(strval, NULL, 0);
646 if (value >= 65536) {
647 printf("ERROR: MAC Size must be 65535 or less. Value supplied: %u",
648 value);
649 return false;
650 }
651 data[0] = (value >> 8) & 0xFF;
652 data[1] = value & 0xFF;
653 new_tlv_len = 2;
654 break;
655 case TLV_CODE_MANUF_DATE:
656 if (set_date(data, strval) != 0)
657 return false;
658 new_tlv_len = 19;
659 break;
660 case TLV_CODE_MAC_BASE:
661 if (set_mac(data, strval) != 0)
662 return false;
663 new_tlv_len = 6;
664 break;
665 case TLV_CODE_CRC_32:
666 printf("WARNING: The CRC TLV is set automatically and cannot be set manually.\n");
667 return false;
668 case TLV_CODE_VENDOR_EXT:
669 default:
670 if (set_bytes(data, strval, &new_tlv_len) != 0)
671 return false;
672 break;
673 }
674
675 // Is there room for this TLV?
676 if ((be16_to_cpu(eeprom_hdr->totallen) + ENT_SIZE + new_tlv_len) >
677 TLV_TOTAL_LEN_MAX) {
678 printf("ERROR: There is not enough room in the EERPOM to save data.\n");
679 return false;
680 }
681
682 // Add TLV at the end, overwriting CRC TLV if it exists
683 if (tlvinfo_find_tlv(eeprom, TLV_CODE_CRC_32, &eeprom_index))
684 eeprom_hdr->totallen =
685 cpu_to_be16(be16_to_cpu(eeprom_hdr->totallen) -
686 ENT_SIZE - 4);
687 else
688 eeprom_index = HDR_SIZE + be16_to_cpu(eeprom_hdr->totallen);
689 eeprom_tlv = to_entry(&eeprom[eeprom_index]);
690 eeprom_tlv->type = tcode;
691 eeprom_tlv->length = new_tlv_len;
692 memcpy(eeprom_tlv->value, data, new_tlv_len);
693
694 // Update the total length and calculate (add) a new CRC-32 TLV
695 eeprom_hdr->totallen = cpu_to_be16(be16_to_cpu(eeprom_hdr->totallen) +
696 ENT_SIZE + new_tlv_len);
697 update_crc(eeprom);
698
699 return true;
700 }
701
702 /**
703 * set_mac
704 *
705 * Converts a string MAC address into a binary buffer.
706 *
707 * This function takes a pointer to a MAC address string
708 * (i.e."XX:XX:XX:XX:XX:XX", where "XX" is a two-digit hex number).
709 * The string format is verified and then converted to binary and
710 * stored in a buffer.
711 */
set_mac(char * buf,const char * string)712 static int set_mac(char *buf, const char *string)
713 {
714 char *p = (char *)string;
715 int i;
716 int err = 0;
717 char *end;
718
719 if (!p) {
720 printf("ERROR: NULL mac addr string passed in.\n");
721 return -1;
722 }
723
724 if (strlen(p) != 17) {
725 printf("ERROR: MAC address strlen() != 17 -- %zu\n", strlen(p));
726 printf("ERROR: Bad MAC address format: %s\n", string);
727 return -1;
728 }
729
730 for (i = 0; i < 17; i++) {
731 if ((i % 3) == 2) {
732 if (p[i] != ':') {
733 err++;
734 printf("ERROR: mac: p[%i] != :, found: `%c'\n",
735 i, p[i]);
736 break;
737 }
738 continue;
739 } else if (!is_hex(p[i])) {
740 err++;
741 printf("ERROR: mac: p[%i] != hex digit, found: `%c'\n",
742 i, p[i]);
743 break;
744 }
745 }
746
747 if (err != 0) {
748 printf("ERROR: Bad MAC address format: %s\n", string);
749 return -1;
750 }
751
752 /* Convert string to binary */
753 for (i = 0, p = (char *)string; i < 6; i++) {
754 buf[i] = p ? simple_strtoul(p, &end, 16) : 0;
755 if (p)
756 p = (*end) ? end + 1 : end;
757 }
758
759 if (!is_valid_ethaddr((u8 *)buf)) {
760 printf("ERROR: MAC address must not be 00:00:00:00:00:00, a multicast address or FF:FF:FF:FF:FF:FF.\n");
761 printf("ERROR: Bad MAC address format: %s\n", string);
762 return -1;
763 }
764
765 return 0;
766 }
767
768 /**
769 * set_date
770 *
771 * Validates the format of the data string
772 *
773 * This function takes a pointer to a date string (i.e. MM/DD/YYYY hh:mm:ss)
774 * and validates that the format is correct. If so the string is copied
775 * to the supplied buffer.
776 */
set_date(char * buf,const char * string)777 static int set_date(char *buf, const char *string)
778 {
779 int i;
780
781 if (!string) {
782 printf("ERROR: NULL date string passed in.\n");
783 return -1;
784 }
785
786 if (strlen(string) != 19) {
787 printf("ERROR: Date strlen() != 19 -- %zu\n", strlen(string));
788 printf("ERROR: Bad date format (MM/DD/YYYY hh:mm:ss): %s\n",
789 string);
790 return -1;
791 }
792
793 for (i = 0; string[i] != 0; i++) {
794 switch (i) {
795 case 2:
796 case 5:
797 if (string[i] != '/') {
798 printf("ERROR: Bad date format (MM/DD/YYYY hh:mm:ss): %s\n",
799 string);
800 return -1;
801 }
802 break;
803 case 10:
804 if (string[i] != ' ') {
805 printf("ERROR: Bad date format (MM/DD/YYYY hh:mm:ss): %s\n",
806 string);
807 return -1;
808 }
809 break;
810 case 13:
811 case 16:
812 if (string[i] != ':') {
813 printf("ERROR: Bad date format (MM/DD/YYYY hh:mm:ss): %s\n",
814 string);
815 return -1;
816 }
817 break;
818 default:
819 if (!is_digit(string[i])) {
820 printf("ERROR: Bad date format (MM/DD/YYYY hh:mm:ss): %s\n",
821 string);
822 return -1;
823 }
824 break;
825 }
826 }
827
828 strcpy(buf, string);
829 return 0;
830 }
831
832 /**
833 * set_bytes
834 *
835 * Converts a space-separated string of decimal numbers into a
836 * buffer of bytes.
837 *
838 * This function takes a pointer to a space-separated string of decimal
839 * numbers (i.e. "128 0x55 0321") with "C" standard radix specifiers
840 * and converts them to an array of bytes.
841 */
set_bytes(char * buf,const char * string,int * converted_accum)842 static int set_bytes(char *buf, const char *string, int *converted_accum)
843 {
844 char *p = (char *)string;
845 int i;
846 uint byte;
847
848 if (!p) {
849 printf("ERROR: NULL string passed in.\n");
850 return -1;
851 }
852
853 /* Convert string to bytes */
854 for (i = 0, p = (char *)string; (i < TLV_VALUE_MAX_LEN) && (*p != 0);
855 i++) {
856 while ((*p == ' ') || (*p == '\t') || (*p == ',') ||
857 (*p == ';')) {
858 p++;
859 }
860 if (*p != 0) {
861 if (!is_digit(*p)) {
862 printf("ERROR: Non-digit found in byte string: (%s)\n",
863 string);
864 return -1;
865 }
866 byte = simple_strtoul(p, &p, 0);
867 if (byte >= 256) {
868 printf("ERROR: The value specified is greater than 255: (%u) in string: %s\n",
869 byte, string);
870 return -1;
871 }
872 buf[i] = byte & 0xFF;
873 }
874 }
875
876 if (i == TLV_VALUE_MAX_LEN && (*p != 0)) {
877 printf("ERROR: Trying to assign too many bytes (max: %d) in string: %s\n",
878 TLV_VALUE_MAX_LEN, string);
879 return -1;
880 }
881
882 *converted_accum = i;
883 return 0;
884 }
885
show_tlv_devices(void)886 static void show_tlv_devices(void)
887 {
888 unsigned int dev;
889
890 for (dev = 0; dev < MAX_TLV_DEVICES; dev++)
891 if (tlv_devices[dev])
892 printf("TLV: %u%s\n", dev,
893 (dev == current_dev) ? " (*)" : "");
894 }
895
find_tlv_devices(struct udevice ** tlv_devices_p)896 static int find_tlv_devices(struct udevice **tlv_devices_p)
897 {
898 int ret;
899 int count_dev = 0;
900 struct udevice *dev;
901
902 for (ret = uclass_first_device_check(UCLASS_I2C_EEPROM, &dev);
903 dev;
904 ret = uclass_next_device_check(&dev)) {
905 if (ret == 0)
906 tlv_devices_p[count_dev++] = dev;
907 if (count_dev >= MAX_TLV_DEVICES)
908 break;
909 }
910
911 return (count_dev == 0) ? -ENODEV : 0;
912 }
913
find_tlv_device_by_index(int dev_num)914 static struct udevice *find_tlv_device_by_index(int dev_num)
915 {
916 struct udevice *local_tlv_devices[MAX_TLV_DEVICES] = {};
917 struct udevice **tlv_devices_p;
918 int ret;
919
920 if (gd->flags & (GD_FLG_RELOC | GD_FLG_SPL_INIT)) {
921 /* Assume BSS is initialized; use static data */
922 if (tlv_devices[dev_num])
923 return tlv_devices[dev_num];
924 tlv_devices_p = tlv_devices;
925 } else {
926 tlv_devices_p = local_tlv_devices;
927 }
928
929 ret = find_tlv_devices(tlv_devices_p);
930 if (ret == 0 && tlv_devices_p[dev_num])
931 return tlv_devices_p[dev_num];
932
933 return NULL;
934 }
935
936 /**
937 * read_tlv_eeprom - read the hwinfo from i2c EEPROM
938 */
read_tlv_eeprom(void * eeprom,int offset,int len,int dev_num)939 int read_tlv_eeprom(void *eeprom, int offset, int len, int dev_num)
940 {
941 struct udevice *dev;
942
943 if (dev_num >= MAX_TLV_DEVICES)
944 return -EINVAL;
945
946 dev = find_tlv_device_by_index(dev_num);
947 if (!dev)
948 return -ENODEV;
949
950 return i2c_eeprom_read(dev, offset, eeprom, len);
951 }
952
953 /**
954 * write_tlv_eeprom - write the hwinfo to i2c EEPROM
955 */
write_tlv_eeprom(void * eeprom,int len)956 int write_tlv_eeprom(void *eeprom, int len)
957 {
958 if (!(gd->flags & GD_FLG_RELOC))
959 return -ENODEV;
960 if (!tlv_devices[current_dev])
961 return -ENODEV;
962
963 return i2c_eeprom_write(tlv_devices[current_dev], 0, eeprom, len);
964 }
965
read_tlvinfo_tlv_eeprom(void * eeprom,struct tlvinfo_header ** hdr,struct tlvinfo_tlv ** first_entry,int dev_num)966 int read_tlvinfo_tlv_eeprom(void *eeprom, struct tlvinfo_header **hdr,
967 struct tlvinfo_tlv **first_entry, int dev_num)
968 {
969 int ret;
970 struct tlvinfo_header *tlv_hdr;
971 struct tlvinfo_tlv *tlv_ent;
972
973 /* Read TLV header */
974 ret = read_tlv_eeprom(eeprom, 0, HDR_SIZE, dev_num);
975 if (ret < 0)
976 return ret;
977
978 tlv_hdr = eeprom;
979 if (!is_valid_tlvinfo_header(tlv_hdr))
980 return -EINVAL;
981
982 /* Read TLV entries */
983 tlv_ent = to_entry(&tlv_hdr[1]);
984 ret = read_tlv_eeprom(tlv_ent, HDR_SIZE,
985 be16_to_cpu(tlv_hdr->totallen), dev_num);
986 if (ret < 0)
987 return ret;
988 if (!is_checksum_valid(eeprom))
989 return -EINVAL;
990
991 *hdr = tlv_hdr;
992 *first_entry = tlv_ent;
993
994 return 0;
995 }
996
997 /**
998 * mac_read_from_eeprom
999 *
1000 * Read the MAC addresses from EEPROM
1001 *
1002 * This function reads the MAC addresses from EEPROM and sets the
1003 * appropriate environment variables for each one read.
1004 *
1005 * The environment variables are only set if they haven't been set already.
1006 * This ensures that any user-saved variables are never overwritten.
1007 *
1008 * This function must be called after relocation.
1009 */
mac_read_from_eeprom(void)1010 int mac_read_from_eeprom(void)
1011 {
1012 unsigned int i;
1013 int eeprom_index;
1014 struct tlvinfo_tlv *eeprom_tlv;
1015 int maccount;
1016 u8 macbase[6];
1017 struct tlvinfo_header *eeprom_hdr = to_header(eeprom);
1018
1019 puts("EEPROM: ");
1020
1021 if (read_eeprom(eeprom)) {
1022 printf("Read failed.\n");
1023 return -1;
1024 }
1025
1026 maccount = 1;
1027 if (tlvinfo_find_tlv(eeprom, TLV_CODE_MAC_SIZE, &eeprom_index)) {
1028 eeprom_tlv = to_entry(&eeprom[eeprom_index]);
1029 maccount = (eeprom_tlv->value[0] << 8) | eeprom_tlv->value[1];
1030 }
1031
1032 memcpy(macbase, "\0\0\0\0\0\0", 6);
1033 if (tlvinfo_find_tlv(eeprom, TLV_CODE_MAC_BASE, &eeprom_index)) {
1034 eeprom_tlv = to_entry(&eeprom[eeprom_index]);
1035 memcpy(macbase, eeprom_tlv->value, 6);
1036 }
1037
1038 for (i = 0; i < maccount; i++) {
1039 if (is_valid_ethaddr(macbase)) {
1040 char ethaddr[18];
1041 char enetvar[11];
1042
1043 sprintf(ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
1044 macbase[0], macbase[1], macbase[2],
1045 macbase[3], macbase[4], macbase[5]);
1046 sprintf(enetvar, i ? "eth%daddr" : "ethaddr", i);
1047 /* Only initialize environment variables that are blank
1048 * (i.e. have not yet been set)
1049 */
1050 if (!env_get(enetvar))
1051 env_set(enetvar, ethaddr);
1052
1053 macbase[5]++;
1054 if (macbase[5] == 0) {
1055 macbase[4]++;
1056 if (macbase[4] == 0) {
1057 macbase[3]++;
1058 if (macbase[3] == 0) {
1059 macbase[0] = 0;
1060 macbase[1] = 0;
1061 macbase[2] = 0;
1062 }
1063 }
1064 }
1065 }
1066 }
1067
1068 printf("%s v%u len=%u\n", eeprom_hdr->signature, eeprom_hdr->version,
1069 be16_to_cpu(eeprom_hdr->totallen));
1070
1071 return 0;
1072 }
1073
1074 /**
1075 * populate_serial_number - read the serial number from EEPROM
1076 *
1077 * This function reads the serial number from the EEPROM and sets the
1078 * appropriate environment variable.
1079 *
1080 * The environment variable is only set if it has not been set
1081 * already. This ensures that any user-saved variables are never
1082 * overwritten.
1083 *
1084 * This function must be called after relocation.
1085 */
populate_serial_number(void)1086 int populate_serial_number(void)
1087 {
1088 char serialstr[257];
1089 int eeprom_index;
1090 struct tlvinfo_tlv *eeprom_tlv;
1091
1092 if (env_get("serial#"))
1093 return 0;
1094
1095 if (read_eeprom(eeprom)) {
1096 printf("Read failed.\n");
1097 return -1;
1098 }
1099
1100 if (tlvinfo_find_tlv(eeprom, TLV_CODE_SERIAL_NUMBER, &eeprom_index)) {
1101 eeprom_tlv = to_entry(&eeprom[eeprom_index]);
1102 memcpy(serialstr, eeprom_tlv->value, eeprom_tlv->length);
1103 serialstr[eeprom_tlv->length] = 0;
1104 env_set("serial#", serialstr);
1105 }
1106
1107 return 0;
1108 }
1109