1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Based on board/freescale/common/sys_eeprom.c
4 * Copyright 2006, 2008-2009, 2011 Freescale Semiconductor
5 *
6 * This defines the API for storing board information in the
7 * eeprom. It has been adapted from an earlier version of the
8 * Freescale API, but has a number of key differences. Because
9 * the two APIs are independent and may diverge further, the
10 * Varisys version of the API is implemented separately here.
11 */
12
13 #include <common.h>
14 #include <command.h>
15 #include <env.h>
16 #include <i2c.h>
17 #include <linux/ctype.h>
18 #include <linux/delay.h>
19 #include <u-boot/crc.h>
20
21 #include "eeprom.h"
22
23 #ifdef CONFIG_SYS_I2C_EEPROM_NXID_MAC
24 #define MAX_NUM_PORTS CONFIG_SYS_I2C_EEPROM_NXID_MAC
25 #else
26 #define MAX_NUM_PORTS 8
27 #endif
28 #define NXID_VERSION 0
29
30 /**
31 * static eeprom: EEPROM layout for NXID formats
32 *
33 * See Freescale application note AN3638 for details.
34 */
35 static struct __attribute__ ((__packed__)) eeprom {
36 u8 id[4]; /* 0x00 - 0x03 EEPROM Tag 'NXID' */
37 u8 sn[12]; /* 0x04 - 0x0F Serial Number */
38 u8 errata[5]; /* 0x10 - 0x14 Errata Level */
39 u8 date[6]; /* 0x15 - 0x1a Build Date */
40 u8 res_0; /* 0x1b Reserved */
41 u32 version; /* 0x1c - 0x1f NXID Version */
42 u8 tempcal[8]; /* 0x20 - 0x27 Temperature Calibration Factors */
43 u8 tempcalsys[2]; /* 0x28 - 0x29 System Temperature Calibration Factors */
44 u8 tempcalflags; /* 0x2a Temperature Calibration Flags */
45 u8 res_1[21]; /* 0x2b - 0x3f Reserved */
46 u8 mac_count; /* 0x40 Number of MAC addresses */
47 u8 mac_flag; /* 0x41 MAC table flags */
48 u8 mac[MAX_NUM_PORTS][6]; /* 0x42 - x MAC addresses */
49 u32 crc; /* x+1 CRC32 checksum */
50 } e;
51
52 /* Set to 1 if we've read EEPROM into memory */
53 static int has_been_read;
54
55 /* Is this a valid NXID EEPROM? */
56 #define is_valid ((e.id[0] == 'N') || (e.id[1] == 'X') || \
57 (e.id[2] == 'I') || (e.id[3] == 'D'))
58
59 /** Fixed ID field in EEPROM */
60 static unsigned char uid[16];
61
62 static int eeprom_bus_num = -1;
63 static int eeprom_addr;
64 static int eeprom_addr_len;
65
66 /**
67 * This must be called before any eeprom access.
68 */
init_eeprom(int bus_num,int addr,int addr_len)69 void init_eeprom(int bus_num, int addr, int addr_len)
70 {
71 eeprom_bus_num = bus_num;
72 eeprom_addr = addr;
73 eeprom_addr_len = addr_len;
74 }
75
76 /**
77 * show_eeprom - display the contents of the EEPROM
78 */
show_eeprom(void)79 void show_eeprom(void)
80 {
81 int i;
82 unsigned int crc;
83
84 /* EEPROM tag ID, either CCID or NXID */
85 printf("ID: %c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
86 be32_to_cpu(e.version));
87
88 /* Serial number */
89 printf("SN: %s\n", e.sn);
90
91 printf("UID: ");
92 for (i = 0; i < 16; i++)
93 printf("%02x", uid[i]);
94 printf("\n");
95
96 /* Errata level. */
97 printf("Errata: %s\n", e.errata);
98
99 /* Build date, BCD date values, as YYMMDDhhmmss */
100 printf("Build date: 20%02x/%02x/%02x %02x:%02x:%02x %s\n",
101 e.date[0], e.date[1], e.date[2],
102 e.date[3] & 0x7F, e.date[4], e.date[5],
103 e.date[3] & 0x80 ? "PM" : "");
104
105 /* Show MAC addresses */
106 for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
107 u8 *p = e.mac[i];
108
109 printf("Eth%u: %02x:%02x:%02x:%02x:%02x:%02x\n", i,
110 p[0], p[1], p[2], p[3], p[4], p[5]);
111 }
112
113 crc = crc32(0, (void *)&e, sizeof(e) - 4);
114
115 if (crc == be32_to_cpu(e.crc))
116 printf("CRC: %08x\n", be32_to_cpu(e.crc));
117 else
118 printf("CRC: %08x (should be %08x)\n",
119 be32_to_cpu(e.crc), crc);
120
121 #ifdef DEBUG
122 printf("EEPROM dump: (0x%x bytes)\n", sizeof(e));
123 for (i = 0; i < sizeof(e); i++) {
124 if ((i % 16) == 0)
125 printf("%02X: ", i);
126 printf("%02X ", ((u8 *)&e)[i]);
127 if (((i % 16) == 15) || (i == sizeof(e) - 1))
128 printf("\n");
129 }
130 #endif
131 }
132
133 /**
134 * read_eeprom - read the EEPROM into memory
135 */
read_eeprom(void)136 int read_eeprom(void)
137 {
138 int ret;
139 unsigned int bus;
140
141 if (eeprom_bus_num < 0) {
142 printf("EEPROM not configured\n");
143 return -1;
144 }
145
146 if (has_been_read)
147 return 0;
148
149 bus = i2c_get_bus_num();
150 i2c_set_bus_num(eeprom_bus_num);
151
152 ret = i2c_read(eeprom_addr, 0, eeprom_addr_len,
153 (void *)&e, sizeof(e));
154
155
156 /* Fixed address of ID field */
157 i2c_read(0x5f, 0x80, 1, uid, 16);
158
159 i2c_set_bus_num(bus);
160
161 #ifdef DEBUG
162 show_eeprom();
163 #endif
164
165 has_been_read = (ret == 0) ? 1 : 0;
166
167 return ret;
168 }
169
170 /**
171 * update_crc - update the CRC
172 *
173 * This function should be called after each update to the EEPROM structure,
174 * to make sure the CRC is always correct.
175 */
update_crc(void)176 static void update_crc(void)
177 {
178 u32 crc, crc_offset = offsetof(struct eeprom, crc);
179
180 crc = crc32(0, (void *)&e, crc_offset);
181 e.crc = cpu_to_be32(crc);
182 }
183
184 /**
185 * prog_eeprom - write the EEPROM from memory
186 */
prog_eeprom(void)187 static int prog_eeprom(void)
188 {
189 int ret = 0;
190 int i;
191 void *p;
192 unsigned int bus;
193
194 if (eeprom_bus_num < 0) {
195 printf("EEPROM not configured\n");
196 return -1;
197 }
198
199 /* Set the reserved values to 0xFF */
200 e.res_0 = 0xFF;
201 memset(e.res_1, 0xFF, sizeof(e.res_1));
202 update_crc();
203
204 bus = i2c_get_bus_num();
205 i2c_set_bus_num(eeprom_bus_num);
206
207 /*
208 * The AT24C02 datasheet says that data can only be written in page
209 * mode, which means 8 bytes at a time, and it takes up to 5ms to
210 * complete a given write.
211 */
212 for (i = 0, p = &e; i < sizeof(e); i += 8, p += 8) {
213 ret = i2c_write(eeprom_addr, i, eeprom_addr_len,
214 p, min((int)(sizeof(e) - i), 8));
215 if (ret)
216 break;
217 udelay(5000); /* 5ms write cycle timing */
218 }
219
220 if (!ret) {
221 /* Verify the write by reading back the EEPROM and comparing */
222 struct eeprom e2;
223
224 ret = i2c_read(eeprom_addr, 0,
225 eeprom_addr_len, (void *)&e2, sizeof(e2));
226 if (!ret && memcmp(&e, &e2, sizeof(e)))
227 ret = -1;
228 }
229
230 i2c_set_bus_num(bus);
231
232 if (ret) {
233 printf("Programming failed.\n");
234 has_been_read = 0;
235 return -1;
236 }
237
238 printf("Programming passed.\n");
239 return 0;
240 }
241
242 /**
243 * h2i - converts hex character into a number
244 *
245 * This function takes a hexadecimal character (e.g. '7' or 'C') and returns
246 * the integer equivalent.
247 */
h2i(char p)248 static inline u8 h2i(char p)
249 {
250 if ((p >= '0') && (p <= '9'))
251 return p - '0';
252
253 if ((p >= 'A') && (p <= 'F'))
254 return (p - 'A') + 10;
255
256 if ((p >= 'a') && (p <= 'f'))
257 return (p - 'a') + 10;
258
259 return 0;
260 }
261
262 /**
263 * set_date - stores the build date into the EEPROM
264 *
265 * This function takes a pointer to a string in the format "YYMMDDhhmmss"
266 * (2-digit year, 2-digit month, etc), converts it to a 6-byte BCD string,
267 * and stores it in the build date field of the EEPROM local copy.
268 */
set_date(const char * string)269 static void set_date(const char *string)
270 {
271 unsigned int i;
272
273 if (strlen(string) != 12) {
274 printf("Usage: mac date YYMMDDhhmmss\n");
275 return;
276 }
277
278 for (i = 0; i < 6; i++)
279 e.date[i] = h2i(string[2 * i]) << 4 | h2i(string[2 * i + 1]);
280
281 update_crc();
282 }
283
284 /**
285 * set_mac_address - stores a MAC address into the EEPROM
286 *
287 * This function takes a pointer to MAC address string
288 * (i.e."XX:XX:XX:XX:XX:XX", where "XX" is a two-digit hex number) and
289 * stores it in one of the MAC address fields of the EEPROM local copy.
290 */
set_mac_address(unsigned int index,const char * string)291 static void set_mac_address(unsigned int index, const char *string)
292 {
293 char *p = (char *)string;
294 unsigned int i;
295
296 if ((index >= MAX_NUM_PORTS) || !string) {
297 printf("Usage: mac <n> XX:XX:XX:XX:XX:XX\n");
298 return;
299 }
300
301 for (i = 0; *p && (i < 6); i++) {
302 e.mac[index][i] = simple_strtoul(p, &p, 16);
303 if (*p == ':')
304 p++;
305 }
306
307 update_crc();
308 }
309
do_mac(struct cmd_tbl * cmdtp,int flag,int argc,char * const argv[])310 int do_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
311 {
312 char cmd;
313
314 if (argc == 1) {
315 show_eeprom();
316 return 0;
317 }
318
319 cmd = argv[1][0];
320
321 if (cmd == 'r') {
322 read_eeprom();
323 return 0;
324 }
325
326 if (cmd == 'i') {
327 memcpy(e.id, "NXID", sizeof(e.id));
328 e.version = NXID_VERSION;
329 update_crc();
330 return 0;
331 }
332
333 if (!is_valid) {
334 printf("Please read the EEPROM ('r') and/or set the ID ('i') first.\n");
335 return 0;
336 }
337
338 if (argc == 2) {
339 switch (cmd) {
340 case 's': /* save */
341 prog_eeprom();
342 break;
343 default:
344 return cmd_usage(cmdtp);
345 }
346
347 return 0;
348 }
349
350 /* We know we have at least one parameter */
351
352 switch (cmd) {
353 case 'n': /* serial number */
354 memset(e.sn, 0, sizeof(e.sn));
355 strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
356 update_crc();
357 break;
358 case 'e': /* errata */
359 memset(e.errata, 0, 5);
360 strncpy((char *)e.errata, argv[2], 4);
361 update_crc();
362 break;
363 case 'd': /* date BCD format YYMMDDhhmmss */
364 set_date(argv[2]);
365 break;
366 case 'p': /* MAC table size */
367 e.mac_count = simple_strtoul(argv[2], NULL, 16);
368 update_crc();
369 break;
370 case '0' ... '9': /* "mac 0" through "mac 22" */
371 set_mac_address(simple_strtoul(argv[1], NULL, 10), argv[2]);
372 break;
373 case 'h': /* help */
374 default:
375 return cmd_usage(cmdtp);
376 }
377
378 return 0;
379 }
380
mac_read_from_generic_eeprom(const char * envvar,int chip,int address,int mac_bus)381 int mac_read_from_generic_eeprom(const char *envvar, int chip,
382 int address, int mac_bus)
383 {
384 int ret;
385 unsigned int bus;
386 unsigned char mac[6];
387 char ethaddr[18];
388
389 bus = i2c_get_bus_num();
390 i2c_set_bus_num(mac_bus);
391
392 ret = i2c_read(chip, address, 1, mac, 6);
393
394 i2c_set_bus_num(bus);
395
396 if (!ret) {
397 sprintf(ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
398 mac[0],
399 mac[1],
400 mac[2],
401 mac[3],
402 mac[4],
403 mac[5]);
404
405 printf("MAC: %s\n", ethaddr);
406 env_set(envvar, ethaddr);
407 }
408
409 return ret;
410 }
411
mac_read_from_fixed_id(void)412 void mac_read_from_fixed_id(void)
413 {
414 #ifdef CONFIG_SYS_I2C_MAC1_CHIP_ADDR
415 mac_read_from_generic_eeprom("ethaddr", CONFIG_SYS_I2C_MAC1_CHIP_ADDR,
416 CONFIG_SYS_I2C_MAC1_DATA_ADDR, CONFIG_SYS_I2C_MAC1_BUS);
417 #endif
418 #ifdef CONFIG_SYS_I2C_MAC2_CHIP_ADDR
419 mac_read_from_generic_eeprom("eth1addr", CONFIG_SYS_I2C_MAC2_CHIP_ADDR,
420 CONFIG_SYS_I2C_MAC2_DATA_ADDR, CONFIG_SYS_I2C_MAC2_BUS);
421 #endif
422 }
423
424 /**
425 * mac_read_from_eeprom - read the MAC addresses from EEPROM
426 *
427 * This function reads the MAC addresses from EEPROM and sets the
428 * appropriate environment variables for each one read.
429 *
430 * The environment variables are only set if they haven't been set already.
431 * This ensures that any user-saved variables are never overwritten.
432 *
433 * This function must be called after relocation.
434 *
435 * For NXID v1 EEPROMs, we support loading and up-converting the older NXID v0
436 * format. In a v0 EEPROM, there are only eight MAC addresses and the CRC is
437 * located at a different offset.
438 */
mac_read_from_eeprom_common(void)439 int mac_read_from_eeprom_common(void)
440 {
441 unsigned int i;
442 u32 crc, crc_offset = offsetof(struct eeprom, crc);
443 u32 *crcp; /* Pointer to the CRC in the data read from the EEPROM */
444
445 puts("EEPROM: ");
446
447 if (read_eeprom()) {
448 printf("Read failed.\n");
449 return 0;
450 }
451
452 if (!is_valid) {
453 printf("Invalid ID (%02x %02x %02x %02x)\n",
454 e.id[0], e.id[1], e.id[2], e.id[3]);
455 return 0;
456 }
457
458 crc = crc32(0, (void *)&e, crc_offset);
459 crcp = (void *)&e + crc_offset;
460 if (crc != be32_to_cpu(*crcp)) {
461 printf("CRC mismatch (%08x != %08x)\n", crc,
462 be32_to_cpu(e.crc));
463 return 0;
464 }
465
466 /*
467 * MAC address #9 in v1 occupies the same position as the CRC in v0.
468 * Erase it so that it's not mistaken for a MAC address. We'll
469 * update the CRC later.
470 */
471 if (e.version == 0)
472 memset(e.mac[8], 0xff, 6);
473
474 for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
475 if (memcmp(&e.mac[i], "\0\0\0\0\0\0", 6) &&
476 memcmp(&e.mac[i], "\xFF\xFF\xFF\xFF\xFF\xFF", 6)) {
477 char ethaddr[18];
478 char enetvar[9];
479
480 sprintf(ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
481 e.mac[i][0],
482 e.mac[i][1],
483 e.mac[i][2],
484 e.mac[i][3],
485 e.mac[i][4],
486 e.mac[i][5]);
487 sprintf(enetvar, i ? "eth%daddr" : "ethaddr", i);
488 /* Only initialize environment variables that are blank
489 * (i.e. have not yet been set)
490 */
491 if (!env_get(enetvar))
492 env_set(enetvar, ethaddr);
493 }
494 }
495
496 printf("%c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
497 be32_to_cpu(e.version));
498
499 return 0;
500 }
501