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