1 /* 2 * (C) Copyright 2008 3 * Heiko Schocher, DENX Software Engineering, hs@denx.de. 4 * 5 * See file CREDITS for list of people who contributed to this 6 * project. 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, 21 * MA 02111-1307 USA 22 */ 23 24 #include <common.h> 25 #if defined(CONFIG_MGCOGE) || defined(CONFIG_MGCOGE2NE) 26 #include <mpc8260.h> 27 #endif 28 #include <ioports.h> 29 #include <malloc.h> 30 #include <hush.h> 31 #include <net.h> 32 #include <netdev.h> 33 #include <asm/io.h> 34 35 #if defined(CONFIG_OF_BOARD_SETUP) && defined(CONFIG_OF_LIBFDT) 36 #include <libfdt.h> 37 #endif 38 39 #include "../common/common.h" 40 #if defined(CONFIG_HARD_I2C) || defined(CONFIG_SOFT_I2C) 41 #include <i2c.h> 42 43 static void i2c_write_start_seq(void); 44 static int i2c_make_abort(void); 45 46 int ivm_calc_crc(unsigned char *buf, int len) 47 { 48 const unsigned short crc_tab[16] = { 49 0x0000, 0xCC01, 0xD801, 0x1400, 50 0xF001, 0x3C00, 0x2800, 0xE401, 51 0xA001, 0x6C00, 0x7800, 0xB401, 52 0x5000, 0x9C01, 0x8801, 0x4400}; 53 54 unsigned short crc = 0; /* final result */ 55 unsigned short r1 = 0; /* temp */ 56 unsigned char byte = 0; /* input buffer */ 57 int i; 58 59 /* calculate CRC from array data */ 60 for (i = 0; i < len; i++) { 61 byte = buf[i]; 62 63 /* lower 4 bits */ 64 r1 = crc_tab[crc & 0xF]; 65 crc = ((crc) >> 4) & 0x0FFF; 66 crc = crc ^ r1 ^ crc_tab[byte & 0xF]; 67 68 /* upper 4 bits */ 69 r1 = crc_tab[crc & 0xF]; 70 crc = (crc >> 4) & 0x0FFF; 71 crc = crc ^ r1 ^ crc_tab[(byte >> 4) & 0xF]; 72 } 73 return crc; 74 } 75 76 static int ivm_set_value(char *name, char *value) 77 { 78 char tempbuf[256]; 79 80 if (value != NULL) { 81 sprintf(tempbuf, "%s=%s", name, value); 82 return set_local_var(tempbuf, 0); 83 } else { 84 unset_local_var(name); 85 } 86 return 0; 87 } 88 89 static int ivm_get_value(unsigned char *buf, int len, char *name, int off, 90 int check) 91 { 92 unsigned short val; 93 unsigned char valbuf[30]; 94 95 if ((buf[off + 0] != buf[off + 2]) && 96 (buf[off + 2] != buf[off + 4])) { 97 printf("%s Error corrupted %s\n", __func__, name); 98 val = -1; 99 } else { 100 val = buf[off + 0] + (buf[off + 1] << 8); 101 if ((val == 0) && (check == 1)) 102 val = -1; 103 } 104 sprintf((char *)valbuf, "%x", val); 105 ivm_set_value(name, (char *)valbuf); 106 return val; 107 } 108 109 #define INV_BLOCKSIZE 0x100 110 #define INV_DATAADDRESS 0x21 111 #define INVENTORYDATASIZE (INV_BLOCKSIZE - INV_DATAADDRESS - 3) 112 113 #define IVM_POS_SHORT_TEXT 0 114 #define IVM_POS_MANU_ID 1 115 #define IVM_POS_MANU_SERIAL 2 116 #define IVM_POS_PART_NUMBER 3 117 #define IVM_POS_BUILD_STATE 4 118 #define IVM_POS_SUPPLIER_PART_NUMBER 5 119 #define IVM_POS_DELIVERY_DATE 6 120 #define IVM_POS_SUPPLIER_BUILD_STATE 7 121 #define IVM_POS_CUSTOMER_ID 8 122 #define IVM_POS_CUSTOMER_PROD_ID 9 123 #define IVM_POS_HISTORY 10 124 #define IVM_POS_SYMBOL_ONLY 11 125 126 static char convert_char(char c) 127 { 128 return (c < ' ' || c > '~') ? '.' : c; 129 } 130 131 static int ivm_findinventorystring(int type, 132 unsigned char* const string, 133 unsigned long maxlen, 134 unsigned char *buf) 135 { 136 int xcode = 0; 137 unsigned long cr = 0; 138 unsigned long addr = INV_DATAADDRESS; 139 unsigned long size = 0; 140 unsigned long nr = type; 141 int stop = 0; /* stop on semicolon */ 142 143 memset(string, '\0', maxlen); 144 switch (type) { 145 case IVM_POS_SYMBOL_ONLY: 146 nr = 0; 147 stop= 1; 148 break; 149 default: 150 nr = type; 151 stop = 0; 152 } 153 154 /* Look for the requested number of CR. */ 155 while ((cr != nr) && (addr < INVENTORYDATASIZE)) { 156 if ((buf[addr] == '\r')) { 157 cr++; 158 } 159 addr++; 160 } 161 162 /* 163 * the expected number of CR was found until the end of the IVM 164 * content --> fill string 165 */ 166 if (addr < INVENTORYDATASIZE) { 167 /* Copy the IVM string in the corresponding string */ 168 for (; (buf[addr] != '\r') && 169 ((buf[addr] != ';') || (!stop)) && 170 (size < (maxlen - 1) && 171 (addr < INVENTORYDATASIZE)); addr++) 172 { 173 size += sprintf((char *)string + size, "%c", 174 convert_char (buf[addr])); 175 } 176 177 /* 178 * copy phase is done: check if everything is ok. If not, 179 * the inventory data is most probably corrupted: tell 180 * the world there is a problem! 181 */ 182 if (addr == INVENTORYDATASIZE) { 183 xcode = -1; 184 printf("Error end of string not found\n"); 185 } else if ((size >= (maxlen - 1)) && 186 (buf[addr] != '\r')) { 187 xcode = -1; 188 printf("string too long till next CR\n"); 189 } 190 } else { 191 /* 192 * some CR are missing... 193 * the inventory data is most probably corrupted 194 */ 195 xcode = -1; 196 printf("not enough cr found\n"); 197 } 198 return xcode; 199 } 200 201 #define GET_STRING(name, which, len) \ 202 if (ivm_findinventorystring(which, valbuf, len, buf) == 0) { \ 203 ivm_set_value(name, (char *)valbuf); \ 204 } 205 206 static int ivm_check_crc(unsigned char *buf, int block) 207 { 208 unsigned long crc; 209 unsigned long crceeprom; 210 211 crc = ivm_calc_crc(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 2); 212 crceeprom = (buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 1] + \ 213 buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 2] * 256); 214 if (crc != crceeprom) { 215 if (block == 0) 216 printf("Error CRC Block: %d EEprom: calculated: \ 217 %lx EEprom: %lx\n", block, crc, crceeprom); 218 return -1; 219 } 220 return 0; 221 } 222 223 static int ivm_analyze_block2(unsigned char *buf, int len) 224 { 225 unsigned char valbuf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN]; 226 unsigned long count; 227 228 /* IVM_MacAddress */ 229 sprintf((char *)valbuf, "%pM", buf); 230 ivm_set_value("IVM_MacAddress", (char *)valbuf); 231 if (getenv("ethaddr") == NULL) 232 setenv((char *)"ethaddr", (char *)valbuf); 233 /* IVM_MacCount */ 234 count = (buf[10] << 24) + 235 (buf[11] << 16) + 236 (buf[12] << 8) + 237 buf[13]; 238 if (count == 0xffffffff) 239 count = 1; 240 sprintf((char *)valbuf, "%lx", count); 241 ivm_set_value("IVM_MacCount", (char *)valbuf); 242 return 0; 243 } 244 245 int ivm_analyze_eeprom(unsigned char *buf, int len) 246 { 247 unsigned short val; 248 unsigned char valbuf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN]; 249 unsigned char *tmp; 250 251 if (ivm_check_crc(buf, 0) != 0) 252 return -1; 253 254 ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN, 255 "IVM_BoardId", 0, 1); 256 val = ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN, 257 "IVM_HWKey", 6, 1); 258 if (val != 0xffff) { 259 sprintf((char *)valbuf, "%x", ((val / 100) % 10)); 260 ivm_set_value("IVM_HWVariant", (char *)valbuf); 261 sprintf((char *)valbuf, "%x", (val % 100)); 262 ivm_set_value("IVM_HWVersion", (char *)valbuf); 263 } 264 ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN, 265 "IVM_Functions", 12, 0); 266 267 GET_STRING("IVM_Symbol", IVM_POS_SYMBOL_ONLY, 8) 268 GET_STRING("IVM_DeviceName", IVM_POS_SHORT_TEXT, 64) 269 tmp = (unsigned char *) getenv("IVM_DeviceName"); 270 if (tmp) { 271 int len = strlen((char *)tmp); 272 int i = 0; 273 274 while (i < len) { 275 if (tmp[i] == ';') { 276 ivm_set_value("IVM_ShortText", 277 (char *)&tmp[i + 1]); 278 break; 279 } 280 i++; 281 } 282 if (i >= len) 283 ivm_set_value("IVM_ShortText", NULL); 284 } else { 285 ivm_set_value("IVM_ShortText", NULL); 286 } 287 GET_STRING("IVM_ManufacturerID", IVM_POS_MANU_ID, 32) 288 GET_STRING("IVM_ManufacturerSerialNumber", IVM_POS_MANU_SERIAL, 20) 289 GET_STRING("IVM_ManufacturerPartNumber", IVM_POS_PART_NUMBER, 32) 290 GET_STRING("IVM_ManufacturerBuildState", IVM_POS_BUILD_STATE, 32) 291 GET_STRING("IVM_SupplierPartNumber", IVM_POS_SUPPLIER_PART_NUMBER, 32) 292 GET_STRING("IVM_DelieveryDate", IVM_POS_DELIVERY_DATE, 32) 293 GET_STRING("IVM_SupplierBuildState", IVM_POS_SUPPLIER_BUILD_STATE, 32) 294 GET_STRING("IVM_CustomerID", IVM_POS_CUSTOMER_ID, 32) 295 GET_STRING("IVM_CustomerProductID", IVM_POS_CUSTOMER_PROD_ID, 32) 296 297 if (ivm_check_crc(&buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN * 2], 2) != 0) 298 return 0; 299 ivm_analyze_block2(&buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN * 2], 300 CONFIG_SYS_IVM_EEPROM_PAGE_LEN); 301 302 return 0; 303 } 304 305 int ivm_read_eeprom(void) 306 { 307 #if defined(CONFIG_I2C_MUX) 308 I2C_MUX_DEVICE *dev = NULL; 309 #endif 310 uchar i2c_buffer[CONFIG_SYS_IVM_EEPROM_MAX_LEN]; 311 uchar *buf; 312 unsigned dev_addr = CONFIG_SYS_IVM_EEPROM_ADR; 313 int ret; 314 315 #if defined(CONFIG_I2C_MUX) 316 /* First init the Bus, select the Bus */ 317 #if defined(CONFIG_SYS_I2C_IVM_BUS) 318 dev = i2c_mux_ident_muxstring((uchar *)CONFIG_SYS_I2C_IVM_BUS); 319 #else 320 buf = (unsigned char *) getenv("EEprom_ivm"); 321 if (buf != NULL) 322 dev = i2c_mux_ident_muxstring(buf); 323 #endif 324 if (dev == NULL) { 325 printf("Error couldnt add Bus for IVM\n"); 326 return -1; 327 } 328 i2c_set_bus_num(dev->busid); 329 #endif 330 331 buf = (unsigned char *) getenv("EEprom_ivm_addr"); 332 if (buf != NULL) 333 dev_addr = simple_strtoul((char *)buf, NULL, 16); 334 335 /* add deblocking here */ 336 i2c_make_abort(); 337 338 ret = i2c_read(dev_addr, 0, 1, i2c_buffer, 339 CONFIG_SYS_IVM_EEPROM_MAX_LEN); 340 if (ret != 0) { 341 printf ("Error reading EEprom\n"); 342 return -2; 343 } 344 345 return ivm_analyze_eeprom(i2c_buffer, CONFIG_SYS_IVM_EEPROM_MAX_LEN); 346 } 347 348 #if defined(CONFIG_SYS_I2C_INIT_BOARD) 349 #define DELAY_ABORT_SEQ 62 /* @200kHz 9 clocks = 44us, 62us is ok */ 350 #define DELAY_HALF_PERIOD (500 / (CONFIG_SYS_I2C_SPEED / 1000)) 351 352 #if defined(CONFIG_MGCOGE) || defined(CONFIG_MGCOGE2NE) 353 #define SDA_MASK 0x00010000 354 #define SCL_MASK 0x00020000 355 static void set_pin(int state, unsigned long mask) 356 { 357 ioport_t *iop = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 3); 358 359 if (state) 360 setbits_be32(&iop->pdat, mask); 361 else 362 clrbits_be32(&iop->pdat, mask); 363 364 setbits_be32(&iop->pdir, mask); 365 } 366 367 static int get_pin(unsigned long mask) 368 { 369 ioport_t *iop = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 3); 370 371 clrbits_be32(&iop->pdir, mask); 372 return 0 != (in_be32(&iop->pdat) & mask); 373 } 374 375 static void set_sda(int state) 376 { 377 set_pin(state, SDA_MASK); 378 } 379 380 static void set_scl(int state) 381 { 382 set_pin(state, SCL_MASK); 383 } 384 385 static int get_sda(void) 386 { 387 return get_pin(SDA_MASK); 388 } 389 390 static int get_scl(void) 391 { 392 return get_pin(SCL_MASK); 393 } 394 395 #if defined(CONFIG_HARD_I2C) 396 static void setports(int gpio) 397 { 398 ioport_t *iop = ioport_addr((immap_t *)CONFIG_SYS_IMMR, 3); 399 400 if (gpio) { 401 clrbits_be32(&iop->ppar, (SDA_MASK | SCL_MASK)); 402 clrbits_be32(&iop->podr, (SDA_MASK | SCL_MASK)); 403 } else { 404 setbits_be32(&iop->ppar, (SDA_MASK | SCL_MASK)); 405 clrbits_be32(&iop->pdir, (SDA_MASK | SCL_MASK)); 406 setbits_be32(&iop->podr, (SDA_MASK | SCL_MASK)); 407 } 408 } 409 #endif 410 #endif 411 412 #if !defined(CONFIG_MPC83xx) 413 static void i2c_write_start_seq(void) 414 { 415 set_sda(1); 416 udelay(DELAY_HALF_PERIOD); 417 set_scl(1); 418 udelay(DELAY_HALF_PERIOD); 419 set_sda(0); 420 udelay(DELAY_HALF_PERIOD); 421 set_scl(0); 422 udelay(DELAY_HALF_PERIOD); 423 } 424 425 /* 426 * I2C is a synchronous protocol and resets of the processor in the middle 427 * of an access can block the I2C Bus until a powerdown of the full unit is 428 * done. This function toggles the SCL until the SCL and SCA line are 429 * released, but max. 16 times, after this a I2C start-sequence is sent. 430 * This I2C Deblocking mechanism was developed by Keymile in association 431 * with Anatech and Atmel in 1998. 432 */ 433 static int i2c_make_abort(void) 434 { 435 436 #if defined(CONFIG_HARD_I2C) && !defined(MACH_TYPE_KM_KIRKWOOD) 437 immap_t *immap = (immap_t *)CONFIG_SYS_IMMR ; 438 i2c8260_t *i2c = (i2c8260_t *)&immap->im_i2c; 439 440 /* 441 * disable I2C controller first, otherwhise it thinks we want to 442 * talk to the slave port... 443 */ 444 clrbits_8(&i2c->i2c_i2mod, 0x01); 445 446 /* Set the PortPins to GPIO */ 447 setports(1); 448 #endif 449 450 int scl_state = 0; 451 int sda_state = 0; 452 int i = 0; 453 int ret = 0; 454 455 if (!get_sda()) { 456 ret = -1; 457 while (i < 16) { 458 i++; 459 set_scl(0); 460 udelay(DELAY_ABORT_SEQ); 461 set_scl(1); 462 udelay(DELAY_ABORT_SEQ); 463 scl_state = get_scl(); 464 sda_state = get_sda(); 465 if (scl_state && sda_state) { 466 ret = 0; 467 break; 468 } 469 } 470 } 471 if (ret == 0) 472 for (i = 0; i < 5; i++) 473 i2c_write_start_seq(); 474 475 /* respect stop setup time */ 476 udelay(DELAY_ABORT_SEQ); 477 set_scl(1); 478 udelay(DELAY_ABORT_SEQ); 479 set_sda(1); 480 get_sda(); 481 482 #if defined(CONFIG_HARD_I2C) 483 /* Set the PortPins back to use for I2C */ 484 setports(0); 485 #endif 486 return ret; 487 } 488 #endif 489 490 #if defined(CONFIG_MPC83xx) 491 static void i2c_write_start_seq(void) 492 { 493 struct fsl_i2c *dev; 494 dev = (struct fsl_i2c *) (CONFIG_SYS_IMMR + CONFIG_SYS_I2C_OFFSET); 495 udelay(DELAY_ABORT_SEQ); 496 out_8(&dev->cr, (I2C_CR_MEN | I2C_CR_MSTA)); 497 udelay(DELAY_ABORT_SEQ); 498 out_8(&dev->cr, (I2C_CR_MEN)); 499 } 500 501 static int i2c_make_abort(void) 502 { 503 struct fsl_i2c *dev; 504 dev = (struct fsl_i2c *) (CONFIG_SYS_IMMR + CONFIG_SYS_I2C_OFFSET); 505 uchar dummy; 506 uchar last; 507 int nbr_read = 0; 508 int i = 0; 509 int ret = 0; 510 511 /* wait after each operation to finsh with a delay */ 512 out_8(&dev->cr, (I2C_CR_MSTA)); 513 udelay(DELAY_ABORT_SEQ); 514 out_8(&dev->cr, (I2C_CR_MEN | I2C_CR_MSTA)); 515 udelay(DELAY_ABORT_SEQ); 516 dummy = in_8(&dev->dr); 517 udelay(DELAY_ABORT_SEQ); 518 last = in_8(&dev->dr); 519 nbr_read++; 520 521 /* 522 * do read until the last bit is 1, but stop if the full eeprom is 523 * read. 524 */ 525 while (((last & 0x01) != 0x01) && 526 (nbr_read < CONFIG_SYS_IVM_EEPROM_MAX_LEN)) { 527 udelay(DELAY_ABORT_SEQ); 528 last = in_8(&dev->dr); 529 nbr_read++; 530 } 531 if ((last & 0x01) != 0x01) 532 ret = -2; 533 if ((last != 0xff) || (nbr_read > 1)) 534 printf("[INFO] i2c abort after %d bytes (0x%02x)\n", 535 nbr_read, last); 536 udelay(DELAY_ABORT_SEQ); 537 out_8(&dev->cr, (I2C_CR_MEN)); 538 udelay(DELAY_ABORT_SEQ); 539 /* clear status reg */ 540 out_8(&dev->sr, 0); 541 542 for (i = 0; i < 5; i++) 543 i2c_write_start_seq(); 544 if (ret != 0) 545 printf("[ERROR] i2c abort failed after %d bytes (0x%02x)\n", 546 nbr_read, last); 547 548 return ret; 549 } 550 #endif 551 552 /** 553 * i2c_init_board - reset i2c bus. When the board is powercycled during a 554 * bus transfer it might hang; for details see doc/I2C_Edge_Conditions. 555 */ 556 void i2c_init_board(void) 557 { 558 /* Now run the AbortSequence() */ 559 i2c_make_abort(); 560 } 561 #endif 562 #endif 563 564 #if defined(CONFIG_OF_BOARD_SETUP) && defined(CONFIG_OF_LIBFDT) 565 int fdt_set_node_and_value(void *blob, 566 char *nodename, 567 char *regname, 568 void *var, 569 int size) 570 { 571 int ret = 0; 572 int nodeoffset = 0; 573 574 nodeoffset = fdt_path_offset(blob, nodename); 575 if (nodeoffset >= 0) { 576 ret = fdt_setprop(blob, nodeoffset, regname, var, 577 size); 578 if (ret < 0) 579 printf("ft_blob_update(): cannot set %s/%s " 580 "property err:%s\n", nodename, regname, 581 fdt_strerror(ret)); 582 } else { 583 printf("ft_blob_update(): cannot find %s node " 584 "err:%s\n", nodename, fdt_strerror(nodeoffset)); 585 } 586 return ret; 587 } 588 589 int fdt_get_node_and_value(void *blob, 590 char *nodename, 591 char *propname, 592 void **var) 593 { 594 int len; 595 int nodeoffset = 0; 596 597 nodeoffset = fdt_path_offset(blob, nodename); 598 if (nodeoffset >= 0) { 599 *var = (void *)fdt_getprop(blob, nodeoffset, propname, &len); 600 if (len == 0) { 601 /* no value */ 602 printf("%s no value\n", __func__); 603 return -1; 604 } else if (len > 0) { 605 return len; 606 } else { 607 printf("libfdt fdt_getprop(): %s\n", 608 fdt_strerror(len)); 609 return -2; 610 } 611 } else { 612 printf("%s: cannot find %s node err:%s\n", __func__, 613 nodename, fdt_strerror(nodeoffset)); 614 return -3; 615 } 616 } 617 #endif 618 619 #if !defined(MACH_TYPE_KM_KIRKWOOD) 620 int ethernet_present(void) 621 { 622 struct km_bec_fpga *base = 623 (struct km_bec_fpga *)CONFIG_SYS_KMBEC_FPGA_BASE; 624 625 return in_8(&base->bprth) & PIGGY_PRESENT; 626 } 627 #endif 628 629 int board_eth_init(bd_t *bis) 630 { 631 #ifdef CONFIG_KEYMILE_HDLC_ENET 632 (void)keymile_hdlc_enet_initialize(bis); 633 #endif 634 if (ethernet_present()) 635 return cpu_eth_init(bis); 636 637 return -1; 638 } 639