blob: 29aa778dbeca4524788d982b517f74ce1d160b66 [file] [log] [blame]
Haiying Wangbea3f282006-07-12 10:48:05 -04001/*
Timur Tabif098c9c2011-02-09 02:00:09 +00002 * Copyright 2006, 2008-2009, 2011 Freescale Semiconductor
Haiying Wangbea3f282006-07-12 10:48:05 -04003 * York Sun (yorksun@freescale.com)
4 * Haiying Wang (haiying.wang@freescale.com)
Timur Tabie2d31fb2008-06-19 17:56:11 -05005 * Timur Tabi (timur@freescale.com)
Haiying Wangbea3f282006-07-12 10:48:05 -04006 *
Wolfgang Denk1a459662013-07-08 09:37:19 +02007 * SPDX-License-Identifier: GPL-2.0+
Haiying Wangbea3f282006-07-12 10:48:05 -04008 */
9
10#include <common.h>
11#include <command.h>
12#include <i2c.h>
13#include <linux/ctype.h>
14
Timur Tabibfb70712010-09-30 15:36:50 -050015#ifdef CONFIG_SYS_I2C_EEPROM_CCID
Timur Tabie2d31fb2008-06-19 17:56:11 -050016#include "../common/eeprom.h"
Timur Tabibfb70712010-09-30 15:36:50 -050017#define MAX_NUM_PORTS 8
Timur Tabie2d31fb2008-06-19 17:56:11 -050018#endif
Haiying Wangbea3f282006-07-12 10:48:05 -040019
Timur Tabibfb70712010-09-30 15:36:50 -050020#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Shengzhou Liu5536aeb2013-09-13 14:46:01 +080021/* some boards with non-256-bytes EEPROM have special define */
22/* for MAX_NUM_PORTS in board-specific file */
23#ifndef MAX_NUM_PORTS
Ebony Zhu477c8942014-04-25 18:38:44 -050024#define MAX_NUM_PORTS 16
Shengzhou Liu5536aeb2013-09-13 14:46:01 +080025#endif
Timur Tabibfb70712010-09-30 15:36:50 -050026#define NXID_VERSION 1
27#endif
Haiying Wang9a611082009-06-04 16:12:40 -040028
Timur Tabie2d31fb2008-06-19 17:56:11 -050029/**
30 * static eeprom: EEPROM layout for CCID or NXID formats
31 *
32 * See application note AN3638 for details.
33 */
34static struct __attribute__ ((__packed__)) eeprom {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020035#ifdef CONFIG_SYS_I2C_EEPROM_CCID
Timur Tabie2d31fb2008-06-19 17:56:11 -050036 u8 id[4]; /* 0x00 - 0x03 EEPROM Tag 'CCID' */
37 u8 major; /* 0x04 Board revision, major */
38 u8 minor; /* 0x05 Board revision, minor */
39 u8 sn[10]; /* 0x06 - 0x0F Serial Number*/
40 u8 errata[2]; /* 0x10 - 0x11 Errata Level */
41 u8 date[6]; /* 0x12 - 0x17 Build Date */
42 u8 res_0[40]; /* 0x18 - 0x3f Reserved */
43 u8 mac_count; /* 0x40 Number of MAC addresses */
44 u8 mac_flag; /* 0x41 MAC table flags */
Haiying Wang9a611082009-06-04 16:12:40 -040045 u8 mac[MAX_NUM_PORTS][6]; /* 0x42 - 0x71 MAC addresses */
Timur Tabie2d31fb2008-06-19 17:56:11 -050046 u32 crc; /* 0x72 CRC32 checksum */
47#endif
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020048#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -050049 u8 id[4]; /* 0x00 - 0x03 EEPROM Tag 'NXID' */
50 u8 sn[12]; /* 0x04 - 0x0F Serial Number */
51 u8 errata[5]; /* 0x10 - 0x14 Errata Level */
52 u8 date[6]; /* 0x15 - 0x1a Build Date */
53 u8 res_0; /* 0x1b Reserved */
54 u32 version; /* 0x1c - 0x1f NXID Version */
55 u8 tempcal[8]; /* 0x20 - 0x27 Temperature Calibration Factors */
56 u8 tempcalsys[2]; /* 0x28 - 0x29 System Temperature Calibration Factors */
57 u8 tempcalflags; /* 0x2a Temperature Calibration Flags */
58 u8 res_1[21]; /* 0x2b - 0x3f Reserved */
59 u8 mac_count; /* 0x40 Number of MAC addresses */
60 u8 mac_flag; /* 0x41 MAC table flags */
Ebony Zhu477c8942014-04-25 18:38:44 -050061 u8 mac[MAX_NUM_PORTS][6]; /* 0x42 - 0xa1 MAC addresses */
62 u8 res_2[90]; /* 0xa2 - 0xfb Reserved */
63 u32 crc; /* 0xfc - 0xff CRC32 checksum */
Timur Tabie2d31fb2008-06-19 17:56:11 -050064#endif
65} e;
66
67/* Set to 1 if we've read EEPROM into memory */
68static int has_been_read = 0;
69
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020070#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -050071/* Is this a valid NXID EEPROM? */
Kumar Galaafb0b1312009-07-03 12:45:44 -050072#define is_valid ((e.id[0] == 'N') || (e.id[1] == 'X') || \
73 (e.id[2] == 'I') || (e.id[3] == 'D'))
Timur Tabie2d31fb2008-06-19 17:56:11 -050074#endif
75
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020076#ifdef CONFIG_SYS_I2C_EEPROM_CCID
Timur Tabie2d31fb2008-06-19 17:56:11 -050077/* Is this a valid CCID EEPROM? */
Kumar Galaafb0b1312009-07-03 12:45:44 -050078#define is_valid ((e.id[0] == 'C') || (e.id[1] == 'C') || \
79 (e.id[2] == 'I') || (e.id[3] == 'D'))
Timur Tabie2d31fb2008-06-19 17:56:11 -050080#endif
81
82/**
83 * show_eeprom - display the contents of the EEPROM
84 */
85static void show_eeprom(void)
Haiying Wangbea3f282006-07-12 10:48:05 -040086{
87 int i;
Timur Tabie2d31fb2008-06-19 17:56:11 -050088 unsigned int crc;
Haiying Wangbea3f282006-07-12 10:48:05 -040089
Timur Tabie2d31fb2008-06-19 17:56:11 -050090 /* EEPROM tag ID, either CCID or NXID */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020091#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -050092 printf("ID: %c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
Jaiprakash Singhb8baf462015-05-28 14:54:03 +053093 be32_to_cpu(e.version));
Timur Tabie2d31fb2008-06-19 17:56:11 -050094#else
95 printf("ID: %c%c%c%c\n", e.id[0], e.id[1], e.id[2], e.id[3]);
96#endif
Haiying Wangd59feff2008-01-16 17:12:12 -050097
Timur Tabie2d31fb2008-06-19 17:56:11 -050098 /* Serial number */
99 printf("SN: %s\n", e.sn);
Haiying Wangd59feff2008-01-16 17:12:12 -0500100
Timur Tabie2d31fb2008-06-19 17:56:11 -0500101 /* Errata level. */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200102#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -0500103 printf("Errata: %s\n", e.errata);
104#else
105 printf("Errata: %c%c\n",
106 e.errata[0] ? e.errata[0] : '.',
107 e.errata[1] ? e.errata[1] : '.');
108#endif
Haiying Wangd59feff2008-01-16 17:12:12 -0500109
Timur Tabie2d31fb2008-06-19 17:56:11 -0500110 /* Build date, BCD date values, as YYMMDDhhmmss */
111 printf("Build date: 20%02x/%02x/%02x %02x:%02x:%02x %s\n",
112 e.date[0], e.date[1], e.date[2],
113 e.date[3] & 0x7F, e.date[4], e.date[5],
114 e.date[3] & 0x80 ? "PM" : "");
Haiying Wangd59feff2008-01-16 17:12:12 -0500115
Timur Tabie2d31fb2008-06-19 17:56:11 -0500116 /* Show MAC addresses */
Masahiro Yamadab4141192014-11-07 03:03:31 +0900117 for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
Haiying Wang9a611082009-06-04 16:12:40 -0400118
Timur Tabie2d31fb2008-06-19 17:56:11 -0500119 u8 *p = e.mac[i];
120
121 printf("Eth%u: %02x:%02x:%02x:%02x:%02x:%02x\n", i,
122 p[0], p[1], p[2], p[3], p[4], p[5]);
123 }
124
125 crc = crc32(0, (void *)&e, sizeof(e) - 4);
126
127 if (crc == be32_to_cpu(e.crc))
128 printf("CRC: %08x\n", be32_to_cpu(e.crc));
Haiying Wangd59feff2008-01-16 17:12:12 -0500129 else
Timur Tabie2d31fb2008-06-19 17:56:11 -0500130 printf("CRC: %08x (should be %08x)\n",
131 be32_to_cpu(e.crc), crc);
Haiying Wangd59feff2008-01-16 17:12:12 -0500132
Timur Tabie2d31fb2008-06-19 17:56:11 -0500133#ifdef DEBUG
134 printf("EEPROM dump: (0x%x bytes)\n", sizeof(e));
135 for (i = 0; i < sizeof(e); i++) {
136 if ((i % 16) == 0)
137 printf("%02X: ", i);
138 printf("%02X ", ((u8 *)&e)[i]);
139 if (((i % 16) == 15) || (i == sizeof(e) - 1))
140 printf("\n");
Haiying Wangd59feff2008-01-16 17:12:12 -0500141 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500142#endif
Haiying Wangbea3f282006-07-12 10:48:05 -0400143}
144
Timur Tabie2d31fb2008-06-19 17:56:11 -0500145/**
146 * read_eeprom - read the EEPROM into memory
147 */
148static int read_eeprom(void)
Haiying Wangbea3f282006-07-12 10:48:05 -0400149{
Timur Tabie2d31fb2008-06-19 17:56:11 -0500150 int ret;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200151#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500152 unsigned int bus;
153#endif
Haiying Wangbea3f282006-07-12 10:48:05 -0400154
Timur Tabie2d31fb2008-06-19 17:56:11 -0500155 if (has_been_read)
156 return 0;
Haiying Wangbea3f282006-07-12 10:48:05 -0400157
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200158#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500159 bus = i2c_get_bus_num();
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200160 i2c_set_bus_num(CONFIG_SYS_EEPROM_BUS_NUM);
Timur Tabie2d31fb2008-06-19 17:56:11 -0500161#endif
162
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200163 ret = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
Timur Tabie2d31fb2008-06-19 17:56:11 -0500164 (void *)&e, sizeof(e));
165
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200166#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500167 i2c_set_bus_num(bus);
168#endif
169
170#ifdef DEBUG
171 show_eeprom();
172#endif
173
174 has_been_read = (ret == 0) ? 1 : 0;
175
176 return ret;
Haiying Wangbea3f282006-07-12 10:48:05 -0400177}
178
Timur Tabie2d31fb2008-06-19 17:56:11 -0500179/**
Timur Tabi2d04db02009-08-28 16:56:45 -0500180 * update_crc - update the CRC
181 *
182 * This function should be called after each update to the EEPROM structure,
183 * to make sure the CRC is always correct.
184 */
185static void update_crc(void)
186{
187 u32 crc;
188
189 crc = crc32(0, (void *)&e, sizeof(e) - 4);
190 e.crc = cpu_to_be32(crc);
191}
192
193/**
Timur Tabie2d31fb2008-06-19 17:56:11 -0500194 * prog_eeprom - write the EEPROM from memory
195 */
196static int prog_eeprom(void)
Haiying Wangbea3f282006-07-12 10:48:05 -0400197{
Timur Tabi3addcb92010-08-02 13:03:23 -0500198 int ret = 0;
Anton Vorontsov9c671e72009-09-02 02:17:24 +0400199 int i;
Timur Tabie2d31fb2008-06-19 17:56:11 -0500200 void *p;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200201#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500202 unsigned int bus;
203#endif
Haiying Wangbea3f282006-07-12 10:48:05 -0400204
Timur Tabie2d31fb2008-06-19 17:56:11 -0500205 /* Set the reserved values to 0xFF */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200206#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -0500207 e.res_0 = 0xFF;
208 memset(e.res_1, 0xFF, sizeof(e.res_1));
209#else
210 memset(e.res_0, 0xFF, sizeof(e.res_0));
211#endif
Timur Tabi2d04db02009-08-28 16:56:45 -0500212 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500213
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200214#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500215 bus = i2c_get_bus_num();
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200216 i2c_set_bus_num(CONFIG_SYS_EEPROM_BUS_NUM);
Timur Tabie2d31fb2008-06-19 17:56:11 -0500217#endif
218
Timur Tabi3addcb92010-08-02 13:03:23 -0500219 /*
220 * The AT24C02 datasheet says that data can only be written in page
221 * mode, which means 8 bytes at a time, and it takes up to 5ms to
222 * complete a given write.
223 */
Timur Tabi2d04db02009-08-28 16:56:45 -0500224 for (i = 0, p = &e; i < sizeof(e); i += 8, p += 8) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200225 ret = i2c_write(CONFIG_SYS_I2C_EEPROM_ADDR, i, CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
Masahiro Yamadab4141192014-11-07 03:03:31 +0900226 p, min((int)(sizeof(e) - i), 8));
Haiying Wangbea3f282006-07-12 10:48:05 -0400227 if (ret)
228 break;
Timur Tabie2d31fb2008-06-19 17:56:11 -0500229 udelay(5000); /* 5ms write cycle timing */
Haiying Wangbea3f282006-07-12 10:48:05 -0400230 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500231
Timur Tabi3addcb92010-08-02 13:03:23 -0500232 if (!ret) {
233 /* Verify the write by reading back the EEPROM and comparing */
234 struct eeprom e2;
235
236 ret = i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0,
237 CONFIG_SYS_I2C_EEPROM_ADDR_LEN, (void *)&e2, sizeof(e2));
238 if (!ret && memcmp(&e, &e2, sizeof(e)))
239 ret = -1;
240 }
241
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200242#ifdef CONFIG_SYS_EEPROM_BUS_NUM
Timur Tabie2d31fb2008-06-19 17:56:11 -0500243 i2c_set_bus_num(bus);
244#endif
245
Haiying Wangbea3f282006-07-12 10:48:05 -0400246 if (ret) {
247 printf("Programming failed.\n");
Timur Tabi3addcb92010-08-02 13:03:23 -0500248 has_been_read = 0;
Haiying Wangbea3f282006-07-12 10:48:05 -0400249 return -1;
Haiying Wangbea3f282006-07-12 10:48:05 -0400250 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500251
252 printf("Programming passed.\n");
Haiying Wangbea3f282006-07-12 10:48:05 -0400253 return 0;
254}
255
Timur Tabie2d31fb2008-06-19 17:56:11 -0500256/**
257 * h2i - converts hex character into a number
258 *
259 * This function takes a hexadecimal character (e.g. '7' or 'C') and returns
260 * the integer equivalent.
261 */
262static inline u8 h2i(char p)
263{
264 if ((p >= '0') && (p <= '9'))
265 return p - '0';
266
267 if ((p >= 'A') && (p <= 'F'))
268 return (p - 'A') + 10;
269
270 if ((p >= 'a') && (p <= 'f'))
271 return (p - 'a') + 10;
272
273 return 0;
274}
275
276/**
277 * set_date - stores the build date into the EEPROM
278 *
279 * This function takes a pointer to a string in the format "YYMMDDhhmmss"
280 * (2-digit year, 2-digit month, etc), converts it to a 6-byte BCD string,
281 * and stores it in the build date field of the EEPROM local copy.
282 */
283static void set_date(const char *string)
284{
285 unsigned int i;
286
287 if (strlen(string) != 12) {
288 printf("Usage: mac date YYMMDDhhmmss\n");
289 return;
290 }
291
292 for (i = 0; i < 6; i++)
293 e.date[i] = h2i(string[2 * i]) << 4 | h2i(string[2 * i + 1]);
Timur Tabi2d04db02009-08-28 16:56:45 -0500294
295 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500296}
297
298/**
299 * set_mac_address - stores a MAC address into the EEPROM
300 *
301 * This function takes a pointer to MAC address string
302 * (i.e."XX:XX:XX:XX:XX:XX", where "XX" is a two-digit hex number) and
303 * stores it in one of the MAC address fields of the EEPROM local copy.
304 */
305static void set_mac_address(unsigned int index, const char *string)
306{
307 char *p = (char *) string;
308 unsigned int i;
309
Timur Tabibfb70712010-09-30 15:36:50 -0500310 if ((index >= MAX_NUM_PORTS) || !string) {
Timur Tabie2d31fb2008-06-19 17:56:11 -0500311 printf("Usage: mac <n> XX:XX:XX:XX:XX:XX\n");
312 return;
313 }
314
315 for (i = 0; *p && (i < 6); i++) {
316 e.mac[index][i] = simple_strtoul(p, &p, 16);
317 if (*p == ':')
318 p++;
319 }
Timur Tabi2d04db02009-08-28 16:56:45 -0500320
321 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500322}
323
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200324int do_mac(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Haiying Wangbea3f282006-07-12 10:48:05 -0400325{
Timur Tabie2d31fb2008-06-19 17:56:11 -0500326 char cmd;
Haiying Wangbea3f282006-07-12 10:48:05 -0400327
Timur Tabie2d31fb2008-06-19 17:56:11 -0500328 if (argc == 1) {
329 show_eeprom();
330 return 0;
331 }
Haiying Wangbea3f282006-07-12 10:48:05 -0400332
Timur Tabie2d31fb2008-06-19 17:56:11 -0500333 cmd = argv[1][0];
334
335 if (cmd == 'r') {
336 read_eeprom();
337 return 0;
338 }
339
Timur Tabi2d04db02009-08-28 16:56:45 -0500340 if (cmd == 'i') {
341#ifdef CONFIG_SYS_I2C_EEPROM_NXID
342 memcpy(e.id, "NXID", sizeof(e.id));
Jaiprakash Singhb8baf462015-05-28 14:54:03 +0530343 e.version = cpu_to_be32(NXID_VERSION);
Timur Tabi2d04db02009-08-28 16:56:45 -0500344#else
345 memcpy(e.id, "CCID", sizeof(e.id));
346#endif
Timur Tabi3fee3342011-02-09 13:40:51 -0600347 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500348 return 0;
349 }
350
351 if (!is_valid) {
352 printf("Please read the EEPROM ('r') and/or set the ID ('i') first.\n");
353 return 0;
354 }
355
356 if (argc == 2) {
Haiying Wangbea3f282006-07-12 10:48:05 -0400357 switch (cmd) {
Jon Loeliger80e955c2006-08-22 12:25:27 -0500358 case 's': /* save */
Timur Tabie2d31fb2008-06-19 17:56:11 -0500359 prog_eeprom();
Jon Loeliger80e955c2006-08-22 12:25:27 -0500360 break;
Jon Loeliger80e955c2006-08-22 12:25:27 -0500361 default:
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200362 return cmd_usage(cmdtp);
Haiying Wangbea3f282006-07-12 10:48:05 -0400363 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500364
365 return 0;
Haiying Wangbea3f282006-07-12 10:48:05 -0400366 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500367
368 /* We know we have at least one parameter */
369
370 switch (cmd) {
371 case 'n': /* serial number */
372 memset(e.sn, 0, sizeof(e.sn));
373 strncpy((char *)e.sn, argv[2], sizeof(e.sn) - 1);
Timur Tabi2d04db02009-08-28 16:56:45 -0500374 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500375 break;
376 case 'e': /* errata */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200377#ifdef CONFIG_SYS_I2C_EEPROM_NXID
Timur Tabie2d31fb2008-06-19 17:56:11 -0500378 memset(e.errata, 0, 5);
379 strncpy((char *)e.errata, argv[2], 4);
380#else
381 e.errata[0] = argv[2][0];
382 e.errata[1] = argv[2][1];
383#endif
Timur Tabi2d04db02009-08-28 16:56:45 -0500384 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500385 break;
386 case 'd': /* date BCD format YYMMDDhhmmss */
387 set_date(argv[2]);
388 break;
389 case 'p': /* MAC table size */
390 e.mac_count = simple_strtoul(argv[2], NULL, 16);
Timur Tabi2d04db02009-08-28 16:56:45 -0500391 update_crc();
Timur Tabie2d31fb2008-06-19 17:56:11 -0500392 break;
Timur Tabibfb70712010-09-30 15:36:50 -0500393 case '0' ... '9': /* "mac 0" through "mac 22" */
394 set_mac_address(simple_strtoul(argv[1], NULL, 10), argv[2]);
Timur Tabie2d31fb2008-06-19 17:56:11 -0500395 break;
396 case 'h': /* help */
397 default:
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200398 return cmd_usage(cmdtp);
Timur Tabie2d31fb2008-06-19 17:56:11 -0500399 }
400
Haiying Wangbea3f282006-07-12 10:48:05 -0400401 return 0;
402}
403
Timur Tabie2d31fb2008-06-19 17:56:11 -0500404/**
405 * mac_read_from_eeprom - read the MAC addresses from EEPROM
406 *
407 * This function reads the MAC addresses from EEPROM and sets the
408 * appropriate environment variables for each one read.
409 *
410 * The environment variables are only set if they haven't been set already.
411 * This ensures that any user-saved variables are never overwritten.
412 *
413 * This function must be called after relocation.
Timur Tabif098c9c2011-02-09 02:00:09 +0000414 *
415 * For NXID v1 EEPROMs, we support loading and up-converting the older NXID v0
416 * format. In a v0 EEPROM, there are only eight MAC addresses and the CRC is
417 * located at a different offset.
Timur Tabie2d31fb2008-06-19 17:56:11 -0500418 */
Haiying Wangbea3f282006-07-12 10:48:05 -0400419int mac_read_from_eeprom(void)
420{
Timur Tabie2d31fb2008-06-19 17:56:11 -0500421 unsigned int i;
Timur Tabif098c9c2011-02-09 02:00:09 +0000422 u32 crc, crc_offset = offsetof(struct eeprom, crc);
423 u32 *crcp; /* Pointer to the CRC in the data read from the EEPROM */
Timur Tabi2d04db02009-08-28 16:56:45 -0500424
425 puts("EEPROM: ");
Haiying Wangbea3f282006-07-12 10:48:05 -0400426
Timur Tabie2d31fb2008-06-19 17:56:11 -0500427 if (read_eeprom()) {
Haiying Wangbea3f282006-07-12 10:48:05 -0400428 printf("Read failed.\n");
York Sunbffac7a2014-04-30 14:43:46 -0700429 return 0;
Haiying Wangbea3f282006-07-12 10:48:05 -0400430 }
431
Timur Tabie2d31fb2008-06-19 17:56:11 -0500432 if (!is_valid) {
Timur Tabi2d04db02009-08-28 16:56:45 -0500433 printf("Invalid ID (%02x %02x %02x %02x)\n",
434 e.id[0], e.id[1], e.id[2], e.id[3]);
York Sunbffac7a2014-04-30 14:43:46 -0700435 return 0;
Timur Tabie2d31fb2008-06-19 17:56:11 -0500436 }
437
Timur Tabif098c9c2011-02-09 02:00:09 +0000438#ifdef CONFIG_SYS_I2C_EEPROM_NXID
439 /*
440 * If we've read an NXID v0 EEPROM, then we need to set the CRC offset
441 * to where it is in v0.
442 */
443 if (e.version == 0)
444 crc_offset = 0x72;
445#endif
446
447 crc = crc32(0, (void *)&e, crc_offset);
448 crcp = (void *)&e + crc_offset;
449 if (crc != be32_to_cpu(*crcp)) {
Timur Tabi2d04db02009-08-28 16:56:45 -0500450 printf("CRC mismatch (%08x != %08x)\n", crc, be32_to_cpu(e.crc));
York Sunbffac7a2014-04-30 14:43:46 -0700451 return 0;
Haiying Wangbea3f282006-07-12 10:48:05 -0400452 }
Timur Tabie2d31fb2008-06-19 17:56:11 -0500453
Timur Tabif098c9c2011-02-09 02:00:09 +0000454#ifdef CONFIG_SYS_I2C_EEPROM_NXID
455 /*
456 * MAC address #9 in v1 occupies the same position as the CRC in v0.
457 * Erase it so that it's not mistaken for a MAC address. We'll
458 * update the CRC later.
459 */
460 if (e.version == 0)
461 memset(e.mac[8], 0xff, 6);
462#endif
463
Masahiro Yamadab4141192014-11-07 03:03:31 +0900464 for (i = 0; i < min(e.mac_count, (u8)MAX_NUM_PORTS); i++) {
Timur Tabie2d31fb2008-06-19 17:56:11 -0500465 if (memcmp(&e.mac[i], "\0\0\0\0\0\0", 6) &&
466 memcmp(&e.mac[i], "\xFF\xFF\xFF\xFF\xFF\xFF", 6)) {
467 char ethaddr[18];
468 char enetvar[9];
469
470 sprintf(ethaddr, "%02X:%02X:%02X:%02X:%02X:%02X",
471 e.mac[i][0],
472 e.mac[i][1],
473 e.mac[i][2],
474 e.mac[i][3],
475 e.mac[i][4],
476 e.mac[i][5]);
477 sprintf(enetvar, i ? "eth%daddr" : "ethaddr", i);
478 /* Only initialize environment variables that are blank
479 * (i.e. have not yet been set)
480 */
481 if (!getenv(enetvar))
482 setenv(enetvar, ethaddr);
483 }
484 }
485
Timur Tabi2d04db02009-08-28 16:56:45 -0500486#ifdef CONFIG_SYS_I2C_EEPROM_NXID
487 printf("%c%c%c%c v%u\n", e.id[0], e.id[1], e.id[2], e.id[3],
Jaiprakash Singhb8baf462015-05-28 14:54:03 +0530488 be32_to_cpu(e.version));
Timur Tabi2d04db02009-08-28 16:56:45 -0500489#else
490 printf("%c%c%c%c\n", e.id[0], e.id[1], e.id[2], e.id[3]);
491#endif
492
Timur Tabif098c9c2011-02-09 02:00:09 +0000493#ifdef CONFIG_SYS_I2C_EEPROM_NXID
494 /*
495 * Now we need to upconvert the data into v1 format. We do this last so
496 * that at boot time, U-Boot will still say "NXID v0".
497 */
498 if (e.version == 0) {
Jaiprakash Singhb8baf462015-05-28 14:54:03 +0530499 e.version = cpu_to_be32(NXID_VERSION);
Timur Tabif098c9c2011-02-09 02:00:09 +0000500 update_crc();
501 }
502#endif
503
Haiying Wangbea3f282006-07-12 10:48:05 -0400504 return 0;
505}
Timur Tabie2d31fb2008-06-19 17:56:11 -0500506
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200507#ifdef CONFIG_SYS_I2C_EEPROM_CCID
Timur Tabie2d31fb2008-06-19 17:56:11 -0500508
509/**
510 * get_cpu_board_revision - get the CPU board revision on 85xx boards
511 *
512 * Read the EEPROM to determine the board revision.
513 *
514 * This function is called before relocation, so we need to read a private
515 * copy of the EEPROM into a local variable on the stack.
516 *
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200517 * Also, we assume that CONFIG_SYS_EEPROM_BUS_NUM == CONFIG_SYS_SPD_BUS_NUM. The global
518 * variable i2c_bus_num must be compile-time initialized to CONFIG_SYS_SPD_BUS_NUM,
Timur Tabie2d31fb2008-06-19 17:56:11 -0500519 * so that the SPD code will work. This means that all pre-relocation I2C
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200520 * operations can only occur on the CONFIG_SYS_SPD_BUS_NUM bus. So if
521 * CONFIG_SYS_EEPROM_BUS_NUM != CONFIG_SYS_SPD_BUS_NUM, then we can't read the EEPROM when
Timur Tabie2d31fb2008-06-19 17:56:11 -0500522 * this function is called. Oh well.
523 */
524unsigned int get_cpu_board_revision(void)
525{
526 struct board_eeprom {
527 u32 id; /* 0x00 - 0x03 EEPROM Tag 'CCID' */
528 u8 major; /* 0x04 Board revision, major */
529 u8 minor; /* 0x05 Board revision, minor */
530 } be;
531
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200532 i2c_read(CONFIG_SYS_I2C_EEPROM_ADDR, 0, CONFIG_SYS_I2C_EEPROM_ADDR_LEN,
Timur Tabie2d31fb2008-06-19 17:56:11 -0500533 (void *)&be, sizeof(be));
534
535 if (be.id != (('C' << 24) | ('C' << 16) | ('I' << 8) | 'D'))
536 return MPC85XX_CPU_BOARD_REV(0, 0);
537
538 if ((be.major == 0xff) && (be.minor == 0xff))
539 return MPC85XX_CPU_BOARD_REV(0, 0);
540
Rafal Czubake46c7bf2008-10-08 13:41:30 +0200541 return MPC85XX_CPU_BOARD_REV(be.major, be.minor);
Timur Tabie2d31fb2008-06-19 17:56:11 -0500542}
Timur Tabie2d31fb2008-06-19 17:56:11 -0500543#endif