1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright 2006, 2008-2009, 2011 Freescale Semiconductor
4 * York Sun (yorksun@freescale.com)
5 * Haiying Wang (haiying.wang@freescale.com)
6 * Timur Tabi (timur@freescale.com)
7 */
8
9#include <common.h>
10#include <command.h>
11#include <env.h>
12#include <i2c.h>
13#include <init.h>
14#include <linux/ctype.h>
15#include <linux/delay.h>
16#include <u-boot/crc.h>
17
18#ifdef CONFIG_SYS_I2C_EEPROM_CCID
19#include "../common/eeprom.h"
20#define MAX_NUM_PORTS	8
21#endif
22
23#ifdef CONFIG_SYS_I2C_EEPROM_NXID
24/* some boards with non-256-bytes EEPROM have special define */
25/* for MAX_NUM_PORTS in board-specific file */
26#ifndef MAX_NUM_PORTS
27#define MAX_NUM_PORTS	16
28#endif
29#define NXID_VERSION	1
30#endif
31
32/**
33 * static eeprom: EEPROM layout for CCID or NXID formats
34 *
35 * See application note AN3638 for details.
36 */
37static struct __attribute__ ((__packed__)) eeprom {
38#ifdef CONFIG_SYS_I2C_EEPROM_CCID
39	u8 id[4];         /* 0x00 - 0x03 EEPROM Tag 'CCID' */
40	u8 major;         /* 0x04        Board revision, major */
41	u8 minor;         /* 0x05        Board revision, minor */
42	u8 sn[10];        /* 0x06 - 0x0F Serial Number*/
43	u8 errata[2];     /* 0x10 - 0x11 Errata Level */
44	u8 date[6];       /* 0x12 - 0x17 Build Date */
45	u8 res_0[40];     /* 0x18 - 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 - 0x71 MAC addresses */
49	u32 crc;          /* 0x72        CRC32 checksum */
50#endif
51#ifdef CONFIG_SYS_I2C_EEPROM_NXID
52	u8 id[4];         /* 0x00 - 0x03 EEPROM Tag 'NXID' */
53	u8 sn[12];        /* 0x04 - 0x0F Serial Number */
54	u8 errata[5];     /* 0x10 - 0x14 Errata Level */
55	u8 date[6];       /* 0x15 - 0x1a Build Date */
56	u8 res_0;         /* 0x1b        Reserved */
57	u32 version;      /* 0x1c - 0x1f NXID Version */
58	u8 tempcal[8];    /* 0x20 - 0x27 Temperature Calibration Factors */
59	u8 tempcalsys[2]; /* 0x28 - 0x29 System Temperature Calibration Factors */
60	u8 tempcalflags;  /* 0x2a        Temperature Calibration Flags */
61	u8 res_1[21];     /* 0x2b - 0x3f Reserved */
62	u8 mac_count;     /* 0x40        Number of MAC addresses */
63	u8 mac_flag;      /* 0x41        MAC table flags */
64	u8 mac[MAX_NUM_PORTS][6];     /* 0x42 - 0xa1 MAC addresses */
65	u8 res_2[90];     /* 0xa2 - 0xfb Reserved */
66	u32 crc;          /* 0xfc - 0xff CRC32 checksum */
67#endif
68} e;
69
70/* Set to 1 if we've read EEPROM into memory */
71static int has_been_read = 0;
72
73#ifdef CONFIG_SYS_I2C_EEPROM_NXID
74/* Is this a valid NXID EEPROM? */
75#define is_valid ((e.id[0] == 'N') || (e.id[1] == 'X') || \
76		  (e.id[2] == 'I') || (e.id[3] == 'D'))
77#endif
78
79#ifdef CONFIG_SYS_I2C_EEPROM_CCID
80/* Is this a valid CCID EEPROM? */
81#define is_valid ((e.id[0] == 'C') || (e.id[1] == 'C') || \
82		  (e.id[2] == 'I') || (e.id[3] == 'D'))
83#endif
84
85/**
86 * show_eeprom - display the contents of the EEPROM
87 */
88static void show_eeprom(void)
89{
90	int i;
91	unsigned int crc;
92
93	/* EEPROM tag ID, either CCID or NXID */
94#ifdef CONFIG_SYS_I2C_EEPROM_NXID
95	printf("ID: %c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
96	       be32_to_cpu(e.version));
97#else
98	printf("ID: %c%c%c%c\n", e.id[0], e.id[1], e.id[2], e.id[3]);
99#endif
100
101	/* Serial number */
102	printf("SN: %s\n", e.sn);
103
104	/* Errata level. */
105#ifdef CONFIG_SYS_I2C_EEPROM_NXID
106	printf("Errata: %s\n", e.errata);
107#else
108	printf("Errata: %c%c\n",
109		e.errata[0] ? e.errata[0] : '.',
110		e.errata[1] ? e.errata[1] : '.');
111#endif
112
113	/* Build date, BCD date values, as YYMMDDhhmmss */
114	printf("Build date: 20%02x/%02x/%02x %02x:%02x:%02x %s\n",
115		e.date[0], e.date[1], e.date[2],
116		e.date[3] & 0x7F, e.date[4], e.date[5],
117		e.date[3] & 0x80 ? "PM" : "");
118
119	/* Show MAC addresses  */
120	for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
121
122		u8 *p = e.mac[i];
123
124		printf("Eth%u: %02x:%02x:%02x:%02x:%02x:%02x\n", i,
125			p[0], p[1], p[2], p[3],	p[4], p[5]);
126	}
127
128	crc = crc32(0, (void *)&e, sizeof(e) - 4);
129
130	if (crc == be32_to_cpu(e.crc))
131		printf("CRC: %08x\n", be32_to_cpu(e.crc));
132	else
133		printf("CRC: %08x (should be %08x)\n",
134			be32_to_cpu(e.crc), crc);
135
136#ifdef DEBUG
137	printf("EEPROM dump: (0x%x bytes)\n", sizeof(e));
138	for (i = 0; i < sizeof(e); i++) {
139		if ((i % 16) == 0)
140			printf("%02X: ", i);
141		printf("%02X ", ((u8 *)&e)[i]);
142		if (((i % 16) == 15) || (i == sizeof(e) - 1))
143			printf("\n");
144	}
145#endif
146}
147
148/**
149 * read_eeprom - read the EEPROM into memory
150 */
151static int read_eeprom(void)
152{
153	int ret;
154#ifdef CONFIG_SYS_EEPROM_BUS_NUM
155#if !CONFIG_IS_ENABLED(DM_I2C)
156	unsigned int bus;
157#endif
158#endif
159
160	if (has_been_read)
161		return 0;
162
163#ifdef CONFIG_SYS_EEPROM_BUS_NUM
164#if !CONFIG_IS_ENABLED(DM_I2C)
165	bus = i2c_get_bus_num();
166	i2c_set_bus_num(CONFIG_SYS_EEPROM_BUS_NUM);
167#endif
168#endif
169
170#if !CONFIG_IS_ENABLED(DM_I2C)
171	ret = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0,
172		       CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
173		       (void *)&e, sizeof(e));
174#else
175	struct udevice *dev;
176#ifdef CONFIG_SYS_EEPROM_BUS_NUM
177	ret = i2c_get_chip_for_busnum(CONFIG_SYS_EEPROM_BUS_NUM,
178				      CONFIG_SYS_I2C_EEPROM_ADDR,
179				      CONFIG_SYS_I2C_EEPROM_ADDR_LEN, &dev);
180#else
181	ret = i2c_get_chip_for_busnum(0, CONFIG_SYS_I2C_EEPROM_ADDR,
182				      CONFIG_SYS_I2C_EEPROM_ADDR_LEN, &dev);
183#endif
184	if (!ret)
185		ret = dm_i2c_read(dev, 0, (void *)&e, sizeof(e));
186#endif
187
188#ifdef CONFIG_SYS_EEPROM_BUS_NUM
189#if !CONFIG_IS_ENABLED(DM_I2C)
190	i2c_set_bus_num(bus);
191#endif
192#endif
193
194#ifdef DEBUG
195	show_eeprom();
196#endif
197
198	has_been_read = (ret == 0) ? 1 : 0;
199
200	return ret;
201}
202
203/**
204 *  update_crc - update the CRC
205 *
206 *  This function should be called after each update to the EEPROM structure,
207 *  to make sure the CRC is always correct.
208 */
209static void update_crc(void)
210{
211	u32 crc;
212
213	crc = crc32(0, (void *)&e, sizeof(e) - 4);
214	e.crc = cpu_to_be32(crc);
215}
216
217/**
218 * prog_eeprom - write the EEPROM from memory
219 */
220static int prog_eeprom(void)
221{
222	int ret = 0;
223	int i;
224	void *p;
225#ifdef CONFIG_SYS_EEPROM_BUS_NUM
226#if !CONFIG_IS_ENABLED(DM_I2C)
227	unsigned int bus;
228#endif
229#endif
230
231	/* Set the reserved values to 0xFF   */
232#ifdef CONFIG_SYS_I2C_EEPROM_NXID
233	e.res_0 = 0xFF;
234	memset(e.res_1, 0xFF, sizeof(e.res_1));
235#else
236	memset(e.res_0, 0xFF, sizeof(e.res_0));
237#endif
238	update_crc();
239
240#if !CONFIG_IS_ENABLED(DM_I2C)
241#ifdef CONFIG_SYS_EEPROM_BUS_NUM
242	bus = i2c_get_bus_num();
243	i2c_set_bus_num(CONFIG_SYS_EEPROM_BUS_NUM);
244#endif
245#endif
246
247	/*
248	 * The AT24C02 datasheet says that data can only be written in page
249	 * mode, which means 8 bytes at a time, and it takes up to 5ms to
250	 * complete a given write.
251	 */
252	for (i = 0, p = &e; i < sizeof(e); i += 8, p += 8) {
253#if !CONFIG_IS_ENABLED(DM_I2C)
254		ret = i2c_write(CONFIG_SYS_I2C_EEPROM_ADDR, i,
255				CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
256				p, min((int)(sizeof(e) - i), 8));
257#else
258		struct udevice *dev;
259#ifdef CONFIG_SYS_EEPROM_BUS_NUM
260		ret = i2c_get_chip_for_busnum(CONFIG_SYS_EEPROM_BUS_NUM,
261					      CONFIG_SYS_I2C_EEPROM_ADDR,
262					      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
263					      &dev);
264#else
265		ret = i2c_get_chip_for_busnum(0, CONFIG_SYS_I2C_EEPROM_ADDR,
266					      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
267					      &dev);
268#endif
269		if (!ret)
270			ret = dm_i2c_write(dev, i, p, min((int)(sizeof(e) - i),
271							  8));
272#endif
273		if (ret)
274			break;
275		udelay(5000);	/* 5ms write cycle timing */
276	}
277
278	if (!ret) {
279		/* Verify the write by reading back the EEPROM and comparing */
280		struct eeprom e2;
281
282#if !CONFIG_IS_ENABLED(DM_I2C)
283		ret = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0,
284			       CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
285			       (void *)&e2, sizeof(e2));
286#else
287		struct udevice *dev;
288#ifdef CONFIG_SYS_EEPROM_BUS_NUM
289		ret = i2c_get_chip_for_busnum(CONFIG_SYS_EEPROM_BUS_NUM,
290					      CONFIG_SYS_I2C_EEPROM_ADDR,
291					      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
292					      &dev);
293#else
294		ret = i2c_get_chip_for_busnum(0, CONFIG_SYS_I2C_EEPROM_ADDR,
295					      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
296					      &dev);
297#endif
298		if (!ret)
299			ret = dm_i2c_read(dev, 0, (void *)&e2, sizeof(e2));
300#endif
301		if (!ret && memcmp(&e, &e2, sizeof(e)))
302			ret = -1;
303	}
304
305#if !CONFIG_IS_ENABLED(DM_I2C)
306#ifdef CONFIG_SYS_EEPROM_BUS_NUM
307	i2c_set_bus_num(bus);
308#endif
309#endif
310
311	if (ret) {
312		printf("Programming failed.\n");
313		has_been_read = 0;
314		return -1;
315	}
316
317	printf("Programming passed.\n");
318	return 0;
319}
320
321/**
322 * h2i - converts hex character into a number
323 *
324 * This function takes a hexadecimal character (e.g. '7' or 'C') and returns
325 * the integer equivalent.
326 */
327static inline u8 h2i(char p)
328{
329	if ((p >= '0') && (p <= '9'))
330		return p - '0';
331
332	if ((p >= 'A') && (p <= 'F'))
333		return (p - 'A') + 10;
334
335	if ((p >= 'a') && (p <= 'f'))
336		return (p - 'a') + 10;
337
338	return 0;
339}
340
341/**
342 * set_date - stores the build date into the EEPROM
343 *
344 * This function takes a pointer to a string in the format "YYMMDDhhmmss"
345 * (2-digit year, 2-digit month, etc), converts it to a 6-byte BCD string,
346 * and stores it in the build date field of the EEPROM local copy.
347 */
348static void set_date(const char *string)
349{
350	unsigned int i;
351
352	if (strlen(string) != 12) {
353		printf("Usage: mac date YYMMDDhhmmss\n");
354		return;
355	}
356
357	for (i = 0; i < 6; i++)
358		e.date[i] = h2i(string[2 * i]) << 4 | h2i(string[2 * i + 1]);
359
360	update_crc();
361}
362
363/**
364 * set_mac_address - stores a MAC address into the EEPROM
365 *
366 * This function takes a pointer to MAC address string
367 * (i.e."XX:XX:XX:XX:XX:XX", where "XX" is a two-digit hex number) and
368 * stores it in one of the MAC address fields of the EEPROM local copy.
369 */
370static void set_mac_address(unsigned int index, const char *string)
371{
372	char *p = (char *) string;
373	unsigned int i;
374
375	if ((index >= MAX_NUM_PORTS) || !string) {
376		printf("Usage: mac <n> XX:XX:XX:XX:XX:XX\n");
377		return;
378	}
379
380	for (i = 0; *p && (i < 6); i++) {
381		e.mac[index][i] = hextoul(p, &p);
382		if (*p == ':')
383			p++;
384	}
385
386	update_crc();
387}
388
389int do_mac(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
390{
391	char cmd;
392
393	if (argc == 1) {
394		show_eeprom();
395		return 0;
396	}
397
398	cmd = argv[1][0];
399
400	if (cmd == 'r') {
401		read_eeprom();
402		return 0;
403	}
404
405	if (cmd == 'i') {
406#ifdef CONFIG_SYS_I2C_EEPROM_NXID
407		memcpy(e.id, "NXID", sizeof(e.id));
408		e.version = cpu_to_be32(NXID_VERSION);
409#else
410		memcpy(e.id, "CCID", sizeof(e.id));
411#endif
412		update_crc();
413		return 0;
414	}
415
416	if (!is_valid) {
417		printf("Please read the EEPROM ('r') and/or set the ID ('i') first.\n");
418		return 0;
419	}
420
421	if (argc == 2) {
422		switch (cmd) {
423		case 's':	/* save */
424			prog_eeprom();
425			break;
426		default:
427			return CMD_RET_USAGE;
428		}
429
430		return 0;
431	}
432
433	/* We know we have at least one parameter  */
434
435	switch (cmd) {
436	case 'n':	/* serial number */
437		memset(e.sn, 0, sizeof(e.sn));
438		strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
439		update_crc();
440		break;
441	case 'e':	/* errata */
442#ifdef CONFIG_SYS_I2C_EEPROM_NXID
443		memset(e.errata, 0, 5);
444		strncpy((char *)e.errata, argv[2], 4);
445#else
446		e.errata[0] = argv[2][0];
447		e.errata[1] = argv[2][1];
448#endif
449		update_crc();
450		break;
451	case 'd':	/* date BCD format YYMMDDhhmmss */
452		set_date(argv[2]);
453		break;
454	case 'p':	/* MAC table size */
455		e.mac_count = hextoul(argv[2], NULL);
456		update_crc();
457		break;
458	case '0' ... '9':	/* "mac 0" through "mac 22" */
459		set_mac_address(dectoul(argv[1], NULL), argv[2]);
460		break;
461	case 'h':	/* help */
462	default:
463		return cmd_usage(cmdtp);
464	}
465
466	return 0;
467}
468
469/**
470 * mac_read_from_eeprom - read the MAC addresses from EEPROM
471 *
472 * This function reads the MAC addresses from EEPROM and sets the
473 * appropriate environment variables for each one read.
474 *
475 * The environment variables are only set if they haven't been set already.
476 * This ensures that any user-saved variables are never overwritten.
477 *
478 * This function must be called after relocation.
479 *
480 * For NXID v1 EEPROMs, we support loading and up-converting the older NXID v0
481 * format.  In a v0 EEPROM, there are only eight MAC addresses and the CRC is
482 * located at a different offset.
483 */
484int mac_read_from_eeprom(void)
485{
486	unsigned int i;
487	u32 crc, crc_offset = offsetof(struct eeprom, crc);
488	u32 *crcp; /* Pointer to the CRC in the data read from the EEPROM */
489
490	puts("EEPROM: ");
491
492	if (read_eeprom()) {
493		printf("Read failed.\n");
494		return 0;
495	}
496
497	if (!is_valid) {
498		printf("Invalid ID (%02x %02x %02x %02x)\n",
499		       e.id[0], e.id[1], e.id[2], e.id[3]);
500		return 0;
501	}
502
503#ifdef CONFIG_SYS_I2C_EEPROM_NXID
504	/*
505	 * If we've read an NXID v0 EEPROM, then we need to set the CRC offset
506	 * to where it is in v0.
507	 */
508	if (e.version == 0)
509		crc_offset = 0x72;
510#endif
511
512	crc = crc32(0, (void *)&e, crc_offset);
513	crcp = (void *)&e + crc_offset;
514	if (crc != be32_to_cpu(*crcp)) {
515		printf("CRC mismatch (%08x != %08x)\n", crc, be32_to_cpu(e.crc));
516		return 0;
517	}
518
519#ifdef CONFIG_SYS_I2C_EEPROM_NXID
520	/*
521	 * MAC address #9 in v1 occupies the same position as the CRC in v0.
522	 * Erase it so that it's not mistaken for a MAC address.  We'll
523	 * update the CRC later.
524	 */
525	if (e.version == 0)
526		memset(e.mac[8], 0xff, 6);
527#endif
528
529	for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
530		if (memcmp(&e.mac[i], "\0\0\0\0\0\0", 6) &&
531		    memcmp(&e.mac[i], "\xFF\xFF\xFF\xFF\xFF\xFF", 6)) {
532			char ethaddr[18];
533			char enetvar[9];
534
535			sprintf(ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
536				e.mac[i][0],
537				e.mac[i][1],
538				e.mac[i][2],
539				e.mac[i][3],
540				e.mac[i][4],
541				e.mac[i][5]);
542			sprintf(enetvar, i ? "eth%daddr" : "ethaddr", i);
543			/* Only initialize environment variables that are blank
544			 * (i.e. have not yet been set)
545			 */
546			if (!env_get(enetvar))
547				env_set(enetvar, ethaddr);
548		}
549	}
550
551#ifdef CONFIG_SYS_I2C_EEPROM_NXID
552	printf("%c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
553	       be32_to_cpu(e.version));
554#else
555	printf("%c%c%c%c\n", e.id[0], e.id[1], e.id[2], e.id[3]);
556#endif
557
558#ifdef CONFIG_SYS_I2C_EEPROM_NXID
559	/*
560	 * Now we need to upconvert the data into v1 format.  We do this last so
561	 * that at boot time, U-Boot will still say "NXID v0".
562	 */
563	if (e.version == 0) {
564		e.version = cpu_to_be32(NXID_VERSION);
565		update_crc();
566	}
567#endif
568
569	return 0;
570}
571
572#ifdef CONFIG_SYS_I2C_EEPROM_CCID
573
574/**
575 * get_cpu_board_revision - get the CPU board revision on 85xx boards
576 *
577 * Read the EEPROM to determine the board revision.
578 *
579 * This function is called before relocation, so we need to read a private
580 * copy of the EEPROM into a local variable on the stack.
581 *
582 * Also, we assume that CONFIG_SYS_EEPROM_BUS_NUM == CONFIG_SYS_SPD_BUS_NUM.  The global
583 * variable i2c_bus_num must be compile-time initialized to CONFIG_SYS_SPD_BUS_NUM,
584 * so that the SPD code will work.  This means that all pre-relocation I2C
585 * operations can only occur on the CONFIG_SYS_SPD_BUS_NUM bus.  So if
586 * CONFIG_SYS_EEPROM_BUS_NUM != CONFIG_SYS_SPD_BUS_NUM, then we can't read the EEPROM when
587 * this function is called.  Oh well.
588 */
589unsigned int get_cpu_board_revision(void)
590{
591	struct board_eeprom {
592		u32 id;           /* 0x00 - 0x03 EEPROM Tag 'CCID' */
593		u8 major;         /* 0x04        Board revision, major */
594		u8 minor;         /* 0x05        Board revision, minor */
595	} be;
596
597#if !CONFIG_IS_ENABLED(DM_I2C)
598	i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
599		(void *)&be, sizeof(be));
600#else
601	struct udevice *dev;
602	int ret;
603#ifdef CONFIG_SYS_EEPROM_BUS_NUM
604	ret = i2c_get_chip_for_busnum(CONFIG_SYS_EEPROM_BUS_NUM,
605				      CONFIG_SYS_I2C_EEPROM_ADDR,
606				      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
607				      &dev);
608#else
609	ret = i2c_get_chip_for_busnum(0, CONFIG_SYS_I2C_EEPROM_ADDR,
610				      CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
611				      &dev);
612#endif
613	if (!ret)
614		dm_i2c_read(dev, 0, (void *)&be, sizeof(be));
615#endif
616
617	if (be.id != (('C' << 24) | ('C' << 16) | ('I' << 8) | 'D'))
618		return MPC85XX_CPU_BOARD_REV(0, 0);
619
620	if ((be.major == 0xff) && (be.minor == 0xff))
621		return MPC85XX_CPU_BOARD_REV(0, 0);
622
623	return MPC85XX_CPU_BOARD_REV(be.major, be.minor);
624}
625#endif
626
627U_BOOT_LONGHELP(mac,
628	"[read|save|id|num|errata|date|ports|port_number]\n"
629	"mac read\n"
630	"    - read EEPROM content into memory data structure\n"
631	"mac save\n"
632	"    - save memory data structure to the EEPROM\n"
633	"mac id\n"
634	"    - program system id per hard coded value\n"
635	"mac num string\n"
636	"    - program system serial number to value string\n"
637	"mac errata string\n"
638	"    - program errata data to value string\n"
639	"mac date YYMMDDhhmmss\n"
640	"    - program date to string value YYMMDDhhmmss\n"
641	"mac ports N\n"
642	"    - program the number of network ports to integer N\n"
643	"mac X string\n"
644	"    - program MAC addr for port X [X=0,1..] to colon separated string");
645
646U_BOOT_CMD(
647	mac, 3, 1,  do_mac,
648	"display and program the system ID and MAC addresses in EEPROM",
649	mac_help_text);
650