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