blob: 0a0cfceb45ca6d7e424655dec811a6540355df31 [file] [log] [blame]
wdenk81a88242002-10-26 15:22:42 +00001/*
2 * (C) Copyright 2001
3 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
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/*
25 * I2C Functions similar to the standard memory functions.
26 *
27 * There are several parameters in many of the commands that bear further
28 * explanations:
29 *
wdenk81a88242002-10-26 15:22:42 +000030 * {i2c_chip} is the I2C chip address (the first byte sent on the bus).
31 * Each I2C chip on the bus has a unique address. On the I2C data bus,
32 * the address is the upper seven bits and the LSB is the "read/write"
33 * bit. Note that the {i2c_chip} address specified on the command
34 * line is not shifted up: e.g. a typical EEPROM memory chip may have
35 * an I2C address of 0x50, but the data put on the bus will be 0xA0
36 * for write and 0xA1 for read. This "non shifted" address notation
37 * matches at least half of the data sheets :-/.
38 *
39 * {addr} is the address (or offset) within the chip. Small memory
40 * chips have 8 bit addresses. Large memory chips have 16 bit
41 * addresses. Other memory chips have 9, 10, or 11 bit addresses.
42 * Many non-memory chips have multiple registers and {addr} is used
43 * as the register index. Some non-memory chips have only one register
44 * and therefore don't need any {addr} parameter.
45 *
46 * The default {addr} parameter is one byte (.1) which works well for
47 * memories and registers with 8 bits of address space.
48 *
49 * You can specify the length of the {addr} field with the optional .0,
50 * .1, or .2 modifier (similar to the .b, .w, .l modifier). If you are
51 * manipulating a single register device which doesn't use an address
52 * field, use "0.0" for the address and the ".0" length field will
53 * suppress the address in the I2C data stream. This also works for
54 * successive reads using the I2C auto-incrementing memory pointer.
55 *
56 * If you are manipulating a large memory with 2-byte addresses, use
57 * the .2 address modifier, e.g. 210.2 addresses location 528 (decimal).
58 *
59 * Then there are the unfortunate memory chips that spill the most
60 * significant 1, 2, or 3 bits of address into the chip address byte.
61 * This effectively makes one chip (logically) look like 2, 4, or
62 * 8 chips. This is handled (awkwardly) by #defining
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020063 * CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW and using the .1 modifier on the
wdenk81a88242002-10-26 15:22:42 +000064 * {addr} field (since .1 is the default, it doesn't actually have to
65 * be specified). Examples: given a memory chip at I2C chip address
66 * 0x50, the following would happen...
Peter Tyser0f89c542009-04-18 22:34:03 -050067 * i2c md 50 0 10 display 16 bytes starting at 0x000
wdenk81a88242002-10-26 15:22:42 +000068 * On the bus: <S> A0 00 <E> <S> A1 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050069 * i2c md 50 100 10 display 16 bytes starting at 0x100
wdenk81a88242002-10-26 15:22:42 +000070 * On the bus: <S> A2 00 <E> <S> A3 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050071 * i2c md 50 210 10 display 16 bytes starting at 0x210
wdenk81a88242002-10-26 15:22:42 +000072 * On the bus: <S> A4 10 <E> <S> A5 <rd> ... <rd>
73 * This is awfully ugly. It would be nice if someone would think up
74 * a better way of handling this.
75 *
76 * Adapted from cmd_mem.c which is copyright Wolfgang Denk (wd@denx.de).
77 */
78
79#include <common.h>
80#include <command.h>
Heiko Schocher67b23a32008-10-15 09:39:47 +020081#include <environment.h>
wdenk81a88242002-10-26 15:22:42 +000082#include <i2c.h>
Heiko Schocher67b23a32008-10-15 09:39:47 +020083#include <malloc.h>
wdenk81a88242002-10-26 15:22:42 +000084#include <asm/byteorder.h>
85
wdenk81a88242002-10-26 15:22:42 +000086/* Display values from last command.
87 * Memory modify remembered values are different from display memory.
88 */
89static uchar i2c_dp_last_chip;
90static uint i2c_dp_last_addr;
91static uint i2c_dp_last_alen;
92static uint i2c_dp_last_length = 0x10;
93
94static uchar i2c_mm_last_chip;
95static uint i2c_mm_last_addr;
96static uint i2c_mm_last_alen;
97
Ben Warrenbb99ad62006-09-07 16:50:54 -040098/* If only one I2C bus is present, the list of devices to ignore when
99 * the probe command is issued is represented by a 1D array of addresses.
100 * When multiple buses are present, the list is an array of bus-address
101 * pairs. The following macros take care of this */
102
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200103#if defined(CONFIG_SYS_I2C_NOPROBES)
Ben Warrenbb99ad62006-09-07 16:50:54 -0400104#if defined(CONFIG_I2C_MULTI_BUS)
105static struct
106{
107 uchar bus;
108 uchar addr;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200109} i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400110#define GET_BUS_NUM i2c_get_bus_num()
111#define COMPARE_BUS(b,i) (i2c_no_probes[(i)].bus == (b))
112#define COMPARE_ADDR(a,i) (i2c_no_probes[(i)].addr == (a))
113#define NO_PROBE_ADDR(i) i2c_no_probes[(i)].addr
114#else /* single bus */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200115static uchar i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400116#define GET_BUS_NUM 0
117#define COMPARE_BUS(b,i) ((b) == 0) /* Make compiler happy */
118#define COMPARE_ADDR(a,i) (i2c_no_probes[(i)] == (a))
119#define NO_PROBE_ADDR(i) i2c_no_probes[(i)]
120#endif /* CONFIG_MULTI_BUS */
121
122#define NUM_ELEMENTS_NOPROBE (sizeof(i2c_no_probes)/sizeof(i2c_no_probes[0]))
wdenk81a88242002-10-26 15:22:42 +0000123#endif
124
Heiko Schocher67b23a32008-10-15 09:39:47 +0200125#if defined(CONFIG_I2C_MUX)
126static I2C_MUX_DEVICE *i2c_mux_devices = NULL;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200127static int i2c_mux_busid = CONFIG_SYS_MAX_I2C_BUS;
Heiko Schocher67b23a32008-10-15 09:39:47 +0200128
129DECLARE_GLOBAL_DATA_PTR;
130
131#endif
132
Frans Meulenbroeksa266fe92010-03-26 09:46:40 +0100133#define DISP_LINE_LEN 16
134
Peter Tyser655b34a2009-04-18 22:34:01 -0500135/* TODO: Implement architecture-specific get/set functions */
136unsigned int __def_i2c_get_bus_speed(void)
137{
138 return CONFIG_SYS_I2C_SPEED;
139}
140unsigned int i2c_get_bus_speed(void)
141 __attribute__((weak, alias("__def_i2c_get_bus_speed")));
142
143int __def_i2c_set_bus_speed(unsigned int speed)
144{
145 if (speed != CONFIG_SYS_I2C_SPEED)
146 return -1;
147
148 return 0;
149}
150int i2c_set_bus_speed(unsigned int)
151 __attribute__((weak, alias("__def_i2c_set_bus_speed")));
152
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100153/*
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100154 * get_alen: small parser helper function to get address length
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200155 * returns the address length
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100156 */
157static uint get_alen(char *arg)
158{
159 int j;
160 int alen;
161
162 alen = 1;
163 for (j = 0; j < 8; j++) {
164 if (arg[j] == '.') {
165 alen = arg[j+1] - '0';
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100166 break;
167 } else if (arg[j] == '\0')
168 break;
169 }
170 return alen;
171}
172
173/*
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100174 * Syntax:
175 * i2c read {i2c_chip} {devaddr}{.0, .1, .2} {len} {memaddr}
176 */
177
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200178static int do_i2c_read ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100179{
180 u_char chip;
181 uint devaddr, alen, length;
182 u_char *memaddr;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100183
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200184 if (argc != 5)
185 return cmd_usage(cmdtp);
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100186
187 /*
188 * I2C chip address
189 */
190 chip = simple_strtoul(argv[1], NULL, 16);
191
192 /*
193 * I2C data address within the chip. This can be 1 or
194 * 2 bytes long. Some day it might be 3 bytes long :-).
195 */
196 devaddr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100197 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200198 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200199 return cmd_usage(cmdtp);
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100200
201 /*
202 * Length is the number of objects, not number of bytes.
203 */
204 length = simple_strtoul(argv[3], NULL, 16);
205
206 /*
207 * memaddr is the address where to store things in memory
208 */
209 memaddr = (u_char *)simple_strtoul(argv[4], NULL, 16);
210
211 if (i2c_read(chip, devaddr, alen, memaddr, length) != 0) {
212 puts ("Error reading the chip.\n");
213 return 1;
214 }
215 return 0;
216}
217
Frans Meulenbroeks4a8cf332010-03-26 09:46:39 +0100218/*
219 * Syntax:
220 * i2c md {i2c_chip} {addr}{.0, .1, .2} {len}
221 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200222static int do_i2c_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000223{
224 u_char chip;
225 uint addr, alen, length;
226 int j, nbytes, linebytes;
227
228 /* We use the last specified parameters, unless new ones are
229 * entered.
230 */
231 chip = i2c_dp_last_chip;
232 addr = i2c_dp_last_addr;
233 alen = i2c_dp_last_alen;
234 length = i2c_dp_last_length;
235
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200236 if (argc < 3)
237 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000238
239 if ((flag & CMD_FLAG_REPEAT) == 0) {
240 /*
241 * New command specified.
242 */
wdenk81a88242002-10-26 15:22:42 +0000243
244 /*
245 * I2C chip address
246 */
247 chip = simple_strtoul(argv[1], NULL, 16);
248
249 /*
250 * I2C data address within the chip. This can be 1 or
251 * 2 bytes long. Some day it might be 3 bytes long :-).
252 */
253 addr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100254 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200255 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200256 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000257
258 /*
259 * If another parameter, it is the length to display.
260 * Length is the number of objects, not number of bytes.
261 */
262 if (argc > 3)
263 length = simple_strtoul(argv[3], NULL, 16);
264 }
265
266 /*
267 * Print the lines.
268 *
269 * We buffer all read data, so we can make sure data is read only
270 * once.
271 */
272 nbytes = length;
273 do {
274 unsigned char linebuf[DISP_LINE_LEN];
275 unsigned char *cp;
276
277 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
278
Timur Tabie857a5b2006-11-28 12:09:35 -0600279 if (i2c_read(chip, addr, alen, linebuf, linebytes) != 0)
wdenk4b9206e2004-03-23 22:14:11 +0000280 puts ("Error reading the chip.\n");
Timur Tabie857a5b2006-11-28 12:09:35 -0600281 else {
wdenk81a88242002-10-26 15:22:42 +0000282 printf("%04x:", addr);
283 cp = linebuf;
284 for (j=0; j<linebytes; j++) {
285 printf(" %02x", *cp++);
286 addr++;
287 }
wdenk4b9206e2004-03-23 22:14:11 +0000288 puts (" ");
wdenk81a88242002-10-26 15:22:42 +0000289 cp = linebuf;
290 for (j=0; j<linebytes; j++) {
291 if ((*cp < 0x20) || (*cp > 0x7e))
wdenk4b9206e2004-03-23 22:14:11 +0000292 puts (".");
wdenk81a88242002-10-26 15:22:42 +0000293 else
294 printf("%c", *cp);
295 cp++;
296 }
wdenk4b9206e2004-03-23 22:14:11 +0000297 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000298 }
299 nbytes -= linebytes;
300 } while (nbytes > 0);
301
302 i2c_dp_last_chip = chip;
303 i2c_dp_last_addr = addr;
304 i2c_dp_last_alen = alen;
305 i2c_dp_last_length = length;
306
307 return 0;
308}
309
wdenk81a88242002-10-26 15:22:42 +0000310
311/* Write (fill) memory
312 *
313 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500314 * i2c mw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
wdenk81a88242002-10-26 15:22:42 +0000315 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200316static int do_i2c_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000317{
318 uchar chip;
319 ulong addr;
320 uint alen;
321 uchar byte;
322 int count;
wdenk81a88242002-10-26 15:22:42 +0000323
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200324 if ((argc < 4) || (argc > 5))
325 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000326
327 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200328 * Chip is always specified.
329 */
wdenk81a88242002-10-26 15:22:42 +0000330 chip = simple_strtoul(argv[1], NULL, 16);
331
332 /*
333 * Address is always specified.
334 */
335 addr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100336 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200337 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200338 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000339
340 /*
341 * Value to write is always specified.
342 */
343 byte = simple_strtoul(argv[3], NULL, 16);
344
345 /*
346 * Optional count
347 */
Timur Tabie857a5b2006-11-28 12:09:35 -0600348 if (argc == 5)
wdenk81a88242002-10-26 15:22:42 +0000349 count = simple_strtoul(argv[4], NULL, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -0600350 else
wdenk81a88242002-10-26 15:22:42 +0000351 count = 1;
wdenk81a88242002-10-26 15:22:42 +0000352
353 while (count-- > 0) {
Timur Tabie857a5b2006-11-28 12:09:35 -0600354 if (i2c_write(chip, addr++, alen, &byte, 1) != 0)
wdenk4b9206e2004-03-23 22:14:11 +0000355 puts ("Error writing the chip.\n");
wdenk81a88242002-10-26 15:22:42 +0000356 /*
357 * Wait for the write to complete. The write can take
358 * up to 10mSec (we allow a little more time).
wdenk81a88242002-10-26 15:22:42 +0000359 */
d4f5c722005-08-12 21:16:13 +0200360/*
361 * No write delay with FRAM devices.
362 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200363#if !defined(CONFIG_SYS_I2C_FRAM)
wdenk81a88242002-10-26 15:22:42 +0000364 udelay(11000);
d4f5c722005-08-12 21:16:13 +0200365#endif
wdenk81a88242002-10-26 15:22:42 +0000366 }
367
368 return (0);
369}
370
wdenk81a88242002-10-26 15:22:42 +0000371/* Calculate a CRC on memory
372 *
373 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500374 * i2c crc32 {i2c_chip} {addr}{.0, .1, .2} {count}
wdenk81a88242002-10-26 15:22:42 +0000375 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200376static int do_i2c_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000377{
378 uchar chip;
379 ulong addr;
380 uint alen;
381 int count;
382 uchar byte;
383 ulong crc;
384 ulong err;
wdenk81a88242002-10-26 15:22:42 +0000385
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200386 if (argc < 4)
387 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000388
389 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200390 * Chip is always specified.
391 */
wdenk81a88242002-10-26 15:22:42 +0000392 chip = simple_strtoul(argv[1], NULL, 16);
393
394 /*
395 * Address is always specified.
396 */
397 addr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100398 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200399 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200400 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000401
402 /*
403 * Count is always specified
404 */
405 count = simple_strtoul(argv[3], NULL, 16);
406
407 printf ("CRC32 for %08lx ... %08lx ==> ", addr, addr + count - 1);
408 /*
409 * CRC a byte at a time. This is going to be slooow, but hey, the
410 * memories are small and slow too so hopefully nobody notices.
411 */
412 crc = 0;
413 err = 0;
Timur Tabie857a5b2006-11-28 12:09:35 -0600414 while (count-- > 0) {
415 if (i2c_read(chip, addr, alen, &byte, 1) != 0)
wdenk81a88242002-10-26 15:22:42 +0000416 err++;
wdenk81a88242002-10-26 15:22:42 +0000417 crc = crc32 (crc, &byte, 1);
418 addr++;
419 }
Timur Tabie857a5b2006-11-28 12:09:35 -0600420 if (err > 0)
wdenk4b9206e2004-03-23 22:14:11 +0000421 puts ("Error reading the chip,\n");
Timur Tabie857a5b2006-11-28 12:09:35 -0600422 else
wdenk81a88242002-10-26 15:22:42 +0000423 printf ("%08lx\n", crc);
wdenk81a88242002-10-26 15:22:42 +0000424
425 return 0;
426}
427
wdenk81a88242002-10-26 15:22:42 +0000428/* Modify memory.
429 *
430 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500431 * i2c mm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
432 * i2c nm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
wdenk81a88242002-10-26 15:22:42 +0000433 */
434
435static int
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200436mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000437{
438 uchar chip;
439 ulong addr;
440 uint alen;
441 ulong data;
442 int size = 1;
443 int nbytes;
wdenk81a88242002-10-26 15:22:42 +0000444 extern char console_buffer[];
445
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200446 if (argc != 3)
447 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000448
449#ifdef CONFIG_BOOT_RETRY_TIME
450 reset_cmd_timeout(); /* got a good command to get here */
451#endif
452 /*
453 * We use the last specified parameters, unless new ones are
454 * entered.
455 */
456 chip = i2c_mm_last_chip;
457 addr = i2c_mm_last_addr;
458 alen = i2c_mm_last_alen;
459
460 if ((flag & CMD_FLAG_REPEAT) == 0) {
461 /*
462 * New command specified. Check for a size specification.
463 * Defaults to byte if no or incorrect specification.
464 */
465 size = cmd_get_data_size(argv[0], 1);
466
467 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200468 * Chip is always specified.
469 */
wdenk81a88242002-10-26 15:22:42 +0000470 chip = simple_strtoul(argv[1], NULL, 16);
471
472 /*
473 * Address is always specified.
474 */
475 addr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100476 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200477 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200478 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000479 }
480
481 /*
482 * Print the address, followed by value. Then accept input for
483 * the next value. A non-converted value exits.
484 */
485 do {
486 printf("%08lx:", addr);
Timur Tabie857a5b2006-11-28 12:09:35 -0600487 if (i2c_read(chip, addr, alen, (uchar *)&data, size) != 0)
wdenk4b9206e2004-03-23 22:14:11 +0000488 puts ("\nError reading the chip,\n");
Timur Tabie857a5b2006-11-28 12:09:35 -0600489 else {
wdenk81a88242002-10-26 15:22:42 +0000490 data = cpu_to_be32(data);
Timur Tabie857a5b2006-11-28 12:09:35 -0600491 if (size == 1)
wdenk81a88242002-10-26 15:22:42 +0000492 printf(" %02lx", (data >> 24) & 0x000000FF);
Timur Tabie857a5b2006-11-28 12:09:35 -0600493 else if (size == 2)
wdenk81a88242002-10-26 15:22:42 +0000494 printf(" %04lx", (data >> 16) & 0x0000FFFF);
Timur Tabie857a5b2006-11-28 12:09:35 -0600495 else
wdenk81a88242002-10-26 15:22:42 +0000496 printf(" %08lx", data);
wdenk81a88242002-10-26 15:22:42 +0000497 }
498
499 nbytes = readline (" ? ");
500 if (nbytes == 0) {
501 /*
502 * <CR> pressed as only input, don't modify current
503 * location and move to next.
504 */
505 if (incrflag)
506 addr += size;
507 nbytes = size;
508#ifdef CONFIG_BOOT_RETRY_TIME
509 reset_cmd_timeout(); /* good enough to not time out */
510#endif
511 }
512#ifdef CONFIG_BOOT_RETRY_TIME
Timur Tabie857a5b2006-11-28 12:09:35 -0600513 else if (nbytes == -2)
wdenk81a88242002-10-26 15:22:42 +0000514 break; /* timed out, exit the command */
wdenk81a88242002-10-26 15:22:42 +0000515#endif
516 else {
517 char *endp;
518
519 data = simple_strtoul(console_buffer, &endp, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -0600520 if (size == 1)
wdenk81a88242002-10-26 15:22:42 +0000521 data = data << 24;
Timur Tabie857a5b2006-11-28 12:09:35 -0600522 else if (size == 2)
wdenk81a88242002-10-26 15:22:42 +0000523 data = data << 16;
wdenk81a88242002-10-26 15:22:42 +0000524 data = be32_to_cpu(data);
525 nbytes = endp - console_buffer;
526 if (nbytes) {
527#ifdef CONFIG_BOOT_RETRY_TIME
528 /*
529 * good enough to not time out
530 */
531 reset_cmd_timeout();
532#endif
Timur Tabie857a5b2006-11-28 12:09:35 -0600533 if (i2c_write(chip, addr, alen, (uchar *)&data, size) != 0)
wdenk4b9206e2004-03-23 22:14:11 +0000534 puts ("Error writing the chip.\n");
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200535#ifdef CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS
536 udelay(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
wdenk2535d602003-07-17 23:16:40 +0000537#endif
wdenk81a88242002-10-26 15:22:42 +0000538 if (incrflag)
539 addr += size;
540 }
541 }
542 } while (nbytes);
543
Peter Tyser08007072008-08-15 14:36:32 -0500544 i2c_mm_last_chip = chip;
545 i2c_mm_last_addr = addr;
546 i2c_mm_last_alen = alen;
wdenk81a88242002-10-26 15:22:42 +0000547
548 return 0;
549}
550
551/*
552 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500553 * i2c probe {addr}{.0, .1, .2}
wdenk81a88242002-10-26 15:22:42 +0000554 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200555static int do_i2c_probe (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000556{
557 int j;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200558#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000559 int k, skip;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400560 uchar bus = GET_BUS_NUM;
561#endif /* NOPROBES */
wdenk81a88242002-10-26 15:22:42 +0000562
wdenk4b9206e2004-03-23 22:14:11 +0000563 puts ("Valid chip addresses:");
Timur Tabie857a5b2006-11-28 12:09:35 -0600564 for (j = 0; j < 128; j++) {
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200565#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000566 skip = 0;
Timur Tabie857a5b2006-11-28 12:09:35 -0600567 for (k=0; k < NUM_ELEMENTS_NOPROBE; k++) {
568 if (COMPARE_BUS(bus, k) && COMPARE_ADDR(j, k)) {
wdenk81a88242002-10-26 15:22:42 +0000569 skip = 1;
570 break;
571 }
572 }
573 if (skip)
574 continue;
575#endif
Timur Tabie857a5b2006-11-28 12:09:35 -0600576 if (i2c_probe(j) == 0)
wdenk81a88242002-10-26 15:22:42 +0000577 printf(" %02X", j);
wdenk81a88242002-10-26 15:22:42 +0000578 }
wdenk4b9206e2004-03-23 22:14:11 +0000579 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000580
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200581#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000582 puts ("Excluded chip addresses:");
Timur Tabie857a5b2006-11-28 12:09:35 -0600583 for (k=0; k < NUM_ELEMENTS_NOPROBE; k++) {
584 if (COMPARE_BUS(bus,k))
Ben Warrenbb99ad62006-09-07 16:50:54 -0400585 printf(" %02X", NO_PROBE_ADDR(k));
586 }
wdenk4b9206e2004-03-23 22:14:11 +0000587 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000588#endif
589
590 return 0;
591}
592
wdenk81a88242002-10-26 15:22:42 +0000593/*
594 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500595 * i2c loop {i2c_chip} {addr}{.0, .1, .2} [{length}] [{delay}]
wdenk81a88242002-10-26 15:22:42 +0000596 * {length} - Number of bytes to read
597 * {delay} - A DECIMAL number and defaults to 1000 uSec
598 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200599static int do_i2c_loop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000600{
601 u_char chip;
602 ulong alen;
603 uint addr;
604 uint length;
605 u_char bytes[16];
606 int delay;
wdenk81a88242002-10-26 15:22:42 +0000607
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200608 if (argc < 3)
609 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000610
611 /*
612 * Chip is always specified.
613 */
614 chip = simple_strtoul(argv[1], NULL, 16);
615
616 /*
617 * Address is always specified.
618 */
619 addr = simple_strtoul(argv[2], NULL, 16);
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100620 alen = get_alen(argv[2]);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200621 if (alen > 3)
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200622 return cmd_usage(cmdtp);
wdenk81a88242002-10-26 15:22:42 +0000623
624 /*
625 * Length is the number of objects, not number of bytes.
626 */
627 length = 1;
628 length = simple_strtoul(argv[3], NULL, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -0600629 if (length > sizeof(bytes))
wdenk81a88242002-10-26 15:22:42 +0000630 length = sizeof(bytes);
wdenk81a88242002-10-26 15:22:42 +0000631
632 /*
633 * The delay time (uSec) is optional.
634 */
635 delay = 1000;
Timur Tabie857a5b2006-11-28 12:09:35 -0600636 if (argc > 3)
wdenk81a88242002-10-26 15:22:42 +0000637 delay = simple_strtoul(argv[4], NULL, 10);
wdenk81a88242002-10-26 15:22:42 +0000638 /*
639 * Run the loop...
640 */
Timur Tabie857a5b2006-11-28 12:09:35 -0600641 while (1) {
642 if (i2c_read(chip, addr, alen, bytes, length) != 0)
wdenk4b9206e2004-03-23 22:14:11 +0000643 puts ("Error reading the chip.\n");
wdenk81a88242002-10-26 15:22:42 +0000644 udelay(delay);
645 }
646
647 /* NOTREACHED */
648 return 0;
649}
650
wdenk81a88242002-10-26 15:22:42 +0000651/*
652 * The SDRAM command is separately configured because many
653 * (most?) embedded boards don't use SDRAM DIMMs.
654 */
Jon Loeligerc76fe472007-07-08 18:02:23 -0500655#if defined(CONFIG_CMD_SDRAM)
Larry Johnson632de062008-01-11 23:26:18 -0500656static void print_ddr2_tcyc (u_char const b)
657{
658 printf ("%d.", (b >> 4) & 0x0F);
659 switch (b & 0x0F) {
660 case 0x0:
661 case 0x1:
662 case 0x2:
663 case 0x3:
664 case 0x4:
665 case 0x5:
666 case 0x6:
667 case 0x7:
668 case 0x8:
669 case 0x9:
670 printf ("%d ns\n", b & 0x0F);
671 break;
672 case 0xA:
673 puts ("25 ns\n");
674 break;
675 case 0xB:
676 puts ("33 ns\n");
677 break;
678 case 0xC:
679 puts ("66 ns\n");
680 break;
681 case 0xD:
682 puts ("75 ns\n");
683 break;
684 default:
685 puts ("?? ns\n");
686 break;
687 }
688}
689
690static void decode_bits (u_char const b, char const *str[], int const do_once)
691{
692 u_char mask;
693
694 for (mask = 0x80; mask != 0x00; mask >>= 1, ++str) {
695 if (b & mask) {
696 puts (*str);
697 if (do_once)
698 return;
699 }
700 }
701}
wdenk81a88242002-10-26 15:22:42 +0000702
703/*
704 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500705 * i2c sdram {i2c_chip}
wdenk81a88242002-10-26 15:22:42 +0000706 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200707static int do_sdram (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000708{
Larry Johnson632de062008-01-11 23:26:18 -0500709 enum { unknown, EDO, SDRAM, DDR2 } type;
710
wdenk81a88242002-10-26 15:22:42 +0000711 u_char chip;
712 u_char data[128];
713 u_char cksum;
714 int j;
715
Larry Johnson632de062008-01-11 23:26:18 -0500716 static const char *decode_CAS_DDR2[] = {
717 " TBD", " 6", " 5", " 4", " 3", " 2", " TBD", " TBD"
718 };
719
720 static const char *decode_CAS_default[] = {
721 " TBD", " 7", " 6", " 5", " 4", " 3", " 2", " 1"
722 };
723
724 static const char *decode_CS_WE_default[] = {
725 " TBD", " 6", " 5", " 4", " 3", " 2", " 1", " 0"
726 };
727
728 static const char *decode_byte21_default[] = {
729 " TBD (bit 7)\n",
730 " Redundant row address\n",
731 " Differential clock input\n",
732 " Registerd DQMB inputs\n",
733 " Buffered DQMB inputs\n",
734 " On-card PLL\n",
735 " Registered address/control lines\n",
736 " Buffered address/control lines\n"
737 };
738
739 static const char *decode_byte22_DDR2[] = {
740 " TBD (bit 7)\n",
741 " TBD (bit 6)\n",
742 " TBD (bit 5)\n",
743 " TBD (bit 4)\n",
744 " TBD (bit 3)\n",
745 " Supports partial array self refresh\n",
746 " Supports 50 ohm ODT\n",
747 " Supports weak driver\n"
748 };
749
750 static const char *decode_row_density_DDR2[] = {
751 "512 MiB", "256 MiB", "128 MiB", "16 GiB",
752 "8 GiB", "4 GiB", "2 GiB", "1 GiB"
753 };
754
755 static const char *decode_row_density_default[] = {
756 "512 MiB", "256 MiB", "128 MiB", "64 MiB",
757 "32 MiB", "16 MiB", "8 MiB", "4 MiB"
758 };
759
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200760 if (argc < 2)
761 return cmd_usage(cmdtp);
762
wdenk81a88242002-10-26 15:22:42 +0000763 /*
764 * Chip is always specified.
Larry Johnson632de062008-01-11 23:26:18 -0500765 */
766 chip = simple_strtoul (argv[1], NULL, 16);
wdenk81a88242002-10-26 15:22:42 +0000767
Larry Johnson632de062008-01-11 23:26:18 -0500768 if (i2c_read (chip, 0, 1, data, sizeof (data)) != 0) {
wdenk4b9206e2004-03-23 22:14:11 +0000769 puts ("No SDRAM Serial Presence Detect found.\n");
wdenk81a88242002-10-26 15:22:42 +0000770 return 1;
771 }
772
773 cksum = 0;
774 for (j = 0; j < 63; j++) {
775 cksum += data[j];
776 }
Timur Tabie857a5b2006-11-28 12:09:35 -0600777 if (cksum != data[63]) {
wdenk81a88242002-10-26 15:22:42 +0000778 printf ("WARNING: Configuration data checksum failure:\n"
Larry Johnson632de062008-01-11 23:26:18 -0500779 " is 0x%02x, calculated 0x%02x\n", data[63], cksum);
wdenk81a88242002-10-26 15:22:42 +0000780 }
Larry Johnson632de062008-01-11 23:26:18 -0500781 printf ("SPD data revision %d.%d\n",
wdenk81a88242002-10-26 15:22:42 +0000782 (data[62] >> 4) & 0x0F, data[62] & 0x0F);
Larry Johnson632de062008-01-11 23:26:18 -0500783 printf ("Bytes used 0x%02X\n", data[0]);
784 printf ("Serial memory size 0x%02X\n", 1 << data[1]);
785
wdenk4b9206e2004-03-23 22:14:11 +0000786 puts ("Memory type ");
Larry Johnson632de062008-01-11 23:26:18 -0500787 switch (data[2]) {
Larry Johnson0df6b842008-01-10 22:23:39 -0500788 case 2:
789 type = EDO;
790 puts ("EDO\n");
791 break;
792 case 4:
793 type = SDRAM;
794 puts ("SDRAM\n");
795 break;
796 case 8:
797 type = DDR2;
798 puts ("DDR2\n");
799 break;
800 default:
801 type = unknown;
802 puts ("unknown\n");
803 break;
wdenk81a88242002-10-26 15:22:42 +0000804 }
Larry Johnson632de062008-01-11 23:26:18 -0500805
wdenk4b9206e2004-03-23 22:14:11 +0000806 puts ("Row address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -0600807 if ((data[3] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -0500808 printf ("%d\n", data[3] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -0600809 else
Larry Johnson632de062008-01-11 23:26:18 -0500810 printf ("%d/%d\n", data[3] & 0x0F, (data[3] >> 4) & 0x0F);
811
wdenk4b9206e2004-03-23 22:14:11 +0000812 puts ("Column address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -0600813 if ((data[4] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -0500814 printf ("%d\n", data[4] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -0600815 else
Larry Johnson632de062008-01-11 23:26:18 -0500816 printf ("%d/%d\n", data[4] & 0x0F, (data[4] >> 4) & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500817
818 switch (type) {
819 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500820 printf ("Number of ranks %d\n",
821 (data[5] & 0x07) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -0500822 break;
823 default:
Larry Johnson632de062008-01-11 23:26:18 -0500824 printf ("Module rows %d\n", data[5]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500825 break;
826 }
827
828 switch (type) {
829 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500830 printf ("Module data width %d bits\n", data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500831 break;
832 default:
Larry Johnson632de062008-01-11 23:26:18 -0500833 printf ("Module data width %d bits\n",
834 (data[7] << 8) | data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500835 break;
836 }
837
wdenk4b9206e2004-03-23 22:14:11 +0000838 puts ("Interface signal levels ");
wdenk81a88242002-10-26 15:22:42 +0000839 switch(data[8]) {
Larry Johnson0df6b842008-01-10 22:23:39 -0500840 case 0: puts ("TTL 5.0 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +0000841 case 1: puts ("LVTTL\n"); break;
Larry Johnson0df6b842008-01-10 22:23:39 -0500842 case 2: puts ("HSTL 1.5 V\n"); break;
843 case 3: puts ("SSTL 3.3 V\n"); break;
844 case 4: puts ("SSTL 2.5 V\n"); break;
845 case 5: puts ("SSTL 1.8 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +0000846 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +0000847 }
Larry Johnson0df6b842008-01-10 22:23:39 -0500848
849 switch (type) {
850 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500851 printf ("SDRAM cycle time ");
852 print_ddr2_tcyc (data[9]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500853 break;
854 default:
Larry Johnson632de062008-01-11 23:26:18 -0500855 printf ("SDRAM cycle time %d.%d ns\n",
856 (data[9] >> 4) & 0x0F, data[9] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500857 break;
858 }
859
860 switch (type) {
861 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500862 printf ("SDRAM access time 0.%d%d ns\n",
863 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500864 break;
865 default:
Larry Johnson632de062008-01-11 23:26:18 -0500866 printf ("SDRAM access time %d.%d ns\n",
867 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500868 break;
869 }
870
wdenk4b9206e2004-03-23 22:14:11 +0000871 puts ("EDC configuration ");
Larry Johnson632de062008-01-11 23:26:18 -0500872 switch (data[11]) {
wdenk4b9206e2004-03-23 22:14:11 +0000873 case 0: puts ("None\n"); break;
874 case 1: puts ("Parity\n"); break;
875 case 2: puts ("ECC\n"); break;
876 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +0000877 }
Larry Johnson632de062008-01-11 23:26:18 -0500878
Timur Tabie857a5b2006-11-28 12:09:35 -0600879 if ((data[12] & 0x80) == 0)
wdenk4b9206e2004-03-23 22:14:11 +0000880 puts ("No self refresh, rate ");
Timur Tabie857a5b2006-11-28 12:09:35 -0600881 else
wdenk4b9206e2004-03-23 22:14:11 +0000882 puts ("Self refresh, rate ");
Larry Johnson632de062008-01-11 23:26:18 -0500883
wdenk81a88242002-10-26 15:22:42 +0000884 switch(data[12] & 0x7F) {
Larry Johnson632de062008-01-11 23:26:18 -0500885 case 0: puts ("15.625 us\n"); break;
886 case 1: puts ("3.9 us\n"); break;
887 case 2: puts ("7.8 us\n"); break;
888 case 3: puts ("31.3 us\n"); break;
889 case 4: puts ("62.5 us\n"); break;
890 case 5: puts ("125 us\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +0000891 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +0000892 }
Larry Johnson0df6b842008-01-10 22:23:39 -0500893
894 switch (type) {
895 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500896 printf ("SDRAM width (primary) %d\n", data[13]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500897 break;
898 default:
Larry Johnson632de062008-01-11 23:26:18 -0500899 printf ("SDRAM width (primary) %d\n", data[13] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500900 if ((data[13] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -0500901 printf (" (second bank) %d\n",
902 2 * (data[13] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -0500903 }
904 break;
wdenk81a88242002-10-26 15:22:42 +0000905 }
Larry Johnson0df6b842008-01-10 22:23:39 -0500906
907 switch (type) {
908 case DDR2:
909 if (data[14] != 0)
Larry Johnson632de062008-01-11 23:26:18 -0500910 printf ("EDC width %d\n", data[14]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500911 break;
912 default:
913 if (data[14] != 0) {
Larry Johnson632de062008-01-11 23:26:18 -0500914 printf ("EDC width %d\n",
915 data[14] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -0500916
917 if ((data[14] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -0500918 printf (" (second bank) %d\n",
919 2 * (data[14] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -0500920 }
921 }
922 break;
923 }
924
Larry Johnson632de062008-01-11 23:26:18 -0500925 if (DDR2 != type) {
926 printf ("Min clock delay, back-to-back random column addresses "
927 "%d\n", data[15]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500928 }
929
wdenk4b9206e2004-03-23 22:14:11 +0000930 puts ("Burst length(s) ");
931 if (data[16] & 0x80) puts (" Page");
932 if (data[16] & 0x08) puts (" 8");
933 if (data[16] & 0x04) puts (" 4");
934 if (data[16] & 0x02) puts (" 2");
935 if (data[16] & 0x01) puts (" 1");
936 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -0500937 printf ("Number of banks %d\n", data[17]);
Larry Johnson0df6b842008-01-10 22:23:39 -0500938
939 switch (type) {
940 case DDR2:
941 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -0500942 decode_bits (data[18], decode_CAS_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500943 putc ('\n');
944 break;
945 default:
946 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -0500947 decode_bits (data[18], decode_CAS_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500948 putc ('\n');
949 break;
950 }
951
952 if (DDR2 != type) {
953 puts ("CS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -0500954 decode_bits (data[19], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500955 putc ('\n');
956 }
957
958 if (DDR2 != type) {
959 puts ("WE latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -0500960 decode_bits (data[20], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500961 putc ('\n');
962 }
963
964 switch (type) {
965 case DDR2:
966 puts ("Module attributes:\n");
967 if (data[21] & 0x80)
968 puts (" TBD (bit 7)\n");
969 if (data[21] & 0x40)
970 puts (" Analysis probe installed\n");
971 if (data[21] & 0x20)
972 puts (" TBD (bit 5)\n");
973 if (data[21] & 0x10)
974 puts (" FET switch external enable\n");
Larry Johnson632de062008-01-11 23:26:18 -0500975 printf (" %d PLLs on DIMM\n", (data[21] >> 2) & 0x03);
Larry Johnson0df6b842008-01-10 22:23:39 -0500976 if (data[20] & 0x11) {
Larry Johnson632de062008-01-11 23:26:18 -0500977 printf (" %d active registers on DIMM\n",
978 (data[21] & 0x03) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -0500979 }
980 break;
981 default:
982 puts ("Module attributes:\n");
983 if (!data[21])
984 puts (" (none)\n");
Larry Johnson632de062008-01-11 23:26:18 -0500985 else
986 decode_bits (data[21], decode_byte21_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500987 break;
988 }
989
990 switch (type) {
991 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -0500992 decode_bits (data[22], decode_byte22_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -0500993 break;
994 default:
995 puts ("Device attributes:\n");
996 if (data[22] & 0x80) puts (" TBD (bit 7)\n");
997 if (data[22] & 0x40) puts (" TBD (bit 6)\n");
998 if (data[22] & 0x20) puts (" Upper Vcc tolerance 5%\n");
999 else puts (" Upper Vcc tolerance 10%\n");
1000 if (data[22] & 0x10) puts (" Lower Vcc tolerance 5%\n");
1001 else puts (" Lower Vcc tolerance 10%\n");
1002 if (data[22] & 0x08) puts (" Supports write1/read burst\n");
1003 if (data[22] & 0x04) puts (" Supports precharge all\n");
1004 if (data[22] & 0x02) puts (" Supports auto precharge\n");
1005 if (data[22] & 0x01) puts (" Supports early RAS# precharge\n");
1006 break;
1007 }
1008
1009 switch (type) {
1010 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001011 printf ("SDRAM cycle time (2nd highest CAS latency) ");
1012 print_ddr2_tcyc (data[23]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001013 break;
1014 default:
Larry Johnson632de062008-01-11 23:26:18 -05001015 printf ("SDRAM cycle time (2nd highest CAS latency) %d."
1016 "%d ns\n", (data[23] >> 4) & 0x0F, data[23] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001017 break;
1018 }
1019
1020 switch (type) {
1021 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001022 printf ("SDRAM access from clock (2nd highest CAS latency) 0."
1023 "%d%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001024 break;
1025 default:
Larry Johnson632de062008-01-11 23:26:18 -05001026 printf ("SDRAM access from clock (2nd highest CAS latency) %d."
1027 "%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001028 break;
1029 }
1030
1031 switch (type) {
1032 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001033 printf ("SDRAM cycle time (3rd highest CAS latency) ");
1034 print_ddr2_tcyc (data[25]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001035 break;
1036 default:
Larry Johnson632de062008-01-11 23:26:18 -05001037 printf ("SDRAM cycle time (3rd highest CAS latency) %d."
1038 "%d ns\n", (data[25] >> 4) & 0x0F, data[25] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001039 break;
1040 }
1041
1042 switch (type) {
1043 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001044 printf ("SDRAM access from clock (3rd highest CAS latency) 0."
1045 "%d%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001046 break;
1047 default:
Larry Johnson632de062008-01-11 23:26:18 -05001048 printf ("SDRAM access from clock (3rd highest CAS latency) %d."
1049 "%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001050 break;
1051 }
1052
1053 switch (type) {
1054 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001055 printf ("Minimum row precharge %d.%02d ns\n",
1056 (data[27] >> 2) & 0x3F, 25 * (data[27] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001057 break;
1058 default:
Larry Johnson632de062008-01-11 23:26:18 -05001059 printf ("Minimum row precharge %d ns\n", data[27]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001060 break;
1061 }
1062
1063 switch (type) {
1064 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001065 printf ("Row active to row active min %d.%02d ns\n",
1066 (data[28] >> 2) & 0x3F, 25 * (data[28] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001067 break;
1068 default:
Larry Johnson632de062008-01-11 23:26:18 -05001069 printf ("Row active to row active min %d ns\n", data[28]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001070 break;
1071 }
1072
1073 switch (type) {
1074 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001075 printf ("RAS to CAS delay min %d.%02d ns\n",
1076 (data[29] >> 2) & 0x3F, 25 * (data[29] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001077 break;
1078 default:
Larry Johnson632de062008-01-11 23:26:18 -05001079 printf ("RAS to CAS delay min %d ns\n", data[29]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001080 break;
1081 }
1082
Larry Johnson632de062008-01-11 23:26:18 -05001083 printf ("Minimum RAS pulse width %d ns\n", data[30]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001084
1085 switch (type) {
1086 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001087 puts ("Density of each row ");
1088 decode_bits (data[31], decode_row_density_DDR2, 1);
1089 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001090 break;
1091 default:
Larry Johnson632de062008-01-11 23:26:18 -05001092 puts ("Density of each row ");
1093 decode_bits (data[31], decode_row_density_default, 1);
1094 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001095 break;
1096 }
1097
1098 switch (type) {
1099 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001100 puts ("Command and Address setup ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001101 if (data[32] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001102 printf ("1.%d%d ns\n",
1103 ((data[32] >> 4) & 0x0F) - 10, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001104 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001105 printf ("0.%d%d ns\n",
1106 ((data[32] >> 4) & 0x0F), data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001107 }
1108 break;
1109 default:
Larry Johnson632de062008-01-11 23:26:18 -05001110 printf ("Command and Address setup %c%d.%d ns\n",
1111 (data[32] & 0x80) ? '-' : '+',
1112 (data[32] >> 4) & 0x07, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001113 break;
1114 }
1115
1116 switch (type) {
1117 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001118 puts ("Command and Address hold ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001119 if (data[33] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001120 printf ("1.%d%d ns\n",
1121 ((data[33] >> 4) & 0x0F) - 10, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001122 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001123 printf ("0.%d%d ns\n",
1124 ((data[33] >> 4) & 0x0F), data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001125 }
1126 break;
1127 default:
Larry Johnson632de062008-01-11 23:26:18 -05001128 printf ("Command and Address hold %c%d.%d ns\n",
1129 (data[33] & 0x80) ? '-' : '+',
1130 (data[33] >> 4) & 0x07, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001131 break;
1132 }
1133
1134 switch (type) {
1135 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001136 printf ("Data signal input setup 0.%d%d ns\n",
1137 (data[34] >> 4) & 0x0F, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001138 break;
1139 default:
Larry Johnson632de062008-01-11 23:26:18 -05001140 printf ("Data signal input setup %c%d.%d ns\n",
1141 (data[34] & 0x80) ? '-' : '+',
1142 (data[34] >> 4) & 0x07, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001143 break;
1144 }
1145
1146 switch (type) {
1147 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001148 printf ("Data signal input hold 0.%d%d ns\n",
1149 (data[35] >> 4) & 0x0F, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001150 break;
1151 default:
Larry Johnson632de062008-01-11 23:26:18 -05001152 printf ("Data signal input hold %c%d.%d ns\n",
1153 (data[35] & 0x80) ? '-' : '+',
1154 (data[35] >> 4) & 0x07, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001155 break;
1156 }
1157
wdenk4b9206e2004-03-23 22:14:11 +00001158 puts ("Manufacturer's JEDEC ID ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001159 for (j = 64; j <= 71; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001160 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001161 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001162 printf ("Manufacturing Location %02X\n", data[72]);
wdenk4b9206e2004-03-23 22:14:11 +00001163 puts ("Manufacturer's Part Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001164 for (j = 73; j <= 90; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001165 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001166 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001167 printf ("Revision Code %02X %02X\n", data[91], data[92]);
1168 printf ("Manufacturing Date %02X %02X\n", data[93], data[94]);
wdenk4b9206e2004-03-23 22:14:11 +00001169 puts ("Assembly Serial Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001170 for (j = 95; j <= 98; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001171 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001172 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +00001173
Larry Johnson0df6b842008-01-10 22:23:39 -05001174 if (DDR2 != type) {
Larry Johnson632de062008-01-11 23:26:18 -05001175 printf ("Speed rating PC%d\n",
1176 data[126] == 0x66 ? 66 : data[126]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001177 }
wdenk81a88242002-10-26 15:22:42 +00001178 return 0;
1179}
Jon Loeliger90253172007-07-10 11:02:44 -05001180#endif
wdenk81a88242002-10-26 15:22:42 +00001181
Heiko Schocher67b23a32008-10-15 09:39:47 +02001182#if defined(CONFIG_I2C_MUX)
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001183static int do_i2c_add_bus(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Heiko Schocher67b23a32008-10-15 09:39:47 +02001184{
1185 int ret=0;
1186
1187 if (argc == 1) {
1188 /* show all busses */
1189 I2C_MUX *mux;
1190 I2C_MUX_DEVICE *device = i2c_mux_devices;
1191
1192 printf ("Busses reached over muxes:\n");
1193 while (device != NULL) {
1194 printf ("Bus ID: %x\n", device->busid);
1195 printf (" reached over Mux(es):\n");
1196 mux = device->mux;
1197 while (mux != NULL) {
1198 printf (" %s@%x ch: %x\n", mux->name, mux->chip, mux->channel);
1199 mux = mux->next;
1200 }
1201 device = device->next;
1202 }
1203 } else {
1204 I2C_MUX_DEVICE *dev;
1205
1206 dev = i2c_mux_ident_muxstring ((uchar *)argv[1]);
1207 ret = 0;
1208 }
1209 return ret;
1210}
1211#endif /* CONFIG_I2C_MUX */
1212
Ben Warrenbb99ad62006-09-07 16:50:54 -04001213#if defined(CONFIG_I2C_MULTI_BUS)
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001214static int do_i2c_bus_num(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001215{
1216 int bus_idx, ret=0;
1217
Timur Tabie857a5b2006-11-28 12:09:35 -06001218 if (argc == 1)
1219 /* querying current setting */
Ben Warrenbb99ad62006-09-07 16:50:54 -04001220 printf("Current bus is %d\n", i2c_get_bus_num());
Timur Tabie857a5b2006-11-28 12:09:35 -06001221 else {
Ben Warrenbb99ad62006-09-07 16:50:54 -04001222 bus_idx = simple_strtoul(argv[1], NULL, 10);
1223 printf("Setting bus to %d\n", bus_idx);
1224 ret = i2c_set_bus_num(bus_idx);
Timur Tabie857a5b2006-11-28 12:09:35 -06001225 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001226 printf("Failure changing bus number (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001227 }
1228 return ret;
1229}
1230#endif /* CONFIG_I2C_MULTI_BUS */
1231
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001232static int do_i2c_bus_speed(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001233{
1234 int speed, ret=0;
1235
Timur Tabie857a5b2006-11-28 12:09:35 -06001236 if (argc == 1)
1237 /* querying current speed */
Ben Warrenbb99ad62006-09-07 16:50:54 -04001238 printf("Current bus speed=%d\n", i2c_get_bus_speed());
Timur Tabie857a5b2006-11-28 12:09:35 -06001239 else {
Ben Warrenbb99ad62006-09-07 16:50:54 -04001240 speed = simple_strtoul(argv[1], NULL, 10);
1241 printf("Setting bus speed to %d Hz\n", speed);
1242 ret = i2c_set_bus_speed(speed);
Timur Tabie857a5b2006-11-28 12:09:35 -06001243 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001244 printf("Failure changing bus speed (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001245 }
1246 return ret;
1247}
1248
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001249static int do_i2c_mm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001250{
1251 return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
1252}
1253
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001254static int do_i2c_nm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001255{
1256 return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
1257}
1258
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001259static int do_i2c_reset(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001260{
1261 i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
1262 return 0;
1263}
1264
1265static cmd_tbl_t cmd_i2c_sub[] = {
1266#if defined(CONFIG_I2C_MUX)
1267 U_BOOT_CMD_MKENT(bus, 1, 1, do_i2c_add_bus, "", ""),
1268#endif /* CONFIG_I2C_MUX */
1269 U_BOOT_CMD_MKENT(crc32, 3, 1, do_i2c_crc, "", ""),
1270#if defined(CONFIG_I2C_MULTI_BUS)
1271 U_BOOT_CMD_MKENT(dev, 1, 1, do_i2c_bus_num, "", ""),
1272#endif /* CONFIG_I2C_MULTI_BUS */
1273 U_BOOT_CMD_MKENT(loop, 3, 1, do_i2c_loop, "", ""),
1274 U_BOOT_CMD_MKENT(md, 3, 1, do_i2c_md, "", ""),
1275 U_BOOT_CMD_MKENT(mm, 2, 1, do_i2c_mm, "", ""),
1276 U_BOOT_CMD_MKENT(mw, 3, 1, do_i2c_mw, "", ""),
1277 U_BOOT_CMD_MKENT(nm, 2, 1, do_i2c_nm, "", ""),
1278 U_BOOT_CMD_MKENT(probe, 0, 1, do_i2c_probe, "", ""),
Frans Meulenbroeks652e5352010-02-25 10:12:16 +01001279 U_BOOT_CMD_MKENT(read, 5, 1, do_i2c_read, "", ""),
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001280 U_BOOT_CMD_MKENT(reset, 0, 1, do_i2c_reset, "", ""),
1281#if defined(CONFIG_CMD_SDRAM)
1282 U_BOOT_CMD_MKENT(sdram, 1, 1, do_sdram, "", ""),
1283#endif
1284 U_BOOT_CMD_MKENT(speed, 1, 1, do_i2c_bus_speed, "", ""),
1285};
1286
Heiko Schocherf1d2b312010-09-17 13:10:39 +02001287#ifndef CONFIG_RELOC_FIXUP_WORKS
1288void i2c_reloc(void) {
1289 fixup_cmdtable(cmd_i2c_sub, ARRAY_SIZE(cmd_i2c_sub));
1290}
1291#endif
1292
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001293static int do_i2c(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001294{
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001295 cmd_tbl_t *c;
1296
Heiko Schocher4444b222010-09-17 13:10:35 +02001297 if (argc < 2)
1298 return cmd_usage(cmdtp);
1299
Peter Tysere96ad5d2009-04-18 22:34:04 -05001300 /* Strip off leading 'i2c' command argument */
1301 argc--;
1302 argv++;
1303
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001304 c = find_cmd_tbl(argv[0], &cmd_i2c_sub[0], ARRAY_SIZE(cmd_i2c_sub));
1305
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001306 if (c)
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001307 return c->cmd(cmdtp, flag, argc, argv);
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001308 else
1309 return cmd_usage(cmdtp);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001310}
wdenk8bde7f72003-06-27 21:31:46 +00001311
1312/***************************************************/
1313
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001314U_BOOT_CMD(
1315 i2c, 6, 1, do_i2c,
Peter Tyser2fb26042009-01-27 18:03:12 -06001316 "I2C sub-system",
Peter Tyser9166b772009-04-18 22:34:06 -05001317#if defined(CONFIG_I2C_MUX)
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001318 "bus [muxtype:muxaddr:muxchannel] - add a new bus reached over muxes\ni2c "
Peter Tyser9166b772009-04-18 22:34:06 -05001319#endif /* CONFIG_I2C_MUX */
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001320 "crc32 chip address[.0, .1, .2] count - compute CRC32 checksum\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001321#if defined(CONFIG_I2C_MULTI_BUS)
Peter Tyser9bc2e4e2008-10-01 12:25:04 -05001322 "i2c dev [dev] - show or set current I2C bus\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001323#endif /* CONFIG_I2C_MULTI_BUS */
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001324 "i2c loop chip address[.0, .1, .2] [# of objects] - looping read of device\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001325 "i2c md chip address[.0, .1, .2] [# of objects] - read from I2C device\n"
1326 "i2c mm chip address[.0, .1, .2] - write to I2C device (auto-incrementing)\n"
1327 "i2c mw chip address[.0, .1, .2] value [count] - write to I2C device (fill)\n"
1328 "i2c nm chip address[.0, .1, .2] - write to I2C device (constant address)\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001329 "i2c probe - show devices on the I2C bus\n"
Frans Meulenbroeks652e5352010-02-25 10:12:16 +01001330 "i2c read chip address[.0, .1, .2] length memaddress - read to memory \n"
Heiko Schochere43a27c2008-10-15 09:33:30 +02001331 "i2c reset - re-init the I2C Controller\n"
Jon Loeligerc76fe472007-07-08 18:02:23 -05001332#if defined(CONFIG_CMD_SDRAM)
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001333 "i2c sdram chip - print SDRAM configuration information\n"
Jon Loeliger90253172007-07-10 11:02:44 -05001334#endif
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001335 "i2c speed [speed] - show or set I2C bus speed"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001336);
Heiko Schocher67b23a32008-10-15 09:39:47 +02001337
1338#if defined(CONFIG_I2C_MUX)
Frans Meulenbroeksfd03ea82010-03-26 09:46:42 +01001339static int i2c_mux_add_device(I2C_MUX_DEVICE *dev)
Heiko Schocher67b23a32008-10-15 09:39:47 +02001340{
1341 I2C_MUX_DEVICE *devtmp = i2c_mux_devices;
1342
1343 if (i2c_mux_devices == NULL) {
1344 i2c_mux_devices = dev;
1345 return 0;
1346 }
1347 while (devtmp->next != NULL)
1348 devtmp = devtmp->next;
1349
1350 devtmp->next = dev;
1351 return 0;
1352}
1353
1354I2C_MUX_DEVICE *i2c_mux_search_device(int id)
1355{
1356 I2C_MUX_DEVICE *device = i2c_mux_devices;
1357
1358 while (device != NULL) {
1359 if (device->busid == id)
1360 return device;
1361 device = device->next;
1362 }
1363 return NULL;
1364}
1365
1366/* searches in the buf from *pos the next ':'.
1367 * returns:
1368 * 0 if found (with *pos = where)
1369 * < 0 if an error occured
1370 * > 0 if the end of buf is reached
1371 */
1372static int i2c_mux_search_next (int *pos, uchar *buf, int len)
1373{
1374 while ((buf[*pos] != ':') && (*pos < len)) {
1375 *pos += 1;
1376 }
1377 if (*pos >= len)
1378 return 1;
1379 if (buf[*pos] != ':')
1380 return -1;
1381 return 0;
1382}
1383
1384static int i2c_mux_get_busid (void)
1385{
1386 int tmp = i2c_mux_busid;
1387
1388 i2c_mux_busid ++;
1389 return tmp;
1390}
1391
1392/* Analyses a Muxstring and sends immediately the
1393 Commands to the Muxes. Runs from Flash.
1394 */
1395int i2c_mux_ident_muxstring_f (uchar *buf)
1396{
1397 int pos = 0;
1398 int oldpos;
1399 int ret = 0;
1400 int len = strlen((char *)buf);
1401 int chip;
1402 uchar channel;
1403 int was = 0;
1404
1405 while (ret == 0) {
1406 oldpos = pos;
1407 /* search name */
1408 ret = i2c_mux_search_next(&pos, buf, len);
1409 if (ret != 0)
1410 printf ("ERROR\n");
1411 /* search address */
1412 pos ++;
1413 oldpos = pos;
1414 ret = i2c_mux_search_next(&pos, buf, len);
1415 if (ret != 0)
1416 printf ("ERROR\n");
1417 buf[pos] = 0;
1418 chip = simple_strtoul((char *)&buf[oldpos], NULL, 16);
1419 buf[pos] = ':';
1420 /* search channel */
1421 pos ++;
1422 oldpos = pos;
1423 ret = i2c_mux_search_next(&pos, buf, len);
1424 if (ret < 0)
1425 printf ("ERROR\n");
1426 was = 0;
1427 if (buf[pos] != 0) {
1428 buf[pos] = 0;
1429 was = 1;
1430 }
1431 channel = simple_strtoul((char *)&buf[oldpos], NULL, 16);
1432 if (was)
1433 buf[pos] = ':';
1434 if (i2c_write(chip, 0, 0, &channel, 1) != 0) {
1435 printf ("Error setting Mux: chip:%x channel: \
1436 %x\n", chip, channel);
1437 return -1;
1438 }
1439 pos ++;
1440 oldpos = pos;
1441
1442 }
1443
1444 return 0;
1445}
1446
1447/* Analyses a Muxstring and if this String is correct
1448 * adds a new I2C Bus.
1449 */
1450I2C_MUX_DEVICE *i2c_mux_ident_muxstring (uchar *buf)
1451{
1452 I2C_MUX_DEVICE *device;
1453 I2C_MUX *mux;
1454 int pos = 0;
1455 int oldpos;
1456 int ret = 0;
1457 int len = strlen((char *)buf);
1458 int was = 0;
1459
1460 device = (I2C_MUX_DEVICE *)malloc (sizeof(I2C_MUX_DEVICE));
1461 device->mux = NULL;
1462 device->busid = i2c_mux_get_busid ();
1463 device->next = NULL;
1464 while (ret == 0) {
1465 mux = (I2C_MUX *)malloc (sizeof(I2C_MUX));
1466 mux->next = NULL;
1467 /* search name of mux */
1468 oldpos = pos;
1469 ret = i2c_mux_search_next(&pos, buf, len);
1470 if (ret != 0)
1471 printf ("%s no name.\n", __FUNCTION__);
1472 mux->name = (char *)malloc (pos - oldpos + 1);
1473 memcpy (mux->name, &buf[oldpos], pos - oldpos);
1474 mux->name[pos - oldpos] = 0;
1475 /* search address */
1476 pos ++;
1477 oldpos = pos;
1478 ret = i2c_mux_search_next(&pos, buf, len);
1479 if (ret != 0)
1480 printf ("%s no mux address.\n", __FUNCTION__);
1481 buf[pos] = 0;
1482 mux->chip = simple_strtoul((char *)&buf[oldpos], NULL, 16);
1483 buf[pos] = ':';
1484 /* search channel */
1485 pos ++;
1486 oldpos = pos;
1487 ret = i2c_mux_search_next(&pos, buf, len);
1488 if (ret < 0)
1489 printf ("%s no mux channel.\n", __FUNCTION__);
1490 was = 0;
1491 if (buf[pos] != 0) {
1492 buf[pos] = 0;
1493 was = 1;
1494 }
1495 mux->channel = simple_strtoul((char *)&buf[oldpos], NULL, 16);
1496 if (was)
1497 buf[pos] = ':';
1498 if (device->mux == NULL)
1499 device->mux = mux;
1500 else {
1501 I2C_MUX *muxtmp = device->mux;
1502 while (muxtmp->next != NULL) {
1503 muxtmp = muxtmp->next;
1504 }
1505 muxtmp->next = mux;
1506 }
1507 pos ++;
1508 oldpos = pos;
1509 }
1510 if (ret > 0) {
1511 /* Add Device */
1512 i2c_mux_add_device (device);
1513 return device;
1514 }
1515
1516 return NULL;
1517}
1518
1519int i2x_mux_select_mux(int bus)
1520{
1521 I2C_MUX_DEVICE *dev;
1522 I2C_MUX *mux;
1523
1524 if ((gd->flags & GD_FLG_RELOC) != GD_FLG_RELOC) {
1525 /* select Default Mux Bus */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001526#if defined(CONFIG_SYS_I2C_IVM_BUS)
1527 i2c_mux_ident_muxstring_f ((uchar *)CONFIG_SYS_I2C_IVM_BUS);
Heiko Schocher67b23a32008-10-15 09:39:47 +02001528#else
1529 {
1530 unsigned char *buf;
1531 buf = (unsigned char *) getenv("EEprom_ivm");
1532 if (buf != NULL)
1533 i2c_mux_ident_muxstring_f (buf);
1534 }
1535#endif
1536 return 0;
1537 }
1538 dev = i2c_mux_search_device(bus);
1539 if (dev == NULL)
1540 return -1;
1541
1542 mux = dev->mux;
1543 while (mux != NULL) {
1544 if (i2c_write(mux->chip, 0, 0, &mux->channel, 1) != 0) {
1545 printf ("Error setting Mux: chip:%x channel: \
1546 %x\n", mux->chip, mux->channel);
1547 return -1;
1548 }
1549 mux = mux->next;
1550 }
1551 return 0;
1552}
1553#endif /* CONFIG_I2C_MUX */