common/cmd_i2c.c

   1 /*
   2  * (C) Copyright 2009
   3  * Sergey Kubushyn, himself, ksi@koi8.net
   4  *
   5  * Changes for unified multibus/multiadapter I2C support.
   6  *
   7  * (C) Copyright 2001
   8  * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
   9  *
  10  * SPDX-License-Identifier:     GPL-2.0+
  11  */
  12
  13 /*
  14  * I2C Functions similar to the standard memory functions.
  15  *
  16  * There are several parameters in many of the commands that bear further
  17  * explanations:
  18  *
  19  * {i2c_chip} is the I2C chip address (the first byte sent on the bus).
  20  *   Each I2C chip on the bus has a unique address.  On the I2C data bus,
  21  *   the address is the upper seven bits and the LSB is the "read/write"
  22  *   bit.  Note that the {i2c_chip} address specified on the command
  23  *   line is not shifted up: e.g. a typical EEPROM memory chip may have
  24  *   an I2C address of 0x50, but the data put on the bus will be 0xA0
  25  *   for write and 0xA1 for read.  This "non shifted" address notation
  26  *   matches at least half of the data sheets :-/.
  27  *
  28  * {addr} is the address (or offset) within the chip.  Small memory
  29  *   chips have 8 bit addresses.  Large memory chips have 16 bit
  30  *   addresses.  Other memory chips have 9, 10, or 11 bit addresses.
  31  *   Many non-memory chips have multiple registers and {addr} is used
  32  *   as the register index.  Some non-memory chips have only one register
  33  *   and therefore don't need any {addr} parameter.
  34  *
  35  *   The default {addr} parameter is one byte (.1) which works well for
  36  *   memories and registers with 8 bits of address space.
  37  *
  38  *   You can specify the length of the {addr} field with the optional .0,
  39  *   .1, or .2 modifier (similar to the .b, .w, .l modifier).  If you are
  40  *   manipulating a single register device which doesn't use an address
  41  *   field, use "0.0" for the address and the ".0" length field will
  42  *   suppress the address in the I2C data stream.  This also works for
  43  *   successive reads using the I2C auto-incrementing memory pointer.
  44  *
  45  *   If you are manipulating a large memory with 2-byte addresses, use
  46  *   the .2 address modifier, e.g. 210.2 addresses location 528 (decimal).
  47  *
  48  *   Then there are the unfortunate memory chips that spill the most
  49  *   significant 1, 2, or 3 bits of address into the chip address byte.
  50  *   This effectively makes one chip (logically) look like 2, 4, or
  51  *   8 chips.  This is handled (awkwardly) by #defining
  52  *   CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW and using the .1 modifier on the
  53  *   {addr} field (since .1 is the default, it doesn't actually have to
  54  *   be specified).  Examples: given a memory chip at I2C chip address
  55  *   0x50, the following would happen...
  56  *     i2c md 50 0 10   display 16 bytes starting at 0x000
  57  *                      On the bus: <S> A0 00 <E> <S> A1 <rd> ... <rd>
  58  *     i2c md 50 100 10 display 16 bytes starting at 0x100
  59  *                      On the bus: <S> A2 00 <E> <S> A3 <rd> ... <rd>
  60  *     i2c md 50 210 10 display 16 bytes starting at 0x210
  61  *                      On the bus: <S> A4 10 <E> <S> A5 <rd> ... <rd>
  62  *   This is awfully ugly.  It would be nice if someone would think up
  63  *   a better way of handling this.
  64  *
  65  * Adapted from cmd_mem.c which is copyright Wolfgang Denk (wd@denx.de).
  66  */
  67
  68 #include <common.h>
  69 #include <bootretry.h>
  70 #include <cli.h>
  71 #include <command.h>
  72 #include <edid.h>
  73 #include <environment.h>
  74 #include <i2c.h>
  75 #include <malloc.h>
  76 #include <asm/byteorder.h>
  77 #include <linux/compiler.h>
  78
  79 DECLARE_GLOBAL_DATA_PTR;
  80
  81 /* Display values from last command.
  82  * Memory modify remembered values are different from display memory.
  83  */
  84 static uchar    i2c_dp_last_chip;
  85 static uint     i2c_dp_last_addr;
  86 static uint     i2c_dp_last_alen;
  87 static uint     i2c_dp_last_length = 0x10;
  88
  89 static uchar    i2c_mm_last_chip;
  90 static uint     i2c_mm_last_addr;
  91 static uint     i2c_mm_last_alen;
  92
  93 /* If only one I2C bus is present, the list of devices to ignore when
  94  * the probe command is issued is represented by a 1D array of addresses.
  95  * When multiple buses are present, the list is an array of bus-address
  96  * pairs.  The following macros take care of this */
  97
  98 #if defined(CONFIG_SYS_I2C_NOPROBES)
  99 #if defined(CONFIG_SYS_I2C) || defined(CONFIG_I2C_MULTI_BUS)
 100 static struct
 101 {
 102         uchar   bus;
 103         uchar   addr;
 104 } i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
 105 #define GET_BUS_NUM     i2c_get_bus_num()
 106 #define COMPARE_BUS(b,i)        (i2c_no_probes[(i)].bus == (b))
 107 #define COMPARE_ADDR(a,i)       (i2c_no_probes[(i)].addr == (a))
 108 #define NO_PROBE_ADDR(i)        i2c_no_probes[(i)].addr
 109 #else           /* single bus */
 110 static uchar i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
 111 #define GET_BUS_NUM     0
 112 #define COMPARE_BUS(b,i)        ((b) == 0)      /* Make compiler happy */
 113 #define COMPARE_ADDR(a,i)       (i2c_no_probes[(i)] == (a))
 114 #define NO_PROBE_ADDR(i)        i2c_no_probes[(i)]
 115 #endif  /* defined(CONFIG_SYS_I2C) */
 116 #endif
 117
 118 #define DISP_LINE_LEN   16
 119
 120 /**
 121  * i2c_init_board() - Board-specific I2C bus init
 122  *
 123  * This function is the default no-op implementation of I2C bus
 124  * initialization. This function can be overriden by board-specific
 125  * implementation if needed.
 126  */
 127 __weak
 128 void i2c_init_board(void)
 129 {
 130 }
 131
 132 /* TODO: Implement architecture-specific get/set functions */
 133
 134 /**
 135  * i2c_get_bus_speed() - Return I2C bus speed
 136  *
 137  * This function is the default implementation of function for retrieveing
 138  * the current I2C bus speed in Hz.
 139  *
 140  * A driver implementing runtime switching of I2C bus speed must override
 141  * this function to report the speed correctly. Simple or legacy drivers
 142  * can use this fallback.
 143  *
 144  * Returns I2C bus speed in Hz.
 145  */
 146 #if !defined(CONFIG_SYS_I2C)
 147 /*
 148  * TODO: Implement architecture-specific get/set functions
 149  * Should go away, if we switched completely to new multibus support
 150  */
 151 __weak
 152 unsigned int i2c_get_bus_speed(void)
 153 {
 154         return CONFIG_SYS_I2C_SPEED;
 155 }
 156
 157 /**
 158  * i2c_set_bus_speed() - Configure I2C bus speed
 159  * @speed:      Newly set speed of the I2C bus in Hz
 160  *
 161  * This function is the default implementation of function for setting
 162  * the I2C bus speed in Hz.
 163  *
 164  * A driver implementing runtime switching of I2C bus speed must override
 165  * this function to report the speed correctly. Simple or legacy drivers
 166  * can use this fallback.
 167  *
 168  * Returns zero on success, negative value on error.
 169  */
 170 __weak
 171 int i2c_set_bus_speed(unsigned int speed)
 172 {
 173         if (speed != CONFIG_SYS_I2C_SPEED)
 174                 return -1;
 175
 176         return 0;
 177 }
 178 #endif
 179
 180 /**
 181  * get_alen() - Small parser helper function to get address length
 182  *
 183  * Returns the address length.
 184  */
 185 static uint get_alen(char *arg)
 186 {
 187         int     j;
 188         int     alen;
 189
 190         alen = 1;
 191         for (j = 0; j < 8; j++) {
 192                 if (arg[j] == '.') {
 193                         alen = arg[j+1] - '0';
 194                         break;
 195                 } else if (arg[j] == '\0')
 196                         break;
 197         }
 198         return alen;
 199 }
 200
 201 enum i2c_err_op {
 202         I2C_ERR_READ,
 203         I2C_ERR_WRITE,
 204 };
 205
 206 static int i2c_report_err(int ret, enum i2c_err_op op)
 207 {
 208         printf("Error %s the chip: %d\n",
 209                op == I2C_ERR_READ ? "reading" : "writing", ret);
 210
 211         return CMD_RET_FAILURE;
 212 }
 213
 214 /**
 215  * do_i2c_read() - Handle the "i2c read" command-line command
 216  * @cmdtp:      Command data struct pointer
 217  * @flag:       Command flag
 218  * @argc:       Command-line argument count
 219  * @argv:       Array of command-line arguments
 220  *
 221  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 222  * on error.
 223  *
 224  * Syntax:
 225  *      i2c read {i2c_chip} {devaddr}{.0, .1, .2} {len} {memaddr}
 226  */
 227 static int do_i2c_read ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 228 {
 229         u_char  chip;
 230         uint    devaddr, alen, length;
 231         u_char  *memaddr;
 232
 233         if (argc != 5)
 234                 return CMD_RET_USAGE;
 235
 236         /*
 237          * I2C chip address
 238          */
 239         chip = simple_strtoul(argv[1], NULL, 16);
 240
 241         /*
 242          * I2C data address within the chip.  This can be 1 or
 243          * 2 bytes long.  Some day it might be 3 bytes long :-).
 244          */
 245         devaddr = simple_strtoul(argv[2], NULL, 16);
 246         alen = get_alen(argv[2]);
 247         if (alen > 3)
 248                 return CMD_RET_USAGE;
 249
 250         /*
 251          * Length is the number of objects, not number of bytes.
 252          */
 253         length = simple_strtoul(argv[3], NULL, 16);
 254
 255         /*
 256          * memaddr is the address where to store things in memory
 257          */
 258         memaddr = (u_char *)simple_strtoul(argv[4], NULL, 16);
 259
 260         if (i2c_read(chip, devaddr, alen, memaddr, length) != 0) {
 261                 i2c_report_err(-1, I2C_ERR_READ);
 262                 return 1;
 263         }
 264         return 0;
 265 }
 266
 267 static int do_i2c_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 268 {
 269         u_char  chip;
 270         uint    devaddr, alen, length;
 271         u_char  *memaddr;
 272
 273         if (argc != 5)
 274                 return cmd_usage(cmdtp);
 275
 276         /*
 277          * memaddr is the address where to store things in memory
 278          */
 279         memaddr = (u_char *)simple_strtoul(argv[1], NULL, 16);
 280
 281         /*
 282          * I2C chip address
 283          */
 284         chip = simple_strtoul(argv[2], NULL, 16);
 285
 286         /*
 287          * I2C data address within the chip.  This can be 1 or
 288          * 2 bytes long.  Some day it might be 3 bytes long :-).
 289          */
 290         devaddr = simple_strtoul(argv[3], NULL, 16);
 291         alen = get_alen(argv[3]);
 292         if (alen > 3)
 293                 return cmd_usage(cmdtp);
 294
 295         /*
 296          * Length is the number of objects, not number of bytes.
 297          */
 298         length = simple_strtoul(argv[4], NULL, 16);
 299
 300         while (length-- > 0) {
 301                 if (i2c_write(chip, devaddr++, alen, memaddr++, 1) != 0) {
 302                         return i2c_report_err(-1, I2C_ERR_WRITE);
 303                 }
 304 /*
 305  * No write delay with FRAM devices.
 306  */
 307 #if !defined(CONFIG_SYS_I2C_FRAM)
 308                 udelay(11000);
 309 #endif
 310         }
 311         return 0;
 312 }
 313
 314 /**
 315  * do_i2c_md() - Handle the "i2c md" command-line command
 316  * @cmdtp:      Command data struct pointer
 317  * @flag:       Command flag
 318  * @argc:       Command-line argument count
 319  * @argv:       Array of command-line arguments
 320  *
 321  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 322  * on error.
 323  *
 324  * Syntax:
 325  *      i2c md {i2c_chip} {addr}{.0, .1, .2} {len}
 326  */
 327 static int do_i2c_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 328 {
 329         u_char  chip;
 330         uint    addr, alen, length;
 331         int     j, nbytes, linebytes;
 332
 333         /* We use the last specified parameters, unless new ones are
 334          * entered.
 335          */
 336         chip   = i2c_dp_last_chip;
 337         addr   = i2c_dp_last_addr;
 338         alen   = i2c_dp_last_alen;
 339         length = i2c_dp_last_length;
 340
 341         if (argc < 3)
 342                 return CMD_RET_USAGE;
 343
 344         if ((flag & CMD_FLAG_REPEAT) == 0) {
 345                 /*
 346                  * New command specified.
 347                  */
 348
 349                 /*
 350                  * I2C chip address
 351                  */
 352                 chip = simple_strtoul(argv[1], NULL, 16);
 353
 354                 /*
 355                  * I2C data address within the chip.  This can be 1 or
 356                  * 2 bytes long.  Some day it might be 3 bytes long :-).
 357                  */
 358                 addr = simple_strtoul(argv[2], NULL, 16);
 359                 alen = get_alen(argv[2]);
 360                 if (alen > 3)
 361                         return CMD_RET_USAGE;
 362
 363                 /*
 364                  * If another parameter, it is the length to display.
 365                  * Length is the number of objects, not number of bytes.
 366                  */
 367                 if (argc > 3)
 368                         length = simple_strtoul(argv[3], NULL, 16);
 369         }
 370
 371         /*
 372          * Print the lines.
 373          *
 374          * We buffer all read data, so we can make sure data is read only
 375          * once.
 376          */
 377         nbytes = length;
 378         do {
 379                 unsigned char   linebuf[DISP_LINE_LEN];
 380                 unsigned char   *cp;
 381
 382                 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
 383
 384                 if (i2c_read(chip, addr, alen, linebuf, linebytes) != 0)
 385                         i2c_report_err(-1, I2C_ERR_READ);
 386                 else {
 387                         printf("%04x:", addr);
 388                         cp = linebuf;
 389                         for (j=0; j<linebytes; j++) {
 390                                 printf(" %02x", *cp++);
 391                                 addr++;
 392                         }
 393                         puts ("    ");
 394                         cp = linebuf;
 395                         for (j=0; j<linebytes; j++) {
 396                                 if ((*cp < 0x20) || (*cp > 0x7e))
 397                                         puts (".");
 398                                 else
 399                                         printf("%c", *cp);
 400                                 cp++;
 401                         }
 402                         putc ('\n');
 403                 }
 404                 nbytes -= linebytes;
 405         } while (nbytes > 0);
 406
 407         i2c_dp_last_chip   = chip;
 408         i2c_dp_last_addr   = addr;
 409         i2c_dp_last_alen   = alen;
 410         i2c_dp_last_length = length;
 411
 412         return 0;
 413 }
 414
 415 /**
 416  * do_i2c_mw() - Handle the "i2c mw" command-line command
 417  * @cmdtp:      Command data struct pointer
 418  * @flag:       Command flag
 419  * @argc:       Command-line argument count
 420  * @argv:       Array of command-line arguments
 421  *
 422  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 423  * on error.
 424  *
 425  * Syntax:
 426  *      i2c mw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
 427  */
 428 static int do_i2c_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 429 {
 430         uchar   chip;
 431         ulong   addr;
 432         uint    alen;
 433         uchar   byte;
 434         int     count;
 435
 436         if ((argc < 4) || (argc > 5))
 437                 return CMD_RET_USAGE;
 438
 439         /*
 440          * Chip is always specified.
 441          */
 442         chip = simple_strtoul(argv[1], NULL, 16);
 443
 444         /*
 445          * Address is always specified.
 446          */
 447         addr = simple_strtoul(argv[2], NULL, 16);
 448         alen = get_alen(argv[2]);
 449         if (alen > 3)
 450                 return CMD_RET_USAGE;
 451
 452         /*
 453          * Value to write is always specified.
 454          */
 455         byte = simple_strtoul(argv[3], NULL, 16);
 456
 457         /*
 458          * Optional count
 459          */
 460         if (argc == 5)
 461                 count = simple_strtoul(argv[4], NULL, 16);
 462         else
 463                 count = 1;
 464
 465         while (count-- > 0) {
 466                 if (i2c_write(chip, addr++, alen, &byte, 1) != 0)
 467                         i2c_report_err(-1, I2C_ERR_WRITE);
 468                 /*
 469                  * Wait for the write to complete.  The write can take
 470                  * up to 10mSec (we allow a little more time).
 471                  */
 472 /*
 473  * No write delay with FRAM devices.
 474  */
 475 #if !defined(CONFIG_SYS_I2C_FRAM)
 476                 udelay(11000);
 477 #endif
 478         }
 479
 480         return 0;
 481 }
 482
 483 /**
 484  * do_i2c_crc() - Handle the "i2c crc32" command-line command
 485  * @cmdtp:      Command data struct pointer
 486  * @flag:       Command flag
 487  * @argc:       Command-line argument count
 488  * @argv:       Array of command-line arguments
 489  *
 490  * Calculate a CRC on memory
 491  *
 492  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 493  * on error.
 494  *
 495  * Syntax:
 496  *      i2c crc32 {i2c_chip} {addr}{.0, .1, .2} {count}
 497  */
 498 static int do_i2c_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 499 {
 500         uchar   chip;
 501         ulong   addr;
 502         uint    alen;
 503         int     count;
 504         uchar   byte;
 505         ulong   crc;
 506         ulong   err;
 507
 508         if (argc < 4)
 509                 return CMD_RET_USAGE;
 510
 511         /*
 512          * Chip is always specified.
 513          */
 514         chip = simple_strtoul(argv[1], NULL, 16);
 515
 516         /*
 517          * Address is always specified.
 518          */
 519         addr = simple_strtoul(argv[2], NULL, 16);
 520         alen = get_alen(argv[2]);
 521         if (alen > 3)
 522                 return CMD_RET_USAGE;
 523
 524         /*
 525          * Count is always specified
 526          */
 527         count = simple_strtoul(argv[3], NULL, 16);
 528
 529         printf ("CRC32 for %08lx ... %08lx ==> ", addr, addr + count - 1);
 530         /*
 531          * CRC a byte at a time.  This is going to be slooow, but hey, the
 532          * memories are small and slow too so hopefully nobody notices.
 533          */
 534         crc = 0;
 535         err = 0;
 536         while (count-- > 0) {
 537                 if (i2c_read(chip, addr, alen, &byte, 1) != 0)
 538                         err++;
 539                 crc = crc32 (crc, &byte, 1);
 540                 addr++;
 541         }
 542         if (err > 0)
 543                 i2c_report_err(-1, I2C_ERR_READ);
 544         else
 545                 printf ("%08lx\n", crc);
 546
 547         return 0;
 548 }
 549
 550 /**
 551  * mod_i2c_mem() - Handle the "i2c mm" and "i2c nm" command-line command
 552  * @cmdtp:      Command data struct pointer
 553  * @flag:       Command flag
 554  * @argc:       Command-line argument count
 555  * @argv:       Array of command-line arguments
 556  *
 557  * Modify memory.
 558  *
 559  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 560  * on error.
 561  *
 562  * Syntax:
 563  *      i2c mm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
 564  *      i2c nm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
 565  */
 566 static int
 567 mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
 568 {
 569         uchar   chip;
 570         ulong   addr;
 571         uint    alen;
 572         ulong   data;
 573         int     size = 1;
 574         int     nbytes;
 575
 576         if (argc != 3)
 577                 return CMD_RET_USAGE;
 578
 579         bootretry_reset_cmd_timeout();  /* got a good command to get here */
 580         /*
 581          * We use the last specified parameters, unless new ones are
 582          * entered.
 583          */
 584         chip = i2c_mm_last_chip;
 585         addr = i2c_mm_last_addr;
 586         alen = i2c_mm_last_alen;
 587
 588         if ((flag & CMD_FLAG_REPEAT) == 0) {
 589                 /*
 590                  * New command specified.  Check for a size specification.
 591                  * Defaults to byte if no or incorrect specification.
 592                  */
 593                 size = cmd_get_data_size(argv[0], 1);
 594
 595                 /*
 596                  * Chip is always specified.
 597                  */
 598                 chip = simple_strtoul(argv[1], NULL, 16);
 599
 600                 /*
 601                  * Address is always specified.
 602                  */
 603                 addr = simple_strtoul(argv[2], NULL, 16);
 604                 alen = get_alen(argv[2]);
 605                 if (alen > 3)
 606                         return CMD_RET_USAGE;
 607         }
 608
 609         /*
 610          * Print the address, followed by value.  Then accept input for
 611          * the next value.  A non-converted value exits.
 612          */
 613         do {
 614                 printf("%08lx:", addr);
 615                 if (i2c_read(chip, addr, alen, (uchar *)&data, size) != 0)
 616                         i2c_report_err(-1, I2C_ERR_READ);
 617                 else {
 618                         data = cpu_to_be32(data);
 619                         if (size == 1)
 620                                 printf(" %02lx", (data >> 24) & 0x000000FF);
 621                         else if (size == 2)
 622                                 printf(" %04lx", (data >> 16) & 0x0000FFFF);
 623                         else
 624                                 printf(" %08lx", data);
 625                 }
 626
 627                 nbytes = cli_readline(" ? ");
 628                 if (nbytes == 0) {
 629                         /*
 630                          * <CR> pressed as only input, don't modify current
 631                          * location and move to next.
 632                          */
 633                         if (incrflag)
 634                                 addr += size;
 635                         nbytes = size;
 636                         /* good enough to not time out */
 637                         bootretry_reset_cmd_timeout();
 638                 }
 639 #ifdef CONFIG_BOOT_RETRY_TIME
 640                 else if (nbytes == -2)
 641                         break;  /* timed out, exit the command  */
 642 #endif
 643                 else {
 644                         char *endp;
 645
 646                         data = simple_strtoul(console_buffer, &endp, 16);
 647                         if (size == 1)
 648                                 data = data << 24;
 649                         else if (size == 2)
 650                                 data = data << 16;
 651                         data = be32_to_cpu(data);
 652                         nbytes = endp - console_buffer;
 653                         if (nbytes) {
 654                                 /*
 655                                  * good enough to not time out
 656                                  */
 657                                 bootretry_reset_cmd_timeout();
 658                                 if (i2c_write(chip, addr, alen, (uchar *)&data, size) != 0)
 659                                         i2c_report_err(-1, I2C_ERR_WRITE);
 660 #ifdef CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS
 661                                 udelay(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
 662 #endif
 663                                 if (incrflag)
 664                                         addr += size;
 665                         }
 666                 }
 667         } while (nbytes);
 668
 669         i2c_mm_last_chip = chip;
 670         i2c_mm_last_addr = addr;
 671         i2c_mm_last_alen = alen;
 672
 673         return 0;
 674 }
 675
 676 /**
 677  * do_i2c_probe() - Handle the "i2c probe" command-line command
 678  * @cmdtp:      Command data struct pointer
 679  * @flag:       Command flag
 680  * @argc:       Command-line argument count
 681  * @argv:       Array of command-line arguments
 682  *
 683  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 684  * on error.
 685  *
 686  * Syntax:
 687  *      i2c probe {addr}
 688  *
 689  * Returns zero (success) if one or more I2C devices was found
 690  */
 691 static int do_i2c_probe (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 692 {
 693         int j;
 694         int addr = -1;
 695         int found = 0;
 696 #if defined(CONFIG_SYS_I2C_NOPROBES)
 697         int k, skip;
 698         unsigned int bus = GET_BUS_NUM;
 699 #endif  /* NOPROBES */
 700
 701         if (argc == 2)
 702                 addr = simple_strtol(argv[1], 0, 16);
 703
 704         puts ("Valid chip addresses:");
 705         for (j = 0; j < 128; j++) {
 706                 if ((0 <= addr) && (j != addr))
 707                         continue;
 708
 709 #if defined(CONFIG_SYS_I2C_NOPROBES)
 710                 skip = 0;
 711                 for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
 712                         if (COMPARE_BUS(bus, k) && COMPARE_ADDR(j, k)) {
 713                                 skip = 1;
 714                                 break;
 715                         }
 716                 }
 717                 if (skip)
 718                         continue;
 719 #endif
 720                 if (i2c_probe(j) == 0) {
 721                         printf(" %02X", j);
 722                         found++;
 723                 }
 724         }
 725         putc ('\n');
 726
 727 #if defined(CONFIG_SYS_I2C_NOPROBES)
 728         puts ("Excluded chip addresses:");
 729         for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
 730                 if (COMPARE_BUS(bus,k))
 731                         printf(" %02X", NO_PROBE_ADDR(k));
 732         }
 733         putc ('\n');
 734 #endif
 735
 736         return (0 == found);
 737 }
 738
 739 /**
 740  * do_i2c_loop() - Handle the "i2c loop" command-line command
 741  * @cmdtp:      Command data struct pointer
 742  * @flag:       Command flag
 743  * @argc:       Command-line argument count
 744  * @argv:       Array of command-line arguments
 745  *
 746  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
 747  * on error.
 748  *
 749  * Syntax:
 750  *      i2c loop {i2c_chip} {addr}{.0, .1, .2} [{length}] [{delay}]
 751  *      {length} - Number of bytes to read
 752  *      {delay}  - A DECIMAL number and defaults to 1000 uSec
 753  */
 754 static int do_i2c_loop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 755 {
 756         u_char  chip;
 757         ulong   alen;
 758         uint    addr;
 759         uint    length;
 760         u_char  bytes[16];
 761         int     delay;
 762
 763         if (argc < 3)
 764                 return CMD_RET_USAGE;
 765
 766         /*
 767          * Chip is always specified.
 768          */
 769         chip = simple_strtoul(argv[1], NULL, 16);
 770
 771         /*
 772          * Address is always specified.
 773          */
 774         addr = simple_strtoul(argv[2], NULL, 16);
 775         alen = get_alen(argv[2]);
 776         if (alen > 3)
 777                 return CMD_RET_USAGE;
 778
 779         /*
 780          * Length is the number of objects, not number of bytes.
 781          */
 782         length = 1;
 783         length = simple_strtoul(argv[3], NULL, 16);
 784         if (length > sizeof(bytes))
 785                 length = sizeof(bytes);
 786
 787         /*
 788          * The delay time (uSec) is optional.
 789          */
 790         delay = 1000;
 791         if (argc > 3)
 792                 delay = simple_strtoul(argv[4], NULL, 10);
 793         /*
 794          * Run the loop...
 795          */
 796         while (1) {
 797                 if (i2c_read(chip, addr, alen, bytes, length) != 0)
 798                         i2c_report_err(-1, I2C_ERR_READ);
 799                 udelay(delay);
 800         }
 801
 802         /* NOTREACHED */
 803         return 0;
 804 }
 805
 806 /*
 807  * The SDRAM command is separately configured because many
 808  * (most?) embedded boards don't use SDRAM DIMMs.
 809  *
 810  * FIXME: Document and probably move elsewhere!
 811  */
 812 #if defined(CONFIG_CMD_SDRAM)
 813 static void print_ddr2_tcyc (u_char const b)
 814 {
 815         printf ("%d.", (b >> 4) & 0x0F);
 816         switch (b & 0x0F) {
 817         case 0x0:
 818         case 0x1:
 819         case 0x2:
 820         case 0x3:
 821         case 0x4:
 822         case 0x5:
 823         case 0x6:
 824         case 0x7:
 825         case 0x8:
 826         case 0x9:
 827                 printf ("%d ns\n", b & 0x0F);
 828                 break;
 829         case 0xA:
 830                 puts ("25 ns\n");
 831                 break;
 832         case 0xB:
 833                 puts ("33 ns\n");
 834                 break;
 835         case 0xC:
 836                 puts ("66 ns\n");
 837                 break;
 838         case 0xD:
 839                 puts ("75 ns\n");
 840                 break;
 841         default:
 842                 puts ("?? ns\n");
 843                 break;
 844         }
 845 }
 846
 847 static void decode_bits (u_char const b, char const *str[], int const do_once)
 848 {
 849         u_char mask;
 850
 851         for (mask = 0x80; mask != 0x00; mask >>= 1, ++str) {
 852                 if (b & mask) {
 853                         puts (*str);
 854                         if (do_once)
 855                                 return;
 856                 }
 857         }
 858 }
 859
 860 /*
 861  * Syntax:
 862  *      i2c sdram {i2c_chip}
 863  */
 864 static int do_sdram (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 865 {
 866         enum { unknown, EDO, SDRAM, DDR2 } type;
 867
 868         u_char  chip;
 869         u_char  data[128];
 870         u_char  cksum;
 871         int     j;
 872
 873         static const char *decode_CAS_DDR2[] = {
 874                 " TBD", " 6", " 5", " 4", " 3", " 2", " TBD", " TBD"
 875         };
 876
 877         static const char *decode_CAS_default[] = {
 878                 " TBD", " 7", " 6", " 5", " 4", " 3", " 2", " 1"
 879         };
 880
 881         static const char *decode_CS_WE_default[] = {
 882                 " TBD", " 6", " 5", " 4", " 3", " 2", " 1", " 0"
 883         };
 884
 885         static const char *decode_byte21_default[] = {
 886                 "  TBD (bit 7)\n",
 887                 "  Redundant row address\n",
 888                 "  Differential clock input\n",
 889                 "  Registerd DQMB inputs\n",
 890                 "  Buffered DQMB inputs\n",
 891                 "  On-card PLL\n",
 892                 "  Registered address/control lines\n",
 893                 "  Buffered address/control lines\n"
 894         };
 895
 896         static const char *decode_byte22_DDR2[] = {
 897                 "  TBD (bit 7)\n",
 898                 "  TBD (bit 6)\n",
 899                 "  TBD (bit 5)\n",
 900                 "  TBD (bit 4)\n",
 901                 "  TBD (bit 3)\n",
 902                 "  Supports partial array self refresh\n",
 903                 "  Supports 50 ohm ODT\n",
 904                 "  Supports weak driver\n"
 905         };
 906
 907         static const char *decode_row_density_DDR2[] = {
 908                 "512 MiB", "256 MiB", "128 MiB", "16 GiB",
 909                 "8 GiB", "4 GiB", "2 GiB", "1 GiB"
 910         };
 911
 912         static const char *decode_row_density_default[] = {
 913                 "512 MiB", "256 MiB", "128 MiB", "64 MiB",
 914                 "32 MiB", "16 MiB", "8 MiB", "4 MiB"
 915         };
 916
 917         if (argc < 2)
 918                 return CMD_RET_USAGE;
 919
 920         /*
 921          * Chip is always specified.
 922          */
 923         chip = simple_strtoul (argv[1], NULL, 16);
 924
 925         if (i2c_read (chip, 0, 1, data, sizeof (data)) != 0) {
 926                 puts ("No SDRAM Serial Presence Detect found.\n");
 927                 return 1;
 928         }
 929
 930         cksum = 0;
 931         for (j = 0; j < 63; j++) {
 932                 cksum += data[j];
 933         }
 934         if (cksum != data[63]) {
 935                 printf ("WARNING: Configuration data checksum failure:\n"
 936                         "  is 0x%02x, calculated 0x%02x\n", data[63], cksum);
 937         }
 938         printf ("SPD data revision            %d.%d\n",
 939                 (data[62] >> 4) & 0x0F, data[62] & 0x0F);
 940         printf ("Bytes used                   0x%02X\n", data[0]);
 941         printf ("Serial memory size           0x%02X\n", 1 << data[1]);
 942
 943         puts ("Memory type                  ");
 944         switch (data[2]) {
 945         case 2:
 946                 type = EDO;
 947                 puts ("EDO\n");
 948                 break;
 949         case 4:
 950                 type = SDRAM;
 951                 puts ("SDRAM\n");
 952                 break;
 953         case 8:
 954                 type = DDR2;
 955                 puts ("DDR2\n");
 956                 break;
 957         default:
 958                 type = unknown;
 959                 puts ("unknown\n");
 960                 break;
 961         }
 962
 963         puts ("Row address bits             ");
 964         if ((data[3] & 0x00F0) == 0)
 965                 printf ("%d\n", data[3] & 0x0F);
 966         else
 967                 printf ("%d/%d\n", data[3] & 0x0F, (data[3] >> 4) & 0x0F);
 968
 969         puts ("Column address bits          ");
 970         if ((data[4] & 0x00F0) == 0)
 971                 printf ("%d\n", data[4] & 0x0F);
 972         else
 973                 printf ("%d/%d\n", data[4] & 0x0F, (data[4] >> 4) & 0x0F);
 974
 975         switch (type) {
 976         case DDR2:
 977                 printf ("Number of ranks              %d\n",
 978                         (data[5] & 0x07) + 1);
 979                 break;
 980         default:
 981                 printf ("Module rows                  %d\n", data[5]);
 982                 break;
 983         }
 984
 985         switch (type) {
 986         case DDR2:
 987                 printf ("Module data width            %d bits\n", data[6]);
 988                 break;
 989         default:
 990                 printf ("Module data width            %d bits\n",
 991                         (data[7] << 8) | data[6]);
 992                 break;
 993         }
 994
 995         puts ("Interface signal levels      ");
 996         switch(data[8]) {
 997                 case 0:  puts ("TTL 5.0 V\n");  break;
 998                 case 1:  puts ("LVTTL\n");      break;
 999                 case 2:  puts ("HSTL 1.5 V\n"); break;
1000                 case 3:  puts ("SSTL 3.3 V\n"); break;
1001                 case 4:  puts ("SSTL 2.5 V\n"); break;
1002                 case 5:  puts ("SSTL 1.8 V\n"); break;
1003                 default: puts ("unknown\n");    break;
1004         }
1005
1006         switch (type) {
1007         case DDR2:
1008                 printf ("SDRAM cycle time             ");
1009                 print_ddr2_tcyc (data[9]);
1010                 break;
1011         default:
1012                 printf ("SDRAM cycle time             %d.%d ns\n",
1013                         (data[9] >> 4) & 0x0F, data[9] & 0x0F);
1014                 break;
1015         }
1016
1017         switch (type) {
1018         case DDR2:
1019                 printf ("SDRAM access time            0.%d%d ns\n",
1020                         (data[10] >> 4) & 0x0F, data[10] & 0x0F);
1021                 break;
1022         default:
1023                 printf ("SDRAM access time            %d.%d ns\n",
1024                         (data[10] >> 4) & 0x0F, data[10] & 0x0F);
1025                 break;
1026         }
1027
1028         puts ("EDC configuration            ");
1029         switch (data[11]) {
1030                 case 0:  puts ("None\n");       break;
1031                 case 1:  puts ("Parity\n");     break;
1032                 case 2:  puts ("ECC\n");        break;
1033                 default: puts ("unknown\n");    break;
1034         }
1035
1036         if ((data[12] & 0x80) == 0)
1037                 puts ("No self refresh, rate        ");
1038         else
1039                 puts ("Self refresh, rate           ");
1040
1041         switch(data[12] & 0x7F) {
1042                 case 0:  puts ("15.625 us\n");  break;
1043                 case 1:  puts ("3.9 us\n");     break;
1044                 case 2:  puts ("7.8 us\n");     break;
1045                 case 3:  puts ("31.3 us\n");    break;
1046                 case 4:  puts ("62.5 us\n");    break;
1047                 case 5:  puts ("125 us\n");     break;
1048                 default: puts ("unknown\n");    break;
1049         }
1050
1051         switch (type) {
1052         case DDR2:
1053                 printf ("SDRAM width (primary)        %d\n", data[13]);
1054                 break;
1055         default:
1056                 printf ("SDRAM width (primary)        %d\n", data[13] & 0x7F);
1057                 if ((data[13] & 0x80) != 0) {
1058                         printf ("  (second bank)              %d\n",
1059                                 2 * (data[13] & 0x7F));
1060                 }
1061                 break;
1062         }
1063
1064         switch (type) {
1065         case DDR2:
1066                 if (data[14] != 0)
1067                         printf ("EDC width                    %d\n", data[14]);
1068                 break;
1069         default:
1070                 if (data[14] != 0) {
1071                         printf ("EDC width                    %d\n",
1072                                 data[14] & 0x7F);
1073
1074                         if ((data[14] & 0x80) != 0) {
1075                                 printf ("  (second bank)              %d\n",
1076                                         2 * (data[14] & 0x7F));
1077                         }
1078                 }
1079                 break;
1080         }
1081
1082         if (DDR2 != type) {
1083                 printf ("Min clock delay, back-to-back random column addresses "
1084                         "%d\n", data[15]);
1085         }
1086
1087         puts ("Burst length(s)             ");
1088         if (data[16] & 0x80) puts (" Page");
1089         if (data[16] & 0x08) puts (" 8");
1090         if (data[16] & 0x04) puts (" 4");
1091         if (data[16] & 0x02) puts (" 2");
1092         if (data[16] & 0x01) puts (" 1");
1093         putc ('\n');
1094         printf ("Number of banks              %d\n", data[17]);
1095
1096         switch (type) {
1097         case DDR2:
1098                 puts ("CAS latency(s)              ");
1099                 decode_bits (data[18], decode_CAS_DDR2, 0);
1100                 putc ('\n');
1101                 break;
1102         default:
1103                 puts ("CAS latency(s)              ");
1104                 decode_bits (data[18], decode_CAS_default, 0);
1105                 putc ('\n');
1106                 break;
1107         }
1108
1109         if (DDR2 != type) {
1110                 puts ("CS latency(s)               ");
1111                 decode_bits (data[19], decode_CS_WE_default, 0);
1112                 putc ('\n');
1113         }
1114
1115         if (DDR2 != type) {
1116                 puts ("WE latency(s)               ");
1117                 decode_bits (data[20], decode_CS_WE_default, 0);
1118                 putc ('\n');
1119         }
1120
1121         switch (type) {
1122         case DDR2:
1123                 puts ("Module attributes:\n");
1124                 if (data[21] & 0x80)
1125                         puts ("  TBD (bit 7)\n");
1126                 if (data[21] & 0x40)
1127                         puts ("  Analysis probe installed\n");
1128                 if (data[21] & 0x20)
1129                         puts ("  TBD (bit 5)\n");
1130                 if (data[21] & 0x10)
1131                         puts ("  FET switch external enable\n");
1132                 printf ("  %d PLLs on DIMM\n", (data[21] >> 2) & 0x03);
1133                 if (data[20] & 0x11) {
1134                         printf ("  %d active registers on DIMM\n",
1135                                 (data[21] & 0x03) + 1);
1136                 }
1137                 break;
1138         default:
1139                 puts ("Module attributes:\n");
1140                 if (!data[21])
1141                         puts ("  (none)\n");
1142                 else
1143                         decode_bits (data[21], decode_byte21_default, 0);
1144                 break;
1145         }
1146
1147         switch (type) {
1148         case DDR2:
1149                 decode_bits (data[22], decode_byte22_DDR2, 0);
1150                 break;
1151         default:
1152                 puts ("Device attributes:\n");
1153                 if (data[22] & 0x80) puts ("  TBD (bit 7)\n");
1154                 if (data[22] & 0x40) puts ("  TBD (bit 6)\n");
1155                 if (data[22] & 0x20) puts ("  Upper Vcc tolerance 5%\n");
1156                 else                 puts ("  Upper Vcc tolerance 10%\n");
1157                 if (data[22] & 0x10) puts ("  Lower Vcc tolerance 5%\n");
1158                 else                 puts ("  Lower Vcc tolerance 10%\n");
1159                 if (data[22] & 0x08) puts ("  Supports write1/read burst\n");
1160                 if (data[22] & 0x04) puts ("  Supports precharge all\n");
1161                 if (data[22] & 0x02) puts ("  Supports auto precharge\n");
1162                 if (data[22] & 0x01) puts ("  Supports early RAS# precharge\n");
1163                 break;
1164         }
1165
1166         switch (type) {
1167         case DDR2:
1168                 printf ("SDRAM cycle time (2nd highest CAS latency)        ");
1169                 print_ddr2_tcyc (data[23]);
1170                 break;
1171         default:
1172                 printf ("SDRAM cycle time (2nd highest CAS latency)        %d."
1173                         "%d ns\n", (data[23] >> 4) & 0x0F, data[23] & 0x0F);
1174                 break;
1175         }
1176
1177         switch (type) {
1178         case DDR2:
1179                 printf ("SDRAM access from clock (2nd highest CAS latency) 0."
1180                         "%d%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
1181                 break;
1182         default:
1183                 printf ("SDRAM access from clock (2nd highest CAS latency) %d."
1184                         "%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
1185                 break;
1186         }
1187
1188         switch (type) {
1189         case DDR2:
1190                 printf ("SDRAM cycle time (3rd highest CAS latency)        ");
1191                 print_ddr2_tcyc (data[25]);
1192                 break;
1193         default:
1194                 printf ("SDRAM cycle time (3rd highest CAS latency)        %d."
1195                         "%d ns\n", (data[25] >> 4) & 0x0F, data[25] & 0x0F);
1196                 break;
1197         }
1198
1199         switch (type) {
1200         case DDR2:
1201                 printf ("SDRAM access from clock (3rd highest CAS latency) 0."
1202                         "%d%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
1203                 break;
1204         default:
1205                 printf ("SDRAM access from clock (3rd highest CAS latency) %d."
1206                         "%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
1207                 break;
1208         }
1209
1210         switch (type) {
1211         case DDR2:
1212                 printf ("Minimum row precharge        %d.%02d ns\n",
1213                         (data[27] >> 2) & 0x3F, 25 * (data[27] & 0x03));
1214                 break;
1215         default:
1216                 printf ("Minimum row precharge        %d ns\n", data[27]);
1217                 break;
1218         }
1219
1220         switch (type) {
1221         case DDR2:
1222                 printf ("Row active to row active min %d.%02d ns\n",
1223                         (data[28] >> 2) & 0x3F, 25 * (data[28] & 0x03));
1224                 break;
1225         default:
1226                 printf ("Row active to row active min %d ns\n", data[28]);
1227                 break;
1228         }
1229
1230         switch (type) {
1231         case DDR2:
1232                 printf ("RAS to CAS delay min         %d.%02d ns\n",
1233                         (data[29] >> 2) & 0x3F, 25 * (data[29] & 0x03));
1234                 break;
1235         default:
1236                 printf ("RAS to CAS delay min         %d ns\n", data[29]);
1237                 break;
1238         }
1239
1240         printf ("Minimum RAS pulse width      %d ns\n", data[30]);
1241
1242         switch (type) {
1243         case DDR2:
1244                 puts ("Density of each row          ");
1245                 decode_bits (data[31], decode_row_density_DDR2, 1);
1246                 putc ('\n');
1247                 break;
1248         default:
1249                 puts ("Density of each row          ");
1250                 decode_bits (data[31], decode_row_density_default, 1);
1251                 putc ('\n');
1252                 break;
1253         }
1254
1255         switch (type) {
1256         case DDR2:
1257                 puts ("Command and Address setup    ");
1258                 if (data[32] >= 0xA0) {
1259                         printf ("1.%d%d ns\n",
1260                                 ((data[32] >> 4) & 0x0F) - 10, data[32] & 0x0F);
1261                 } else {
1262                         printf ("0.%d%d ns\n",
1263                                 ((data[32] >> 4) & 0x0F), data[32] & 0x0F);
1264                 }
1265                 break;
1266         default:
1267                 printf ("Command and Address setup    %c%d.%d ns\n",
1268                         (data[32] & 0x80) ? '-' : '+',
1269                         (data[32] >> 4) & 0x07, data[32] & 0x0F);
1270                 break;
1271         }
1272
1273         switch (type) {
1274         case DDR2:
1275                 puts ("Command and Address hold     ");
1276                 if (data[33] >= 0xA0) {
1277                         printf ("1.%d%d ns\n",
1278                                 ((data[33] >> 4) & 0x0F) - 10, data[33] & 0x0F);
1279                 } else {
1280                         printf ("0.%d%d ns\n",
1281                                 ((data[33] >> 4) & 0x0F), data[33] & 0x0F);
1282                 }
1283                 break;
1284         default:
1285                 printf ("Command and Address hold     %c%d.%d ns\n",
1286                         (data[33] & 0x80) ? '-' : '+',
1287                         (data[33] >> 4) & 0x07, data[33] & 0x0F);
1288                 break;
1289         }
1290
1291         switch (type) {
1292         case DDR2:
1293                 printf ("Data signal input setup      0.%d%d ns\n",
1294                         (data[34] >> 4) & 0x0F, data[34] & 0x0F);
1295                 break;
1296         default:
1297                 printf ("Data signal input setup      %c%d.%d ns\n",
1298                         (data[34] & 0x80) ? '-' : '+',
1299                         (data[34] >> 4) & 0x07, data[34] & 0x0F);
1300                 break;
1301         }
1302
1303         switch (type) {
1304         case DDR2:
1305                 printf ("Data signal input hold       0.%d%d ns\n",
1306                         (data[35] >> 4) & 0x0F, data[35] & 0x0F);
1307                 break;
1308         default:
1309                 printf ("Data signal input hold       %c%d.%d ns\n",
1310                         (data[35] & 0x80) ? '-' : '+',
1311                         (data[35] >> 4) & 0x07, data[35] & 0x0F);
1312                 break;
1313         }
1314
1315         puts ("Manufacturer's JEDEC ID      ");
1316         for (j = 64; j <= 71; j++)
1317                 printf ("%02X ", data[j]);
1318         putc ('\n');
1319         printf ("Manufacturing Location       %02X\n", data[72]);
1320         puts ("Manufacturer's Part Number   ");
1321         for (j = 73; j <= 90; j++)
1322                 printf ("%02X ", data[j]);
1323         putc ('\n');
1324         printf ("Revision Code                %02X %02X\n", data[91], data[92]);
1325         printf ("Manufacturing Date           %02X %02X\n", data[93], data[94]);
1326         puts ("Assembly Serial Number       ");
1327         for (j = 95; j <= 98; j++)
1328                 printf ("%02X ", data[j]);
1329         putc ('\n');
1330
1331         if (DDR2 != type) {
1332                 printf ("Speed rating                 PC%d\n",
1333                         data[126] == 0x66 ? 66 : data[126]);
1334         }
1335         return 0;
1336 }
1337 #endif
1338
1339 /*
1340  * Syntax:
1341  *      i2c edid {i2c_chip}
1342  */
1343 #if defined(CONFIG_I2C_EDID)
1344 int do_edid(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
1345 {
1346         u_char chip;
1347         struct edid1_info edid;
1348
1349         if (argc < 2) {
1350                 cmd_usage(cmdtp);
1351                 return 1;
1352         }
1353
1354         chip = simple_strtoul(argv[1], NULL, 16);
1355         if (i2c_read(chip, 0, 1, (uchar *)&edid, sizeof(edid)) != 0) {
1356                 i2c_report_err(-1, I2C_ERR_READ);
1357                 return 1;
1358         }
1359
1360         if (edid_check_info(&edid)) {
1361                 puts("Content isn't valid EDID.\n");
1362                 return 1;
1363         }
1364
1365         edid_print_info(&edid);
1366         return 0;
1367
1368 }
1369 #endif /* CONFIG_I2C_EDID */
1370
1371 /**
1372  * do_i2c_show_bus() - Handle the "i2c bus" command-line command
1373  * @cmdtp:      Command data struct pointer
1374  * @flag:       Command flag
1375  * @argc:       Command-line argument count
1376  * @argv:       Array of command-line arguments
1377  *
1378  * Returns zero always.
1379  */
1380 #if defined(CONFIG_SYS_I2C)
1381 static int do_i2c_show_bus(cmd_tbl_t *cmdtp, int flag, int argc,
1382                                 char * const argv[])
1383 {
1384         int     i;
1385 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
1386         int     j;
1387 #endif
1388
1389         if (argc == 1) {
1390                 /* show all busses */
1391                 for (i = 0; i < CONFIG_SYS_NUM_I2C_BUSES; i++) {
1392                         printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
1393 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
1394                         for (j = 0; j < CONFIG_SYS_I2C_MAX_HOPS; j++) {
1395                                 if (i2c_bus[i].next_hop[j].chip == 0)
1396                                         break;
1397                                 printf("->%s@0x%2x:%d",
1398                                        i2c_bus[i].next_hop[j].mux.name,
1399                                        i2c_bus[i].next_hop[j].chip,
1400                                        i2c_bus[i].next_hop[j].channel);
1401                         }
1402 #endif
1403                         printf("\n");
1404                 }
1405         } else {
1406                 /* show specific bus */
1407                 i = simple_strtoul(argv[1], NULL, 10);
1408                 if (i >= CONFIG_SYS_NUM_I2C_BUSES) {
1409                         printf("Invalid bus %d\n", i);
1410                         return -1;
1411                 }
1412                 printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
1413 #ifndef CONFIG_SYS_I2C_DIRECT_BUS
1414                         for (j = 0; j < CONFIG_SYS_I2C_MAX_HOPS; j++) {
1415                                 if (i2c_bus[i].next_hop[j].chip == 0)
1416                                         break;
1417                                 printf("->%s@0x%2x:%d",
1418                                        i2c_bus[i].next_hop[j].mux.name,
1419                                        i2c_bus[i].next_hop[j].chip,
1420                                        i2c_bus[i].next_hop[j].channel);
1421                         }
1422 #endif
1423                 printf("\n");
1424         }
1425
1426         return 0;
1427 }
1428 #endif
1429
1430 /**
1431  * do_i2c_bus_num() - Handle the "i2c dev" command-line command
1432  * @cmdtp:      Command data struct pointer
1433  * @flag:       Command flag
1434  * @argc:       Command-line argument count
1435  * @argv:       Array of command-line arguments
1436  *
1437  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1438  * on error.
1439  */
1440 #if defined(CONFIG_SYS_I2C) || defined(CONFIG_I2C_MULTI_BUS)
1441 static int do_i2c_bus_num(cmd_tbl_t *cmdtp, int flag, int argc,
1442                                 char * const argv[])
1443 {
1444         int             ret = 0;
1445         unsigned int    bus_no;
1446
1447         if (argc == 1)
1448                 /* querying current setting */
1449                 printf("Current bus is %d\n", i2c_get_bus_num());
1450         else {
1451                 bus_no = simple_strtoul(argv[1], NULL, 10);
1452 #if defined(CONFIG_SYS_I2C)
1453                 if (bus_no >= CONFIG_SYS_NUM_I2C_BUSES) {
1454                         printf("Invalid bus %d\n", bus_no);
1455                         return -1;
1456                 }
1457 #endif
1458                 printf("Setting bus to %d\n", bus_no);
1459                 ret = i2c_set_bus_num(bus_no);
1460                 if (ret)
1461                         printf("Failure changing bus number (%d)\n", ret);
1462         }
1463         return ret;
1464 }
1465 #endif  /* defined(CONFIG_SYS_I2C) */
1466
1467 /**
1468  * do_i2c_bus_speed() - Handle the "i2c speed" command-line command
1469  * @cmdtp:      Command data struct pointer
1470  * @flag:       Command flag
1471  * @argc:       Command-line argument count
1472  * @argv:       Array of command-line arguments
1473  *
1474  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1475  * on error.
1476  */
1477 static int do_i2c_bus_speed(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1478 {
1479         int speed, ret=0;
1480
1481         if (argc == 1)
1482                 /* querying current speed */
1483                 printf("Current bus speed=%d\n", i2c_get_bus_speed());
1484         else {
1485                 speed = simple_strtoul(argv[1], NULL, 10);
1486                 printf("Setting bus speed to %d Hz\n", speed);
1487                 ret = i2c_set_bus_speed(speed);
1488                 if (ret)
1489                         printf("Failure changing bus speed (%d)\n", ret);
1490         }
1491         return ret;
1492 }
1493
1494 /**
1495  * do_i2c_mm() - Handle the "i2c mm" command-line command
1496  * @cmdtp:      Command data struct pointer
1497  * @flag:       Command flag
1498  * @argc:       Command-line argument count
1499  * @argv:       Array of command-line arguments
1500  *
1501  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1502  * on error.
1503  */
1504 static int do_i2c_mm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1505 {
1506         return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
1507 }
1508
1509 /**
1510  * do_i2c_nm() - Handle the "i2c nm" command-line command
1511  * @cmdtp:      Command data struct pointer
1512  * @flag:       Command flag
1513  * @argc:       Command-line argument count
1514  * @argv:       Array of command-line arguments
1515  *
1516  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1517  * on error.
1518  */
1519 static int do_i2c_nm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1520 {
1521         return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
1522 }
1523
1524 /**
1525  * do_i2c_reset() - Handle the "i2c reset" command-line command
1526  * @cmdtp:      Command data struct pointer
1527  * @flag:       Command flag
1528  * @argc:       Command-line argument count
1529  * @argv:       Array of command-line arguments
1530  *
1531  * Returns zero always.
1532  */
1533 static int do_i2c_reset(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1534 {
1535 #if defined(CONFIG_SYS_I2C)
1536         i2c_init(I2C_ADAP->speed, I2C_ADAP->slaveaddr);
1537 #else
1538         i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
1539 #endif
1540         return 0;
1541 }
1542
1543 static cmd_tbl_t cmd_i2c_sub[] = {
1544 #if defined(CONFIG_SYS_I2C)
1545         U_BOOT_CMD_MKENT(bus, 1, 1, do_i2c_show_bus, "", ""),
1546 #endif
1547         U_BOOT_CMD_MKENT(crc32, 3, 1, do_i2c_crc, "", ""),
1548 #if defined(CONFIG_SYS_I2C) || \
1549         defined(CONFIG_I2C_MULTI_BUS)
1550         U_BOOT_CMD_MKENT(dev, 1, 1, do_i2c_bus_num, "", ""),
1551 #endif  /* CONFIG_I2C_MULTI_BUS */
1552 #if defined(CONFIG_I2C_EDID)
1553         U_BOOT_CMD_MKENT(edid, 1, 1, do_edid, "", ""),
1554 #endif  /* CONFIG_I2C_EDID */
1555         U_BOOT_CMD_MKENT(loop, 3, 1, do_i2c_loop, "", ""),
1556         U_BOOT_CMD_MKENT(md, 3, 1, do_i2c_md, "", ""),
1557         U_BOOT_CMD_MKENT(mm, 2, 1, do_i2c_mm, "", ""),
1558         U_BOOT_CMD_MKENT(mw, 3, 1, do_i2c_mw, "", ""),
1559         U_BOOT_CMD_MKENT(nm, 2, 1, do_i2c_nm, "", ""),
1560         U_BOOT_CMD_MKENT(probe, 0, 1, do_i2c_probe, "", ""),
1561         U_BOOT_CMD_MKENT(read, 5, 1, do_i2c_read, "", ""),
1562         U_BOOT_CMD_MKENT(write, 5, 0, do_i2c_write, "", ""),
1563         U_BOOT_CMD_MKENT(reset, 0, 1, do_i2c_reset, "", ""),
1564 #if defined(CONFIG_CMD_SDRAM)
1565         U_BOOT_CMD_MKENT(sdram, 1, 1, do_sdram, "", ""),
1566 #endif
1567         U_BOOT_CMD_MKENT(speed, 1, 1, do_i2c_bus_speed, "", ""),
1568 };
1569
1570 #ifdef CONFIG_NEEDS_MANUAL_RELOC
1571 void i2c_reloc(void) {
1572         fixup_cmdtable(cmd_i2c_sub, ARRAY_SIZE(cmd_i2c_sub));
1573 }
1574 #endif
1575
1576 /**
1577  * do_i2c() - Handle the "i2c" command-line command
1578  * @cmdtp:      Command data struct pointer
1579  * @flag:       Command flag
1580  * @argc:       Command-line argument count
1581  * @argv:       Array of command-line arguments
1582  *
1583  * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1584  * on error.
1585  */
1586 static int do_i2c(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
1587 {
1588         cmd_tbl_t *c;
1589
1590         if (argc < 2)
1591                 return CMD_RET_USAGE;
1592
1593         /* Strip off leading 'i2c' command argument */
1594         argc--;
1595         argv++;
1596
1597         c = find_cmd_tbl(argv[0], &cmd_i2c_sub[0], ARRAY_SIZE(cmd_i2c_sub));
1598
1599         if (c)
1600                 return c->cmd(cmdtp, flag, argc, argv);
1601         else
1602                 return CMD_RET_USAGE;
1603 }
1604
1605 /***************************************************/
1606 #ifdef CONFIG_SYS_LONGHELP
1607 static char i2c_help_text[] =
1608 #if defined(CONFIG_SYS_I2C)
1609         "bus [muxtype:muxaddr:muxchannel] - show I2C bus info\n"
1610 #endif
1611         "crc32 chip address[.0, .1, .2] count - compute CRC32 checksum\n"
1612 #if defined(CONFIG_SYS_I2C) || \
1613         defined(CONFIG_I2C_MULTI_BUS)
1614         "i2c dev [dev] - show or set current I2C bus\n"
1615 #endif  /* CONFIG_I2C_MULTI_BUS */
1616 #if defined(CONFIG_I2C_EDID)
1617         "i2c edid chip - print EDID configuration information\n"
1618 #endif  /* CONFIG_I2C_EDID */
1619         "i2c loop chip address[.0, .1, .2] [# of objects] - looping read of device\n"
1620         "i2c md chip address[.0, .1, .2] [# of objects] - read from I2C device\n"
1621         "i2c mm chip address[.0, .1, .2] - write to I2C device (auto-incrementing)\n"
1622         "i2c mw chip address[.0, .1, .2] value [count] - write to I2C device (fill)\n"
1623         "i2c nm chip address[.0, .1, .2] - write to I2C device (constant address)\n"
1624         "i2c probe [address] - test for and show device(s) on the I2C bus\n"
1625         "i2c read chip address[.0, .1, .2] length memaddress - read to memory \n"
1626         "i2c write memaddress chip address[.0, .1, .2] length - write memory to i2c\n"
1627         "i2c reset - re-init the I2C Controller\n"
1628 #if defined(CONFIG_CMD_SDRAM)
1629         "i2c sdram chip - print SDRAM configuration information\n"
1630 #endif
1631         "i2c speed [speed] - show or set I2C bus speed";
1632 #endif
1633
1634 U_BOOT_CMD(
1635         i2c, 6, 1, do_i2c,
1636         "I2C sub-system",
1637         i2c_help_text
1638 );