blob: 1bc0db860c3344dad85466fc52c0c61cddca3998 [file] [log] [blame]
wdenk81a88242002-10-26 15:22:42 +00001/*
Heiko Schocher3f4978c2012-01-16 21:12:24 +00002 * (C) Copyright 2009
3 * Sergey Kubushyn, himself, ksi@koi8.net
4 *
5 * Changes for unified multibus/multiadapter I2C support.
6 *
wdenk81a88242002-10-26 15:22:42 +00007 * (C) Copyright 2001
8 * Gerald Van Baren, Custom IDEAS, vanbaren@cideas.com.
9 *
Wolfgang Denk1a459662013-07-08 09:37:19 +020010 * SPDX-License-Identifier: GPL-2.0+
wdenk81a88242002-10-26 15:22:42 +000011 */
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 *
wdenk81a88242002-10-26 15:22:42 +000019 * {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
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020052 * CONFIG_SYS_I2C_EEPROM_ADDR_OVERFLOW and using the .1 modifier on the
wdenk81a88242002-10-26 15:22:42 +000053 * {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...
Peter Tyser0f89c542009-04-18 22:34:03 -050056 * i2c md 50 0 10 display 16 bytes starting at 0x000
wdenk81a88242002-10-26 15:22:42 +000057 * On the bus: <S> A0 00 <E> <S> A1 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050058 * i2c md 50 100 10 display 16 bytes starting at 0x100
wdenk81a88242002-10-26 15:22:42 +000059 * On the bus: <S> A2 00 <E> <S> A3 <rd> ... <rd>
Peter Tyser0f89c542009-04-18 22:34:03 -050060 * i2c md 50 210 10 display 16 bytes starting at 0x210
wdenk81a88242002-10-26 15:22:42 +000061 * 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>
Simon Glass0098e172014-04-10 20:01:30 -060069#include <bootretry.h>
Simon Glass18d66532014-04-10 20:01:25 -060070#include <cli.h>
wdenk81a88242002-10-26 15:22:42 +000071#include <command.h>
Simon Glass63656b72014-12-10 08:55:48 -070072#include <dm.h>
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +000073#include <edid.h>
Heiko Schocher67b23a32008-10-15 09:39:47 +020074#include <environment.h>
Simon Glass63656b72014-12-10 08:55:48 -070075#include <errno.h>
wdenk81a88242002-10-26 15:22:42 +000076#include <i2c.h>
Heiko Schocher67b23a32008-10-15 09:39:47 +020077#include <malloc.h>
wdenk81a88242002-10-26 15:22:42 +000078#include <asm/byteorder.h>
Marek Vasut2515d842012-11-12 14:34:25 +000079#include <linux/compiler.h>
wdenk81a88242002-10-26 15:22:42 +000080
Heiko Schocher3f4978c2012-01-16 21:12:24 +000081DECLARE_GLOBAL_DATA_PTR;
82
wdenk81a88242002-10-26 15:22:42 +000083/* Display values from last command.
84 * Memory modify remembered values are different from display memory.
85 */
Masahiro Yamada54684612014-12-20 03:34:23 +090086static uint i2c_dp_last_chip;
wdenk81a88242002-10-26 15:22:42 +000087static uint i2c_dp_last_addr;
88static uint i2c_dp_last_alen;
89static uint i2c_dp_last_length = 0x10;
90
Masahiro Yamada54684612014-12-20 03:34:23 +090091static uint i2c_mm_last_chip;
wdenk81a88242002-10-26 15:22:42 +000092static uint i2c_mm_last_addr;
93static uint i2c_mm_last_alen;
94
Ben Warrenbb99ad62006-09-07 16:50:54 -040095/* If only one I2C bus is present, the list of devices to ignore when
96 * the probe command is issued is represented by a 1D array of addresses.
97 * When multiple buses are present, the list is an array of bus-address
98 * pairs. The following macros take care of this */
99
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200100#if defined(CONFIG_SYS_I2C_NOPROBES)
Heiko Schocher9a2accb2012-10-25 10:32:14 +0200101#if defined(CONFIG_SYS_I2C) || defined(CONFIG_I2C_MULTI_BUS)
Ben Warrenbb99ad62006-09-07 16:50:54 -0400102static struct
103{
104 uchar bus;
105 uchar addr;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200106} i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400107#define GET_BUS_NUM i2c_get_bus_num()
108#define COMPARE_BUS(b,i) (i2c_no_probes[(i)].bus == (b))
109#define COMPARE_ADDR(a,i) (i2c_no_probes[(i)].addr == (a))
110#define NO_PROBE_ADDR(i) i2c_no_probes[(i)].addr
111#else /* single bus */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200112static uchar i2c_no_probes[] = CONFIG_SYS_I2C_NOPROBES;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400113#define GET_BUS_NUM 0
114#define COMPARE_BUS(b,i) ((b) == 0) /* Make compiler happy */
115#define COMPARE_ADDR(a,i) (i2c_no_probes[(i)] == (a))
116#define NO_PROBE_ADDR(i) i2c_no_probes[(i)]
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000117#endif /* defined(CONFIG_SYS_I2C) */
Heiko Schocher67b23a32008-10-15 09:39:47 +0200118#endif
119
Frans Meulenbroeksa266fe92010-03-26 09:46:40 +0100120#define DISP_LINE_LEN 16
121
Simon Glass63656b72014-12-10 08:55:48 -0700122/*
123 * Default for driver model is to use the chip's existing address length.
124 * For legacy code, this is not stored, so we need to use a suitable
125 * default.
126 */
127#ifdef CONFIG_DM_I2C
128#define DEFAULT_ADDR_LEN (-1)
129#else
130#define DEFAULT_ADDR_LEN 1
131#endif
132
133#ifdef CONFIG_DM_I2C
134static struct udevice *i2c_cur_bus;
135
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700136static int cmd_i2c_set_bus_num(unsigned int busnum)
Simon Glass63656b72014-12-10 08:55:48 -0700137{
138 struct udevice *bus;
139 int ret;
140
141 ret = uclass_get_device_by_seq(UCLASS_I2C, busnum, &bus);
142 if (ret) {
143 debug("%s: No bus %d\n", __func__, busnum);
144 return ret;
145 }
146 i2c_cur_bus = bus;
147
148 return 0;
149}
150
151static int i2c_get_cur_bus(struct udevice **busp)
152{
153 if (!i2c_cur_bus) {
154 puts("No I2C bus selected\n");
155 return -ENODEV;
156 }
157 *busp = i2c_cur_bus;
158
159 return 0;
160}
161
162static int i2c_get_cur_bus_chip(uint chip_addr, struct udevice **devp)
163{
164 struct udevice *bus;
165 int ret;
166
167 ret = i2c_get_cur_bus(&bus);
168 if (ret)
169 return ret;
170
Simon Glass25ab4b02015-01-25 08:26:55 -0700171 return i2c_get_chip(bus, chip_addr, 1, devp);
Simon Glass63656b72014-12-10 08:55:48 -0700172}
173
174#endif
175
Marek Vasut06afa382012-11-12 14:34:27 +0000176/**
177 * i2c_init_board() - Board-specific I2C bus init
178 *
179 * This function is the default no-op implementation of I2C bus
180 * initialization. This function can be overriden by board-specific
181 * implementation if needed.
182 */
Marek Vasut2515d842012-11-12 14:34:25 +0000183__weak
184void i2c_init_board(void)
Stefan Biglerc649dda2011-04-08 16:24:08 +0200185{
Stefan Biglerc649dda2011-04-08 16:24:08 +0200186}
Stefan Biglerc649dda2011-04-08 16:24:08 +0200187
Peter Tyser655b34a2009-04-18 22:34:01 -0500188/* TODO: Implement architecture-specific get/set functions */
Marek Vasut06afa382012-11-12 14:34:27 +0000189
190/**
191 * i2c_get_bus_speed() - Return I2C bus speed
192 *
193 * This function is the default implementation of function for retrieveing
194 * the current I2C bus speed in Hz.
195 *
196 * A driver implementing runtime switching of I2C bus speed must override
197 * this function to report the speed correctly. Simple or legacy drivers
198 * can use this fallback.
199 *
200 * Returns I2C bus speed in Hz.
201 */
Simon Glass63656b72014-12-10 08:55:48 -0700202#if !defined(CONFIG_SYS_I2C) && !defined(CONFIG_DM_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000203/*
204 * TODO: Implement architecture-specific get/set functions
205 * Should go away, if we switched completely to new multibus support
206 */
Marek Vasut2515d842012-11-12 14:34:25 +0000207__weak
208unsigned int i2c_get_bus_speed(void)
Peter Tyser655b34a2009-04-18 22:34:01 -0500209{
210 return CONFIG_SYS_I2C_SPEED;
211}
Peter Tyser655b34a2009-04-18 22:34:01 -0500212
Marek Vasut06afa382012-11-12 14:34:27 +0000213/**
214 * i2c_set_bus_speed() - Configure I2C bus speed
215 * @speed: Newly set speed of the I2C bus in Hz
216 *
217 * This function is the default implementation of function for setting
218 * the I2C bus speed in Hz.
219 *
220 * A driver implementing runtime switching of I2C bus speed must override
221 * this function to report the speed correctly. Simple or legacy drivers
222 * can use this fallback.
223 *
224 * Returns zero on success, negative value on error.
225 */
Marek Vasut2515d842012-11-12 14:34:25 +0000226__weak
227int i2c_set_bus_speed(unsigned int speed)
Peter Tyser655b34a2009-04-18 22:34:01 -0500228{
229 if (speed != CONFIG_SYS_I2C_SPEED)
230 return -1;
231
232 return 0;
233}
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000234#endif
Peter Tyser655b34a2009-04-18 22:34:01 -0500235
Marek Vasut06afa382012-11-12 14:34:27 +0000236/**
237 * get_alen() - Small parser helper function to get address length
238 *
239 * Returns the address length.
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100240 */
Simon Glass63656b72014-12-10 08:55:48 -0700241static uint get_alen(char *arg, int default_len)
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100242{
243 int j;
244 int alen;
245
Simon Glass63656b72014-12-10 08:55:48 -0700246 alen = default_len;
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100247 for (j = 0; j < 8; j++) {
248 if (arg[j] == '.') {
249 alen = arg[j+1] - '0';
Frans Meulenbroeks2c0dc992010-03-26 09:46:41 +0100250 break;
251 } else if (arg[j] == '\0')
252 break;
253 }
254 return alen;
255}
256
Simon Glassc1a6f372014-11-11 10:46:17 -0700257enum i2c_err_op {
258 I2C_ERR_READ,
259 I2C_ERR_WRITE,
260};
261
262static int i2c_report_err(int ret, enum i2c_err_op op)
263{
264 printf("Error %s the chip: %d\n",
265 op == I2C_ERR_READ ? "reading" : "writing", ret);
266
267 return CMD_RET_FAILURE;
268}
269
Marek Vasut06afa382012-11-12 14:34:27 +0000270/**
271 * do_i2c_read() - Handle the "i2c read" command-line command
272 * @cmdtp: Command data struct pointer
273 * @flag: Command flag
274 * @argc: Command-line argument count
275 * @argv: Array of command-line arguments
276 *
277 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
278 * on error.
279 *
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100280 * Syntax:
281 * i2c read {i2c_chip} {devaddr}{.0, .1, .2} {len} {memaddr}
282 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200283static int do_i2c_read ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100284{
Masahiro Yamada54684612014-12-20 03:34:23 +0900285 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700286 uint devaddr, length;
287 int alen;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100288 u_char *memaddr;
Simon Glass63656b72014-12-10 08:55:48 -0700289 int ret;
290#ifdef CONFIG_DM_I2C
291 struct udevice *dev;
292#endif
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100293
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200294 if (argc != 5)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000295 return CMD_RET_USAGE;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100296
297 /*
298 * I2C chip address
299 */
300 chip = simple_strtoul(argv[1], NULL, 16);
301
302 /*
303 * I2C data address within the chip. This can be 1 or
304 * 2 bytes long. Some day it might be 3 bytes long :-).
305 */
306 devaddr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700307 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200308 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000309 return CMD_RET_USAGE;
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100310
311 /*
312 * Length is the number of objects, not number of bytes.
313 */
314 length = simple_strtoul(argv[3], NULL, 16);
315
316 /*
317 * memaddr is the address where to store things in memory
318 */
319 memaddr = (u_char *)simple_strtoul(argv[4], NULL, 16);
320
Simon Glass63656b72014-12-10 08:55:48 -0700321#ifdef CONFIG_DM_I2C
322 ret = i2c_get_cur_bus_chip(chip, &dev);
323 if (!ret && alen != -1)
324 ret = i2c_set_chip_offset_len(dev, alen);
325 if (!ret)
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700326 ret = dm_i2c_read(dev, devaddr, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700327#else
328 ret = i2c_read(chip, devaddr, alen, memaddr, length);
329#endif
330 if (ret)
331 return i2c_report_err(ret, I2C_ERR_READ);
332
Frans Meulenbroeks652e5352010-02-25 10:12:16 +0100333 return 0;
334}
335
York Sunff5d2dc2012-09-16 08:02:30 +0000336static int do_i2c_write(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
337{
Masahiro Yamada54684612014-12-20 03:34:23 +0900338 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700339 uint devaddr, length;
340 int alen;
York Sunff5d2dc2012-09-16 08:02:30 +0000341 u_char *memaddr;
Simon Glass63656b72014-12-10 08:55:48 -0700342 int ret;
343#ifdef CONFIG_DM_I2C
344 struct udevice *dev;
Lubomir Popoved16f142015-01-30 19:56:04 +0200345 struct dm_i2c_chip *i2c_chip;
Simon Glass63656b72014-12-10 08:55:48 -0700346#endif
York Sunff5d2dc2012-09-16 08:02:30 +0000347
Lubomir Popoved16f142015-01-30 19:56:04 +0200348 if ((argc < 5) || (argc > 6))
York Sunff5d2dc2012-09-16 08:02:30 +0000349 return cmd_usage(cmdtp);
350
351 /*
352 * memaddr is the address where to store things in memory
353 */
354 memaddr = (u_char *)simple_strtoul(argv[1], NULL, 16);
355
356 /*
357 * I2C chip address
358 */
359 chip = simple_strtoul(argv[2], NULL, 16);
360
361 /*
362 * I2C data address within the chip. This can be 1 or
363 * 2 bytes long. Some day it might be 3 bytes long :-).
364 */
365 devaddr = simple_strtoul(argv[3], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700366 alen = get_alen(argv[3], DEFAULT_ADDR_LEN);
York Sunff5d2dc2012-09-16 08:02:30 +0000367 if (alen > 3)
368 return cmd_usage(cmdtp);
369
370 /*
Lubomir Popoved16f142015-01-30 19:56:04 +0200371 * Length is the number of bytes.
York Sunff5d2dc2012-09-16 08:02:30 +0000372 */
373 length = simple_strtoul(argv[4], NULL, 16);
374
Simon Glass63656b72014-12-10 08:55:48 -0700375#ifdef CONFIG_DM_I2C
376 ret = i2c_get_cur_bus_chip(chip, &dev);
377 if (!ret && alen != -1)
378 ret = i2c_set_chip_offset_len(dev, alen);
379 if (ret)
380 return i2c_report_err(ret, I2C_ERR_WRITE);
Lubomir Popoved16f142015-01-30 19:56:04 +0200381 i2c_chip = dev_get_parent_platdata(dev);
382 if (!i2c_chip)
383 return i2c_report_err(ret, I2C_ERR_WRITE);
Simon Glass63656b72014-12-10 08:55:48 -0700384#endif
385
Lubomir Popoved16f142015-01-30 19:56:04 +0200386 if (argc == 6 && !strcmp(argv[5], "-s")) {
387 /*
388 * Write all bytes in a single I2C transaction. If the target
389 * device is an EEPROM, it is your responsibility to not cross
390 * a page boundary. No write delay upon completion, take this
391 * into account if linking commands.
392 */
Simon Glass63656b72014-12-10 08:55:48 -0700393#ifdef CONFIG_DM_I2C
Lubomir Popoved16f142015-01-30 19:56:04 +0200394 i2c_chip->flags &= ~DM_I2C_CHIP_WR_ADDRESS;
395 ret = dm_i2c_write(dev, devaddr, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700396#else
Lubomir Popoved16f142015-01-30 19:56:04 +0200397 ret = i2c_write(chip, devaddr, alen, memaddr, length);
Simon Glass63656b72014-12-10 08:55:48 -0700398#endif
399 if (ret)
400 return i2c_report_err(ret, I2C_ERR_WRITE);
Lubomir Popoved16f142015-01-30 19:56:04 +0200401 } else {
402 /*
403 * Repeated addressing - perform <length> separate
404 * write transactions of one byte each
405 */
406 while (length-- > 0) {
407#ifdef CONFIG_DM_I2C
408 i2c_chip->flags |= DM_I2C_CHIP_WR_ADDRESS;
409 ret = dm_i2c_write(dev, devaddr++, memaddr++, 1);
410#else
411 ret = i2c_write(chip, devaddr++, alen, memaddr++, 1);
412#endif
413 if (ret)
414 return i2c_report_err(ret, I2C_ERR_WRITE);
York Sunff5d2dc2012-09-16 08:02:30 +0000415/*
416 * No write delay with FRAM devices.
417 */
418#if !defined(CONFIG_SYS_I2C_FRAM)
Lubomir Popoved16f142015-01-30 19:56:04 +0200419 udelay(11000);
York Sunff5d2dc2012-09-16 08:02:30 +0000420#endif
Lubomir Popoved16f142015-01-30 19:56:04 +0200421 }
York Sunff5d2dc2012-09-16 08:02:30 +0000422 }
423 return 0;
424}
425
Simon Glass63656b72014-12-10 08:55:48 -0700426#ifdef CONFIG_DM_I2C
427static int do_i2c_flags(cmd_tbl_t *cmdtp, int flag, int argc,
428 char *const argv[])
429{
430 struct udevice *dev;
431 uint flags;
432 int chip;
433 int ret;
434
435 if (argc < 2)
436 return CMD_RET_USAGE;
437
438 chip = simple_strtoul(argv[1], NULL, 16);
439 ret = i2c_get_cur_bus_chip(chip, &dev);
440 if (ret)
441 return i2c_report_err(ret, I2C_ERR_READ);
442
443 if (argc > 2) {
444 flags = simple_strtoul(argv[2], NULL, 16);
445 ret = i2c_set_chip_flags(dev, flags);
446 } else {
447 ret = i2c_get_chip_flags(dev, &flags);
448 if (!ret)
449 printf("%x\n", flags);
450 }
451 if (ret)
452 return i2c_report_err(ret, I2C_ERR_READ);
453
454 return 0;
455}
456#endif
457
Marek Vasut06afa382012-11-12 14:34:27 +0000458/**
459 * do_i2c_md() - Handle the "i2c md" command-line command
460 * @cmdtp: Command data struct pointer
461 * @flag: Command flag
462 * @argc: Command-line argument count
463 * @argv: Array of command-line arguments
464 *
465 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
466 * on error.
467 *
Frans Meulenbroeks4a8cf332010-03-26 09:46:39 +0100468 * Syntax:
469 * i2c md {i2c_chip} {addr}{.0, .1, .2} {len}
470 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200471static int do_i2c_md ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000472{
Masahiro Yamada54684612014-12-20 03:34:23 +0900473 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700474 uint addr, length;
475 int alen;
wdenk81a88242002-10-26 15:22:42 +0000476 int j, nbytes, linebytes;
Simon Glass63656b72014-12-10 08:55:48 -0700477 int ret;
478#ifdef CONFIG_DM_I2C
479 struct udevice *dev;
480#endif
wdenk81a88242002-10-26 15:22:42 +0000481
482 /* We use the last specified parameters, unless new ones are
483 * entered.
484 */
485 chip = i2c_dp_last_chip;
486 addr = i2c_dp_last_addr;
487 alen = i2c_dp_last_alen;
488 length = i2c_dp_last_length;
489
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200490 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000491 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000492
493 if ((flag & CMD_FLAG_REPEAT) == 0) {
494 /*
495 * New command specified.
496 */
wdenk81a88242002-10-26 15:22:42 +0000497
498 /*
499 * I2C chip address
500 */
501 chip = simple_strtoul(argv[1], NULL, 16);
502
503 /*
504 * I2C data address within the chip. This can be 1 or
505 * 2 bytes long. Some day it might be 3 bytes long :-).
506 */
507 addr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700508 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200509 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000510 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000511
512 /*
513 * If another parameter, it is the length to display.
514 * Length is the number of objects, not number of bytes.
515 */
516 if (argc > 3)
517 length = simple_strtoul(argv[3], NULL, 16);
518 }
519
Simon Glass63656b72014-12-10 08:55:48 -0700520#ifdef CONFIG_DM_I2C
521 ret = i2c_get_cur_bus_chip(chip, &dev);
522 if (!ret && alen != -1)
523 ret = i2c_set_chip_offset_len(dev, alen);
524 if (ret)
525 return i2c_report_err(ret, I2C_ERR_READ);
526#endif
527
wdenk81a88242002-10-26 15:22:42 +0000528 /*
529 * Print the lines.
530 *
531 * We buffer all read data, so we can make sure data is read only
532 * once.
533 */
534 nbytes = length;
535 do {
536 unsigned char linebuf[DISP_LINE_LEN];
537 unsigned char *cp;
538
539 linebytes = (nbytes > DISP_LINE_LEN) ? DISP_LINE_LEN : nbytes;
540
Simon Glass63656b72014-12-10 08:55:48 -0700541#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700542 ret = dm_i2c_read(dev, addr, linebuf, linebytes);
Simon Glass63656b72014-12-10 08:55:48 -0700543#else
544 ret = i2c_read(chip, addr, alen, linebuf, linebytes);
545#endif
546 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900547 return i2c_report_err(ret, I2C_ERR_READ);
Timur Tabie857a5b2006-11-28 12:09:35 -0600548 else {
wdenk81a88242002-10-26 15:22:42 +0000549 printf("%04x:", addr);
550 cp = linebuf;
551 for (j=0; j<linebytes; j++) {
552 printf(" %02x", *cp++);
553 addr++;
554 }
wdenk4b9206e2004-03-23 22:14:11 +0000555 puts (" ");
wdenk81a88242002-10-26 15:22:42 +0000556 cp = linebuf;
557 for (j=0; j<linebytes; j++) {
558 if ((*cp < 0x20) || (*cp > 0x7e))
wdenk4b9206e2004-03-23 22:14:11 +0000559 puts (".");
wdenk81a88242002-10-26 15:22:42 +0000560 else
561 printf("%c", *cp);
562 cp++;
563 }
wdenk4b9206e2004-03-23 22:14:11 +0000564 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000565 }
566 nbytes -= linebytes;
567 } while (nbytes > 0);
568
569 i2c_dp_last_chip = chip;
570 i2c_dp_last_addr = addr;
571 i2c_dp_last_alen = alen;
572 i2c_dp_last_length = length;
573
574 return 0;
575}
576
Marek Vasut06afa382012-11-12 14:34:27 +0000577/**
578 * do_i2c_mw() - Handle the "i2c mw" command-line command
579 * @cmdtp: Command data struct pointer
580 * @flag: Command flag
581 * @argc: Command-line argument count
582 * @argv: Array of command-line arguments
583 *
584 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
585 * on error.
wdenk81a88242002-10-26 15:22:42 +0000586 *
587 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500588 * i2c mw {i2c_chip} {addr}{.0, .1, .2} {data} [{count}]
wdenk81a88242002-10-26 15:22:42 +0000589 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200590static int do_i2c_mw ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000591{
Masahiro Yamada54684612014-12-20 03:34:23 +0900592 uint chip;
wdenk81a88242002-10-26 15:22:42 +0000593 ulong addr;
Simon Glass63656b72014-12-10 08:55:48 -0700594 int alen;
wdenk81a88242002-10-26 15:22:42 +0000595 uchar byte;
596 int count;
Simon Glass63656b72014-12-10 08:55:48 -0700597 int ret;
598#ifdef CONFIG_DM_I2C
599 struct udevice *dev;
600#endif
wdenk81a88242002-10-26 15:22:42 +0000601
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200602 if ((argc < 4) || (argc > 5))
Simon Glass4c12eeb2011-12-10 08:44:01 +0000603 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000604
605 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200606 * Chip is always specified.
607 */
wdenk81a88242002-10-26 15:22:42 +0000608 chip = simple_strtoul(argv[1], NULL, 16);
609
610 /*
611 * Address is always specified.
612 */
613 addr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700614 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200615 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000616 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000617
Simon Glass63656b72014-12-10 08:55:48 -0700618#ifdef CONFIG_DM_I2C
619 ret = i2c_get_cur_bus_chip(chip, &dev);
620 if (!ret && alen != -1)
621 ret = i2c_set_chip_offset_len(dev, alen);
622 if (ret)
623 return i2c_report_err(ret, I2C_ERR_WRITE);
624#endif
wdenk81a88242002-10-26 15:22:42 +0000625 /*
626 * Value to write is always specified.
627 */
628 byte = simple_strtoul(argv[3], NULL, 16);
629
630 /*
631 * Optional count
632 */
Timur Tabie857a5b2006-11-28 12:09:35 -0600633 if (argc == 5)
wdenk81a88242002-10-26 15:22:42 +0000634 count = simple_strtoul(argv[4], NULL, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -0600635 else
wdenk81a88242002-10-26 15:22:42 +0000636 count = 1;
wdenk81a88242002-10-26 15:22:42 +0000637
638 while (count-- > 0) {
Simon Glass63656b72014-12-10 08:55:48 -0700639#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700640 ret = dm_i2c_write(dev, addr++, &byte, 1);
Simon Glass63656b72014-12-10 08:55:48 -0700641#else
642 ret = i2c_write(chip, addr++, alen, &byte, 1);
643#endif
644 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900645 return i2c_report_err(ret, I2C_ERR_WRITE);
wdenk81a88242002-10-26 15:22:42 +0000646 /*
647 * Wait for the write to complete. The write can take
648 * up to 10mSec (we allow a little more time).
wdenk81a88242002-10-26 15:22:42 +0000649 */
d4f5c722005-08-12 21:16:13 +0200650/*
651 * No write delay with FRAM devices.
652 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200653#if !defined(CONFIG_SYS_I2C_FRAM)
wdenk81a88242002-10-26 15:22:42 +0000654 udelay(11000);
d4f5c722005-08-12 21:16:13 +0200655#endif
wdenk81a88242002-10-26 15:22:42 +0000656 }
657
Marek Vasut06afa382012-11-12 14:34:27 +0000658 return 0;
wdenk81a88242002-10-26 15:22:42 +0000659}
660
Marek Vasut06afa382012-11-12 14:34:27 +0000661/**
662 * do_i2c_crc() - Handle the "i2c crc32" command-line command
663 * @cmdtp: Command data struct pointer
664 * @flag: Command flag
665 * @argc: Command-line argument count
666 * @argv: Array of command-line arguments
667 *
668 * Calculate a CRC on memory
669 *
670 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
671 * on error.
wdenk81a88242002-10-26 15:22:42 +0000672 *
673 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500674 * i2c crc32 {i2c_chip} {addr}{.0, .1, .2} {count}
wdenk81a88242002-10-26 15:22:42 +0000675 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200676static int do_i2c_crc (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000677{
Masahiro Yamada54684612014-12-20 03:34:23 +0900678 uint chip;
wdenk81a88242002-10-26 15:22:42 +0000679 ulong addr;
Simon Glass63656b72014-12-10 08:55:48 -0700680 int alen;
wdenk81a88242002-10-26 15:22:42 +0000681 int count;
682 uchar byte;
683 ulong crc;
684 ulong err;
Simon Glass63656b72014-12-10 08:55:48 -0700685 int ret = 0;
686#ifdef CONFIG_DM_I2C
687 struct udevice *dev;
688#endif
wdenk81a88242002-10-26 15:22:42 +0000689
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200690 if (argc < 4)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000691 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000692
693 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200694 * Chip is always specified.
695 */
wdenk81a88242002-10-26 15:22:42 +0000696 chip = simple_strtoul(argv[1], NULL, 16);
697
698 /*
699 * Address is always specified.
700 */
701 addr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700702 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200703 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000704 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000705
Simon Glass63656b72014-12-10 08:55:48 -0700706#ifdef CONFIG_DM_I2C
707 ret = i2c_get_cur_bus_chip(chip, &dev);
708 if (!ret && alen != -1)
709 ret = i2c_set_chip_offset_len(dev, alen);
710 if (ret)
711 return i2c_report_err(ret, I2C_ERR_READ);
712#endif
wdenk81a88242002-10-26 15:22:42 +0000713 /*
714 * Count is always specified
715 */
716 count = simple_strtoul(argv[3], NULL, 16);
717
718 printf ("CRC32 for %08lx ... %08lx ==> ", addr, addr + count - 1);
719 /*
720 * CRC a byte at a time. This is going to be slooow, but hey, the
721 * memories are small and slow too so hopefully nobody notices.
722 */
723 crc = 0;
724 err = 0;
Timur Tabie857a5b2006-11-28 12:09:35 -0600725 while (count-- > 0) {
Simon Glass63656b72014-12-10 08:55:48 -0700726#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700727 ret = dm_i2c_read(dev, addr, &byte, 1);
Simon Glass63656b72014-12-10 08:55:48 -0700728#else
729 ret = i2c_read(chip, addr, alen, &byte, 1);
730#endif
731 if (ret)
wdenk81a88242002-10-26 15:22:42 +0000732 err++;
wdenk81a88242002-10-26 15:22:42 +0000733 crc = crc32 (crc, &byte, 1);
734 addr++;
735 }
Timur Tabie857a5b2006-11-28 12:09:35 -0600736 if (err > 0)
Simon Glass63656b72014-12-10 08:55:48 -0700737 i2c_report_err(ret, I2C_ERR_READ);
Timur Tabie857a5b2006-11-28 12:09:35 -0600738 else
wdenk81a88242002-10-26 15:22:42 +0000739 printf ("%08lx\n", crc);
wdenk81a88242002-10-26 15:22:42 +0000740
741 return 0;
742}
743
Marek Vasut06afa382012-11-12 14:34:27 +0000744/**
745 * mod_i2c_mem() - Handle the "i2c mm" and "i2c nm" command-line command
746 * @cmdtp: Command data struct pointer
747 * @flag: Command flag
748 * @argc: Command-line argument count
749 * @argv: Array of command-line arguments
750 *
751 * Modify memory.
752 *
753 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
754 * on error.
wdenk81a88242002-10-26 15:22:42 +0000755 *
756 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500757 * i2c mm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
758 * i2c nm{.b, .w, .l} {i2c_chip} {addr}{.0, .1, .2}
wdenk81a88242002-10-26 15:22:42 +0000759 */
wdenk81a88242002-10-26 15:22:42 +0000760static int
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200761mod_i2c_mem(cmd_tbl_t *cmdtp, int incrflag, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000762{
Masahiro Yamada54684612014-12-20 03:34:23 +0900763 uint chip;
wdenk81a88242002-10-26 15:22:42 +0000764 ulong addr;
Simon Glass63656b72014-12-10 08:55:48 -0700765 int alen;
wdenk81a88242002-10-26 15:22:42 +0000766 ulong data;
767 int size = 1;
768 int nbytes;
Simon Glass63656b72014-12-10 08:55:48 -0700769 int ret;
770#ifdef CONFIG_DM_I2C
771 struct udevice *dev;
772#endif
wdenk81a88242002-10-26 15:22:42 +0000773
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200774 if (argc != 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000775 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000776
Simon Glassb26440f2014-04-10 20:01:31 -0600777 bootretry_reset_cmd_timeout(); /* got a good command to get here */
wdenk81a88242002-10-26 15:22:42 +0000778 /*
779 * We use the last specified parameters, unless new ones are
780 * entered.
781 */
782 chip = i2c_mm_last_chip;
783 addr = i2c_mm_last_addr;
784 alen = i2c_mm_last_alen;
785
786 if ((flag & CMD_FLAG_REPEAT) == 0) {
787 /*
788 * New command specified. Check for a size specification.
789 * Defaults to byte if no or incorrect specification.
790 */
791 size = cmd_get_data_size(argv[0], 1);
792
793 /*
Wolfgang Denk53677ef2008-05-20 16:00:29 +0200794 * Chip is always specified.
795 */
wdenk81a88242002-10-26 15:22:42 +0000796 chip = simple_strtoul(argv[1], NULL, 16);
797
798 /*
799 * Address is always specified.
800 */
801 addr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -0700802 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +0200803 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000804 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000805 }
806
Simon Glass63656b72014-12-10 08:55:48 -0700807#ifdef CONFIG_DM_I2C
808 ret = i2c_get_cur_bus_chip(chip, &dev);
809 if (!ret && alen != -1)
810 ret = i2c_set_chip_offset_len(dev, alen);
811 if (ret)
812 return i2c_report_err(ret, I2C_ERR_WRITE);
813#endif
814
wdenk81a88242002-10-26 15:22:42 +0000815 /*
816 * Print the address, followed by value. Then accept input for
817 * the next value. A non-converted value exits.
818 */
819 do {
820 printf("%08lx:", addr);
Simon Glass63656b72014-12-10 08:55:48 -0700821#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700822 ret = dm_i2c_read(dev, addr, (uchar *)&data, size);
Simon Glass63656b72014-12-10 08:55:48 -0700823#else
824 ret = i2c_read(chip, addr, alen, (uchar *)&data, size);
825#endif
826 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900827 return i2c_report_err(ret, I2C_ERR_READ);
828
829 data = cpu_to_be32(data);
830 if (size == 1)
831 printf(" %02lx", (data >> 24) & 0x000000FF);
832 else if (size == 2)
833 printf(" %04lx", (data >> 16) & 0x0000FFFF);
834 else
835 printf(" %08lx", data);
wdenk81a88242002-10-26 15:22:42 +0000836
Simon Glasse1bf8242014-04-10 20:01:27 -0600837 nbytes = cli_readline(" ? ");
wdenk81a88242002-10-26 15:22:42 +0000838 if (nbytes == 0) {
839 /*
840 * <CR> pressed as only input, don't modify current
841 * location and move to next.
842 */
843 if (incrflag)
844 addr += size;
845 nbytes = size;
Simon Glassb26440f2014-04-10 20:01:31 -0600846 /* good enough to not time out */
847 bootretry_reset_cmd_timeout();
wdenk81a88242002-10-26 15:22:42 +0000848 }
849#ifdef CONFIG_BOOT_RETRY_TIME
Timur Tabie857a5b2006-11-28 12:09:35 -0600850 else if (nbytes == -2)
wdenk81a88242002-10-26 15:22:42 +0000851 break; /* timed out, exit the command */
wdenk81a88242002-10-26 15:22:42 +0000852#endif
853 else {
854 char *endp;
855
856 data = simple_strtoul(console_buffer, &endp, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -0600857 if (size == 1)
wdenk81a88242002-10-26 15:22:42 +0000858 data = data << 24;
Timur Tabie857a5b2006-11-28 12:09:35 -0600859 else if (size == 2)
wdenk81a88242002-10-26 15:22:42 +0000860 data = data << 16;
wdenk81a88242002-10-26 15:22:42 +0000861 data = be32_to_cpu(data);
862 nbytes = endp - console_buffer;
863 if (nbytes) {
wdenk81a88242002-10-26 15:22:42 +0000864 /*
865 * good enough to not time out
866 */
Simon Glassb26440f2014-04-10 20:01:31 -0600867 bootretry_reset_cmd_timeout();
Simon Glass63656b72014-12-10 08:55:48 -0700868#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700869 ret = dm_i2c_write(dev, addr, (uchar *)&data,
870 size);
Simon Glass63656b72014-12-10 08:55:48 -0700871#else
872 ret = i2c_write(chip, addr, alen,
873 (uchar *)&data, size);
874#endif
875 if (ret)
Masahiro Yamada9e533cb2015-02-05 13:50:26 +0900876 return i2c_report_err(ret,
877 I2C_ERR_WRITE);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200878#ifdef CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS
879 udelay(CONFIG_SYS_EEPROM_PAGE_WRITE_DELAY_MS * 1000);
wdenk2535d602003-07-17 23:16:40 +0000880#endif
wdenk81a88242002-10-26 15:22:42 +0000881 if (incrflag)
882 addr += size;
883 }
884 }
885 } while (nbytes);
886
Peter Tyser08007072008-08-15 14:36:32 -0500887 i2c_mm_last_chip = chip;
888 i2c_mm_last_addr = addr;
889 i2c_mm_last_alen = alen;
wdenk81a88242002-10-26 15:22:42 +0000890
891 return 0;
892}
893
Marek Vasut06afa382012-11-12 14:34:27 +0000894/**
895 * do_i2c_probe() - Handle the "i2c probe" command-line command
896 * @cmdtp: Command data struct pointer
897 * @flag: Command flag
898 * @argc: Command-line argument count
899 * @argv: Array of command-line arguments
900 *
901 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
902 * on error.
903 *
wdenk81a88242002-10-26 15:22:42 +0000904 * Syntax:
Eric Nelson54b99e52012-09-23 10:12:56 +0000905 * i2c probe {addr}
906 *
907 * Returns zero (success) if one or more I2C devices was found
wdenk81a88242002-10-26 15:22:42 +0000908 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200909static int do_i2c_probe (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000910{
911 int j;
Eric Nelson54b99e52012-09-23 10:12:56 +0000912 int addr = -1;
913 int found = 0;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200914#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000915 int k, skip;
Heiko Schocher3f4978c2012-01-16 21:12:24 +0000916 unsigned int bus = GET_BUS_NUM;
Ben Warrenbb99ad62006-09-07 16:50:54 -0400917#endif /* NOPROBES */
Simon Glass63656b72014-12-10 08:55:48 -0700918 int ret;
919#ifdef CONFIG_DM_I2C
920 struct udevice *bus, *dev;
921
922 if (i2c_get_cur_bus(&bus))
923 return CMD_RET_FAILURE;
924#endif
wdenk81a88242002-10-26 15:22:42 +0000925
Eric Nelson54b99e52012-09-23 10:12:56 +0000926 if (argc == 2)
927 addr = simple_strtol(argv[1], 0, 16);
928
wdenk4b9206e2004-03-23 22:14:11 +0000929 puts ("Valid chip addresses:");
Timur Tabie857a5b2006-11-28 12:09:35 -0600930 for (j = 0; j < 128; j++) {
Eric Nelson54b99e52012-09-23 10:12:56 +0000931 if ((0 <= addr) && (j != addr))
932 continue;
933
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200934#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000935 skip = 0;
Axel Lincfb25cc2013-06-22 21:56:35 +0800936 for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
Timur Tabie857a5b2006-11-28 12:09:35 -0600937 if (COMPARE_BUS(bus, k) && COMPARE_ADDR(j, k)) {
wdenk81a88242002-10-26 15:22:42 +0000938 skip = 1;
939 break;
940 }
941 }
942 if (skip)
943 continue;
944#endif
Simon Glass63656b72014-12-10 08:55:48 -0700945#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -0700946 ret = dm_i2c_probe(bus, j, 0, &dev);
Simon Glass63656b72014-12-10 08:55:48 -0700947#else
948 ret = i2c_probe(j);
949#endif
950 if (ret == 0) {
wdenk81a88242002-10-26 15:22:42 +0000951 printf(" %02X", j);
Eric Nelson54b99e52012-09-23 10:12:56 +0000952 found++;
953 }
wdenk81a88242002-10-26 15:22:42 +0000954 }
wdenk4b9206e2004-03-23 22:14:11 +0000955 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000956
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200957#if defined(CONFIG_SYS_I2C_NOPROBES)
wdenk81a88242002-10-26 15:22:42 +0000958 puts ("Excluded chip addresses:");
Axel Lincfb25cc2013-06-22 21:56:35 +0800959 for (k = 0; k < ARRAY_SIZE(i2c_no_probes); k++) {
Timur Tabie857a5b2006-11-28 12:09:35 -0600960 if (COMPARE_BUS(bus,k))
Ben Warrenbb99ad62006-09-07 16:50:54 -0400961 printf(" %02X", NO_PROBE_ADDR(k));
962 }
wdenk4b9206e2004-03-23 22:14:11 +0000963 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +0000964#endif
965
Eric Nelson54b99e52012-09-23 10:12:56 +0000966 return (0 == found);
wdenk81a88242002-10-26 15:22:42 +0000967}
968
Marek Vasut06afa382012-11-12 14:34:27 +0000969/**
970 * do_i2c_loop() - Handle the "i2c loop" command-line command
971 * @cmdtp: Command data struct pointer
972 * @flag: Command flag
973 * @argc: Command-line argument count
974 * @argv: Array of command-line arguments
975 *
976 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
977 * on error.
978 *
wdenk81a88242002-10-26 15:22:42 +0000979 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -0500980 * i2c loop {i2c_chip} {addr}{.0, .1, .2} [{length}] [{delay}]
wdenk81a88242002-10-26 15:22:42 +0000981 * {length} - Number of bytes to read
982 * {delay} - A DECIMAL number and defaults to 1000 uSec
983 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200984static int do_i2c_loop(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +0000985{
Masahiro Yamada54684612014-12-20 03:34:23 +0900986 uint chip;
Simon Glass63656b72014-12-10 08:55:48 -0700987 int alen;
wdenk81a88242002-10-26 15:22:42 +0000988 uint addr;
989 uint length;
990 u_char bytes[16];
991 int delay;
Simon Glass63656b72014-12-10 08:55:48 -0700992 int ret;
993#ifdef CONFIG_DM_I2C
994 struct udevice *dev;
995#endif
wdenk81a88242002-10-26 15:22:42 +0000996
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200997 if (argc < 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +0000998 return CMD_RET_USAGE;
wdenk81a88242002-10-26 15:22:42 +0000999
1000 /*
1001 * Chip is always specified.
1002 */
1003 chip = simple_strtoul(argv[1], NULL, 16);
1004
1005 /*
1006 * Address is always specified.
1007 */
1008 addr = simple_strtoul(argv[2], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -07001009 alen = get_alen(argv[2], DEFAULT_ADDR_LEN);
Reinhard Meyer7a92e532010-08-25 14:41:16 +02001010 if (alen > 3)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001011 return CMD_RET_USAGE;
Simon Glass63656b72014-12-10 08:55:48 -07001012#ifdef CONFIG_DM_I2C
1013 ret = i2c_get_cur_bus_chip(chip, &dev);
1014 if (!ret && alen != -1)
1015 ret = i2c_set_chip_offset_len(dev, alen);
1016 if (ret)
1017 return i2c_report_err(ret, I2C_ERR_WRITE);
1018#endif
wdenk81a88242002-10-26 15:22:42 +00001019
1020 /*
1021 * Length is the number of objects, not number of bytes.
1022 */
1023 length = 1;
1024 length = simple_strtoul(argv[3], NULL, 16);
Timur Tabie857a5b2006-11-28 12:09:35 -06001025 if (length > sizeof(bytes))
wdenk81a88242002-10-26 15:22:42 +00001026 length = sizeof(bytes);
wdenk81a88242002-10-26 15:22:42 +00001027
1028 /*
1029 * The delay time (uSec) is optional.
1030 */
1031 delay = 1000;
Timur Tabie857a5b2006-11-28 12:09:35 -06001032 if (argc > 3)
wdenk81a88242002-10-26 15:22:42 +00001033 delay = simple_strtoul(argv[4], NULL, 10);
wdenk81a88242002-10-26 15:22:42 +00001034 /*
1035 * Run the loop...
1036 */
Timur Tabie857a5b2006-11-28 12:09:35 -06001037 while (1) {
Simon Glass63656b72014-12-10 08:55:48 -07001038#ifdef CONFIG_DM_I2C
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001039 ret = dm_i2c_read(dev, addr, bytes, length);
Simon Glass63656b72014-12-10 08:55:48 -07001040#else
1041 ret = i2c_read(chip, addr, alen, bytes, length);
1042#endif
1043 if (ret)
1044 i2c_report_err(ret, I2C_ERR_READ);
wdenk81a88242002-10-26 15:22:42 +00001045 udelay(delay);
1046 }
1047
1048 /* NOTREACHED */
1049 return 0;
1050}
1051
wdenk81a88242002-10-26 15:22:42 +00001052/*
1053 * The SDRAM command is separately configured because many
1054 * (most?) embedded boards don't use SDRAM DIMMs.
Marek Vasut06afa382012-11-12 14:34:27 +00001055 *
1056 * FIXME: Document and probably move elsewhere!
wdenk81a88242002-10-26 15:22:42 +00001057 */
Jon Loeligerc76fe472007-07-08 18:02:23 -05001058#if defined(CONFIG_CMD_SDRAM)
Larry Johnson632de062008-01-11 23:26:18 -05001059static void print_ddr2_tcyc (u_char const b)
1060{
1061 printf ("%d.", (b >> 4) & 0x0F);
1062 switch (b & 0x0F) {
1063 case 0x0:
1064 case 0x1:
1065 case 0x2:
1066 case 0x3:
1067 case 0x4:
1068 case 0x5:
1069 case 0x6:
1070 case 0x7:
1071 case 0x8:
1072 case 0x9:
1073 printf ("%d ns\n", b & 0x0F);
1074 break;
1075 case 0xA:
1076 puts ("25 ns\n");
1077 break;
1078 case 0xB:
1079 puts ("33 ns\n");
1080 break;
1081 case 0xC:
1082 puts ("66 ns\n");
1083 break;
1084 case 0xD:
1085 puts ("75 ns\n");
1086 break;
1087 default:
1088 puts ("?? ns\n");
1089 break;
1090 }
1091}
1092
1093static void decode_bits (u_char const b, char const *str[], int const do_once)
1094{
1095 u_char mask;
1096
1097 for (mask = 0x80; mask != 0x00; mask >>= 1, ++str) {
1098 if (b & mask) {
1099 puts (*str);
1100 if (do_once)
1101 return;
1102 }
1103 }
1104}
wdenk81a88242002-10-26 15:22:42 +00001105
1106/*
1107 * Syntax:
Peter Tyser0f89c542009-04-18 22:34:03 -05001108 * i2c sdram {i2c_chip}
wdenk81a88242002-10-26 15:22:42 +00001109 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001110static int do_sdram (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
wdenk81a88242002-10-26 15:22:42 +00001111{
Larry Johnson632de062008-01-11 23:26:18 -05001112 enum { unknown, EDO, SDRAM, DDR2 } type;
1113
Masahiro Yamada54684612014-12-20 03:34:23 +09001114 uint chip;
wdenk81a88242002-10-26 15:22:42 +00001115 u_char data[128];
1116 u_char cksum;
1117 int j;
1118
Larry Johnson632de062008-01-11 23:26:18 -05001119 static const char *decode_CAS_DDR2[] = {
1120 " TBD", " 6", " 5", " 4", " 3", " 2", " TBD", " TBD"
1121 };
1122
1123 static const char *decode_CAS_default[] = {
1124 " TBD", " 7", " 6", " 5", " 4", " 3", " 2", " 1"
1125 };
1126
1127 static const char *decode_CS_WE_default[] = {
1128 " TBD", " 6", " 5", " 4", " 3", " 2", " 1", " 0"
1129 };
1130
1131 static const char *decode_byte21_default[] = {
1132 " TBD (bit 7)\n",
1133 " Redundant row address\n",
1134 " Differential clock input\n",
1135 " Registerd DQMB inputs\n",
1136 " Buffered DQMB inputs\n",
1137 " On-card PLL\n",
1138 " Registered address/control lines\n",
1139 " Buffered address/control lines\n"
1140 };
1141
1142 static const char *decode_byte22_DDR2[] = {
1143 " TBD (bit 7)\n",
1144 " TBD (bit 6)\n",
1145 " TBD (bit 5)\n",
1146 " TBD (bit 4)\n",
1147 " TBD (bit 3)\n",
1148 " Supports partial array self refresh\n",
1149 " Supports 50 ohm ODT\n",
1150 " Supports weak driver\n"
1151 };
1152
1153 static const char *decode_row_density_DDR2[] = {
1154 "512 MiB", "256 MiB", "128 MiB", "16 GiB",
1155 "8 GiB", "4 GiB", "2 GiB", "1 GiB"
1156 };
1157
1158 static const char *decode_row_density_default[] = {
1159 "512 MiB", "256 MiB", "128 MiB", "64 MiB",
1160 "32 MiB", "16 MiB", "8 MiB", "4 MiB"
1161 };
1162
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001163 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001164 return CMD_RET_USAGE;
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001165
wdenk81a88242002-10-26 15:22:42 +00001166 /*
1167 * Chip is always specified.
Larry Johnson632de062008-01-11 23:26:18 -05001168 */
1169 chip = simple_strtoul (argv[1], NULL, 16);
wdenk81a88242002-10-26 15:22:42 +00001170
Larry Johnson632de062008-01-11 23:26:18 -05001171 if (i2c_read (chip, 0, 1, data, sizeof (data)) != 0) {
wdenk4b9206e2004-03-23 22:14:11 +00001172 puts ("No SDRAM Serial Presence Detect found.\n");
wdenk81a88242002-10-26 15:22:42 +00001173 return 1;
1174 }
1175
1176 cksum = 0;
1177 for (j = 0; j < 63; j++) {
1178 cksum += data[j];
1179 }
Timur Tabie857a5b2006-11-28 12:09:35 -06001180 if (cksum != data[63]) {
wdenk81a88242002-10-26 15:22:42 +00001181 printf ("WARNING: Configuration data checksum failure:\n"
Larry Johnson632de062008-01-11 23:26:18 -05001182 " is 0x%02x, calculated 0x%02x\n", data[63], cksum);
wdenk81a88242002-10-26 15:22:42 +00001183 }
Larry Johnson632de062008-01-11 23:26:18 -05001184 printf ("SPD data revision %d.%d\n",
wdenk81a88242002-10-26 15:22:42 +00001185 (data[62] >> 4) & 0x0F, data[62] & 0x0F);
Larry Johnson632de062008-01-11 23:26:18 -05001186 printf ("Bytes used 0x%02X\n", data[0]);
1187 printf ("Serial memory size 0x%02X\n", 1 << data[1]);
1188
wdenk4b9206e2004-03-23 22:14:11 +00001189 puts ("Memory type ");
Larry Johnson632de062008-01-11 23:26:18 -05001190 switch (data[2]) {
Larry Johnson0df6b842008-01-10 22:23:39 -05001191 case 2:
1192 type = EDO;
1193 puts ("EDO\n");
1194 break;
1195 case 4:
1196 type = SDRAM;
1197 puts ("SDRAM\n");
1198 break;
1199 case 8:
1200 type = DDR2;
1201 puts ("DDR2\n");
1202 break;
1203 default:
1204 type = unknown;
1205 puts ("unknown\n");
1206 break;
wdenk81a88242002-10-26 15:22:42 +00001207 }
Larry Johnson632de062008-01-11 23:26:18 -05001208
wdenk4b9206e2004-03-23 22:14:11 +00001209 puts ("Row address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001210 if ((data[3] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -05001211 printf ("%d\n", data[3] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -06001212 else
Larry Johnson632de062008-01-11 23:26:18 -05001213 printf ("%d/%d\n", data[3] & 0x0F, (data[3] >> 4) & 0x0F);
1214
wdenk4b9206e2004-03-23 22:14:11 +00001215 puts ("Column address bits ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001216 if ((data[4] & 0x00F0) == 0)
Larry Johnson632de062008-01-11 23:26:18 -05001217 printf ("%d\n", data[4] & 0x0F);
Timur Tabie857a5b2006-11-28 12:09:35 -06001218 else
Larry Johnson632de062008-01-11 23:26:18 -05001219 printf ("%d/%d\n", data[4] & 0x0F, (data[4] >> 4) & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001220
1221 switch (type) {
1222 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001223 printf ("Number of ranks %d\n",
1224 (data[5] & 0x07) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -05001225 break;
1226 default:
Larry Johnson632de062008-01-11 23:26:18 -05001227 printf ("Module rows %d\n", data[5]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001228 break;
1229 }
1230
1231 switch (type) {
1232 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001233 printf ("Module data width %d bits\n", data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001234 break;
1235 default:
Larry Johnson632de062008-01-11 23:26:18 -05001236 printf ("Module data width %d bits\n",
1237 (data[7] << 8) | data[6]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001238 break;
1239 }
1240
wdenk4b9206e2004-03-23 22:14:11 +00001241 puts ("Interface signal levels ");
wdenk81a88242002-10-26 15:22:42 +00001242 switch(data[8]) {
Larry Johnson0df6b842008-01-10 22:23:39 -05001243 case 0: puts ("TTL 5.0 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001244 case 1: puts ("LVTTL\n"); break;
Larry Johnson0df6b842008-01-10 22:23:39 -05001245 case 2: puts ("HSTL 1.5 V\n"); break;
1246 case 3: puts ("SSTL 3.3 V\n"); break;
1247 case 4: puts ("SSTL 2.5 V\n"); break;
1248 case 5: puts ("SSTL 1.8 V\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001249 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001250 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001251
1252 switch (type) {
1253 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001254 printf ("SDRAM cycle time ");
1255 print_ddr2_tcyc (data[9]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001256 break;
1257 default:
Larry Johnson632de062008-01-11 23:26:18 -05001258 printf ("SDRAM cycle time %d.%d ns\n",
1259 (data[9] >> 4) & 0x0F, data[9] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001260 break;
1261 }
1262
1263 switch (type) {
1264 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001265 printf ("SDRAM access time 0.%d%d ns\n",
1266 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001267 break;
1268 default:
Larry Johnson632de062008-01-11 23:26:18 -05001269 printf ("SDRAM access time %d.%d ns\n",
1270 (data[10] >> 4) & 0x0F, data[10] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001271 break;
1272 }
1273
wdenk4b9206e2004-03-23 22:14:11 +00001274 puts ("EDC configuration ");
Larry Johnson632de062008-01-11 23:26:18 -05001275 switch (data[11]) {
wdenk4b9206e2004-03-23 22:14:11 +00001276 case 0: puts ("None\n"); break;
1277 case 1: puts ("Parity\n"); break;
1278 case 2: puts ("ECC\n"); break;
1279 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001280 }
Larry Johnson632de062008-01-11 23:26:18 -05001281
Timur Tabie857a5b2006-11-28 12:09:35 -06001282 if ((data[12] & 0x80) == 0)
wdenk4b9206e2004-03-23 22:14:11 +00001283 puts ("No self refresh, rate ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001284 else
wdenk4b9206e2004-03-23 22:14:11 +00001285 puts ("Self refresh, rate ");
Larry Johnson632de062008-01-11 23:26:18 -05001286
wdenk81a88242002-10-26 15:22:42 +00001287 switch(data[12] & 0x7F) {
Larry Johnson632de062008-01-11 23:26:18 -05001288 case 0: puts ("15.625 us\n"); break;
1289 case 1: puts ("3.9 us\n"); break;
1290 case 2: puts ("7.8 us\n"); break;
1291 case 3: puts ("31.3 us\n"); break;
1292 case 4: puts ("62.5 us\n"); break;
1293 case 5: puts ("125 us\n"); break;
wdenk4b9206e2004-03-23 22:14:11 +00001294 default: puts ("unknown\n"); break;
wdenk81a88242002-10-26 15:22:42 +00001295 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001296
1297 switch (type) {
1298 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001299 printf ("SDRAM width (primary) %d\n", data[13]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001300 break;
1301 default:
Larry Johnson632de062008-01-11 23:26:18 -05001302 printf ("SDRAM width (primary) %d\n", data[13] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001303 if ((data[13] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001304 printf (" (second bank) %d\n",
1305 2 * (data[13] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -05001306 }
1307 break;
wdenk81a88242002-10-26 15:22:42 +00001308 }
Larry Johnson0df6b842008-01-10 22:23:39 -05001309
1310 switch (type) {
1311 case DDR2:
1312 if (data[14] != 0)
Larry Johnson632de062008-01-11 23:26:18 -05001313 printf ("EDC width %d\n", data[14]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001314 break;
1315 default:
1316 if (data[14] != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001317 printf ("EDC width %d\n",
1318 data[14] & 0x7F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001319
1320 if ((data[14] & 0x80) != 0) {
Larry Johnson632de062008-01-11 23:26:18 -05001321 printf (" (second bank) %d\n",
1322 2 * (data[14] & 0x7F));
Larry Johnson0df6b842008-01-10 22:23:39 -05001323 }
1324 }
1325 break;
1326 }
1327
Larry Johnson632de062008-01-11 23:26:18 -05001328 if (DDR2 != type) {
1329 printf ("Min clock delay, back-to-back random column addresses "
1330 "%d\n", data[15]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001331 }
1332
wdenk4b9206e2004-03-23 22:14:11 +00001333 puts ("Burst length(s) ");
1334 if (data[16] & 0x80) puts (" Page");
1335 if (data[16] & 0x08) puts (" 8");
1336 if (data[16] & 0x04) puts (" 4");
1337 if (data[16] & 0x02) puts (" 2");
1338 if (data[16] & 0x01) puts (" 1");
1339 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001340 printf ("Number of banks %d\n", data[17]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001341
1342 switch (type) {
1343 case DDR2:
1344 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001345 decode_bits (data[18], decode_CAS_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001346 putc ('\n');
1347 break;
1348 default:
1349 puts ("CAS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001350 decode_bits (data[18], decode_CAS_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001351 putc ('\n');
1352 break;
1353 }
1354
1355 if (DDR2 != type) {
1356 puts ("CS latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001357 decode_bits (data[19], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001358 putc ('\n');
1359 }
1360
1361 if (DDR2 != type) {
1362 puts ("WE latency(s) ");
Larry Johnson632de062008-01-11 23:26:18 -05001363 decode_bits (data[20], decode_CS_WE_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001364 putc ('\n');
1365 }
1366
1367 switch (type) {
1368 case DDR2:
1369 puts ("Module attributes:\n");
1370 if (data[21] & 0x80)
1371 puts (" TBD (bit 7)\n");
1372 if (data[21] & 0x40)
1373 puts (" Analysis probe installed\n");
1374 if (data[21] & 0x20)
1375 puts (" TBD (bit 5)\n");
1376 if (data[21] & 0x10)
1377 puts (" FET switch external enable\n");
Larry Johnson632de062008-01-11 23:26:18 -05001378 printf (" %d PLLs on DIMM\n", (data[21] >> 2) & 0x03);
Larry Johnson0df6b842008-01-10 22:23:39 -05001379 if (data[20] & 0x11) {
Larry Johnson632de062008-01-11 23:26:18 -05001380 printf (" %d active registers on DIMM\n",
1381 (data[21] & 0x03) + 1);
Larry Johnson0df6b842008-01-10 22:23:39 -05001382 }
1383 break;
1384 default:
1385 puts ("Module attributes:\n");
1386 if (!data[21])
1387 puts (" (none)\n");
Larry Johnson632de062008-01-11 23:26:18 -05001388 else
1389 decode_bits (data[21], decode_byte21_default, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001390 break;
1391 }
1392
1393 switch (type) {
1394 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001395 decode_bits (data[22], decode_byte22_DDR2, 0);
Larry Johnson0df6b842008-01-10 22:23:39 -05001396 break;
1397 default:
1398 puts ("Device attributes:\n");
1399 if (data[22] & 0x80) puts (" TBD (bit 7)\n");
1400 if (data[22] & 0x40) puts (" TBD (bit 6)\n");
1401 if (data[22] & 0x20) puts (" Upper Vcc tolerance 5%\n");
1402 else puts (" Upper Vcc tolerance 10%\n");
1403 if (data[22] & 0x10) puts (" Lower Vcc tolerance 5%\n");
1404 else puts (" Lower Vcc tolerance 10%\n");
1405 if (data[22] & 0x08) puts (" Supports write1/read burst\n");
1406 if (data[22] & 0x04) puts (" Supports precharge all\n");
1407 if (data[22] & 0x02) puts (" Supports auto precharge\n");
1408 if (data[22] & 0x01) puts (" Supports early RAS# precharge\n");
1409 break;
1410 }
1411
1412 switch (type) {
1413 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001414 printf ("SDRAM cycle time (2nd highest CAS latency) ");
1415 print_ddr2_tcyc (data[23]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001416 break;
1417 default:
Larry Johnson632de062008-01-11 23:26:18 -05001418 printf ("SDRAM cycle time (2nd highest CAS latency) %d."
1419 "%d ns\n", (data[23] >> 4) & 0x0F, data[23] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001420 break;
1421 }
1422
1423 switch (type) {
1424 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001425 printf ("SDRAM access from clock (2nd highest CAS latency) 0."
1426 "%d%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001427 break;
1428 default:
Larry Johnson632de062008-01-11 23:26:18 -05001429 printf ("SDRAM access from clock (2nd highest CAS latency) %d."
1430 "%d ns\n", (data[24] >> 4) & 0x0F, data[24] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001431 break;
1432 }
1433
1434 switch (type) {
1435 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001436 printf ("SDRAM cycle time (3rd highest CAS latency) ");
1437 print_ddr2_tcyc (data[25]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001438 break;
1439 default:
Larry Johnson632de062008-01-11 23:26:18 -05001440 printf ("SDRAM cycle time (3rd highest CAS latency) %d."
1441 "%d ns\n", (data[25] >> 4) & 0x0F, data[25] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001442 break;
1443 }
1444
1445 switch (type) {
1446 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001447 printf ("SDRAM access from clock (3rd highest CAS latency) 0."
1448 "%d%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001449 break;
1450 default:
Larry Johnson632de062008-01-11 23:26:18 -05001451 printf ("SDRAM access from clock (3rd highest CAS latency) %d."
1452 "%d ns\n", (data[26] >> 4) & 0x0F, data[26] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001453 break;
1454 }
1455
1456 switch (type) {
1457 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001458 printf ("Minimum row precharge %d.%02d ns\n",
1459 (data[27] >> 2) & 0x3F, 25 * (data[27] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001460 break;
1461 default:
Larry Johnson632de062008-01-11 23:26:18 -05001462 printf ("Minimum row precharge %d ns\n", data[27]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001463 break;
1464 }
1465
1466 switch (type) {
1467 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001468 printf ("Row active to row active min %d.%02d ns\n",
1469 (data[28] >> 2) & 0x3F, 25 * (data[28] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001470 break;
1471 default:
Larry Johnson632de062008-01-11 23:26:18 -05001472 printf ("Row active to row active min %d ns\n", data[28]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001473 break;
1474 }
1475
1476 switch (type) {
1477 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001478 printf ("RAS to CAS delay min %d.%02d ns\n",
1479 (data[29] >> 2) & 0x3F, 25 * (data[29] & 0x03));
Larry Johnson0df6b842008-01-10 22:23:39 -05001480 break;
1481 default:
Larry Johnson632de062008-01-11 23:26:18 -05001482 printf ("RAS to CAS delay min %d ns\n", data[29]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001483 break;
1484 }
1485
Larry Johnson632de062008-01-11 23:26:18 -05001486 printf ("Minimum RAS pulse width %d ns\n", data[30]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001487
1488 switch (type) {
1489 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001490 puts ("Density of each row ");
1491 decode_bits (data[31], decode_row_density_DDR2, 1);
1492 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001493 break;
1494 default:
Larry Johnson632de062008-01-11 23:26:18 -05001495 puts ("Density of each row ");
1496 decode_bits (data[31], decode_row_density_default, 1);
1497 putc ('\n');
Larry Johnson0df6b842008-01-10 22:23:39 -05001498 break;
1499 }
1500
1501 switch (type) {
1502 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001503 puts ("Command and Address setup ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001504 if (data[32] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001505 printf ("1.%d%d ns\n",
1506 ((data[32] >> 4) & 0x0F) - 10, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001507 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001508 printf ("0.%d%d ns\n",
1509 ((data[32] >> 4) & 0x0F), data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001510 }
1511 break;
1512 default:
Larry Johnson632de062008-01-11 23:26:18 -05001513 printf ("Command and Address setup %c%d.%d ns\n",
1514 (data[32] & 0x80) ? '-' : '+',
1515 (data[32] >> 4) & 0x07, data[32] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001516 break;
1517 }
1518
1519 switch (type) {
1520 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001521 puts ("Command and Address hold ");
Larry Johnson0df6b842008-01-10 22:23:39 -05001522 if (data[33] >= 0xA0) {
Larry Johnson632de062008-01-11 23:26:18 -05001523 printf ("1.%d%d ns\n",
1524 ((data[33] >> 4) & 0x0F) - 10, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001525 } else {
Larry Johnson632de062008-01-11 23:26:18 -05001526 printf ("0.%d%d ns\n",
1527 ((data[33] >> 4) & 0x0F), data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001528 }
1529 break;
1530 default:
Larry Johnson632de062008-01-11 23:26:18 -05001531 printf ("Command and Address hold %c%d.%d ns\n",
1532 (data[33] & 0x80) ? '-' : '+',
1533 (data[33] >> 4) & 0x07, data[33] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001534 break;
1535 }
1536
1537 switch (type) {
1538 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001539 printf ("Data signal input setup 0.%d%d ns\n",
1540 (data[34] >> 4) & 0x0F, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001541 break;
1542 default:
Larry Johnson632de062008-01-11 23:26:18 -05001543 printf ("Data signal input setup %c%d.%d ns\n",
1544 (data[34] & 0x80) ? '-' : '+',
1545 (data[34] >> 4) & 0x07, data[34] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001546 break;
1547 }
1548
1549 switch (type) {
1550 case DDR2:
Larry Johnson632de062008-01-11 23:26:18 -05001551 printf ("Data signal input hold 0.%d%d ns\n",
1552 (data[35] >> 4) & 0x0F, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001553 break;
1554 default:
Larry Johnson632de062008-01-11 23:26:18 -05001555 printf ("Data signal input hold %c%d.%d ns\n",
1556 (data[35] & 0x80) ? '-' : '+',
1557 (data[35] >> 4) & 0x07, data[35] & 0x0F);
Larry Johnson0df6b842008-01-10 22:23:39 -05001558 break;
1559 }
1560
wdenk4b9206e2004-03-23 22:14:11 +00001561 puts ("Manufacturer's JEDEC ID ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001562 for (j = 64; j <= 71; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001563 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001564 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001565 printf ("Manufacturing Location %02X\n", data[72]);
wdenk4b9206e2004-03-23 22:14:11 +00001566 puts ("Manufacturer's Part Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001567 for (j = 73; j <= 90; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001568 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001569 putc ('\n');
Larry Johnson632de062008-01-11 23:26:18 -05001570 printf ("Revision Code %02X %02X\n", data[91], data[92]);
1571 printf ("Manufacturing Date %02X %02X\n", data[93], data[94]);
wdenk4b9206e2004-03-23 22:14:11 +00001572 puts ("Assembly Serial Number ");
Timur Tabie857a5b2006-11-28 12:09:35 -06001573 for (j = 95; j <= 98; j++)
Larry Johnson632de062008-01-11 23:26:18 -05001574 printf ("%02X ", data[j]);
wdenk4b9206e2004-03-23 22:14:11 +00001575 putc ('\n');
wdenk81a88242002-10-26 15:22:42 +00001576
Larry Johnson0df6b842008-01-10 22:23:39 -05001577 if (DDR2 != type) {
Larry Johnson632de062008-01-11 23:26:18 -05001578 printf ("Speed rating PC%d\n",
1579 data[126] == 0x66 ? 66 : data[126]);
Larry Johnson0df6b842008-01-10 22:23:39 -05001580 }
wdenk81a88242002-10-26 15:22:42 +00001581 return 0;
1582}
Jon Loeliger90253172007-07-10 11:02:44 -05001583#endif
wdenk81a88242002-10-26 15:22:42 +00001584
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001585/*
1586 * Syntax:
1587 * i2c edid {i2c_chip}
1588 */
1589#if defined(CONFIG_I2C_EDID)
1590int do_edid(cmd_tbl_t *cmdtp, int flag, int argc, char *const argv[])
1591{
Masahiro Yamada54684612014-12-20 03:34:23 +09001592 uint chip;
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001593 struct edid1_info edid;
Simon Glass63656b72014-12-10 08:55:48 -07001594 int ret;
1595#ifdef CONFIG_DM_I2C
1596 struct udevice *dev;
1597#endif
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001598
1599 if (argc < 2) {
1600 cmd_usage(cmdtp);
1601 return 1;
1602 }
1603
1604 chip = simple_strtoul(argv[1], NULL, 16);
Simon Glass63656b72014-12-10 08:55:48 -07001605#ifdef CONFIG_DM_I2C
1606 ret = i2c_get_cur_bus_chip(chip, &dev);
1607 if (!ret)
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001608 ret = dm_i2c_read(dev, 0, (uchar *)&edid, sizeof(edid));
Simon Glass63656b72014-12-10 08:55:48 -07001609#else
1610 ret = i2c_read(chip, 0, 1, (uchar *)&edid, sizeof(edid));
1611#endif
1612 if (ret)
1613 return i2c_report_err(ret, I2C_ERR_READ);
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001614
1615 if (edid_check_info(&edid)) {
1616 puts("Content isn't valid EDID.\n");
1617 return 1;
1618 }
1619
1620 edid_print_info(&edid);
1621 return 0;
1622
1623}
1624#endif /* CONFIG_I2C_EDID */
1625
Simon Glass59aa9df2015-05-04 11:30:57 -06001626#ifdef CONFIG_DM_I2C
1627static void show_bus(struct udevice *bus)
1628{
1629 struct udevice *dev;
1630
1631 printf("Bus %d:\t%s", bus->req_seq, bus->name);
1632 if (device_active(bus))
1633 printf(" (active %d)", bus->seq);
1634 printf("\n");
1635 for (device_find_first_child(bus, &dev);
1636 dev;
1637 device_find_next_child(&dev)) {
1638 struct dm_i2c_chip *chip = dev_get_parent_platdata(dev);
1639
1640 printf(" %02x: %s, offset len %x, flags %x\n",
1641 chip->chip_addr, dev->name, chip->offset_len,
1642 chip->flags);
1643 }
1644}
1645#endif
1646
Marek Vasut06afa382012-11-12 14:34:27 +00001647/**
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001648 * do_i2c_show_bus() - Handle the "i2c bus" command-line command
Marek Vasut06afa382012-11-12 14:34:27 +00001649 * @cmdtp: Command data struct pointer
1650 * @flag: Command flag
1651 * @argc: Command-line argument count
1652 * @argv: Array of command-line arguments
1653 *
1654 * Returns zero always.
1655 */
Simon Glass59aa9df2015-05-04 11:30:57 -06001656#if defined(CONFIG_SYS_I2C) || defined(CONFIG_DM_I2C)
Jeroen Hofstee0e350f82014-06-23 00:22:08 +02001657static int do_i2c_show_bus(cmd_tbl_t *cmdtp, int flag, int argc,
1658 char * const argv[])
Heiko Schocher67b23a32008-10-15 09:39:47 +02001659{
Heiko Schocher67b23a32008-10-15 09:39:47 +02001660 if (argc == 1) {
1661 /* show all busses */
Simon Glass59aa9df2015-05-04 11:30:57 -06001662#ifdef CONFIG_DM_I2C
1663 struct udevice *bus;
1664 struct uclass *uc;
1665 int ret;
1666
1667 ret = uclass_get(UCLASS_I2C, &uc);
1668 if (ret)
1669 return CMD_RET_FAILURE;
1670 uclass_foreach_dev(bus, uc)
1671 show_bus(bus);
1672#else
1673 int i;
1674
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001675 for (i = 0; i < CONFIG_SYS_NUM_I2C_BUSES; i++) {
1676 printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
1677#ifndef CONFIG_SYS_I2C_DIRECT_BUS
Simon Glass59aa9df2015-05-04 11:30:57 -06001678 int j;
1679
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001680 for (j = 0; j < CONFIG_SYS_I2C_MAX_HOPS; j++) {
1681 if (i2c_bus[i].next_hop[j].chip == 0)
1682 break;
1683 printf("->%s@0x%2x:%d",
1684 i2c_bus[i].next_hop[j].mux.name,
1685 i2c_bus[i].next_hop[j].chip,
1686 i2c_bus[i].next_hop[j].channel);
Heiko Schocher67b23a32008-10-15 09:39:47 +02001687 }
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001688#endif
1689 printf("\n");
Heiko Schocher67b23a32008-10-15 09:39:47 +02001690 }
Simon Glass59aa9df2015-05-04 11:30:57 -06001691#endif
Heiko Schocher67b23a32008-10-15 09:39:47 +02001692 } else {
Simon Glass59aa9df2015-05-04 11:30:57 -06001693 int i;
1694
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001695 /* show specific bus */
1696 i = simple_strtoul(argv[1], NULL, 10);
Simon Glass59aa9df2015-05-04 11:30:57 -06001697#ifdef CONFIG_DM_I2C
1698 struct udevice *bus;
1699 int ret;
1700
1701 ret = uclass_get_device_by_seq(UCLASS_I2C, i, &bus);
1702 if (ret) {
1703 printf("Invalid bus %d: err=%d\n", i, ret);
1704 return CMD_RET_FAILURE;
1705 }
1706 show_bus(bus);
1707#else
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001708 if (i >= CONFIG_SYS_NUM_I2C_BUSES) {
1709 printf("Invalid bus %d\n", i);
1710 return -1;
1711 }
1712 printf("Bus %d:\t%s", i, I2C_ADAP_NR(i)->name);
1713#ifndef CONFIG_SYS_I2C_DIRECT_BUS
Simon Glass59aa9df2015-05-04 11:30:57 -06001714 int j;
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001715 for (j = 0; j < CONFIG_SYS_I2C_MAX_HOPS; j++) {
1716 if (i2c_bus[i].next_hop[j].chip == 0)
1717 break;
1718 printf("->%s@0x%2x:%d",
1719 i2c_bus[i].next_hop[j].mux.name,
1720 i2c_bus[i].next_hop[j].chip,
1721 i2c_bus[i].next_hop[j].channel);
1722 }
1723#endif
1724 printf("\n");
Simon Glass59aa9df2015-05-04 11:30:57 -06001725#endif
Heiko Schocher67b23a32008-10-15 09:39:47 +02001726 }
Heiko Schocher67b23a32008-10-15 09:39:47 +02001727
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001728 return 0;
1729}
1730#endif
1731
Marek Vasut06afa382012-11-12 14:34:27 +00001732/**
1733 * do_i2c_bus_num() - Handle the "i2c dev" command-line command
1734 * @cmdtp: Command data struct pointer
1735 * @flag: Command flag
1736 * @argc: Command-line argument count
1737 * @argv: Array of command-line arguments
1738 *
1739 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1740 * on error.
1741 */
Simon Glass63656b72014-12-10 08:55:48 -07001742#if defined(CONFIG_SYS_I2C) || defined(CONFIG_I2C_MULTI_BUS) || \
1743 defined(CONFIG_DM_I2C)
Jeroen Hofstee0e350f82014-06-23 00:22:08 +02001744static int do_i2c_bus_num(cmd_tbl_t *cmdtp, int flag, int argc,
1745 char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001746{
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001747 int ret = 0;
Simon Glass63656b72014-12-10 08:55:48 -07001748 int bus_no;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001749
Simon Glass63656b72014-12-10 08:55:48 -07001750 if (argc == 1) {
Timur Tabie857a5b2006-11-28 12:09:35 -06001751 /* querying current setting */
Simon Glass63656b72014-12-10 08:55:48 -07001752#ifdef CONFIG_DM_I2C
1753 struct udevice *bus;
1754
1755 if (!i2c_get_cur_bus(&bus))
1756 bus_no = bus->seq;
1757 else
1758 bus_no = -1;
1759#else
1760 bus_no = i2c_get_bus_num();
1761#endif
1762 printf("Current bus is %d\n", bus_no);
1763 } else {
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001764 bus_no = simple_strtoul(argv[1], NULL, 10);
Heiko Schocher880a4122013-08-23 09:39:16 +02001765#if defined(CONFIG_SYS_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001766 if (bus_no >= CONFIG_SYS_NUM_I2C_BUSES) {
1767 printf("Invalid bus %d\n", bus_no);
1768 return -1;
1769 }
Heiko Schocher880a4122013-08-23 09:39:16 +02001770#endif
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001771 printf("Setting bus to %d\n", bus_no);
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001772#ifdef CONFIG_DM_I2C
1773 ret = cmd_i2c_set_bus_num(bus_no);
1774#else
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001775 ret = i2c_set_bus_num(bus_no);
Simon Glassf9a4c2d2015-01-12 18:02:07 -07001776#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001777 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001778 printf("Failure changing bus number (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001779 }
1780 return ret;
1781}
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001782#endif /* defined(CONFIG_SYS_I2C) */
Ben Warrenbb99ad62006-09-07 16:50:54 -04001783
Marek Vasut06afa382012-11-12 14:34:27 +00001784/**
1785 * do_i2c_bus_speed() - Handle the "i2c speed" command-line command
1786 * @cmdtp: Command data struct pointer
1787 * @flag: Command flag
1788 * @argc: Command-line argument count
1789 * @argv: Array of command-line arguments
1790 *
1791 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1792 * on error.
1793 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001794static int do_i2c_bus_speed(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001795{
1796 int speed, ret=0;
1797
Simon Glass63656b72014-12-10 08:55:48 -07001798#ifdef CONFIG_DM_I2C
1799 struct udevice *bus;
1800
1801 if (i2c_get_cur_bus(&bus))
1802 return 1;
1803#endif
1804 if (argc == 1) {
1805#ifdef CONFIG_DM_I2C
Simon Glassca88b9b2015-02-05 21:41:32 -07001806 speed = dm_i2c_get_bus_speed(bus);
Simon Glass63656b72014-12-10 08:55:48 -07001807#else
1808 speed = i2c_get_bus_speed();
1809#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001810 /* querying current speed */
Simon Glass63656b72014-12-10 08:55:48 -07001811 printf("Current bus speed=%d\n", speed);
1812 } else {
Ben Warrenbb99ad62006-09-07 16:50:54 -04001813 speed = simple_strtoul(argv[1], NULL, 10);
1814 printf("Setting bus speed to %d Hz\n", speed);
Simon Glass63656b72014-12-10 08:55:48 -07001815#ifdef CONFIG_DM_I2C
Simon Glassca88b9b2015-02-05 21:41:32 -07001816 ret = dm_i2c_set_bus_speed(bus, speed);
Simon Glass63656b72014-12-10 08:55:48 -07001817#else
Ben Warrenbb99ad62006-09-07 16:50:54 -04001818 ret = i2c_set_bus_speed(speed);
Simon Glass63656b72014-12-10 08:55:48 -07001819#endif
Timur Tabie857a5b2006-11-28 12:09:35 -06001820 if (ret)
Ben Warrenbb99ad62006-09-07 16:50:54 -04001821 printf("Failure changing bus speed (%d)\n", ret);
Ben Warrenbb99ad62006-09-07 16:50:54 -04001822 }
1823 return ret;
1824}
1825
Marek Vasut06afa382012-11-12 14:34:27 +00001826/**
1827 * do_i2c_mm() - Handle the "i2c mm" command-line command
1828 * @cmdtp: Command data struct pointer
1829 * @flag: Command flag
1830 * @argc: Command-line argument count
1831 * @argv: Array of command-line arguments
1832 *
1833 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1834 * on error.
1835 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001836static int do_i2c_mm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001837{
1838 return mod_i2c_mem (cmdtp, 1, flag, argc, argv);
1839}
1840
Marek Vasut06afa382012-11-12 14:34:27 +00001841/**
1842 * do_i2c_nm() - Handle the "i2c nm" command-line command
1843 * @cmdtp: Command data struct pointer
1844 * @flag: Command flag
1845 * @argc: Command-line argument count
1846 * @argv: Array of command-line arguments
1847 *
1848 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1849 * on error.
1850 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001851static int do_i2c_nm(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001852{
1853 return mod_i2c_mem (cmdtp, 0, flag, argc, argv);
1854}
1855
Marek Vasut06afa382012-11-12 14:34:27 +00001856/**
1857 * do_i2c_reset() - Handle the "i2c reset" command-line command
1858 * @cmdtp: Command data struct pointer
1859 * @flag: Command flag
1860 * @argc: Command-line argument count
1861 * @argv: Array of command-line arguments
1862 *
1863 * Returns zero always.
1864 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001865static int do_i2c_reset(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001866{
Simon Glass63656b72014-12-10 08:55:48 -07001867#if defined(CONFIG_DM_I2C)
1868 struct udevice *bus;
1869
1870 if (i2c_get_cur_bus(&bus))
1871 return CMD_RET_FAILURE;
1872 if (i2c_deblock(bus)) {
1873 printf("Error: Not supported by the driver\n");
1874 return CMD_RET_FAILURE;
1875 }
1876#elif defined(CONFIG_SYS_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001877 i2c_init(I2C_ADAP->speed, I2C_ADAP->slaveaddr);
1878#else
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001879 i2c_init(CONFIG_SYS_I2C_SPEED, CONFIG_SYS_I2C_SLAVE);
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001880#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001881 return 0;
1882}
1883
1884static cmd_tbl_t cmd_i2c_sub[] = {
Simon Glass59aa9df2015-05-04 11:30:57 -06001885#if defined(CONFIG_SYS_I2C) || defined(CONFIG_DM_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001886 U_BOOT_CMD_MKENT(bus, 1, 1, do_i2c_show_bus, "", ""),
Heiko Schocher9a2accb2012-10-25 10:32:14 +02001887#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001888 U_BOOT_CMD_MKENT(crc32, 3, 1, do_i2c_crc, "", ""),
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001889#if defined(CONFIG_SYS_I2C) || \
Simon Glass63656b72014-12-10 08:55:48 -07001890 defined(CONFIG_I2C_MULTI_BUS) || defined(CONFIG_DM_I2C)
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001891 U_BOOT_CMD_MKENT(dev, 1, 1, do_i2c_bus_num, "", ""),
1892#endif /* CONFIG_I2C_MULTI_BUS */
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001893#if defined(CONFIG_I2C_EDID)
1894 U_BOOT_CMD_MKENT(edid, 1, 1, do_edid, "", ""),
1895#endif /* CONFIG_I2C_EDID */
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001896 U_BOOT_CMD_MKENT(loop, 3, 1, do_i2c_loop, "", ""),
1897 U_BOOT_CMD_MKENT(md, 3, 1, do_i2c_md, "", ""),
1898 U_BOOT_CMD_MKENT(mm, 2, 1, do_i2c_mm, "", ""),
1899 U_BOOT_CMD_MKENT(mw, 3, 1, do_i2c_mw, "", ""),
1900 U_BOOT_CMD_MKENT(nm, 2, 1, do_i2c_nm, "", ""),
1901 U_BOOT_CMD_MKENT(probe, 0, 1, do_i2c_probe, "", ""),
Frans Meulenbroeks652e5352010-02-25 10:12:16 +01001902 U_BOOT_CMD_MKENT(read, 5, 1, do_i2c_read, "", ""),
Lubomir Popoved16f142015-01-30 19:56:04 +02001903 U_BOOT_CMD_MKENT(write, 6, 0, do_i2c_write, "", ""),
Simon Glass63656b72014-12-10 08:55:48 -07001904#ifdef CONFIG_DM_I2C
1905 U_BOOT_CMD_MKENT(flags, 2, 1, do_i2c_flags, "", ""),
1906#endif
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001907 U_BOOT_CMD_MKENT(reset, 0, 1, do_i2c_reset, "", ""),
1908#if defined(CONFIG_CMD_SDRAM)
1909 U_BOOT_CMD_MKENT(sdram, 1, 1, do_sdram, "", ""),
1910#endif
1911 U_BOOT_CMD_MKENT(speed, 1, 1, do_i2c_bus_speed, "", ""),
1912};
1913
Wolfgang Denk2e5167c2010-10-28 20:00:11 +02001914#ifdef CONFIG_NEEDS_MANUAL_RELOC
Heiko Schocherf1d2b312010-09-17 13:10:39 +02001915void i2c_reloc(void) {
1916 fixup_cmdtable(cmd_i2c_sub, ARRAY_SIZE(cmd_i2c_sub));
1917}
1918#endif
1919
Marek Vasut06afa382012-11-12 14:34:27 +00001920/**
1921 * do_i2c() - Handle the "i2c" command-line command
1922 * @cmdtp: Command data struct pointer
1923 * @flag: Command flag
1924 * @argc: Command-line argument count
1925 * @argv: Array of command-line arguments
1926 *
1927 * Returns zero on success, CMD_RET_USAGE in case of misuse and negative
1928 * on error.
1929 */
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001930static int do_i2c(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
Ben Warrenbb99ad62006-09-07 16:50:54 -04001931{
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001932 cmd_tbl_t *c;
1933
Heiko Schocher4444b222010-09-17 13:10:35 +02001934 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001935 return CMD_RET_USAGE;
Heiko Schocher4444b222010-09-17 13:10:35 +02001936
Peter Tysere96ad5d2009-04-18 22:34:04 -05001937 /* Strip off leading 'i2c' command argument */
1938 argc--;
1939 argv++;
1940
Frans Meulenbroeksbfc3b772010-02-25 10:12:14 +01001941 c = find_cmd_tbl(argv[0], &cmd_i2c_sub[0], ARRAY_SIZE(cmd_i2c_sub));
1942
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001943 if (c)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001944 return c->cmd(cmdtp, flag, argc, argv);
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001945 else
Simon Glass4c12eeb2011-12-10 08:44:01 +00001946 return CMD_RET_USAGE;
Ben Warrenbb99ad62006-09-07 16:50:54 -04001947}
wdenk8bde7f72003-06-27 21:31:46 +00001948
1949/***************************************************/
Kim Phillips088f1b12012-10-29 13:34:31 +00001950#ifdef CONFIG_SYS_LONGHELP
1951static char i2c_help_text[] =
Simon Glass59aa9df2015-05-04 11:30:57 -06001952#if defined(CONFIG_SYS_I2C) || defined(CONFIG_DM_I2C)
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001953 "bus [muxtype:muxaddr:muxchannel] - show I2C bus info\n"
Heiko Schocher9a2accb2012-10-25 10:32:14 +02001954#endif
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001955 "crc32 chip address[.0, .1, .2] count - compute CRC32 checksum\n"
Heiko Schocher3f4978c2012-01-16 21:12:24 +00001956#if defined(CONFIG_SYS_I2C) || \
Simon Glass63656b72014-12-10 08:55:48 -07001957 defined(CONFIG_I2C_MULTI_BUS) || defined(CONFIG_DM_I2C)
Peter Tyser9bc2e4e2008-10-01 12:25:04 -05001958 "i2c dev [dev] - show or set current I2C bus\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001959#endif /* CONFIG_I2C_MULTI_BUS */
Tom Wai-Hong Tam735987c2012-12-05 14:46:40 +00001960#if defined(CONFIG_I2C_EDID)
1961 "i2c edid chip - print EDID configuration information\n"
1962#endif /* CONFIG_I2C_EDID */
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001963 "i2c loop chip address[.0, .1, .2] [# of objects] - looping read of device\n"
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001964 "i2c md chip address[.0, .1, .2] [# of objects] - read from I2C device\n"
1965 "i2c mm chip address[.0, .1, .2] - write to I2C device (auto-incrementing)\n"
1966 "i2c mw chip address[.0, .1, .2] value [count] - write to I2C device (fill)\n"
1967 "i2c nm chip address[.0, .1, .2] - write to I2C device (constant address)\n"
Eric Nelson54b99e52012-09-23 10:12:56 +00001968 "i2c probe [address] - test for and show device(s) on the I2C bus\n"
Simon Glass63656b72014-12-10 08:55:48 -07001969 "i2c read chip address[.0, .1, .2] length memaddress - read to memory\n"
Lubomir Popoved16f142015-01-30 19:56:04 +02001970 "i2c write memaddress chip address[.0, .1, .2] length [-s] - write memory\n"
1971 " to I2C; the -s option selects bulk write in a single transaction\n"
Simon Glass63656b72014-12-10 08:55:48 -07001972#ifdef CONFIG_DM_I2C
1973 "i2c flags chip [flags] - set or get chip flags\n"
1974#endif
Heiko Schochere43a27c2008-10-15 09:33:30 +02001975 "i2c reset - re-init the I2C Controller\n"
Jon Loeligerc76fe472007-07-08 18:02:23 -05001976#if defined(CONFIG_CMD_SDRAM)
Frans Meulenbroeksfb0070e2010-02-25 10:12:15 +01001977 "i2c sdram chip - print SDRAM configuration information\n"
Jon Loeliger90253172007-07-10 11:02:44 -05001978#endif
Kim Phillips088f1b12012-10-29 13:34:31 +00001979 "i2c speed [speed] - show or set I2C bus speed";
1980#endif
1981
1982U_BOOT_CMD(
Lubomir Popoved16f142015-01-30 19:56:04 +02001983 i2c, 7, 1, do_i2c,
Kim Phillips088f1b12012-10-29 13:34:31 +00001984 "I2C sub-system",
1985 i2c_help_text
Matthias Fuchsd9fc7032007-03-08 16:25:47 +01001986);